diff --git a/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil b/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil index 2771eb9bac07..86510282c3b7 100644 --- a/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil +++ b/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil @@ -1,6 +1,7 @@ include "contract_instance_retrieval.pil"; include "../constants_gen.pil"; +include "../trees/indexed_tree_check.pil"; // Bytecode retrieval. // @@ -97,17 +98,25 @@ pol commit remaining_bytecodes_inv; #[NO_REMAINING_BYTECODES] sel * (REMAINING_BYTECODES * (no_remaining_bytecodes * (1 - remaining_bytecodes_inv) + remaining_bytecodes_inv) - 1 + no_remaining_bytecodes) = 0; -pol commit is_new_class; // @boolean (by lookup into retrieved_bytecodes_tree_check when instance_exists == 1; constrained to 0 when instance_exists == 0) +pol commit is_new_class; // @boolean (by lookup into indexed_tree_check when instance_exists == 1; constrained to 0 when instance_exists == 0) + +// Lookup constant support: Can be removed when we support constants in lookups. +pol commit retrieved_bytecodes_tree_height; +instance_exists * (retrieved_bytecodes_tree_height - constants.AVM_RETRIEVED_BYTECODES_TREE_HEIGHT) = 0; #[IS_NEW_CLASS_CHECK] instance_exists { - current_class_id, - is_new_class, - prev_retrieved_bytecodes_tree_root -} in retrieved_bytecodes_tree_check.sel { - retrieved_bytecodes_tree_check.class_id, - retrieved_bytecodes_tree_check.leaf_not_exists, - retrieved_bytecodes_tree_check.root + is_new_class, // not_exists + current_class_id, // value + prev_retrieved_bytecodes_tree_root, + retrieved_bytecodes_tree_height, + precomputed.zero // sel_silo = 0 (no siloing) +} in indexed_tree_check.sel { + indexed_tree_check.not_exists, + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo }; // Enforce is_new_class == 0 if the instance does not exist. @@ -139,19 +148,21 @@ should_retrieve { #[RETRIEVED_BYTECODES_INSERTION] should_retrieve { - current_class_id, - should_retrieve, // 1 + current_class_id, // value prev_retrieved_bytecodes_tree_root, - prev_retrieved_bytecodes_tree_size, next_retrieved_bytecodes_tree_root, - next_retrieved_bytecodes_tree_size -} in retrieved_bytecodes_tree_check.sel { - retrieved_bytecodes_tree_check.class_id, - retrieved_bytecodes_tree_check.write, - retrieved_bytecodes_tree_check.root, - retrieved_bytecodes_tree_check.tree_size_before_write, - retrieved_bytecodes_tree_check.write_root, - retrieved_bytecodes_tree_check.tree_size_after_write + prev_retrieved_bytecodes_tree_size, + next_retrieved_bytecodes_tree_size, + retrieved_bytecodes_tree_height, + precomputed.zero // sel_silo = 0 (no siloing) +} in indexed_tree_check.write { + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.write_root, + indexed_tree_check.tree_size_before_write, + indexed_tree_check.tree_size_after_write, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo }; // If instance does not exist, force current_class_id to 0. diff --git a/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil b/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil index 7545c08a303c..2186f47fe884 100644 --- a/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil +++ b/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil @@ -129,20 +129,32 @@ namespace contract_instance_retrieval; // Protocol contracts do not have an address nullifier in the nullifier tree. should_check_nullifier = sel * (1 - is_protocol_contract); + // Lookup constant support: Can be removed when we support constants in lookups. + pol commit nullifier_tree_height; + should_check_nullifier * (nullifier_tree_height - constants.NULLIFIER_TREE_HEIGHT) = 0; + + // Lookup constant support: Can be removed when we support constants in lookups. + pol commit siloing_separator; + should_check_nullifier * (siloing_separator - constants.DOM_SEP__SILOED_NULLIFIER) = 0; + // Nullifier existence check (deployment nullifier read) #[DEPLOYMENT_NULLIFIER_READ] should_check_nullifier { exists, // does the contract address nullifier exist? gates later lookups.... address, // the deployment nullifier nullifier_tree_root, - deployer_protocol_contract_address, - sel // 1 (yes silo) - } in nullifier_check.sel { - nullifier_check.exists, - nullifier_check.nullifier, - nullifier_check.root, - nullifier_check.address, - nullifier_check.sel_silo + nullifier_tree_height, + sel, // 1 (yes silo) + siloing_separator, + deployer_protocol_contract_address + } in indexed_tree_check.sel { + indexed_tree_check.exists, + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo, + indexed_tree_check.siloing_separator, + indexed_tree_check.address }; // For protocol contracts we retrieve the derived address from the protocol contract trace, else use the input address diff --git a/barretenberg/cpp/pil/vm2/execution.pil b/barretenberg/cpp/pil/vm2/execution.pil index 593c4fd14dc2..7c74a520f6f2 100644 --- a/barretenberg/cpp/pil/vm2/execution.pil +++ b/barretenberg/cpp/pil/vm2/execution.pil @@ -24,11 +24,9 @@ include "execution/gas.pil"; include "execution/registers.pil"; include "trees/merkle_check.pil"; -include "trees/nullifier_check.pil"; +include "trees/indexed_tree_check.pil"; include "trees/public_data_check.pil"; -include "trees/written_public_data_slots_tree_check.pil"; include "trees/l1_to_l2_message_tree_check.pil"; -include "trees/retrieved_bytecodes_tree_check.pil"; include "bytecode/address_derivation.pil"; include "bytecode/bc_decomposition.pil"; @@ -517,21 +515,36 @@ sel_gas_to_radix * ((/*num_limbs=*/register[2] - num_p_limbs) * sel_use_num_limb ////////////////////////////////////////// // SSTORE, Dynamic DA Gas Calculation ////////////////////////////////////////// + +// Lookup constant support: Can be removed when we support constants in lookups. +pol commit written_slots_tree_height; +sel_gas_sstore * (written_slots_tree_height - constants.AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT) = 0; + +// Lookup constant support: Can be removed when we support constants in lookups. +pol commit written_slots_tree_siloing_separator; +sel_gas_sstore * (written_slots_tree_siloing_separator - constants.DOM_SEP__PUBLIC_LEAF_SLOT) = 0; + // We can probably unconditionally write to the written_public_data_slots_tree here // to avoid writing later in opcode execution, since the root would be reverted if it errors before // the opcode execution. However, this feels like an early optimization // since the simulator would need to write at the gas step which is a bit weird. #[CHECK_WRITTEN_STORAGE_SLOT] sel_gas_sstore { - contract_address, - register[1], // slot dynamic_da_gas_factor, - prev_written_public_data_slots_tree_root -} in written_public_data_slots_tree_check.sel { - written_public_data_slots_tree_check.address, - written_public_data_slots_tree_check.slot, - written_public_data_slots_tree_check.leaf_not_exists, - written_public_data_slots_tree_check.root + register[1], // value + prev_written_public_data_slots_tree_root, + written_slots_tree_height, + sel_gas_sstore, // sel_silo = 1 + written_slots_tree_siloing_separator, + contract_address +} in indexed_tree_check.sel { + indexed_tree_check.not_exists, + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo, + indexed_tree_check.siloing_separator, + indexed_tree_check.address }; /////////////////////////////////////////////////////////////////////////////// @@ -775,6 +788,10 @@ sel_execute_returndata_size * (mem_tag_reg[0] - constants.MEM_TAG_U32) = 0; // W #[RETRIEVED_BYTECODES_TREE_SIZE_NOT_CHANGED] (1 - sel_first_row_in_context) * (prev_retrieved_bytecodes_tree_size - retrieved_bytecodes_tree_size) = 0; +// Shared between nullifier_exists.pil and emit_nullifier.pil. +// Lookup constant support: Can be removed when we support constants in lookups. +pol commit nullifier_tree_height; + // Whether the opcode logic failed. pol commit sel_opcode_error; // @boolean sel_opcode_error * (1 - sel_opcode_error) = 0; diff --git a/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil b/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil index 056d90073532..70f44afb1a9d 100644 --- a/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil +++ b/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil @@ -12,7 +12,7 @@ include "../constants_gen.pil"; * - register[0] as the nullifier input register (FF) * * Interactions: - * - The gadget performs a lookup into the nullifier_check gadget to attempt to write the nullifier. + * - The gadget performs a lookup into the indexed_tree_check gadget to attempt to write the nullifier. * - This lookup is only performed if no limit error occurs. * * Errors: @@ -54,28 +54,42 @@ namespace execution; // this is a virtual gadget that shares rows with the execu // =========== OPCODE EXECUTION =========== + pol commit nullifier_pi_offset; + sel_write_nullifier * (constants.AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + prev_num_nullifiers_emitted - nullifier_pi_offset) = 0; + + // From execution.pil. + sel_write_nullifier * (nullifier_tree_height - constants.NULLIFIER_TREE_HEIGHT) = 0; + + // Lookup constant support: Can be removed when we support constants in lookups. + pol commit nullifier_siloing_separator; + sel_write_nullifier * (nullifier_siloing_separator - constants.DOM_SEP__SILOED_NULLIFIER) = 0; + // Lookup into nullifier tree check to attempt write #[WRITE_NULLIFIER] sel_write_nullifier { - /*nullifier=*/ register[0], // input: nullifier to write - prev_nullifier_tree_root, // input: pre-write tree root (from context.pil) - /*exists=*/ sel_opcode_error, // output: 1 if nullifier already exists (error) - nullifier_tree_root, // output: new tree root (updates context.pil column!) - prev_nullifier_tree_size, // input: pre-write tree size (from context.pil) - discard, // input: (from execution_discard) will this write eventually be reverted (so it shouldn't be written to public inputs)? - /*nullifier_index=*/ prev_num_nullifiers_emitted, // input: the nullifier index to write to in public inputs - /*sel_silo=1*/ sel_write_nullifier, // input: sel_silo = 1 (always silo for contract nullifiers) - contract_address // input: contract address for siloing (from context) - } in nullifier_check.write { - nullifier_check.nullifier, - nullifier_check.root, - nullifier_check.exists, // nullifier collision - nullifier_check.write_root, // post-write tree root - nullifier_check.tree_size_before_write, - nullifier_check.discard, - nullifier_check.nullifier_index, // index to write to in public inputs - nullifier_check.sel_silo, - nullifier_check.address // contract address for siloing + /*nullifier=*/ register[0], // input: nullifier to write + prev_nullifier_tree_root, // input: pre-write tree root (from context.pil) + /*exists=*/ sel_opcode_error, // output: 1 if nullifier already exists (error) + nullifier_tree_root, // output: new tree root (updates context.pil column!) + prev_nullifier_tree_size, // input: pre-write tree size (from context.pil) + discard, // input: (from execution_discard) will this write eventually be reverted (so it shouldn't be written to public inputs)? + nullifier_pi_offset, // input: the index to write to in public inputs + nullifier_tree_height, // input: the tree height + /*sel_silo=1*/ sel_write_nullifier, // input: sel_silo = 1 (always silo for contract nullifiers) + nullifier_siloing_separator, // input: siloing separator + contract_address // input: contract address for siloing (from context) + } in indexed_tree_check.write { + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.exists, // nullifier collision + indexed_tree_check.write_root, // post-write tree root + indexed_tree_check.tree_size_before_write, + indexed_tree_check.discard, + indexed_tree_check.public_inputs_index, // index to write to in public inputs + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo, + indexed_tree_check.siloing_separator, + indexed_tree_check.address // contract address for siloing }; pol SUCCESSFUL_WRITE = sel_write_nullifier * (1 - sel_opcode_error); diff --git a/barretenberg/cpp/pil/vm2/opcodes/nullifier_exists.pil b/barretenberg/cpp/pil/vm2/opcodes/nullifier_exists.pil index d4c5deb31cc5..d81d96a4aa53 100644 --- a/barretenberg/cpp/pil/vm2/opcodes/nullifier_exists.pil +++ b/barretenberg/cpp/pil/vm2/opcodes/nullifier_exists.pil @@ -13,7 +13,7 @@ include "../constants_gen.pil"; * * Memory reads and writes are handled by standard execution logic. * - * The gadget performs a lookup into the nullifier_check gadget to determine if the nullifier + * The gadget performs a lookup into the indexed_tree_check gadget to determine if the nullifier * exists. The nullifier is already siloed by the caller (no siloing happens in this opcode). * The result is written to the output register. * @@ -27,23 +27,27 @@ namespace execution; // this is a virtual gadget that shares rows with the execu #[skippable_if] sel_execute_nullifier_exists = 0; // from execution.pil. + // From execution.pil. + sel_execute_nullifier_exists * (nullifier_tree_height - constants.NULLIFIER_TREE_HEIGHT) = 0; // Lookup into nullifier tree check to determine existence #[NULLIFIER_EXISTS_CHECK] sel_execute_nullifier_exists { // Outputs - /*exists=*/ register[1], // output: whether nullifier exists + /*exists=*/ register[1], // output: whether nullifier exists // Inputs - /*nullifier=*/ register[0], // input: siloed nullifier to check - prev_nullifier_tree_root, // input: tree root from context - /*sel_silo=0*/ precomputed.zero // input: sel_silo = 0 (nullifier is already siloed, address also omitted) - } in nullifier_check.sel { + /*value=*/ register[0], // input: siloed nullifier to check + prev_nullifier_tree_root, // input: tree root from context + nullifier_tree_height, // input: tree height + /*sel_silo=0*/ precomputed.zero // input: sel_silo = 0 (nullifier is already siloed, address and separator omitted) + } in indexed_tree_check.sel { // Outputs - nullifier_check.exists, + indexed_tree_check.exists, // Inputs - nullifier_check.nullifier, - nullifier_check.root, - nullifier_check.sel_silo + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo }; // Tag result (`exists`) as u1 (via mem_tag_reg[1]). diff --git a/barretenberg/cpp/pil/vm2/opcodes/sstore.pil b/barretenberg/cpp/pil/vm2/opcodes/sstore.pil index 878ecbeea220..111fc75946bf 100644 --- a/barretenberg/cpp/pil/vm2/opcodes/sstore.pil +++ b/barretenberg/cpp/pil/vm2/opcodes/sstore.pil @@ -1,6 +1,6 @@ include "../constants_gen.pil"; include "../trees/public_data_check.pil"; -include "../trees/written_public_data_slots_tree_check.pil"; +include "../trees/indexed_tree_check.pil"; // SSTORE opcode: Writes a value to storage at the provided slot // @@ -14,7 +14,7 @@ include "../trees/written_public_data_slots_tree_check.pil"; // - register[1]: Contains the storage slot to write to // // The opcode leverages the public_data_check gadget to verify the storage write operation -// and the written_public_data_slots_tree_check gadget to track written slots for gas calculation. +// and the indexed_tree_check gadget to track written slots for gas calculation. // namespace execution; // this is a virtual gadget that shares rows with the execution trace @@ -55,21 +55,25 @@ namespace execution; // this is a virtual gadget that shares rows with the execu #[RECORD_WRITTEN_STORAGE_SLOT] sel_write_public_data { - contract_address, register[1], // slot - sel_write_public_data/*=1*/, prev_written_public_data_slots_tree_root, - prev_written_public_data_slots_tree_size, written_public_data_slots_tree_root, - written_public_data_slots_tree_size - } in written_public_data_slots_tree_check.sel { - written_public_data_slots_tree_check.address, - written_public_data_slots_tree_check.slot, - written_public_data_slots_tree_check.write, - written_public_data_slots_tree_check.root, - written_public_data_slots_tree_check.tree_size_before_write, - written_public_data_slots_tree_check.write_root, - written_public_data_slots_tree_check.tree_size_after_write + prev_written_public_data_slots_tree_size, + written_public_data_slots_tree_size, + written_slots_tree_height, // From execution.pil. Gated by sel_gas_sstore, which is a requirement for sel_write_public_data. + sel_write_public_data, // sel_silo = 1 + written_slots_tree_siloing_separator, // From execution.pil. Gated by sel_gas_sstore, which is a requirement for sel_write_public_data. + contract_address + } in indexed_tree_check.write { + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.write_root, + indexed_tree_check.tree_size_before_write, + indexed_tree_check.tree_size_after_write, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo, + indexed_tree_check.siloing_separator, + indexed_tree_check.address }; #[STORAGE_WRITE] diff --git a/barretenberg/cpp/pil/vm2/poseidon2_hash.pil b/barretenberg/cpp/pil/vm2/poseidon2_hash.pil index 322101ffc73b..44095288288e 100644 --- a/barretenberg/cpp/pil/vm2/poseidon2_hash.pil +++ b/barretenberg/cpp/pil/vm2/poseidon2_hash.pil @@ -7,8 +7,8 @@ include "precomputed.pil"; * output, input_len and use destination selector start (= 1). The caller will pass 1,2, or 3 for input_len. This follows * from the below constraints that `num_perm_rounds_rem == 1` and `end ==1`. * - * Example (nullifier_check.pil): - * sel_silo { siloing_separator, address, nullifier, siloed_nullifier, const_three } + * Example (indexed_tree_check.pil): + * sel_silo { siloing_separator, address, value, siloed_value, const_three } * in poseidon2_hash.start { poseidon2_hash.input_0, poseidon2_hash.input_1, * poseidon2_hash.input_2, poseidon2_hash.output, poseidon2_hash.input_len }; * @@ -56,12 +56,10 @@ include "precomputed.pil"; * - class_id_derivation.pil * - merkle_check.pil * - note_hash_tree_check.pil - * - nullifier_check.pil + * - indexed_tree_check.pil * - public_data_check.pil - * - retrieved_bytecodes_tree_check.pil * - tx.pil * - update_check.pil - * - written_public_data_slots_tree_check.pil */ namespace poseidon2_hash; diff --git a/barretenberg/cpp/pil/vm2/trees/indexed_tree_check.pil b/barretenberg/cpp/pil/vm2/trees/indexed_tree_check.pil new file mode 100644 index 000000000000..319db349e3f0 --- /dev/null +++ b/barretenberg/cpp/pil/vm2/trees/indexed_tree_check.pil @@ -0,0 +1,282 @@ +include "merkle_check.pil"; +include "../ff_gt.pil"; +include "../poseidon2_hash.pil"; +include "../precomputed.pil"; +include "../public_inputs.pil"; + +/** + * This gadget reads and writes in an indexed tree. An indexed tree is a Merkle tree where leaves + * contain a value and linked-list pointers (next_value, next_index) to the leaf with the next + * highest value. When we read from the tree, we check whether a value exists or not. + * For this we perform a low leaf membership proof and: + * - if the low leaf value is equal to the value, that means the value is present in the tree, and we assert that + * exists is true. + * - if the low leaf value is not equal to the value, we assert that the low leaf is indeed a valid low leaf for the + * requested value, proving non existence of the value in the tree. In that case we check exists is false. + * In order to validate that a leaf is a low leaf of the value, we need to check that low_leaf.value < value + * and that low_leaf.next_value > value. However, we need to consider the case where next_value is zero, which + * means "infinity". The highest value inserted in the tree will point to infinity as the "next_value". + * In order to write, we perform the above, and also: + * - We update the low leaf. The low leaf must now point to the leaf we are going to insert. + * - We construct the new leaf and insert it into the tree at 'tree_size_before_write' + * Note: Indexed trees start prefilled with at least two items, so we can assume that no low leaf will be all zeroes + * and that there will always be a low leaf for any given value. + * + * This gadget is generic and can be used for any indexed tree with just one value per leaf (nullifier tree, retrieved bytecodes tree, + * written public data slots tree, etc.). The caller provides the tree height, and optionally a siloing + * separator and contract address to silo the value before insertion. + * + * Values can be optionally siloed with a contract address to bind them to their originating contract. + * The siloing_separator and address are provided by the caller when sel_silo is set. + * + * Shape: + * One row per read or write operation. + * + * Errors: + * - Failing write: When exists == true on a write operation, the value already exists in the tree. + * In this case, the write_root equals the input root and no tree update occurs. + * + * Read usage: + * sel { + * exists, + * not_exists, + * value, + * tree_root, + * tree_height, + * sel_silo, + * siloing_separator, // Can be omitted if sel_silo is precomputed.zero + * address // Can be omitted if sel_silo is precomputed.zero + * } in indexed_tree_check.sel { + * indexed_tree_check.exists, // Output + * indexed_tree_check.not_exists, // Output + * indexed_tree_check.value, // Input + * indexed_tree_check.root, // Input + * indexed_tree_check.tree_height, // Input + * indexed_tree_check.sel_silo, // Input + * indexed_tree_check.siloing_separator, // Input (omit if sel_silo == 0) + * indexed_tree_check.address // Input (omit if sel_silo == 0) + * }; + * + * Write usage: + * sel { + * value, + * prev_tree_root, + * exists, + * not_exists, + * next_tree_root, + * prev_tree_size, + * next_tree_size, + * discard, // Can be omitted if not writing to public inputs + * public_inputs_index, // Can be omitted if not writing to public inputs + * tree_height, + * sel_silo, + * siloing_separator, // Can be omitted if sel_silo is precomputed.zero + * address // Can be omitted if sel_silo is precomputed.zero + * } in indexed_tree_check.write { + * indexed_tree_check.value, // Input + * indexed_tree_check.root, // Input + * indexed_tree_check.exists, // Output + * indexed_tree_check.not_exists, // Output + * indexed_tree_check.write_root, // Output + * indexed_tree_check.tree_size_before_write, // Input + * indexed_tree_check.tree_size_after_write, // Output + * indexed_tree_check.discard, // Input (omit if not writing to public inputs) + * indexed_tree_check.public_inputs_index, // Input (omit if not writing to public inputs) + * indexed_tree_check.tree_height, // Input + * indexed_tree_check.sel_silo, // Input + * indexed_tree_check.siloing_separator, // Input (omit if sel_silo == 0) + * indexed_tree_check.address // Input (omit if sel_silo == 0) + * }; + * + * Note: On a failing write (when exists == true), the write_root equals the input root and no tree update occurs. + * The siloing_separator and address columns should be omitted (or set to zero) when sel_silo == 0. + * Set discard to 1 to skip writing the siloed value to public inputs (e.g., for transient trees). + * + * Preconditions: + * - low_leaf_index < 2^tree_height (Merkle check requirement) + * - tree_size_before_write < 2^tree_height (Merkle check requirement) + * - The tree genesis state must have an irreproducible hash for uninitialized leaves (0). + * + * Interactions: + * - poseidon2_hash: Conditional siloing (sel_silo), low leaf hash, updated low leaf hash (sel_insert), new leaf hash (sel_insert) + * - merkle_check: Low leaf membership/update (sel_insert), new leaf insertion (sel_insert) + * - ff_gt: Low leaf value validation (not_exists), next value validation (next_value_is_nonzero) + * - public_inputs: Write siloed value to public inputs (sel_write_to_public_inputs) + * + **/ +namespace indexed_tree_check; + pol commit sel; // @boolean + sel * (1 - sel) = 0; + + #[skippable_if] + sel = 0; + + // ====== INPUTS ====== + pol commit write; // @boolean + write * (1 - write) = 0; + // Allows this gadget to be looked up by the write column + write * (1 - sel) = 0; + + pol commit value; + pol commit root; + pol commit exists; // @boolean + exists * (1 - exists) = 0; + pol commit not_exists; // @boolean (by definition) + not_exists = sel * (1 - exists); + pol commit sel_silo; // @boolean + sel_silo * (1 - sel_silo) = 0; + pol commit address; + pol commit siloing_separator; + pol commit tree_height; + + // Write specific inputs + pol commit write_root; + pol commit tree_size_before_write; + pol commit tree_size_after_write; + pol commit discard; // @boolean + discard * (1 - discard) = 0; + pol commit public_inputs_index; + + // ========= SILOING ========= + pol commit siloed_value; + #[PASSTHROUGH_SILOING] + (1 - sel_silo) * (value - siloed_value) = 0; + + pol commit const_three; + sel * (const_three - 3) = 0; + + #[SILO_POSEIDON2] + sel_silo { + siloing_separator, address, value, + siloed_value, const_three + } in poseidon2_hash.start { + poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, + poseidon2_hash.output, poseidon2_hash.input_len + }; + + // ========= LOW LEAF VALIDATION ========= + // Note: We don't validate that the low leaf is not empty. This is because we force hashing the low leaf for the + // membership check. An empty leaf would pass the low leaf validation, but the membership check would fail, + // since uninitialized leaves have hash 0, which is not the poseidon2 hash of an empty leaf. + // It is expected that no circuit introduces an empty leaf with its proper hash ever into an indexed tree. + // Doing so would break the tree as it'd be a valid low leaf for any insertion. + pol commit low_leaf_value; + pol commit low_leaf_next_index; + pol commit low_leaf_next_value; + pol commit low_leaf_hash; + + pol commit value_low_leaf_value_diff_inv; // @zero-check + pol VALUE_LOW_LEAF_VALUE_DIFF = siloed_value - low_leaf_value; + + // VALUE_LOW_LEAF_VALUE_DIFF == 0 <==> exists == 1 + #[EXISTS_CHECK] + sel * (VALUE_LOW_LEAF_VALUE_DIFF * (exists * (1 - value_low_leaf_value_diff_inv) + value_low_leaf_value_diff_inv) - 1 + exists) = 0; + + // If the leaf doesn't exist, we need to validate that the value is greater than the low leaf value + + #[LOW_LEAF_VALUE_VALIDATION] + not_exists { siloed_value, low_leaf_value, sel } + in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; + + // If next value is not zero (which would be infinity), it has to be greater than the value. + // We commit next_value_is_nonzero instead of next_value_is_zero since it'll be used as a selector for a lookup + pol commit next_value_is_nonzero; // @boolean + next_value_is_nonzero * (1 - next_value_is_nonzero) = 0; + pol NEXT_VALUE_IS_ZERO = 1 - next_value_is_nonzero; + + pol commit next_value_inv; // @zero-check + #[NEXT_VALUE_IS_ZERO_CHECK] + not_exists * (low_leaf_next_value * (NEXT_VALUE_IS_ZERO * (1 - next_value_inv) + next_value_inv) - 1 + NEXT_VALUE_IS_ZERO) = 0; + + #[LOW_LEAF_NEXT_VALUE_VALIDATION] + next_value_is_nonzero { low_leaf_next_value, siloed_value, sel } + in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; + + // ========= HANDLE REDUNDANT WRITES ========= + // sel_insert implies sel since write implies sel + pol commit sel_insert; // @boolean (by definition) + sel_insert = write * (1 - exists); + + // On a redundant write, the root must not change + write * exists * (root - write_root) = 0; + tree_size_after_write = tree_size_before_write + sel_insert; + + // ========= COMPUTE LOW LEAF UPDATE ========= + // These columns are unconstrained if sel_insert is 0 + pol commit updated_low_leaf_next_index; + pol commit updated_low_leaf_next_value; + sel_insert * (tree_size_before_write - updated_low_leaf_next_index) = 0; + sel_insert * (siloed_value - updated_low_leaf_next_value) = 0; + + // ========= LOW LEAF MERKLE CHECK & UPDATE ========= + // Unconstrained if sel_insert=0 + // Tracegen must set it to zero if sel_insert is 0 (precondition to merkle check). + pol commit updated_low_leaf_hash; + + #[LOW_LEAF_POSEIDON2] + sel { + low_leaf_value, low_leaf_next_value, low_leaf_next_index, + low_leaf_hash, const_three + } in poseidon2_hash.start { + poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, + poseidon2_hash.output, poseidon2_hash.input_len + }; + + #[UPDATED_LOW_LEAF_POSEIDON2] + sel_insert { + low_leaf_value, updated_low_leaf_next_value, updated_low_leaf_next_index, + updated_low_leaf_hash, const_three + } in poseidon2_hash.start { + poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, + poseidon2_hash.output, poseidon2_hash.input_len + }; + + pol commit low_leaf_index; + + // The intermediate root is the root of the tree after the low leaf update but before the new leaf is inserted. + // Unconstrained if sel_insert is 0. Tracegen must set it to zero in that case (precondition to merkle check). + pol commit intermediate_root; + + #[LOW_LEAF_MERKLE_CHECK] + sel { + sel_insert, low_leaf_hash, updated_low_leaf_hash, + low_leaf_index, tree_height, root, intermediate_root + } in merkle_check.start { + merkle_check.write, merkle_check.read_node, merkle_check.write_node, + merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root + }; + + // ========= NEW LEAF INSERTION ========= + // Unconstrained if sel_insert=0 + pol commit new_leaf_hash; + + #[NEW_LEAF_POSEIDON2] + sel_insert { + siloed_value, low_leaf_next_value, low_leaf_next_index, + new_leaf_hash, const_three + } in poseidon2_hash.start { + poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, + poseidon2_hash.output, poseidon2_hash.input_len + }; + + #[NEW_LEAF_MERKLE_CHECK] + sel_insert { + sel, precomputed.zero, new_leaf_hash, + tree_size_before_write, tree_height, intermediate_root, write_root + } in merkle_check.start { + merkle_check.write, merkle_check.read_node, merkle_check.write_node, + merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root + }; + + // ====== WRITE TO PUBLIC INPUTS ====== + pol commit sel_write_to_public_inputs; // @boolean (by definition) + sel_write_to_public_inputs = sel_insert * (1 - discard); + + #[WRITE_VALUE_TO_PUBLIC_INPUTS] + sel_write_to_public_inputs { + public_inputs_index, + siloed_value + } in public_inputs.sel { + precomputed.idx, + public_inputs.cols[0] + }; diff --git a/barretenberg/cpp/pil/vm2/trees/nullifier_check.pil b/barretenberg/cpp/pil/vm2/trees/nullifier_check.pil deleted file mode 100644 index 4c941fc8816e..000000000000 --- a/barretenberg/cpp/pil/vm2/trees/nullifier_check.pil +++ /dev/null @@ -1,271 +0,0 @@ -include "merkle_check.pil"; -include "../ff_gt.pil"; -include "../poseidon2_hash.pil"; -include "../constants_gen.pil"; -include "../precomputed.pil"; - -/** - * This gadget reads and writes in the nullifier tree. The nullifier tree is an indexed tree where leaves - * contain nullifiers. When we read from the nullifier tree, we check whether a nullifier exists or not. - * For this we perform a low leaf membership proof and: - * - if the low leaf nullifier is equal to the nullifier, that means that nullifier is present in the tree, and we assert that - * exists is true. - * - if the low leaf nullifier is not equal to the nullifier, we assert that the low leaf is indeed a valid low leaf for the - * requested nullifier, proving non existence of the nullifier in the tree. In that case we check exists is false. - * In order to validate that a leaf is a low leaf of the nullifier, we need to check that the low_leaf.nullifier is < nullifier - * and that low_leaf.next_nullifier is > nullifier. However, we need to consider the case where next_nullifier is zero, which - * means "infinity". The highest nullifier inserted in the tree will point to infinity as the "next_nullifier". - * In order to write, we perform the above, and also: - * - We update the low leaf. The low leaf must now point to the leaf we are going to insert. - * - We construct the new leaf and insert it into the tree at 'tree_size_before_write' - * Note: Indexed trees start prefilled with at least two items, so we can assume that no low leaf will be all zeroes - * and that there will always be a low leaf for any given value. - * - * Nullifiers can be optionally siloed with a contract address to bind them to their originating contract. - * - * Shape: - * One row per read or write operation. - * - * Errors: - * - Failing write: When exists == true on a write operation, the nullifier already exists in the tree. - * In this case, the write_root equals the input root and no tree update occurs. - * - * Read usage: - * sel { exists, - * nullifier, - * nullifier_tree_root, - * sel_silo, - * address // Can be omitted if sel_silo is precomputed.zero - * } in nullifier_check.sel { - * nullifier_check.exists, // Output - * nullifier_check.nullifier, // Input - * nullifier_check.root, // Input - * nullifier_check.sel_silo, // Input - * nullifier_check.address // Input (omit if sel_silo == 0) - * }; - * - * Write usage: - * pol commit error; - * - * sel { - * nullifier, - * prev_nullifier_tree_root, - * error, - * next_nullifier_tree_root, - * prev_nullifier_tree_size, - * discard, - * nullifier_index, - * sel_silo, - * address // Can be omitted if sel_silo is precomputed.zero - * } in nullifier_check.write { - * nullifier_check.nullifier, // Input - * nullifier_check.root, // Input - * nullifier_check.exists, // Output - * nullifier_check.write_root, // Output - * nullifier_check.tree_size_before_write,// Input - * nullifier_check.discard, // Input - * nullifier_check.nullifier_index, // Input - * nullifier_check.sel_silo, // Input - * nullifier_check.address // Input (omit if sel_silo == 0) - * }; - * - * Note: On a failing write (when exists == true), the write_root equals the input root and no tree update occurs. - * The address column should be omitted (or set to zero) when sel_silo == 0. - * The nullifier_index must always be provided on write as it's used for public input indexing. - * - * Preconditions: - * - low_leaf_index < 2^constants.NULLIFIER_TREE_HEIGHT (Merkle check requirement) - * - tree_size_before_write < 2^constants.NULLIFIER_TREE_HEIGHT (Merkle check requirement) - * - nullifier_index < constants.MAX_NULLIFIERS_PER_TX (public input indexing requirement) - * - The nullifier tree genesis state must have an irreproducible hash for uninitialized leaves (0). - * - * Interactions: - * - poseidon2_hash: Conditional siloing (sel_silo), low leaf hash, updated low leaf hash (sel_insert), new leaf hash (sel_insert) - * - merkle_check: Low leaf membership/update (sel_insert), new leaf insertion (sel_insert) - * - ff_gt: Low leaf nullifier validation (leaf_not_exists), next nullifier validation (next_nullifier_is_nonzero) - * - public_inputs: Write siloed nullifier to public inputs (sel_write_to_public_inputs) - * - **/ -namespace nullifier_check; - pol commit sel; // @boolean - sel * (1 - sel) = 0; - - #[skippable_if] - sel = 0; - - // ====== INPUTS ====== - pol commit write; // @boolean - write * (1 - write) = 0; - // Allows this gadget to be looked up by the write column - write * (1 - sel) = 0; - - pol commit nullifier; - pol commit root; - pol commit exists; // @boolean - exists * (1 - exists) = 0; - pol commit sel_silo; // @boolean - sel_silo * (1 - sel_silo) = 0; - pol commit address; - - // Write specific inputs - pol commit write_root; - pol commit tree_size_before_write; - pol commit discard; // @boolean - discard * (1 - discard) = 0; - pol commit nullifier_index; - - // ========= SILOING ========= - pol commit siloed_nullifier; - #[PASSTHROUGH_SILOING] - (1 - sel_silo) * (nullifier - siloed_nullifier) = 0; - - // Lookup constant support: Can be removed when we support constants in lookups. - pol commit siloing_separator; - sel * (constants.DOM_SEP__SILOED_NULLIFIER - siloing_separator) = 0; - pol commit const_three; - sel * (const_three - 3) = 0; - - #[SILO_POSEIDON2] - sel_silo { - siloing_separator, address, nullifier, - siloed_nullifier, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - // ========= LOW LEAF VALIDATION ========= - // Note: We don't validate that the low leaf is not empty. This is because we force hashing the low leaf for the - // membership check. An empty leaf would pass the low leaf validation, but the membership check would fail, - // since uninitialized leaves have hash 0, which is not the poseidon2 hash of an empty leaf. - // It is expected that no circuit introduces an empty leaf with its proper hash ever into an indexed tree. - // Doing so would break the tree as it'd be a valid low leaf for any insertion. - pol commit low_leaf_nullifier; - pol commit low_leaf_next_index; - pol commit low_leaf_next_nullifier; - pol commit low_leaf_hash; - - pol commit nullifier_low_leaf_nullifier_diff_inv; // @zero-check - pol NULLIFIER_LOW_LEAF_NULLIFIER_DIFF = siloed_nullifier - low_leaf_nullifier; - - // NULLIFIER_LOW_LEAF_NULLIFIER_DIFF == 0 <==> exists == 1 - #[EXISTS_CHECK] - sel * (NULLIFIER_LOW_LEAF_NULLIFIER_DIFF * (exists * (1 - nullifier_low_leaf_nullifier_diff_inv) + nullifier_low_leaf_nullifier_diff_inv) - 1 + exists) = 0; - - // If the leaf doesn't exist, we need to validate that the nullifier is greater than the low leaf nullifier - // We commit leaf not exists as well as exists since it'll be used as a selector for the following lookup - pol commit leaf_not_exists; // @boolean (by definition) - leaf_not_exists = sel * (1 - exists); - - #[LOW_LEAF_NULLIFIER_VALIDATION] - leaf_not_exists { siloed_nullifier, low_leaf_nullifier, sel } - in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; - - // If next nullifier is not zero (which would be infinity), it has to be greater than the nullifier. - // We commit next_nullifier_is_nonzero instead of next_nullifier_is_zero since it'll be used as a selector for a lookup - pol commit next_nullifier_is_nonzero; // @boolean - next_nullifier_is_nonzero * (1 - next_nullifier_is_nonzero) = 0; - pol NEXT_NULLIFIER_IS_ZERO = 1 - next_nullifier_is_nonzero; - - pol commit next_nullifier_inv; // @zero-check - #[NEXT_NULLIFIER_IS_ZERO_CHECK] - leaf_not_exists * (low_leaf_next_nullifier * (NEXT_NULLIFIER_IS_ZERO * (1 - next_nullifier_inv) + next_nullifier_inv) - 1 + NEXT_NULLIFIER_IS_ZERO) = 0; - - #[LOW_LEAF_NEXT_NULLIFIER_VALIDATION] - next_nullifier_is_nonzero { low_leaf_next_nullifier, siloed_nullifier, sel } - in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; - - // ========= HANDLE FAILING WRITES ========= - // sel_insert implies sel since write implies sel - pol commit sel_insert; // @boolean (by definition) - sel_insert = write * (1 - exists); - - // On a failing write, the root must not change - write * exists * (root - write_root) = 0; - - // ========= COMPUTE LOW LEAF UPDATE ========= - // These columns are unconstrained if sel_insert is 0 - pol commit updated_low_leaf_next_index; - pol commit updated_low_leaf_next_nullifier; - sel_insert * (tree_size_before_write - updated_low_leaf_next_index) = 0; - sel_insert * (siloed_nullifier - updated_low_leaf_next_nullifier) = 0; - - // ========= LOW LEAF MERKLE CHECK & UPDATE ========= - // Unconstrained if sel_insert=0 - // Tracegen must set it to zero if sel_insert is 0 (precondition to merkle check). - pol commit updated_low_leaf_hash; - - #[LOW_LEAF_POSEIDON2] - sel { - low_leaf_nullifier, low_leaf_next_nullifier, low_leaf_next_index, - low_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - #[UPDATED_LOW_LEAF_POSEIDON2] - sel_insert { - low_leaf_nullifier, updated_low_leaf_next_nullifier, updated_low_leaf_next_index, - updated_low_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - pol commit low_leaf_index; - - // The intermediate root is the root of the tree after the low leaf update but before the new leaf is inserted. - // Unconstrained if sel_insert is 0. Tracegen must set it to zero in that case (precondition to merkle check). - pol commit intermediate_root; - // Lookup constant support: Can be removed when we support constants in lookups. - pol commit tree_height; - sel * (tree_height - constants.NULLIFIER_TREE_HEIGHT) = 0; - - #[LOW_LEAF_MERKLE_CHECK] - sel { - sel_insert, low_leaf_hash, updated_low_leaf_hash, - low_leaf_index, tree_height, root, intermediate_root - } in merkle_check.start { - merkle_check.write, merkle_check.read_node, merkle_check.write_node, - merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root - }; - - // ========= NEW LEAF INSERTION ========= - // Unconstrained if sel_insert=0 - pol commit new_leaf_hash; - - #[NEW_LEAF_POSEIDON2] - sel_insert { - siloed_nullifier, low_leaf_next_nullifier, low_leaf_next_index, - new_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - #[NEW_LEAF_MERKLE_CHECK] - sel_insert { - sel, precomputed.zero, new_leaf_hash, - tree_size_before_write, tree_height, intermediate_root, write_root - } in merkle_check.start { - merkle_check.write, merkle_check.read_node, merkle_check.write_node, - merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root - }; - - // ====== WRITE TO PUBLIC INPUTS ====== - pol commit sel_write_to_public_inputs; // @boolean (by definition) - sel_write_to_public_inputs = sel_insert * (1 - discard); - - // Unconstrained if sel_write_to_public_inputs=0 - pol commit public_inputs_index; - sel_write_to_public_inputs * (constants.AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + nullifier_index - public_inputs_index) = 0; - - #[WRITE_NULLIFIER_TO_PUBLIC_INPUTS] - sel_write_to_public_inputs { - public_inputs_index, - siloed_nullifier - } in public_inputs.sel { - precomputed.idx, - public_inputs.cols[0] - }; diff --git a/barretenberg/cpp/pil/vm2/trees/retrieved_bytecodes_tree_check.pil b/barretenberg/cpp/pil/vm2/trees/retrieved_bytecodes_tree_check.pil deleted file mode 100644 index ed2d721d0383..000000000000 --- a/barretenberg/cpp/pil/vm2/trees/retrieved_bytecodes_tree_check.pil +++ /dev/null @@ -1,166 +0,0 @@ -include "merkle_check.pil"; - -include "../ff_gt.pil"; -include "../poseidon2_hash.pil"; -include "../constants_gen.pil"; -include "../precomputed.pil"; - -// This gadget is used to track the unique class ids that have been retrieved in the TX. -// It's a transient indexed tree that starts empty (with a prefill) on every transaction, -// and it's discarded at the end of the transaction execution. -// The leaves only contain the class id and the indexed tree pointers. -// -// Read usage: -// sel { -// class_id, -// leaf_not_exists, -// retrieved_bytecodes_tree_root -// } in retrieved_bytecodes_tree_check.sel { -// retrieved_bytecodes_tree_check.class_id, -// retrieved_bytecodes_tree_check.leaf_not_exists, -// retrieved_bytecodes_tree_check.root -// }; -// -// Write usage: -// sel { -// class_id, -// sel, // 1 -// prev_retrieved_bytecodes_tree_root, -// prev_retrieved_bytecodes_tree_size, -// next_retrieved_bytecodes_tree_root, -// next_retrieved_bytecodes_tree_size -// } in retrieved_bytecodes_tree_check.sel { -// retrieved_bytecodes_tree_check.class_id, -// retrieved_bytecodes_tree_check.write, -// retrieved_bytecodes_tree_check.root, -// retrieved_bytecodes_tree_check.tree_size_before_write, -// retrieved_bytecodes_tree_check.write_root, -// retrieved_bytecodes_tree_check.tree_size_after_write -// }; - -namespace retrieved_bytecodes_tree_check; - pol commit sel; - sel * (1 - sel) = 0; - - #[skippable_if] - sel = 0; - - // Inputs to the gadget - pol commit write; - write * (1 - write) = 0; - - pol commit class_id; - pol commit root; - pol commit leaf_not_exists; - leaf_not_exists * (1 - leaf_not_exists) = 0; - pol EXISTS = 1 - leaf_not_exists; - - // Write specific inputs - pol commit write_root; - pol commit tree_size_before_write; - pol commit tree_size_after_write; - - // Hints - pol commit low_leaf_class_id; - pol commit low_leaf_next_index; - pol commit low_leaf_next_class_id; - - pol commit updated_low_leaf_next_index; - pol commit updated_low_leaf_next_class_id; - - pol commit low_leaf_index; - - // ========= HANDLE REDUNDANT WRITES ========= - pol commit should_insert; - should_insert = write * leaf_not_exists; - // On a failing write, the root must not change - write * EXISTS * (root - write_root) = 0; - - tree_size_after_write = tree_size_before_write + should_insert; - - // ========= COMPUTE LOW LEAF UPDATE ========= - should_insert * (tree_size_before_write - updated_low_leaf_next_index) = 0; - should_insert * (class_id - updated_low_leaf_next_class_id) = 0; - - // ========= LOW LEAF MERKLE CHECK ========= - pol commit low_leaf_hash; - // The intermediate root is the root of the tree after the low leaf update but before the new leaf is inserted. - pol commit intermediate_root; - // Lookup constant support: Can be removed when we support constants in lookups. - pol commit tree_height; - sel * (constants.AVM_RETRIEVED_BYTECODES_TREE_HEIGHT - tree_height) = 0; - pol commit const_three; - sel * (const_three - 3) = 0; - - #[LOW_LEAF_POSEIDON2] - sel { - low_leaf_class_id, low_leaf_next_class_id, low_leaf_next_index, - low_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - pol commit updated_low_leaf_hash; - - #[UPDATED_LOW_LEAF_POSEIDON2] - should_insert { - low_leaf_class_id, updated_low_leaf_next_class_id, updated_low_leaf_next_index, - updated_low_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - #[LOW_LEAF_MERKLE_CHECK] - sel { should_insert, low_leaf_hash, updated_low_leaf_hash, - low_leaf_index, tree_height, root, intermediate_root } - in merkle_check.start { merkle_check.write, merkle_check.read_node, merkle_check.write_node, - merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root }; - - // ========= LOW LEAF VALIDATION ========= - pol commit class_id_low_leaf_class_id_diff_inv; - pol CLASS_ID_LOW_LEAF_CLASS_ID_DIFF = class_id - low_leaf_class_id; - - // CLASS_ID_LOW_LEAF_CLASS_ID_DIFF == 0 <==> EXISTS == 1 - #[EXISTS_CHECK] - sel * (CLASS_ID_LOW_LEAF_CLASS_ID_DIFF * (EXISTS * (1 - class_id_low_leaf_class_id_diff_inv) + class_id_low_leaf_class_id_diff_inv) - 1 + EXISTS) = 0; - - // If the leaf doesn't exist, we need to validate that the class id is greater than the low leaf class id - - #[LOW_LEAF_CLASS_ID_VALIDATION] - leaf_not_exists { class_id, low_leaf_class_id, sel } - in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; - - // If next class id is not zero (which would be infinity), it has to be greater than the class id. - // We commit next_class_id_is_nonzero instead of next_class_id_is_zero since it'll be used as a selector for a lookup - pol commit next_class_id_is_nonzero; - next_class_id_is_nonzero * (1 - next_class_id_is_nonzero) = 0; - pol NEXT_CLASS_ID_IS_ZERO = 1 - next_class_id_is_nonzero; - - pol commit next_class_id_inv; - #[NEXT_CLASS_ID_IS_ZERO_CHECK] - leaf_not_exists * (low_leaf_next_class_id * (NEXT_CLASS_ID_IS_ZERO * (1 - next_class_id_inv) + next_class_id_inv) - 1 + NEXT_CLASS_ID_IS_ZERO) = 0; - - #[LOW_LEAF_NEXT_CLASS_ID_VALIDATION] - next_class_id_is_nonzero { low_leaf_next_class_id, class_id, sel } - in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; - - // ========= NEW LEAF INSERTION ========= - pol commit new_leaf_hash; - - #[NEW_LEAF_POSEIDON2] - should_insert { - class_id, low_leaf_next_class_id, low_leaf_next_index, - new_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - #[NEW_LEAF_MERKLE_CHECK] - should_insert { sel, precomputed.zero, new_leaf_hash, - tree_size_before_write, tree_height, intermediate_root, write_root } - in merkle_check.start { merkle_check.write, merkle_check.read_node, merkle_check.write_node, - merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root }; - diff --git a/barretenberg/cpp/pil/vm2/trees/written_public_data_slots_tree_check.pil b/barretenberg/cpp/pil/vm2/trees/written_public_data_slots_tree_check.pil deleted file mode 100644 index c953cd88687a..000000000000 --- a/barretenberg/cpp/pil/vm2/trees/written_public_data_slots_tree_check.pil +++ /dev/null @@ -1,188 +0,0 @@ -include "merkle_check.pil"; - -include "../ff_gt.pil"; -include "../poseidon2_hash.pil"; -include "../constants_gen.pil"; -include "../precomputed.pil"; - -// This gadget is used to track the public data slots that have been written in the TX. -// It's a transient indexed tree that starts empty (with a prefill) on every transaction, -// and it's discarded at the end of the transaction execution. -// The leaves only contain the leaf slot (not the value) and the indexed tree pointers. -// -// Read usage: -// sel { -// contract_address, -// slot, -// leaf_not_exists, -// written_slots_root -// } in written_public_data_slots_tree_check.sel { -// written_public_data_slots_tree_check.address, -// written_public_data_slots_tree_check.slot, -// written_public_data_slots_tree_check.leaf_not_exists, -// written_public_data_slots_tree_check.root -// }; -// -// Write usage: -// sel { -// contract_address, -// slot, -// sel, -// prev_written_slots_root, -// prev_written_slots_tree_size, -// next_written_slots_root, -// next_written_slots_tree_size -// } in written_public_data_slots_tree_check.sel { -// written_public_data_slots_tree_check.address, -// written_public_data_slots_tree_check.slot, -// written_public_data_slots_tree_check.write, -// written_public_data_slots_tree_check.root, -// written_public_data_slots_tree_check.tree_size_before_write, -// written_public_data_slots_tree_check.write_root, -// written_public_data_slots_tree_check.tree_size_after_write -// }; - -namespace written_public_data_slots_tree_check; - pol commit sel; - sel * (1 - sel) = 0; - - #[skippable_if] - sel = 0; - - // Inputs to the gadget - pol commit write; - write * (1 - write) = 0; - - pol commit slot; - pol commit root; - pol commit leaf_not_exists; - leaf_not_exists * (1 - leaf_not_exists) = 0; - pol EXISTS = 1 - leaf_not_exists; - - pol commit address; - - // Write specific inputs - pol commit write_root; - pol commit tree_size_before_write; - pol commit tree_size_after_write; - - // Hints - pol commit low_leaf_slot; - pol commit low_leaf_next_index; - pol commit low_leaf_next_slot; - - pol commit updated_low_leaf_next_index; - pol commit updated_low_leaf_next_slot; - - pol commit low_leaf_index; - - // ========= SILOING ========= - pol commit leaf_slot; - - // Lookup constant support: Can be removed when we support constants in lookups. - pol commit siloing_separator; - sel * (constants.DOM_SEP__PUBLIC_LEAF_SLOT - siloing_separator) = 0; - pol commit const_three; - sel * (const_three - 3) = 0; - - #[SILO_POSEIDON2] - sel { - siloing_separator, address, slot, - leaf_slot, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - // ========= HANDLE REDUNDANT WRITES ========= - pol commit should_insert; - should_insert = write * leaf_not_exists; - // On a failing write, the root must not change - write * EXISTS * (root - write_root) = 0; - - tree_size_after_write = tree_size_before_write + should_insert; - - // ========= COMPUTE LOW LEAF UPDATE ========= - should_insert * (tree_size_before_write - updated_low_leaf_next_index) = 0; - should_insert * (leaf_slot - updated_low_leaf_next_slot) = 0; - - // ========= LOW LEAF MERKLE CHECK ========= - pol commit low_leaf_hash; - // The intermediate root is the root of the tree after the low leaf update but before the new leaf is inserted. - pol commit intermediate_root; - // Lookup constant support: Can be removed when we support constants in lookups. - pol commit tree_height; - sel * (constants.AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT - tree_height) = 0; - - #[LOW_LEAF_POSEIDON2] - sel { - low_leaf_slot, low_leaf_next_slot, low_leaf_next_index, - low_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - pol commit updated_low_leaf_hash; - - #[UPDATED_LOW_LEAF_POSEIDON2] - should_insert { - low_leaf_slot, updated_low_leaf_next_slot, updated_low_leaf_next_index, - updated_low_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - #[LOW_LEAF_MERKLE_CHECK] - sel { should_insert, low_leaf_hash, updated_low_leaf_hash, - low_leaf_index, tree_height, root, intermediate_root } - in merkle_check.start { merkle_check.write, merkle_check.read_node, merkle_check.write_node, - merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root }; - - // ========= LOW LEAF VALIDATION ========= - pol commit slot_low_leaf_slot_diff_inv; - pol SLOT_LOW_LEAF_SLOT_DIFF = leaf_slot - low_leaf_slot; - - // SLOT_LOW_LEAF_SLOT_DIFF == 0 <==> EXISTS == 1 - #[EXISTS_CHECK] - sel * (SLOT_LOW_LEAF_SLOT_DIFF * (EXISTS * (1 - slot_low_leaf_slot_diff_inv) + slot_low_leaf_slot_diff_inv) - 1 + EXISTS) = 0; - - // If the leaf doesn't exist, we need to validate that the slot is greater than the low leaf slot - - #[LOW_LEAF_SLOT_VALIDATION] - leaf_not_exists { leaf_slot, low_leaf_slot, sel } - in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; - - // If next slot is not zero (which would be infinity), it has to be greater than the slot. - // We commit next_slot_is_nonzero instead of next_slot_is_zero since it'll be used as a selector for a lookup - pol commit next_slot_is_nonzero; - next_slot_is_nonzero * (1 - next_slot_is_nonzero) = 0; - pol NEXT_SLOT_IS_ZERO = 1 - next_slot_is_nonzero; - - pol commit next_slot_inv; - #[NEXT_SLOT_IS_ZERO_CHECK] - leaf_not_exists * (low_leaf_next_slot * (NEXT_SLOT_IS_ZERO * (1 - next_slot_inv) + next_slot_inv) - 1 + NEXT_SLOT_IS_ZERO) = 0; - - #[LOW_LEAF_NEXT_SLOT_VALIDATION] - next_slot_is_nonzero { low_leaf_next_slot, leaf_slot, sel } - in ff_gt.sel_gt { ff_gt.a, ff_gt.b, ff_gt.result }; - - // ========= NEW LEAF INSERTION ========= - pol commit new_leaf_hash; - - #[NEW_LEAF_POSEIDON2] - should_insert { - leaf_slot, low_leaf_next_slot, low_leaf_next_index, - new_leaf_hash, const_three - } in poseidon2_hash.start { - poseidon2_hash.input_0, poseidon2_hash.input_1, poseidon2_hash.input_2, - poseidon2_hash.output, poseidon2_hash.input_len - }; - - #[NEW_LEAF_MERKLE_CHECK] - should_insert { sel, precomputed.zero, new_leaf_hash, - tree_size_before_write, tree_height, intermediate_root, write_root } - in merkle_check.start { merkle_check.write, merkle_check.read_node, merkle_check.write_node, - merkle_check.index, merkle_check.path_len, merkle_check.read_root, merkle_check.write_root }; - diff --git a/barretenberg/cpp/pil/vm2/tx.pil b/barretenberg/cpp/pil/vm2/tx.pil index 86281e0a99fc..51c542c14ea9 100644 --- a/barretenberg/cpp/pil/vm2/tx.pil +++ b/barretenberg/cpp/pil/vm2/tx.pil @@ -3,7 +3,7 @@ include "precomputed.pil"; include "constants_gen.pil"; include "execution.pil"; include "trees/note_hash_tree_check.pil"; -include "trees/nullifier_check.pil"; +include "trees/indexed_tree_check.pil"; include "trees/public_data_check.pil"; include "poseidon2_hash.pil"; include "calldata_hashing.pil"; @@ -61,7 +61,7 @@ include "ff_gt.pil"; * - public_inputs.pil: for reading the phase lengths, write side-effects, counters, etc. * - precomputed.pil: for reading the phase specifications. * - trees/note_hash_tree_check.pil: for handling note hashes emission. - * - trees/nullifier_check.pil: for handling nullifiers emission. + * - trees/indexed_tree_check.pil: for handling nullifiers emission. * - trees/public_data_check.pil: for handling public data reads/writes (fee-related). * - poseidon2_hash.pil: for deriving fee balance slot. * - calldata_hashing.pil: for hashing the calldata. @@ -533,6 +533,13 @@ namespace tx; pol commit should_nullifier_append; // @boolean (follows from definition) should_nullifier_append = should_try_nullifier_append * (1 - nullifier_limit_error); + pol commit write_nullifier_pi_offset; + should_nullifier_append * (constants.AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + prev_num_nullifiers_emitted - write_nullifier_pi_offset) = 0; + + // Lookup constant support: Can be removed when we support constants in lookups. + pol commit nullifier_tree_height; + should_nullifier_append * (nullifier_tree_height - constants.NULLIFIER_TREE_HEIGHT) = 0; + // We revert if the nullifier already exists. #[NULLIFIER_APPEND] should_nullifier_append { @@ -542,18 +549,19 @@ namespace tx; next_nullifier_tree_root, prev_nullifier_tree_size, discard, // from tx_discard.pil virtual trace - prev_num_nullifiers_emitted, + write_nullifier_pi_offset, + nullifier_tree_height, precomputed.zero - } in - nullifier_check.write { - nullifier_check.nullifier, - nullifier_check.root, - nullifier_check.exists, - nullifier_check.write_root, - nullifier_check.tree_size_before_write, - nullifier_check.discard, - nullifier_check.nullifier_index, - nullifier_check.sel_silo + } in indexed_tree_check.write { + indexed_tree_check.value, + indexed_tree_check.root, + indexed_tree_check.exists, + indexed_tree_check.write_root, + indexed_tree_check.tree_size_before_write, + indexed_tree_check.discard, + indexed_tree_check.public_inputs_index, + indexed_tree_check.tree_height, + indexed_tree_check.sel_silo }; // If reverted, the next state is unconstrained. This is okay since we are going to restore the state at the end of setup. diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.cpp index 36165769dc54..1cf51321b0c8 100644 --- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.cpp @@ -25,13 +25,9 @@ GadgetFuzzerContextHelper::GadgetFuzzerContextHelper(AztecAddress contract_addre , memory_provider(range_check, execution_id_manager, memory_emitter) , merkle_check(poseidon2, merkle_check_emitter) , poseidon2(execution_id_manager, greater_than, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter) - , written_public_data_slots_tree_check(poseidon2, - merkle_check, - field_gt, - build_public_data_slots_tree(), - written_public_data_slots_tree_check_emitter) - , retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, build_retrieved_bytecodes_tree(), retrieved_bytecodes_tree_check_emitter) + , indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_emitter) + , written_public_data_slots_tree_check(indexed_tree_check, build_public_data_slots_tree()) + , retrieved_bytecodes_tree_check(indexed_tree_check, build_retrieved_bytecodes_tree()) { global_variables = create_default_globals(); @@ -46,8 +42,6 @@ GadgetFuzzerContextHelper::GadgetFuzzerContextHelper(AztecAddress contract_addre UpdateCheck update_check( poseidon2, range_check, greater_than, merkle_db, update_check_emitter, hints.global_variables); - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, build_retrieved_bytecodes_tree(), retrieved_bytecodes_tree_check_emitter); ContractInstanceManager contract_instance_manager( contract_db, merkle_db, update_check, field_gt, hints.protocol_contracts, contract_instance_retrieval_emitter); InternalCallStackManagerProvider internal_call_stack_manager_provider(internal_call_stack_emitter); diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.hpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.hpp index e2b9545fc59b..f26a94786e13 100644 --- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.hpp +++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/context_helper.hpp @@ -10,6 +10,7 @@ #include "barretenberg/vm2/simulation/gadgets/contract_instance_manager.hpp" #include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" #include "barretenberg/vm2/simulation/gadgets/gt.hpp" +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/gadgets/internal_call_stack_manager.hpp" #include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp" #include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" @@ -87,17 +88,17 @@ class GadgetFuzzerContextHelper { EventEmitter update_check_emitter; EventEmitter merkle_check_emitter; EventEmitter contract_instance_retrieval_emitter; - EventEmitter written_public_data_slots_tree_check_emitter; + EventEmitter indexed_tree_check_emitter; EventEmitter bytecode_retrieval_emitter; EventEmitter bytecode_hashing_emitter; EventEmitter bytecode_decomposition_emitter; - EventEmitter retrieved_bytecodes_tree_check_emitter; EventEmitter calldata_event_emitter; DeduplicatingEventEmitter instruction_fetching_emitter; // Gadgets: MerkleCheck merkle_check; Poseidon2 poseidon2; + IndexedTreeCheck indexed_tree_check; WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check; RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check; std::unique_ptr tx_bytecode_manager; diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_retrieval.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_retrieval.test.cpp index ce1248073ee1..9ae0949af321 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_retrieval.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/bc_retrieval.test.cpp @@ -11,14 +11,16 @@ #include "barretenberg/vm2/constraining/testing/check_relation.hpp" #include "barretenberg/vm2/generated/columns.hpp" #include "barretenberg/vm2/generated/relations/bc_retrieval.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/simulation/lib/contract_crypto.hpp" +#include "barretenberg/vm2/simulation/lib/retrieved_bytecodes_tree.hpp" #include "barretenberg/vm2/testing/fixtures.hpp" #include "barretenberg/vm2/testing/macros.hpp" #include "barretenberg/vm2/tracegen/bytecode_trace.hpp" #include "barretenberg/vm2/tracegen/class_id_derivation_trace.hpp" #include "barretenberg/vm2/tracegen/contract_instance_retrieval_trace.hpp" +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" #include "barretenberg/vm2/tracegen/precomputed_trace.hpp" -#include "barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp" #include "barretenberg/vm2/tracegen/test_trace_container.hpp" namespace bb::avm2::constraining { @@ -29,12 +31,13 @@ using testing::random_contract_instance; using tracegen::BytecodeTraceBuilder; using tracegen::ClassIdDerivationTraceBuilder; using tracegen::ContractInstanceRetrievalTraceBuilder; -using tracegen::RetrievedBytecodesTreeCheckTraceBuilder; +using tracegen::IndexedTreeCheckTraceBuilder; using tracegen::TestTraceContainer; using simulation::ClassIdLeafValue; -using simulation::RetrievedBytecodesTreeCheckEvent; -using simulation::RetrievedBytecodesTreeLeafPreimage; +using simulation::IndexedTreeCheckEvent; +using simulation::IndexedTreeLeafData; +using simulation::IndexedTreeReadWriteEvent; using FF = AvmFlavorSettings::FF; using C = Column; @@ -59,7 +62,7 @@ TEST(BytecodeRetrievalConstrainingTest, SuccessfulRetrieval) BytecodeTraceBuilder builder; ContractInstanceRetrievalTraceBuilder contract_instance_retrieval_builder; ClassIdDerivationTraceBuilder class_id_builder; - RetrievedBytecodesTreeCheckTraceBuilder retrieved_bytecodes_tree_check_builder; + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; FF nullifier_root = FF::random_element(); FF public_data_tree_root = FF::random_element(); @@ -105,27 +108,37 @@ TEST(BytecodeRetrievalConstrainingTest, SuccessfulRetrieval) }; // Read the tree of the retrieved bytecodes - retrieved_bytecodes_tree_check_builder.process( - { RetrievedBytecodesTreeCheckEvent{ - .class_id = instance.current_contract_class_id, - .prev_snapshot = snapshot_before, - .next_snapshot = snapshot_after, - .low_leaf_preimage = RetrievedBytecodesTreeLeafPreimage(ClassIdLeafValue(0), 0, 0), - .low_leaf_index = 0, - } }, - trace); + indexed_tree_check_builder.process({ IndexedTreeReadWriteEvent{ + .value = instance.current_contract_class_id, + .prev_snapshot = snapshot_before, + .next_snapshot = snapshot_after, + .tree_height = AVM_RETRIEVED_BYTECODES_TREE_HEIGHT, + .low_leaf_data = + IndexedTreeLeafData{ + .value = 1, + .next_value = 0, + .next_index = 0, + }, + .low_leaf_index = 0, + } }, + trace); // Insertion in the retrieved bytecodes tree - retrieved_bytecodes_tree_check_builder.process( - { RetrievedBytecodesTreeCheckEvent{ - .class_id = instance.current_contract_class_id, - .prev_snapshot = snapshot_before, - .next_snapshot = snapshot_after, - .low_leaf_preimage = RetrievedBytecodesTreeLeafPreimage(ClassIdLeafValue(0), 0, 0), - .low_leaf_index = 0, - .write = true, - } }, - trace); + indexed_tree_check_builder.process({ IndexedTreeReadWriteEvent{ + .value = instance.current_contract_class_id, + .prev_snapshot = snapshot_before, + .next_snapshot = snapshot_after, + .tree_height = AVM_RETRIEVED_BYTECODES_TREE_HEIGHT, + .low_leaf_data = + IndexedTreeLeafData{ + .value = 1, + .next_value = 0, + .next_index = 0, + }, + .low_leaf_index = 0, + .write = true, + } }, + trace); // Build a bytecode retrieval event where instance exists builder.process_retrieval({ { diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/contract_instance_retrieval.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/contract_instance_retrieval.test.cpp index 5dd3f9b6d048..0f1d82eb07a2 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/contract_instance_retrieval.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/contract_instance_retrieval.test.cpp @@ -94,6 +94,8 @@ TEST(ContractInstanceRetrievalConstrainingTest, CompleteValidTrace) { C::contract_instance_retrieval_init_hash, init_hash }, { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root }, { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root }, + { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, { C::contract_instance_retrieval_nullifier_key_x, nullifier_key_x }, { C::contract_instance_retrieval_nullifier_key_y, nullifier_key_y }, { C::contract_instance_retrieval_incoming_viewing_key_x, incoming_viewing_key_x }, @@ -146,6 +148,8 @@ TEST(ContractInstanceRetrievalConstrainingTest, MultipleInstancesTrace) { C::contract_instance_retrieval_init_hash, contract_instance.initialization_hash }, { C::contract_instance_retrieval_public_data_tree_root, FF(base_public_data_tree_root + i) }, { C::contract_instance_retrieval_nullifier_tree_root, FF(base_nullifier_tree_root + i) }, + { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, { C::contract_instance_retrieval_nullifier_key_x, contract_instance.public_keys.nullifier_key.x }, { C::contract_instance_retrieval_nullifier_key_y, contract_instance.public_keys.nullifier_key.y }, { C::contract_instance_retrieval_incoming_viewing_key_x, @@ -195,6 +199,8 @@ TEST(ContractInstanceRetrievalConstrainingTest, NonExistentInstanceTrace) { C::contract_instance_retrieval_init_hash, 0 }, { C::contract_instance_retrieval_public_data_tree_root, public_data_tree_root }, { C::contract_instance_retrieval_nullifier_tree_root, nullifier_tree_root }, + { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, { C::contract_instance_retrieval_deployer_protocol_contract_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, // Protocol Contract conditionals @@ -253,6 +259,8 @@ TEST(ContractInstanceRetrievalConstrainingTest, MaximumFieldValuesTrace) { C::contract_instance_retrieval_init_hash, max_field }, { C::contract_instance_retrieval_public_data_tree_root, max_field }, { C::contract_instance_retrieval_nullifier_tree_root, max_field }, + { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, { C::contract_instance_retrieval_nullifier_key_x, max_field }, { C::contract_instance_retrieval_nullifier_key_y, max_field }, { C::contract_instance_retrieval_incoming_viewing_key_x, max_field }, @@ -432,12 +440,14 @@ TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenValidInstance trace.set( 1, { { // For deployment nullifier lookup - { C::nullifier_check_sel, 1 }, - { C::nullifier_check_exists, 1 }, - { C::nullifier_check_nullifier, contract_address }, - { C::nullifier_check_root, nullifier_tree_root }, - { C::nullifier_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, - { C::nullifier_check_sel_silo, 1 }, + { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_exists, 1 }, + { C::indexed_tree_check_value, contract_address }, + { C::indexed_tree_check_root, nullifier_tree_root }, + { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, + { C::indexed_tree_check_sel_silo, 1 }, + { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, // For address derivation lookup { C::address_derivation_sel, 1 }, { C::address_derivation_address, contract_address }, @@ -508,12 +518,14 @@ TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenNonExistentIn trace.set(1, { { // For deployment nullifier read lookup - { C::nullifier_check_sel, 1 }, - { C::nullifier_check_exists, 0 }, // Non-existent - { C::nullifier_check_nullifier, contract_address }, - { C::nullifier_check_root, nullifier_tree_root }, - { C::nullifier_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, - { C::nullifier_check_sel_silo, 1 }, + { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_exists, 0 }, // Non-existent + { C::indexed_tree_check_value, contract_address }, + { C::indexed_tree_check_root, nullifier_tree_root }, + { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, + { C::indexed_tree_check_sel_silo, 1 }, + { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, // For address derivation lookup { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist { C::address_derivation_address, contract_address }, @@ -586,12 +598,14 @@ TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenAddressZero) trace.set(1, { { // For deployment nullifier read lookup - { C::nullifier_check_sel, 1 }, - { C::nullifier_check_exists, 0 }, // Non-existent - { C::nullifier_check_nullifier, contract_address }, - { C::nullifier_check_root, nullifier_tree_root }, - { C::nullifier_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, - { C::nullifier_check_sel_silo, 1 }, + { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_exists, 0 }, // Non-existent + { C::indexed_tree_check_value, contract_address }, + { C::indexed_tree_check_root, nullifier_tree_root }, + { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, + { C::indexed_tree_check_sel_silo, 1 }, + { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, // For address derivation lookup { C::address_derivation_sel, 0 }, // Not selected since nullifier doesn't exist { C::address_derivation_address, contract_address }, @@ -673,12 +687,14 @@ TEST(ContractInstanceRetrievalConstrainingTest, IntegrationTracegenMultipleInsta trace.set( row, // For deployment nullifier read lookup - { { { C::nullifier_check_sel, 1 }, - { C::nullifier_check_exists, true }, - { C::nullifier_check_nullifier, FF(base_address + i) }, - { C::nullifier_check_root, FF(base_nullifier_tree_root + i) }, - { C::nullifier_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, - { C::nullifier_check_sel_silo, 1 }, + { { { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_exists, true }, + { C::indexed_tree_check_value, FF(base_address + i) }, + { C::indexed_tree_check_root, FF(base_nullifier_tree_root + i) }, + { C::indexed_tree_check_address, CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS }, + { C::indexed_tree_check_sel_silo, 1 }, + { C::indexed_tree_check_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::indexed_tree_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, // For address derivation lookup (only when nullifier exists) { C::address_derivation_sel, 1 }, { C::address_derivation_address, FF(base_address + i) }, diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/emit_nullifier.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/emit_nullifier.test.cpp index 15be4182447f..b1f539bafd07 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/emit_nullifier.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/emit_nullifier.test.cpp @@ -7,33 +7,35 @@ #include "barretenberg/vm2/constraining/flavor_settings.hpp" #include "barretenberg/vm2/constraining/testing/check_relation.hpp" #include "barretenberg/vm2/generated/relations/execution.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/lib/merkle.hpp" #include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" #include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" #include "barretenberg/vm2/testing/macros.hpp" #include "barretenberg/vm2/tracegen/execution_trace.hpp" -#include "barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp" +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" #include "barretenberg/vm2/tracegen/test_trace_container.hpp" namespace bb::avm2::constraining { namespace { using tracegen::ExecutionTraceBuilder; -using tracegen::NullifierTreeCheckTraceBuilder; +using tracegen::IndexedTreeCheckTraceBuilder; using tracegen::TestTraceContainer; using simulation::EventEmitter; +using simulation::IndexedTreeCheck; +using simulation::IndexedTreeCheckEvent; +using simulation::IndexedTreeLeafData; +using simulation::IndexedTreeSiloingParameters; using simulation::MockFieldGreaterThan; using simulation::MockMerkleCheck; using simulation::MockPoseidon2; using simulation::MockRangeCheck; -using simulation::NullifierTreeCheck; -using simulation::NullifierTreeCheckEvent; using simulation::NullifierTreeLeafPreimage; using testing::_; @@ -59,7 +61,11 @@ TEST(EmitNullifierConstrainingTest, Positive) { C::execution_prev_nullifier_tree_size, 1 }, { C::execution_nullifier_tree_size, 2 }, { C::execution_prev_num_nullifiers_emitted, prev_num_nullifiers_emitted }, + { C::execution_nullifier_pi_offset, + prev_num_nullifiers_emitted + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX }, { C::execution_num_nullifiers_emitted, prev_num_nullifiers_emitted + 1 }, + { C::execution_nullifier_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, } }); check_relation(trace); } @@ -79,6 +85,8 @@ TEST(EmitNullifierConstrainingTest, LimitReached) { C::execution_prev_nullifier_tree_size, 1 }, { C::execution_nullifier_tree_size, 1 }, { C::execution_prev_num_nullifiers_emitted, prev_num_nullifiers_emitted }, + { C::execution_nullifier_pi_offset, + prev_num_nullifiers_emitted + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX }, { C::execution_num_nullifiers_emitted, prev_num_nullifiers_emitted }, } }); check_relation(trace); @@ -122,11 +130,14 @@ TEST(EmitNullifierConstrainingTest, Interactions) StrictMock range_check; StrictMock field_gt; - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); FF nullifier = 42; - AztecAddress contract_address = 0xdeadbeef; + auto siloing_params = IndexedTreeSiloingParameters{ + .address = 0xdeadbeef, + .siloing_separator = DOM_SEP__SILOED_NULLIFIER, + }; FF siloed_nullifier = 66; FF low_leaf_nullifier = 99; // siloed nullifier != low leaf nullifier (NO COLLISION) FF low_leaf_hash = 77; @@ -157,16 +168,22 @@ TEST(EmitNullifierConstrainingTest, Interactions) EXPECT_CALL(merkle_check, write).WillOnce(Return(intermediate_root)).WillOnce(Return(post_write_root)); // low leaf preimage - NullifierTreeLeafPreimage low_leaf_preimage = { NullifierLeafValue(low_leaf_nullifier), 0, 0 }; - - AppendOnlyTreeSnapshot next_snapshot = nullifier_tree_check.write(nullifier, - contract_address, - prev_num_nullifiers_emitted, - low_leaf_preimage, - 0, - {}, - prev_snapshot, - insertion_sibling_path); + IndexedTreeLeafData low_leaf_preimage = { + .value = low_leaf_nullifier, + .next_value = 0, + .next_index = 0, + }; + std::vector low_leaf_sibling_path(NULLIFIER_TREE_HEIGHT); + + AppendOnlyTreeSnapshot next_snapshot = indexed_tree_check.write( + nullifier, + siloing_params, + prev_num_nullifiers_emitted + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX, + low_leaf_preimage, + 0, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path); TestTraceContainer trace({ { { C::execution_sel_execute_emit_nullifier, 1 }, @@ -177,16 +194,20 @@ TEST(EmitNullifierConstrainingTest, Interactions) { C::execution_sel_opcode_error, 0 }, // No errors! { C::execution_subtrace_operation_id, AVM_EXEC_OP_ID_EMIT_NULLIFIER }, { C::execution_prev_num_nullifiers_emitted, prev_num_nullifiers_emitted }, + { C::execution_nullifier_pi_offset, + prev_num_nullifiers_emitted + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX }, { C::execution_num_nullifiers_emitted, prev_num_nullifiers_emitted + 1 }, // increment on success { C::execution_prev_nullifier_tree_root, prev_snapshot.root }, { C::execution_nullifier_tree_root, next_snapshot.root }, { C::execution_prev_nullifier_tree_size, prev_snapshot.next_available_leaf_index }, { C::execution_nullifier_tree_size, next_snapshot.next_available_leaf_index }, - { C::execution_contract_address, contract_address }, + { C::execution_contract_address, siloing_params.address }, + { C::execution_nullifier_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_trace_builder; - nullifier_tree_check_trace_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); + IndexedTreeCheckTraceBuilder indexed_tree_check_trace_builder; + indexed_tree_check_trace_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); check_relation(trace); check_interaction(trace); @@ -199,11 +220,14 @@ TEST(EmitNullifierConstrainingTest, InteractionsCollision) StrictMock range_check; StrictMock field_gt; - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); FF nullifier = 42; - AztecAddress contract_address = 0xdeadbeef; + auto siloing_params = IndexedTreeSiloingParameters{ + .address = 0xdeadbeef, + .siloing_separator = DOM_SEP__SILOED_NULLIFIER, + }; FF siloed_nullifier = 66; FF low_leaf_hash = 77; FF pre_write_root = 27; @@ -220,16 +244,23 @@ TEST(EmitNullifierConstrainingTest, InteractionsCollision) EXPECT_CALL(merkle_check, assert_membership).WillOnce(Return()); // low leaf preimage - NullifierTreeLeafPreimage low_leaf_preimage = { NullifierLeafValue(siloed_nullifier), 0, 0 }; + IndexedTreeLeafData low_leaf_preimage = { + .value = siloed_nullifier, + .next_value = 0, + .next_index = 0, + }; + + std::vector low_leaf_sibling_path(NULLIFIER_TREE_HEIGHT); - AppendOnlyTreeSnapshot next_snapshot = nullifier_tree_check.write(nullifier, - contract_address, - prev_num_nullifiers_emitted, - low_leaf_preimage, - 0, - {}, - prev_snapshot, - std::nullopt); + AppendOnlyTreeSnapshot next_snapshot = indexed_tree_check.write( + nullifier, + siloing_params, + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + prev_num_nullifiers_emitted, + low_leaf_preimage, + 0, + low_leaf_sibling_path, + prev_snapshot, + std::nullopt); TestTraceContainer trace({ { { C::execution_sel_execute_emit_nullifier, 1 }, @@ -240,16 +271,20 @@ TEST(EmitNullifierConstrainingTest, InteractionsCollision) { C::execution_sel_opcode_error, 1 }, // collision { C::execution_subtrace_operation_id, AVM_EXEC_OP_ID_EMIT_NULLIFIER }, { C::execution_prev_num_nullifiers_emitted, prev_num_nullifiers_emitted }, + { C::execution_nullifier_pi_offset, + prev_num_nullifiers_emitted + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX }, { C::execution_num_nullifiers_emitted, prev_num_nullifiers_emitted }, // No increment on error { C::execution_prev_nullifier_tree_root, prev_snapshot.root }, { C::execution_nullifier_tree_root, next_snapshot.root }, { C::execution_prev_nullifier_tree_size, prev_snapshot.next_available_leaf_index }, { C::execution_nullifier_tree_size, next_snapshot.next_available_leaf_index }, - { C::execution_contract_address, contract_address }, + { C::execution_contract_address, siloing_params.address }, + { C::execution_nullifier_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_trace_builder; - nullifier_tree_check_trace_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); + IndexedTreeCheckTraceBuilder indexed_tree_check_trace_builder; + indexed_tree_check_trace_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); check_relation(trace); check_interaction(trace); diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/indexed_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/indexed_tree_check.test.cpp new file mode 100644 index 000000000000..3b8ae6267df6 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/indexed_tree_check.test.cpp @@ -0,0 +1,398 @@ +#include +#include + +#include + +#include "barretenberg/crypto/poseidon2/poseidon2.hpp" +#include "barretenberg/vm2/constraining/flavor_settings.hpp" +#include "barretenberg/vm2/constraining/testing/check_relation.hpp" +#include "barretenberg/vm2/generated/relations/indexed_tree_check.hpp" +#include "barretenberg/vm2/simulation/events/event_emitter.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" +#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" +#include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp" +#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" +#include "barretenberg/vm2/simulation/lib/merkle.hpp" +#include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp" +#include "barretenberg/vm2/simulation/testing/mock_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" +#include "barretenberg/vm2/testing/fixtures.hpp" +#include "barretenberg/vm2/testing/macros.hpp" +#include "barretenberg/vm2/testing/test_tree.hpp" +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" +#include "barretenberg/vm2/tracegen/test_trace_container.hpp" + +namespace bb::avm2::constraining { +namespace { + +using ::testing::NiceMock; +using ::testing::TestWithParam; + +using testing::TestMemoryTree; + +using simulation::EventEmitter; +using simulation::FieldGreaterThan; +using simulation::FieldGreaterThanEvent; +using simulation::IndexedTreeCheck; +using simulation::IndexedTreeCheckEvent; +using simulation::IndexedTreeLeafData; +using simulation::IndexedTreeSiloingParameters; +using simulation::MerkleCheck; +using simulation::MerkleCheckEvent; +using simulation::MockExecutionIdManager; +using simulation::MockGreaterThan; +using simulation::MockRangeCheck; +using simulation::NoopEventEmitter; +using simulation::Poseidon2; +using simulation::Poseidon2HashEvent; +using simulation::Poseidon2PermutationEvent; +using simulation::Poseidon2PermutationMemoryEvent; +using simulation::unconstrained_root_from_path; + +using tracegen::IndexedTreeCheckTraceBuilder; +using tracegen::TestTraceContainer; + +using FF = AvmFlavorSettings::FF; +using C = Column; +using IndexedTreeCheckRelation = bb::avm2::indexed_tree_check; +using RawPoseidon2 = crypto::Poseidon2; + +TEST(IndexedTreeCheckConstrainingTest, EmptyRow) +{ + check_relation(testing::empty_trace()); +} + +struct TestParams { + FF value; + bool exists; + IndexedTreeLeafData low_leaf; +}; + +std::vector positive_read_tests = { + // Exists = true, leaf pointers to infinity + TestParams{ .value = 42, .exists = true, .low_leaf = { .value = 42, .next_value = 0, .next_index = 0 } }, + // Exists = true, leaf points to higher value + TestParams{ .value = 42, .exists = true, .low_leaf = { .value = 42, .next_value = 50, .next_index = 28 } }, + // Exists = false, low leaf points to infinity + TestParams{ .value = 42, .exists = false, .low_leaf = { .value = 10, .next_value = 0, .next_index = 0 } }, + // Exists = false, low leaf points to higher value + TestParams{ .value = 42, .exists = false, .low_leaf = { .value = 10, .next_value = 50, .next_index = 28 } } +}; + +class IndexedTreeReadPositiveTests : public TestWithParam {}; + +TEST_P(IndexedTreeReadPositiveTests, Positive) +{ + const auto& param = GetParam(); + + NoopEventEmitter hash_event_emitter; + NoopEventEmitter perm_event_emitter; + NoopEventEmitter perm_mem_event_emitter; + + NiceMock mock_gt; + NiceMock mock_exec_id_manager; + Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); + NoopEventEmitter merkle_event_emitter; + MerkleCheck merkle_check(poseidon2, merkle_event_emitter); + + NiceMock range_check; + + NoopEventEmitter field_gt_event_emitter; + FieldGreaterThan field_gt(range_check, field_gt_event_emitter); + + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check_simulator(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); + + TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; + + FF low_leaf_hash = poseidon2.hash(param.low_leaf.get_hash_inputs()); + uint64_t leaf_index = 30; + std::vector sibling_path; + sibling_path.reserve(NULLIFIER_TREE_HEIGHT); + for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { + sibling_path.emplace_back(i); + } + FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); + + indexed_tree_check_simulator.assert_read(param.value, + /*siloing_params*/ std::nullopt, + param.exists, + param.low_leaf, + leaf_index, + sibling_path, + AppendOnlyTreeSnapshot{ .root = root, .next_available_leaf_index = 128 }); + + indexed_tree_check_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); + EXPECT_EQ(trace.get_num_rows(), 1); + + check_relation(trace); +} + +INSTANTIATE_TEST_SUITE_P(IndexedTreeCheckConstrainingTest, + IndexedTreeReadPositiveTests, + ::testing::ValuesIn(positive_read_tests)); + +TEST(IndexedTreeCheckConstrainingTest, PositiveWriteAppend) +{ + NoopEventEmitter hash_event_emitter; + NoopEventEmitter perm_event_emitter; + NoopEventEmitter perm_mem_event_emitter; + + NiceMock mock_gt; + NiceMock mock_exec_id_manager; + Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); + NoopEventEmitter merkle_event_emitter; + MerkleCheck merkle_check(poseidon2, merkle_event_emitter); + + NiceMock range_check; + + NoopEventEmitter field_gt_event_emitter; + FieldGreaterThan field_gt(range_check, field_gt_event_emitter); + + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check_simulator(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); + + TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; + + FF value = 100; + FF low_value = 40; + TestMemoryTree tree(8, NULLIFIER_TREE_HEIGHT); + + IndexedTreeLeafData low_leaf = { .value = low_value, .next_value = value + 1, .next_index = 10 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 0; + tree.update_element(low_leaf_index, low_leaf_hash); + + AppendOnlyTreeSnapshot prev_snapshot = + AppendOnlyTreeSnapshot{ .root = tree.root(), .next_available_leaf_index = 128 }; + std::vector low_leaf_sibling_path = tree.get_sibling_path(low_leaf_index); + + IndexedTreeLeafData updated_low_leaf = low_leaf; + updated_low_leaf.next_index = prev_snapshot.next_available_leaf_index; + updated_low_leaf.next_value = value; + FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); + tree.update_element(low_leaf_index, updated_low_leaf_hash); + + std::vector insertion_sibling_path = tree.get_sibling_path(prev_snapshot.next_available_leaf_index); + + IndexedTreeLeafData new_leaf = { .value = value, + .next_value = low_leaf.next_value, + .next_index = low_leaf.next_index }; + FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); + tree.update_element(prev_snapshot.next_available_leaf_index, new_leaf_hash); + + indexed_tree_check_simulator.write(value, + /*siloing_params*/ std::nullopt, + 0, + low_leaf, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path); + + indexed_tree_check_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); + + EXPECT_EQ(trace.get_num_rows(), 1); + + check_relation(trace); +} + +TEST(IndexedTreeCheckConstrainingTest, PositiveWriteMembership) +{ + FF value = 42; + IndexedTreeLeafData low_leaf = { .value = 42, .next_value = 0, .next_index = 0 }; + + NoopEventEmitter hash_event_emitter; + NoopEventEmitter perm_event_emitter; + NoopEventEmitter perm_mem_event_emitter; + + NiceMock mock_gt; + NiceMock mock_exec_id_manager; + Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); + NoopEventEmitter merkle_event_emitter; + MerkleCheck merkle_check(poseidon2, merkle_event_emitter); + + NiceMock range_check; + + NoopEventEmitter field_gt_event_emitter; + FieldGreaterThan field_gt(range_check, field_gt_event_emitter); + + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check_simulator(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); + + TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; + + FF low_leaf_hash = poseidon2.hash(low_leaf.get_hash_inputs()); + uint64_t leaf_index = 30; + std::vector sibling_path; + sibling_path.reserve(NULLIFIER_TREE_HEIGHT); + for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { + sibling_path.emplace_back(i); + } + FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); + + indexed_tree_check_simulator.write(value, + std::nullopt, + 10, + low_leaf, + leaf_index, + sibling_path, + AppendOnlyTreeSnapshot{ .root = root, .next_available_leaf_index = 128 }, + /* insertion_sibling_path */ std::nullopt); + + indexed_tree_check_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); + EXPECT_EQ(trace.get_num_rows(), 1); + + check_relation(trace); +} + +TEST(IndexedTreeCheckConstrainingTest, Siloing) +{ + AztecAddress contract_address = 1; + FF value = 42; + FF siloed_value = RawPoseidon2::hash({ DOM_SEP__SILOED_NULLIFIER, FF(contract_address), value }); + IndexedTreeLeafData low_leaf = { .value = siloed_value, .next_value = 0, .next_index = 0 }; + + NoopEventEmitter hash_event_emitter; + NoopEventEmitter perm_event_emitter; + NoopEventEmitter perm_mem_event_emitter; + + NiceMock mock_gt; + NiceMock mock_exec_id_manager; + Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); + NoopEventEmitter merkle_event_emitter; + MerkleCheck merkle_check(poseidon2, merkle_event_emitter); + + NiceMock range_check; + + NoopEventEmitter field_gt_event_emitter; + FieldGreaterThan field_gt(range_check, field_gt_event_emitter); + + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check_simulator(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); + + TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; + + FF low_leaf_hash = poseidon2.hash(low_leaf.get_hash_inputs()); + uint64_t leaf_index = 30; + std::vector sibling_path; + sibling_path.reserve(NULLIFIER_TREE_HEIGHT); + for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { + sibling_path.emplace_back(i); + } + FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); + + indexed_tree_check_simulator.write( + value, + IndexedTreeSiloingParameters{ .address = contract_address, .siloing_separator = DOM_SEP__SILOED_NULLIFIER }, + 10, + low_leaf, + leaf_index, + sibling_path, + AppendOnlyTreeSnapshot{ .root = root, .next_available_leaf_index = 128 }, + /* insertion_sibling_path */ std::nullopt); + + indexed_tree_check_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); + EXPECT_EQ(trace.get_num_rows(), 1); + + check_relation(trace); +} + +TEST(IndexedTreeCheckConstrainingTest, NegativeExistsFlagCheck) +{ + // Test constraint: sel * (VALUE_LOW_LEAF_VALUE_DIFF * (exists * (1 - value_low_leaf_value_diff_inv) + // + value_low_leaf_value_diff_inv) - 1 + exists) = 0 + TestTraceContainer trace({ + { { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_siloed_value, 27 }, + { C::indexed_tree_check_low_leaf_value, 27 }, + { C::indexed_tree_check_value_low_leaf_value_diff_inv, 0 }, + { C::indexed_tree_check_exists, 1 } }, + { { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_siloed_value, 28 }, + { C::indexed_tree_check_low_leaf_value, 27 }, + { C::indexed_tree_check_value_low_leaf_value_diff_inv, FF(1).invert() }, + { C::indexed_tree_check_exists, 0 } }, + }); + + check_relation(trace, IndexedTreeCheckRelation::SR_EXISTS_CHECK); + trace.set(C::indexed_tree_check_exists, 0, 0); + + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, IndexedTreeCheckRelation::SR_EXISTS_CHECK), "EXISTS_CHECK"); + trace.set(C::indexed_tree_check_exists, 0, 1); + trace.set(C::indexed_tree_check_exists, 1, 1); + + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, IndexedTreeCheckRelation::SR_EXISTS_CHECK), "EXISTS_CHECK"); +} + +TEST(IndexedTreeCheckConstrainingTest, NegativeNextValueIsZero) +{ + // Test constraint: not_exists * (low_leaf_next_value * (NEXT_VALUE_IS_ZERO * (1 - next_value_inv) + // + next_value_inv) - 1 + NEXT_VALUE_IS_ZERO) = 0 + TestTraceContainer trace({ + { + { C::indexed_tree_check_not_exists, 1 }, + { C::indexed_tree_check_low_leaf_next_value, 0 }, + { C::indexed_tree_check_next_value_inv, 0 }, + { C::indexed_tree_check_next_value_is_nonzero, 0 }, + }, + { + { C::indexed_tree_check_not_exists, 1 }, + { C::indexed_tree_check_low_leaf_next_value, 1 }, + { C::indexed_tree_check_next_value_inv, FF(1).invert() }, + { C::indexed_tree_check_next_value_is_nonzero, 1 }, + }, + }); + + check_relation(trace, IndexedTreeCheckRelation::SR_NEXT_VALUE_IS_ZERO_CHECK); + + trace.set(C::indexed_tree_check_next_value_is_nonzero, 0, 1); + + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, IndexedTreeCheckRelation::SR_NEXT_VALUE_IS_ZERO_CHECK), + "NEXT_VALUE_IS_ZERO_CHECK"); + + trace.set(C::indexed_tree_check_next_value_is_nonzero, 0, 0); + trace.set(C::indexed_tree_check_next_value_is_nonzero, 1, 0); + + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, IndexedTreeCheckRelation::SR_NEXT_VALUE_IS_ZERO_CHECK), + "NEXT_VALUE_IS_ZERO_CHECK"); +} + +TEST(IndexedTreeCheckConstrainingTest, NegativePassthroughSiloing) +{ + // Test constraint: (1 - sel_silo) * (value - siloed_value) = 0 + TestTraceContainer trace({ + { + { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_sel_silo, 1 }, + { C::indexed_tree_check_value, 27 }, + { C::indexed_tree_check_siloed_value, 42 }, + }, + { + { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_sel_silo, 0 }, + { C::indexed_tree_check_value, 27 }, + { C::indexed_tree_check_siloed_value, 27 }, + }, + }); + + check_relation(trace, IndexedTreeCheckRelation::SR_PASSTHROUGH_SILOING); + + trace.set(C::indexed_tree_check_siloed_value, 1, 28); + + EXPECT_THROW_WITH_MESSAGE( + check_relation(trace, IndexedTreeCheckRelation::SR_PASSTHROUGH_SILOING), + "PASSTHROUGH_SILOING"); +} + +} // namespace +} // namespace bb::avm2::constraining diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_exists.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_exists.test.cpp index 2e4b65f70d1f..52558163567b 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_exists.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_exists.test.cpp @@ -11,31 +11,32 @@ #include "barretenberg/vm2/simulation/gadgets/execution.hpp" #include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" #include "barretenberg/vm2/simulation/interfaces/db.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" #include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" #include "barretenberg/vm2/testing/macros.hpp" #include "barretenberg/vm2/tracegen/execution_trace.hpp" -#include "barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp" +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" #include "barretenberg/vm2/tracegen/test_trace_container.hpp" namespace bb::avm2::constraining { namespace { using tracegen::ExecutionTraceBuilder; -using tracegen::NullifierTreeCheckTraceBuilder; +using tracegen::IndexedTreeCheckTraceBuilder; using tracegen::TestTraceContainer; using simulation::DeduplicatingEventEmitter; using simulation::EventEmitter; using simulation::FieldGreaterThan; using simulation::FieldGreaterThanEvent; +using simulation::IndexedTreeCheck; +using simulation::IndexedTreeCheckEvent; +using simulation::IndexedTreeLeafData; using simulation::MockMerkleCheck; using simulation::MockPoseidon2; using simulation::MockRangeCheck; -using simulation::NullifierTreeCheck; -using simulation::NullifierTreeCheckEvent; using NullifierLeafValue = crypto::merkle_tree::NullifierLeafValue; using NullifierTreeLeafPreimage = simulation::NullifierTreeLeafPreimage; @@ -55,6 +56,7 @@ TEST(NullifierExistsConstrainingTest, PositiveTest) { C::execution_prev_nullifier_tree_root, FF(0xabc) }, { C::execution_mem_tag_reg_0_, static_cast(MemoryTag::FF) }, { C::execution_mem_tag_reg_1_, static_cast(MemoryTag::U1) }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, { C::execution_sel_opcode_error, 0 }, { C::execution_subtrace_operation_id, AVM_EXEC_OP_ID_NULLIFIER_EXISTS } } }); check_relation(trace); @@ -69,6 +71,7 @@ TEST(NullifierExistsConstrainingTest, PositiveNullifierNotExists) { C::execution_prev_nullifier_tree_root, FF(0xabc) }, { C::execution_mem_tag_reg_0_, static_cast(MemoryTag::FF) }, { C::execution_mem_tag_reg_1_, static_cast(MemoryTag::U1) }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, { C::execution_sel_opcode_error, 0 }, { C::execution_subtrace_operation_id, AVM_EXEC_OP_ID_NULLIFIER_EXISTS } } }); check_relation(trace); @@ -83,6 +86,7 @@ TEST(NullifierExistsConstrainingTest, NegativeInvalidOutputTag) { C::execution_prev_nullifier_tree_root, FF(0xabc) }, { C::execution_mem_tag_reg_0_, static_cast(MemoryTag::FF) }, { C::execution_mem_tag_reg_1_, static_cast(MemoryTag::U8) }, // WRONG! + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, { C::execution_sel_opcode_error, 0 }, { C::execution_subtrace_operation_id, AVM_EXEC_OP_ID_NULLIFIER_EXISTS } } }); EXPECT_THROW_WITH_MESSAGE( @@ -110,23 +114,34 @@ TEST(NullifierExistsConstrainingTest, Interactions) DeduplicatingEventEmitter event_emitter; FieldGreaterThan field_gt(range_check, event_emitter); - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); // Siloed nullifier (no siloing happens in the opcode now) FF siloed_nullifier = 42; // For exists=true, the low leaf's nullifier must match the searched nullifier - NullifierTreeLeafPreimage low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(siloed_nullifier), 0, 0); + IndexedTreeLeafData low_leaf = { + .value = siloed_nullifier, + .next_value = 0, + .next_index = 0, + }; AppendOnlyTreeSnapshot nullifier_tree_snapshot = AppendOnlyTreeSnapshot{ .root = 42, .next_available_leaf_index = 128, }; - // sel_silo=false (address unused when not siloing) - nullifier_tree_check.assert_read( - siloed_nullifier, /*contract_address=*/std::nullopt, /*exists=*/true, low_leaf, 0, {}, nullifier_tree_snapshot); + std::vector sibling_path(NULLIFIER_TREE_HEIGHT); + + // sel_silo=false + indexed_tree_check.assert_read(siloed_nullifier, + /*siloing_params=*/std::nullopt, + /*exists=*/true, + low_leaf, + 0, + sibling_path, + nullifier_tree_snapshot); TestTraceContainer trace({ { { C::execution_sel_execute_nullifier_exists, 1 }, @@ -135,12 +150,13 @@ TEST(NullifierExistsConstrainingTest, Interactions) { C::execution_mem_tag_reg_0_, static_cast(MemoryTag::FF) }, { C::execution_mem_tag_reg_1_, static_cast(MemoryTag::U1) }, { C::execution_prev_nullifier_tree_root, nullifier_tree_snapshot.root }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, { C::execution_sel_opcode_error, 0 }, { C::execution_subtrace_operation_id, AVM_EXEC_OP_ID_NULLIFIER_EXISTS }, } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_trace_builder; - nullifier_tree_check_trace_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); + IndexedTreeCheckTraceBuilder indexed_tree_check_trace_builder; + indexed_tree_check_trace_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); check_relation(trace); diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_tree_check.test.cpp deleted file mode 100644 index 181c87c0e509..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/nullifier_tree_check.test.cpp +++ /dev/null @@ -1,402 +0,0 @@ -#include -#include - -#include -#include - -#include "barretenberg/crypto/poseidon2/poseidon2.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/constraining/flavor_settings.hpp" -#include "barretenberg/vm2/constraining/testing/check_relation.hpp" -#include "barretenberg/vm2/generated/relations/merkle_check.hpp" -#include "barretenberg/vm2/generated/relations/nullifier_check.hpp" -#include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/lib/merkle.hpp" -#include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp" -#include "barretenberg/vm2/simulation/testing/mock_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" -#include "barretenberg/vm2/testing/fixtures.hpp" -#include "barretenberg/vm2/testing/macros.hpp" -#include "barretenberg/vm2/testing/test_tree.hpp" -#include "barretenberg/vm2/tracegen/field_gt_trace.hpp" -#include "barretenberg/vm2/tracegen/merkle_check_trace.hpp" -#include "barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp" -#include "barretenberg/vm2/tracegen/poseidon2_trace.hpp" -#include "barretenberg/vm2/tracegen/test_trace_container.hpp" - -namespace bb::avm2::constraining { -namespace { - -using ::testing::NiceMock; -using ::testing::TestWithParam; - -using testing::TestMemoryTree; - -using simulation::EventEmitter; -using simulation::ExecutionIdManager; -using simulation::FieldGreaterThan; -using simulation::FieldGreaterThanEvent; -using simulation::MerkleCheck; -using simulation::MerkleCheckEvent; -using simulation::MockExecutionIdManager; -using simulation::MockGreaterThan; -using simulation::MockRangeCheck; -using simulation::NoopEventEmitter; -using simulation::NullifierTreeCheck; -using simulation::NullifierTreeCheckEvent; -using simulation::NullifierTreeLeafPreimage; -using simulation::Poseidon2; -using simulation::Poseidon2HashEvent; -using simulation::Poseidon2PermutationEvent; -using simulation::Poseidon2PermutationMemoryEvent; -using simulation::unconstrained_root_from_path; - -using tracegen::NullifierTreeCheckTraceBuilder; -using tracegen::TestTraceContainer; - -using FF = AvmFlavorSettings::FF; -using C = Column; -using nullifier_check = bb::avm2::nullifier_check; -using RawPoseidon2 = crypto::Poseidon2; - -TEST(NullifierTreeCheckConstrainingTest, EmptyRow) -{ - check_relation(testing::empty_trace()); -} - -struct TestParams { - FF nullifier; - bool exists; - NullifierTreeLeafPreimage low_leaf; -}; - -std::vector positive_read_tests = { - // Exists = true, leaf pointers to infinity - TestParams{ .nullifier = 42, .exists = true, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 0, 0) }, - // Exists = true, leaf points to higher value - TestParams{ - .nullifier = 42, .exists = true, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 28, 50) }, - // Exists = false, low leaf points to infinity - TestParams{ .nullifier = 42, .exists = false, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(10), 0, 0) }, - // Exists = false, low leaf points to higher value - TestParams{ - .nullifier = 42, .exists = false, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(10), 28, 50) } -}; - -class NullifierReadPositiveTests : public TestWithParam {}; - -TEST_P(NullifierReadPositiveTests, Positive) -{ - const auto& param = GetParam(); - - NoopEventEmitter hash_event_emitter; - NoopEventEmitter perm_event_emitter; - NoopEventEmitter perm_mem_event_emitter; - - NiceMock mock_gt; - NiceMock mock_exec_id_manager; - Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); - NoopEventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - NoopEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check_simulator( - poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_builder; - - FF low_leaf_hash = poseidon2.hash(param.low_leaf.get_hash_inputs()); - uint64_t leaf_index = 30; - std::vector sibling_path; - sibling_path.reserve(NULLIFIER_TREE_HEIGHT); - for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { - sibling_path.emplace_back(i); - } - FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); - - nullifier_tree_check_simulator.assert_read( - param.nullifier, - /*contract_address*/ std::nullopt, - param.exists, - param.low_leaf, - leaf_index, - sibling_path, - AppendOnlyTreeSnapshot{ .root = root, .next_available_leaf_index = 128 }); - - nullifier_tree_check_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); - EXPECT_EQ(trace.get_num_rows(), 1); - - check_relation(trace); -} - -INSTANTIATE_TEST_SUITE_P(NullifierTreeCheckConstrainingTest, - NullifierReadPositiveTests, - ::testing::ValuesIn(positive_read_tests)); - -TEST(NullifierTreeCheckConstrainingTest, PositiveWriteAppend) -{ - NoopEventEmitter hash_event_emitter; - NoopEventEmitter perm_event_emitter; - NoopEventEmitter perm_mem_event_emitter; - - NiceMock mock_gt; - NiceMock mock_exec_id_manager; - Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); - NoopEventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - NoopEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check_simulator( - poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_builder; - - FF nullifier = 100; - FF low_nullifier = 40; - TestMemoryTree nullifier_tree(8, NULLIFIER_TREE_HEIGHT); - - NullifierTreeLeafPreimage low_leaf = - NullifierTreeLeafPreimage(NullifierLeafValue(low_nullifier), 10, nullifier + 1); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 0; - nullifier_tree.update_element(low_leaf_index, low_leaf_hash); - - AppendOnlyTreeSnapshot prev_snapshot = - AppendOnlyTreeSnapshot{ .root = nullifier_tree.root(), .next_available_leaf_index = 128 }; - std::vector low_leaf_sibling_path = nullifier_tree.get_sibling_path(low_leaf_index); - - NullifierTreeLeafPreimage updated_low_leaf = low_leaf; - updated_low_leaf.nextIndex = prev_snapshot.next_available_leaf_index; - updated_low_leaf.nextKey = nullifier; - FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); - nullifier_tree.update_element(low_leaf_index, updated_low_leaf_hash); - - std::vector insertion_sibling_path = nullifier_tree.get_sibling_path(prev_snapshot.next_available_leaf_index); - - NullifierTreeLeafPreimage new_leaf = - NullifierTreeLeafPreimage(NullifierLeafValue(nullifier), low_leaf.nextIndex, low_leaf.nextKey); - FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); - nullifier_tree.update_element(prev_snapshot.next_available_leaf_index, new_leaf_hash); - - nullifier_tree_check_simulator.write(nullifier, - /*contract_address*/ std::nullopt, - 0, - low_leaf, - low_leaf_index, - low_leaf_sibling_path, - prev_snapshot, - insertion_sibling_path); - - nullifier_tree_check_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); - - EXPECT_EQ(trace.get_num_rows(), 1); - - check_relation(trace); -} - -TEST(NullifierTreeCheckConstrainingTest, PositiveWriteMembership) -{ - FF nullifier = 42; - auto low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 0, 0); - NoopEventEmitter hash_event_emitter; - NoopEventEmitter perm_event_emitter; - NoopEventEmitter perm_mem_event_emitter; - - NiceMock mock_gt; - NiceMock mock_exec_id_manager; - Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); - NoopEventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - NoopEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check_simulator( - poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_builder; - - FF low_leaf_hash = poseidon2.hash(low_leaf.get_hash_inputs()); - uint64_t leaf_index = 30; - std::vector sibling_path; - sibling_path.reserve(NULLIFIER_TREE_HEIGHT); - for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { - sibling_path.emplace_back(i); - } - FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); - - nullifier_tree_check_simulator.write(nullifier, - std::nullopt, - 10, - low_leaf, - leaf_index, - sibling_path, - AppendOnlyTreeSnapshot{ .root = root, .next_available_leaf_index = 128 }, - /* insertion_sibling_path */ std::nullopt); - - nullifier_tree_check_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); - EXPECT_EQ(trace.get_num_rows(), 1); - - check_relation(trace); -} - -TEST(NullifierTreeCheckConstrainingTest, Siloing) -{ - AztecAddress contract_address = 1; - FF nullifier = 42; - FF siloed_nullifier = simulation::unconstrained_silo_nullifier(contract_address, nullifier); - auto low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(siloed_nullifier), 0, 0); - NoopEventEmitter hash_event_emitter; - NoopEventEmitter perm_event_emitter; - NoopEventEmitter perm_mem_event_emitter; - - NiceMock mock_gt; - NiceMock mock_exec_id_manager; - Poseidon2 poseidon2(mock_exec_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); - NoopEventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - NoopEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check_simulator( - poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - NullifierTreeCheckTraceBuilder nullifier_tree_check_builder; - - FF low_leaf_hash = poseidon2.hash(low_leaf.get_hash_inputs()); - uint64_t leaf_index = 30; - std::vector sibling_path; - sibling_path.reserve(NULLIFIER_TREE_HEIGHT); - for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { - sibling_path.emplace_back(i); - } - FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); - - nullifier_tree_check_simulator.write(nullifier, - contract_address, - 10, - low_leaf, - leaf_index, - sibling_path, - AppendOnlyTreeSnapshot{ .root = root, .next_available_leaf_index = 128 }, - /* insertion_sibling_path */ std::nullopt); - - nullifier_tree_check_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); - EXPECT_EQ(trace.get_num_rows(), 1); - - check_relation(trace); -} - -TEST(NullifierTreeCheckConstrainingTest, NegativeExistsFlagCheck) -{ - // Test constraint: sel * (NULLIFIER_LOW_LEAF_NULLIFIER_DIFF * (exists * (1 - nullifier_low_leaf_nullifier_diff_inv) - // + nullifier_low_leaf_nullifier_diff_inv) - 1 + exists) = 0 - TestTraceContainer trace({ - { { C::nullifier_check_sel, 1 }, - { C::nullifier_check_siloed_nullifier, 27 }, - { C::nullifier_check_low_leaf_nullifier, 27 }, - { C::nullifier_check_nullifier_low_leaf_nullifier_diff_inv, 0 }, - { C::nullifier_check_exists, 1 } }, - { { C::nullifier_check_sel, 1 }, - { C::nullifier_check_siloed_nullifier, 28 }, - { C::nullifier_check_low_leaf_nullifier, 27 }, - { C::nullifier_check_nullifier_low_leaf_nullifier_diff_inv, FF(1).invert() }, - { C::nullifier_check_exists, 0 } }, - }); - - check_relation(trace, nullifier_check::SR_EXISTS_CHECK); - trace.set(C::nullifier_check_exists, 0, 0); - - EXPECT_THROW_WITH_MESSAGE(check_relation(trace, nullifier_check::SR_EXISTS_CHECK), "EXISTS_CHECK"); - trace.set(C::nullifier_check_exists, 0, 1); - trace.set(C::nullifier_check_exists, 1, 1); - - EXPECT_THROW_WITH_MESSAGE(check_relation(trace, nullifier_check::SR_EXISTS_CHECK), "EXISTS_CHECK"); -} - -TEST(NullifierTreeCheckConstrainingTest, NegativeNextSlotIsZero) -{ - // Test constraint: leaf_not_exists * (low_leaf_next_nullifier * (NEXT_NULLIFIER_IS_ZERO * (1 - next_nullifier_inv) - // + next_nullifier_inv) - 1 + NEXT_NULLIFIER_IS_ZERO) = 0 - TestTraceContainer trace({ - { - { C::nullifier_check_leaf_not_exists, 1 }, - { C::nullifier_check_low_leaf_next_nullifier, 0 }, - { C::nullifier_check_next_nullifier_inv, 0 }, - { C::nullifier_check_next_nullifier_is_nonzero, 0 }, - }, - { - { C::nullifier_check_leaf_not_exists, 1 }, - { C::nullifier_check_low_leaf_next_nullifier, 1 }, - { C::nullifier_check_next_nullifier_inv, FF(1).invert() }, - { C::nullifier_check_next_nullifier_is_nonzero, 1 }, - }, - }); - - check_relation(trace, nullifier_check::SR_NEXT_NULLIFIER_IS_ZERO_CHECK); - - trace.set(C::nullifier_check_next_nullifier_is_nonzero, 0, 1); - - EXPECT_THROW_WITH_MESSAGE(check_relation(trace, nullifier_check::SR_NEXT_NULLIFIER_IS_ZERO_CHECK), - "NEXT_NULLIFIER_IS_ZERO_CHECK"); - - trace.set(C::nullifier_check_next_nullifier_is_nonzero, 0, 0); - trace.set(C::nullifier_check_next_nullifier_is_nonzero, 1, 0); - - EXPECT_THROW_WITH_MESSAGE(check_relation(trace, nullifier_check::SR_NEXT_NULLIFIER_IS_ZERO_CHECK), - "NEXT_NULLIFIER_IS_ZERO_CHECK"); -} - -TEST(NullifierTreeCheckConstrainingTest, NegativePassthrougSiloing) -{ - // Test constraint: sel * (1 - sel_silo) * (nullifier - siloed_nullifier) = 0; - TestTraceContainer trace({ - { - { C::nullifier_check_sel, 1 }, - { C::nullifier_check_sel_silo, 1 }, - { C::nullifier_check_nullifier, 27 }, - { C::nullifier_check_siloed_nullifier, 42 }, - }, - { - { C::nullifier_check_sel, 1 }, - { C::nullifier_check_sel_silo, 0 }, - { C::nullifier_check_nullifier, 27 }, - { C::nullifier_check_siloed_nullifier, 27 }, - }, - }); - - check_relation(trace, nullifier_check::SR_PASSTHROUGH_SILOING); - - trace.set(C::nullifier_check_siloed_nullifier, 1, 28); - - EXPECT_THROW_WITH_MESSAGE(check_relation(trace, nullifier_check::SR_PASSTHROUGH_SILOING), - "PASSTHROUGH_SILOING"); -} - -} // namespace -} // namespace bb::avm2::constraining diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/retrieved_bytecodes_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/retrieved_bytecodes_tree_check.test.cpp deleted file mode 100644 index 40e358536b92..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/retrieved_bytecodes_tree_check.test.cpp +++ /dev/null @@ -1,302 +0,0 @@ -#include -#include - -#include -#include - -#include "barretenberg/crypto/poseidon2/poseidon2.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/common/aztec_types.hpp" -#include "barretenberg/vm2/constraining/flavor_settings.hpp" -#include "barretenberg/vm2/constraining/testing/check_relation.hpp" -#include "barretenberg/vm2/generated/relations/merkle_check.hpp" -#include "barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.hpp" -#include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.hpp" -#include "barretenberg/vm2/simulation/lib/merkle.hpp" -#include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp" -#include "barretenberg/vm2/simulation/testing/mock_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" -#include "barretenberg/vm2/testing/fixtures.hpp" -#include "barretenberg/vm2/testing/macros.hpp" -#include "barretenberg/vm2/testing/test_tree.hpp" -#include "barretenberg/vm2/tracegen/field_gt_trace.hpp" -#include "barretenberg/vm2/tracegen/merkle_check_trace.hpp" -#include "barretenberg/vm2/tracegen/poseidon2_trace.hpp" -#include "barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp" -#include "barretenberg/vm2/tracegen/test_trace_container.hpp" - -namespace bb::avm2::constraining { -namespace { - -using ::testing::NiceMock; - -using simulation::build_retrieved_bytecodes_tree; -using simulation::ClassIdLeafValue; -using simulation::DeduplicatingEventEmitter; -using simulation::EventEmitter; -using simulation::FieldGreaterThan; -using simulation::FieldGreaterThanEvent; -using simulation::MerkleCheck; -using simulation::MerkleCheckEvent; -using simulation::MockExecutionIdManager; -using simulation::MockGreaterThan; -using simulation::MockRangeCheck; -using simulation::NoopEventEmitter; -using simulation::Poseidon2; -using simulation::Poseidon2HashEvent; -using simulation::Poseidon2PermutationEvent; -using simulation::Poseidon2PermutationMemoryEvent; -using simulation::RetrievedBytecodesTree; -using simulation::RetrievedBytecodesTreeCheck; -using simulation::RetrievedBytecodesTreeCheckEvent; -using simulation::RetrievedBytecodesTreeLeafPreimage; - -using tracegen::FieldGreaterThanTraceBuilder; -using tracegen::MerkleCheckTraceBuilder; -using tracegen::Poseidon2TraceBuilder; -using tracegen::RetrievedBytecodesTreeCheckTraceBuilder; -using tracegen::TestTraceContainer; - -using FF = AvmFlavorSettings::FF; -using C = Column; -using retrieved_bytecodes_tree = bb::avm2::retrieved_bytecodes_tree_check; -using RawPoseidon2 = crypto::Poseidon2; - -class RetrievedBytecodesTreeCheckConstrainingTest : public ::testing::Test { - protected: - RetrievedBytecodesTreeCheckConstrainingTest() = default; - - EventEmitter hash_event_emitter; - // Interactions involve the poseidon2 hash, so the others can be noop - NoopEventEmitter perm_event_emitter; - NoopEventEmitter perm_mem_event_emitter; - - NiceMock mock_gt; - NiceMock mock_execution_id_manager; - - Poseidon2 poseidon2 = - Poseidon2(mock_execution_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); -}; - -TEST_F(RetrievedBytecodesTreeCheckConstrainingTest, EmptyRow) -{ - check_relation(testing::empty_trace()); -} - -struct TestParams { - FF class_id; - bool exists; - std::vector pre_existing_leaves; -}; - -std::vector positive_read_tests = { - // Exists = true, leaf pointers to infinity - TestParams{ .class_id = 42, .exists = true, .pre_existing_leaves = { { ClassIdLeafValue(42) } } }, - // Exists = true, leaf points to higher value - TestParams{ - .class_id = 42, .exists = true, .pre_existing_leaves = { { ClassIdLeafValue(42), ClassIdLeafValue(42 + 1) } } }, - // Exists = false, low leaf points to infinity - TestParams{ .class_id = 42, .exists = false, .pre_existing_leaves = { {} } }, - // Exists = false, low leaf points to higher value - TestParams{ .class_id = 42, .exists = false, .pre_existing_leaves = { { ClassIdLeafValue(42 + 1) } } } -}; - -class RetrievedBytecodesReadPositiveTests : public RetrievedBytecodesTreeCheckConstrainingTest, - public ::testing::WithParamInterface {}; - -TEST_P(RetrievedBytecodesReadPositiveTests, Positive) -{ - const auto& param = GetParam(); - - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter retrieved_bytecodes_tree_event_emitter; - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - RetrievedBytecodesTreeCheckTraceBuilder retrieved_bytecodes_tree_builder; - - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - initial_state.insert_indexed_leaves(param.pre_existing_leaves); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_simulator( - poseidon2, merkle_check, field_gt, initial_state, retrieved_bytecodes_tree_event_emitter); - - retrieved_bytecodes_tree_simulator.contains(param.class_id); - - retrieved_bytecodes_tree_builder.process(retrieved_bytecodes_tree_event_emitter.dump_events(), trace); - EXPECT_EQ(trace.get_num_rows(), 1); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - - check_relation(trace); - check_all_interactions(trace); -} - -INSTANTIATE_TEST_SUITE_P(RetrievedBytecodesTreeCheckConstrainingTest, - RetrievedBytecodesReadPositiveTests, - ::testing::ValuesIn(positive_read_tests)); - -TEST_F(RetrievedBytecodesTreeCheckConstrainingTest, PositiveWriteAppend) -{ - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter retrieved_bytecodes_tree_event_emitter; - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - RetrievedBytecodesTreeCheckTraceBuilder retrieved_bytecodes_tree_builder; - - FF class_id = 100; - - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_simulator( - poseidon2, merkle_check, field_gt, initial_state, retrieved_bytecodes_tree_event_emitter); - - retrieved_bytecodes_tree_simulator.insert(class_id); - - retrieved_bytecodes_tree_builder.process(retrieved_bytecodes_tree_event_emitter.dump_events(), trace); - - EXPECT_EQ(trace.get_num_rows(), 1); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - - check_relation(trace); - check_all_interactions(trace); -} - -TEST_F(RetrievedBytecodesTreeCheckConstrainingTest, PositiveWriteMembership) -{ - FF class_id = 42; - auto low_leaf = RetrievedBytecodesTreeLeafPreimage(ClassIdLeafValue(class_id), 0, 0); - - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter retrieved_bytecodes_tree_event_emitter; - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - RetrievedBytecodesTreeCheckTraceBuilder retrieved_bytecodes_tree_builder; - - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - initial_state.insert_indexed_leaves({ { ClassIdLeafValue(class_id) } }); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_simulator( - poseidon2, merkle_check, field_gt, initial_state, retrieved_bytecodes_tree_event_emitter); - - retrieved_bytecodes_tree_simulator.insert(class_id); - - retrieved_bytecodes_tree_builder.process(retrieved_bytecodes_tree_event_emitter.dump_events(), trace); - - EXPECT_EQ(trace.get_num_rows(), 1); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - - check_relation(trace); - check_all_interactions(trace); -} - -TEST_F(RetrievedBytecodesTreeCheckConstrainingTest, NegativeExistsFlagCheck) -{ - // Test constraint: sel * (CLASS_ID_LOW_LEAF_CLASS_ID_DIFF * (EXISTS * (1 - class_id_low_leaf_class_id_diff_inv) - // + class_id_low_leaf_class_id_diff_inv) - 1 + EXISTS) = 0 - TestTraceContainer trace({ - { { C::retrieved_bytecodes_tree_check_sel, 1 }, - { C::retrieved_bytecodes_tree_check_class_id, 27 }, - { C::retrieved_bytecodes_tree_check_low_leaf_class_id, 27 }, - { C::retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv, 0 }, - { C::retrieved_bytecodes_tree_check_leaf_not_exists, 0 } }, - { { C::retrieved_bytecodes_tree_check_sel, 1 }, - { C::retrieved_bytecodes_tree_check_class_id, 28 }, - { C::retrieved_bytecodes_tree_check_low_leaf_class_id, 27 }, - { C::retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv, FF(1).invert() }, - { C::retrieved_bytecodes_tree_check_leaf_not_exists, 1 } }, - }); - - check_relation(trace, retrieved_bytecodes_tree::SR_EXISTS_CHECK); - trace.set(C::retrieved_bytecodes_tree_check_leaf_not_exists, 0, 1); - - EXPECT_THROW_WITH_MESSAGE( - check_relation(trace, retrieved_bytecodes_tree::SR_EXISTS_CHECK), "EXISTS_CHECK"); - trace.set(C::retrieved_bytecodes_tree_check_leaf_not_exists, 0, 0); - trace.set(C::retrieved_bytecodes_tree_check_leaf_not_exists, 1, 0); - - EXPECT_THROW_WITH_MESSAGE( - check_relation(trace, retrieved_bytecodes_tree::SR_EXISTS_CHECK), "EXISTS_CHECK"); -} - -TEST_F(RetrievedBytecodesTreeCheckConstrainingTest, NegativeNextSlotIsZero) -{ - // Test constraint: leaf_not_exists * (low_leaf_next_class_id * (NEXT_CLASS_ID_IS_ZERO * (1 - next_class_id_inv) + - // next_class_id_inv) - 1 + NEXT_CLASS_ID_IS_ZERO) = 0; - - TestTraceContainer trace({ - { - { C::retrieved_bytecodes_tree_check_leaf_not_exists, 1 }, - { C::retrieved_bytecodes_tree_check_low_leaf_next_class_id, 0 }, - { C::retrieved_bytecodes_tree_check_next_class_id_inv, 0 }, - { C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero, 0 }, - }, - { - { C::retrieved_bytecodes_tree_check_leaf_not_exists, 1 }, - { C::retrieved_bytecodes_tree_check_low_leaf_next_class_id, 1 }, - { C::retrieved_bytecodes_tree_check_next_class_id_inv, FF(1).invert() }, - { C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero, 1 }, - }, - }); - - check_relation(trace, retrieved_bytecodes_tree::SR_NEXT_CLASS_ID_IS_ZERO_CHECK); - - trace.set(C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero, 0, 1); - - EXPECT_THROW_WITH_MESSAGE( - check_relation(trace, retrieved_bytecodes_tree::SR_NEXT_CLASS_ID_IS_ZERO_CHECK), - "NEXT_CLASS_ID_IS_ZERO_CHECK"); - - trace.set(C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero, 0, 0); - trace.set(C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero, 1, 0); - - EXPECT_THROW_WITH_MESSAGE( - check_relation(trace, retrieved_bytecodes_tree::SR_NEXT_CLASS_ID_IS_ZERO_CHECK), - "NEXT_CLASS_ID_IS_ZERO_CHECK"); -} - -} // namespace -} // namespace bb::avm2::constraining diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_load.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_load.test.cpp index db422829153e..1fbca5a3c5b3 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_load.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_load.test.cpp @@ -14,10 +14,10 @@ #include "barretenberg/vm2/simulation/testing/mock_dbs.hpp" #include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp" #include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_l1_to_l2_message_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_note_hash_tree_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" #include "barretenberg/vm2/simulation/testing/mock_written_public_data_slots_tree_check.hpp" #include "barretenberg/vm2/testing/macros.hpp" @@ -36,11 +36,11 @@ using simulation::EventEmitter; using simulation::MerkleDB; using simulation::MockExecutionIdManager; using simulation::MockFieldGreaterThan; +using simulation::MockIndexedTreeCheck; using simulation::MockL1ToL2MessageTreeCheck; using simulation::MockLowLevelMerkleDB; using simulation::MockMerkleCheck; using simulation::MockNoteHashTreeCheck; -using simulation::MockNullifierTreeCheck; using simulation::MockPoseidon2; using simulation::MockWrittenPublicDataSlotsTreeCheck; using simulation::PublicDataTreeCheck; @@ -111,7 +111,7 @@ TEST(SLoadConstrainingTest, Interactions) NiceMock execution_id_manager; NiceMock written_public_data_slots_tree_check; NiceMock low_level_merkle_db; - NiceMock nullifier_tree_check; + NiceMock indexed_tree_check; NiceMock note_hash_tree_check; NiceMock l1_to_l2_message_tree_check; @@ -124,7 +124,7 @@ TEST(SLoadConstrainingTest, Interactions) MerkleDB merkle_db(low_level_merkle_db, public_data_tree_check, - nullifier_tree_check, + indexed_tree_check, note_hash_tree_check, written_public_data_slots_tree_check, l1_to_l2_message_tree_check); diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_write.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_write.test.cpp index 15603feb4523..d92385868323 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_write.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/storage_write.test.cpp @@ -8,6 +8,7 @@ #include "barretenberg/vm2/constraining/testing/check_relation.hpp" #include "barretenberg/vm2/generated/relations/execution.hpp" #include "barretenberg/vm2/generated/relations/lookups_sstore.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/public_data_tree_check_event.hpp" #include "barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp" #include "barretenberg/vm2/simulation/gadgets/public_data_tree_check.hpp" @@ -15,27 +16,29 @@ #include "barretenberg/vm2/simulation/testing/mock_dbs.hpp" #include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp" #include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_note_hash_tree_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" #include "barretenberg/vm2/simulation/testing/mock_written_public_data_slots_tree_check.hpp" #include "barretenberg/vm2/testing/macros.hpp" #include "barretenberg/vm2/tracegen/execution_trace.hpp" +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" #include "barretenberg/vm2/tracegen/public_data_tree_trace.hpp" #include "barretenberg/vm2/tracegen/test_trace_container.hpp" -#include "barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp" namespace bb::avm2::constraining { namespace { using tracegen::ExecutionTraceBuilder; +using tracegen::IndexedTreeCheckTraceBuilder; using tracegen::PublicDataTreeTraceBuilder; using tracegen::TestTraceContainer; -using tracegen::WrittenPublicDataSlotsTreeCheckTraceBuilder; using simulation::build_public_data_slots_tree; using simulation::EventEmitter; +using simulation::IndexedTreeCheck; +using simulation::IndexedTreeCheckEvent; using simulation::MockExecutionIdManager; using simulation::MockFieldGreaterThan; using simulation::MockMerkleCheck; @@ -46,7 +49,6 @@ using simulation::PublicDataTreeLeafPreimage; using simulation::unconstrained_compute_leaf_slot; using simulation::unconstrained_root_from_path; using simulation::WrittenPublicDataSlotsTreeCheck; -using simulation::WrittenPublicDataSlotsTreeCheckEvent; using testing::_; using testing::NiceMock; @@ -211,9 +213,11 @@ TEST(SStoreConstrainingTest, Interactions) NiceMock merkle_check; NiceMock execution_id_manager; - EventEmitter written_public_data_slots_emitter; - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, build_public_data_slots_tree(), written_public_data_slots_emitter); + EventEmitter indexed_tree_check_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_emitter); + + WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(indexed_tree_check, + build_public_data_slots_tree()); EventEmitter public_data_tree_check_event_emitter; PublicDataTreeCheck public_data_tree_check( @@ -269,6 +273,8 @@ TEST(SStoreConstrainingTest, Interactions) { C::execution_sel_execute_sstore, 1 }, { C::execution_contract_address, contract_address }, { C::execution_sel_gas_sstore, 1 }, + { C::execution_written_slots_tree_height, AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT }, + { C::execution_written_slots_tree_siloing_separator, DOM_SEP__PUBLIC_LEAF_SLOT }, { C::execution_dynamic_da_gas_factor, 1 }, { C::execution_register_0_, value }, { C::execution_register_1_, slot }, @@ -294,8 +300,8 @@ TEST(SStoreConstrainingTest, Interactions) PublicDataTreeTraceBuilder public_data_tree_trace_builder; public_data_tree_trace_builder.process(public_data_tree_check_event_emitter.dump_events(), trace); - WrittenPublicDataSlotsTreeCheckTraceBuilder written_slots_tree_trace_builder; - written_slots_tree_trace_builder.process(written_public_data_slots_emitter.dump_events(), trace); + IndexedTreeCheckTraceBuilder written_slots_tree_trace_builder; + written_slots_tree_trace_builder.process(indexed_tree_check_emitter.dump_events(), trace); check_relation(trace); check_interaction merkle_check; NiceMock execution_id_manager; - EventEmitter written_public_data_slots_emitter; - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, build_public_data_slots_tree(), written_public_data_slots_emitter); + EventEmitter indexed_tree_check_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_emitter); + WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(indexed_tree_check, + build_public_data_slots_tree()); EventEmitter public_data_tree_check_event_emitter; PublicDataTreeCheck public_data_tree_check( @@ -380,8 +387,8 @@ TEST(SStoreConstrainingTest, NegativeFullAttackWithAllTraces) PublicDataTreeTraceBuilder public_data_tree_trace_builder; public_data_tree_trace_builder.process(public_data_tree_check_event_emitter.dump_events(), trace); - WrittenPublicDataSlotsTreeCheckTraceBuilder written_slots_tree_trace_builder; - written_slots_tree_trace_builder.process(written_public_data_slots_emitter.dump_events(), trace); + IndexedTreeCheckTraceBuilder written_slots_tree_trace_builder; + written_slots_tree_trace_builder.process(indexed_tree_check_emitter.dump_events(), trace); // Inject ghost sstore at row 0 where precomputed_idx matches public_data_check.clk. // The mock execution_id_manager returns 0, so public_data_check.clk=0. diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/written_public_data_slots_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/written_public_data_slots_tree_check.test.cpp deleted file mode 100644 index 2c88d8c2976d..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/written_public_data_slots_tree_check.test.cpp +++ /dev/null @@ -1,329 +0,0 @@ -#include -#include - -#include -#include - -#include "barretenberg/crypto/poseidon2/poseidon2.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/common/aztec_types.hpp" -#include "barretenberg/vm2/constraining/flavor_settings.hpp" -#include "barretenberg/vm2/constraining/testing/check_relation.hpp" -#include "barretenberg/vm2/generated/relations/merkle_check.hpp" -#include "barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.hpp" -#include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp" -#include "barretenberg/vm2/simulation/lib/merkle.hpp" -#include "barretenberg/vm2/simulation/testing/mock_execution_id_manager.hpp" -#include "barretenberg/vm2/simulation/testing/mock_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" -#include "barretenberg/vm2/testing/fixtures.hpp" -#include "barretenberg/vm2/testing/macros.hpp" -#include "barretenberg/vm2/testing/test_tree.hpp" -#include "barretenberg/vm2/tracegen/field_gt_trace.hpp" -#include "barretenberg/vm2/tracegen/merkle_check_trace.hpp" -#include "barretenberg/vm2/tracegen/poseidon2_trace.hpp" -#include "barretenberg/vm2/tracegen/test_trace_container.hpp" -#include "barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp" - -namespace bb::avm2::constraining { -namespace { - -using ::testing::NiceMock; -using ::testing::TestWithParam; - -using testing::TestMemoryTree; - -using simulation::build_public_data_slots_tree; -using simulation::DeduplicatingEventEmitter; -using simulation::EventEmitter; -using simulation::FieldGreaterThan; -using simulation::FieldGreaterThanEvent; -using simulation::MerkleCheck; -using simulation::MerkleCheckEvent; -using simulation::MockExecutionIdManager; -using simulation::MockGreaterThan; -using simulation::MockRangeCheck; -using simulation::NoopEventEmitter; -using simulation::Poseidon2; -using simulation::Poseidon2HashEvent; -using simulation::Poseidon2PermutationEvent; -using simulation::Poseidon2PermutationMemoryEvent; -using simulation::unconstrained_compute_leaf_slot; -using simulation::unconstrained_root_from_path; -using simulation::WrittenPublicDataSlotLeafValue; -using simulation::WrittenPublicDataSlotsTree; -using simulation::WrittenPublicDataSlotsTreeCheck; -using simulation::WrittenPublicDataSlotsTreeCheckEvent; -using simulation::WrittenPublicDataSlotsTreeLeafPreimage; - -using tracegen::FieldGreaterThanTraceBuilder; -using tracegen::MerkleCheckTraceBuilder; -using tracegen::Poseidon2TraceBuilder; -using tracegen::TestTraceContainer; -using tracegen::WrittenPublicDataSlotsTreeCheckTraceBuilder; - -using FF = AvmFlavorSettings::FF; -using C = Column; -using written_public_data_slots_tree_check = bb::avm2::written_public_data_slots_tree_check; -using RawPoseidon2 = crypto::Poseidon2; - -class WrittenPublicDataSlotsTreeCheckConstrainingTest : public ::testing::Test { - protected: - WrittenPublicDataSlotsTreeCheckConstrainingTest() = default; - - EventEmitter hash_event_emitter; - // Interactions involve the poseidon2 hash, so the others can be noop - NoopEventEmitter perm_event_emitter; - NoopEventEmitter perm_mem_event_emitter; - - NiceMock mock_gt; - NiceMock mock_execution_id_manager; - - Poseidon2 poseidon2 = - Poseidon2(mock_execution_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); -}; - -TEST_F(WrittenPublicDataSlotsTreeCheckConstrainingTest, EmptyRow) -{ - check_relation(testing::empty_trace()); -} - -struct TestParams { - FF slot; - AztecAddress contract_address; - bool exists; - std::vector pre_existing_leaves; -}; - -std::vector positive_read_tests = { - // Exists = true, leaf pointers to infinity - TestParams{ - .slot = 42, - .contract_address = 27, - .exists = true, - .pre_existing_leaves = { { WrittenPublicDataSlotLeafValue(unconstrained_compute_leaf_slot(27, 42)) } } }, - // Exists = true, leaf points to higher value - TestParams{ .slot = 42, - .contract_address = 27, - .exists = true, - .pre_existing_leaves = { { WrittenPublicDataSlotLeafValue(unconstrained_compute_leaf_slot(27, 42)), - WrittenPublicDataSlotLeafValue(unconstrained_compute_leaf_slot(27, 42) + - FF(1)) } } }, - // Exists = false, low leaf points to infinity - TestParams{ .slot = 42, .contract_address = 27, .exists = false, .pre_existing_leaves = { {} } }, - // Exists = false, low leaf points to higher value - TestParams{ - .slot = 42, - .contract_address = 27, - .exists = false, - .pre_existing_leaves = { { WrittenPublicDataSlotLeafValue(unconstrained_compute_leaf_slot(27, 42) + FF(1)) } } } -}; - -class WrittenPublicDataSlotsReadPositiveTests : public WrittenPublicDataSlotsTreeCheckConstrainingTest, - public ::testing::WithParamInterface {}; - -TEST_P(WrittenPublicDataSlotsReadPositiveTests, Positive) -{ - const auto& param = GetParam(); - - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter written_public_data_slots_tree_check_event_emitter; - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - WrittenPublicDataSlotsTreeCheckTraceBuilder written_public_data_slots_tree_check_builder; - - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - initial_state.insert_indexed_leaves(param.pre_existing_leaves); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check_simulator( - poseidon2, merkle_check, field_gt, initial_state, written_public_data_slots_tree_check_event_emitter); - - written_public_data_slots_tree_check_simulator.contains(param.contract_address, param.slot); - - written_public_data_slots_tree_check_builder.process( - written_public_data_slots_tree_check_event_emitter.dump_events(), trace); - EXPECT_EQ(trace.get_num_rows(), 1); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - - check_relation(trace); - check_all_interactions(trace); -} - -INSTANTIATE_TEST_SUITE_P(WrittenPublicDataSlotsTreeCheckConstrainingTest, - WrittenPublicDataSlotsReadPositiveTests, - ::testing::ValuesIn(positive_read_tests)); - -TEST_F(WrittenPublicDataSlotsTreeCheckConstrainingTest, PositiveWriteAppend) -{ - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter written_public_data_slots_tree_check_event_emitter; - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - WrittenPublicDataSlotsTreeCheckTraceBuilder written_public_data_slots_tree_check_builder; - - FF slot = 100; - AztecAddress contract_address = 27; - - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check_simulator( - poseidon2, merkle_check, field_gt, initial_state, written_public_data_slots_tree_check_event_emitter); - - written_public_data_slots_tree_check_simulator.insert(contract_address, slot); - - written_public_data_slots_tree_check_builder.process( - written_public_data_slots_tree_check_event_emitter.dump_events(), trace); - - EXPECT_EQ(trace.get_num_rows(), 1); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - - check_relation(trace); - check_all_interactions(trace); -} - -TEST_F(WrittenPublicDataSlotsTreeCheckConstrainingTest, PositiveWriteMembership) -{ - FF slot = 42; - AztecAddress contract_address = 27; - FF leaf_slot = unconstrained_compute_leaf_slot(contract_address, slot); - auto low_leaf = WrittenPublicDataSlotsTreeLeafPreimage(WrittenPublicDataSlotLeafValue(leaf_slot), 0, 0); - - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter written_public_data_slots_tree_check_event_emitter; - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - WrittenPublicDataSlotsTreeCheckTraceBuilder written_public_data_slots_tree_check_builder; - - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - initial_state.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check_simulator( - poseidon2, merkle_check, field_gt, initial_state, written_public_data_slots_tree_check_event_emitter); - - written_public_data_slots_tree_check_simulator.insert(contract_address, slot); - - written_public_data_slots_tree_check_builder.process( - written_public_data_slots_tree_check_event_emitter.dump_events(), trace); - - EXPECT_EQ(trace.get_num_rows(), 1); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - - check_relation(trace); - check_all_interactions(trace); -} - -TEST_F(WrittenPublicDataSlotsTreeCheckConstrainingTest, NegativeExistsFlagCheck) -{ - // Test constraint: sel * (SLOT_LOW_LEAF_SLOT_DIFF * (EXISTS * (1 - slot_low_leaf_slot_diff_inv) - // + slot_low_leaf_slot_diff_inv) - 1 + EXISTS) = 0 - TestTraceContainer trace({ - { { C::written_public_data_slots_tree_check_sel, 1 }, - { C::written_public_data_slots_tree_check_leaf_slot, 27 }, - { C::written_public_data_slots_tree_check_low_leaf_slot, 27 }, - { C::written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv, 0 }, - { C::written_public_data_slots_tree_check_leaf_not_exists, 0 } }, - { { C::written_public_data_slots_tree_check_sel, 1 }, - { C::written_public_data_slots_tree_check_leaf_slot, 28 }, - { C::written_public_data_slots_tree_check_low_leaf_slot, 27 }, - { C::written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv, FF(1).invert() }, - { C::written_public_data_slots_tree_check_leaf_not_exists, 1 } }, - }); - - check_relation(trace, written_public_data_slots_tree_check::SR_EXISTS_CHECK); - trace.set(C::written_public_data_slots_tree_check_leaf_not_exists, 0, 1); - - EXPECT_THROW_WITH_MESSAGE(check_relation( - trace, written_public_data_slots_tree_check::SR_EXISTS_CHECK), - "EXISTS_CHECK"); - trace.set(C::written_public_data_slots_tree_check_leaf_not_exists, 0, 0); - trace.set(C::written_public_data_slots_tree_check_leaf_not_exists, 1, 0); - - EXPECT_THROW_WITH_MESSAGE(check_relation( - trace, written_public_data_slots_tree_check::SR_EXISTS_CHECK), - "EXISTS_CHECK"); -} - -TEST_F(WrittenPublicDataSlotsTreeCheckConstrainingTest, NegativeNextSlotIsZero) -{ - // Test constraint: leaf_not_exists * (low_leaf_next_slot * (NEXT_SLOT_IS_ZERO * (1 - next_slot_inv) - // + next_slot_inv) - 1 + NEXT_SLOT_IS_ZERO) = 0 - TestTraceContainer trace({ - { - { C::written_public_data_slots_tree_check_leaf_not_exists, 1 }, - { C::written_public_data_slots_tree_check_low_leaf_next_slot, 0 }, - { C::written_public_data_slots_tree_check_next_slot_inv, 0 }, - { C::written_public_data_slots_tree_check_next_slot_is_nonzero, 0 }, - }, - { - { C::written_public_data_slots_tree_check_leaf_not_exists, 1 }, - { C::written_public_data_slots_tree_check_low_leaf_next_slot, 1 }, - { C::written_public_data_slots_tree_check_next_slot_inv, FF(1).invert() }, - { C::written_public_data_slots_tree_check_next_slot_is_nonzero, 1 }, - }, - }); - - check_relation( - trace, written_public_data_slots_tree_check::SR_NEXT_SLOT_IS_ZERO_CHECK); - - trace.set(C::written_public_data_slots_tree_check_next_slot_is_nonzero, 0, 1); - - EXPECT_THROW_WITH_MESSAGE(check_relation( - trace, written_public_data_slots_tree_check::SR_NEXT_SLOT_IS_ZERO_CHECK), - "NEXT_SLOT_IS_ZERO_CHECK"); - - trace.set(C::written_public_data_slots_tree_check_next_slot_is_nonzero, 0, 0); - trace.set(C::written_public_data_slots_tree_check_next_slot_is_nonzero, 1, 0); - - EXPECT_THROW_WITH_MESSAGE(check_relation( - trace, written_public_data_slots_tree_check::SR_NEXT_SLOT_IS_ZERO_CHECK), - "NEXT_SLOT_IS_ZERO_CHECK"); -} - -} // namespace -} // namespace bb::avm2::constraining diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp index c25da459ec82..a907e35533c4 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp @@ -8,8 +8,8 @@ namespace bb::avm2 { // clang-format off #define AVM2_PRECOMPUTED_ENTITIES_E(e) e precomputed_addressing_gas, e precomputed_bitwise_input_a, e precomputed_bitwise_input_b, e precomputed_bitwise_output_and, e precomputed_bitwise_output_or, e precomputed_bitwise_output_xor, e precomputed_dyn_gas_id, e precomputed_envvar_pi_row_idx, e precomputed_exec_opcode, e precomputed_exec_opcode_base_da_gas, e precomputed_exec_opcode_dynamic_da_gas, e precomputed_exec_opcode_dynamic_l2_gas, e precomputed_exec_opcode_opcode_gas, e precomputed_expected_tag_reg_0_, e precomputed_expected_tag_reg_1_, e precomputed_expected_tag_reg_2_, e precomputed_expected_tag_reg_3_, e precomputed_expected_tag_reg_4_, e precomputed_expected_tag_reg_5_, e precomputed_first_row, e precomputed_idx, e precomputed_instr_size, e precomputed_invalid_envvar_enum, e precomputed_is_address, e precomputed_is_class_id, e precomputed_is_cleanup, e precomputed_is_collect_fee, e precomputed_is_dagasleft, e precomputed_is_deployer, e precomputed_is_init_hash, e precomputed_is_isstaticcall, e precomputed_is_l2gasleft, e precomputed_is_public_call_request, e precomputed_is_revertible, e precomputed_is_sender, e precomputed_is_teardown, e precomputed_is_transactionfee, e precomputed_is_tree_padding, e precomputed_is_valid_member_enum, e precomputed_keccak_round_constant, e precomputed_next_phase_on_revert, e precomputed_opcode_out_of_range, e precomputed_out_tag, e precomputed_p_decomposition_limb, e precomputed_p_decomposition_limb_index, e precomputed_p_decomposition_radix, e precomputed_power_of_2, e precomputed_read_pi_length_offset, e precomputed_read_pi_start_offset, e precomputed_rw_reg_0_, e precomputed_rw_reg_1_, e precomputed_rw_reg_2_, e precomputed_rw_reg_3_, e precomputed_rw_reg_4_, e precomputed_rw_reg_5_, e precomputed_sel_addressing_gas, e precomputed_sel_envvar_pi_lookup_col0, e precomputed_sel_envvar_pi_lookup_col1, e precomputed_sel_exec_spec, e precomputed_sel_has_tag, e precomputed_sel_keccak, e precomputed_sel_mem_op_reg_0_, e precomputed_sel_mem_op_reg_1_, e precomputed_sel_mem_op_reg_2_, e precomputed_sel_mem_op_reg_3_, e precomputed_sel_mem_op_reg_4_, e precomputed_sel_mem_op_reg_5_, e precomputed_sel_mem_tag_out_of_range, e precomputed_sel_non_revertible_append_l2_l1_msg, e precomputed_sel_non_revertible_append_note_hash, e precomputed_sel_non_revertible_append_nullifier, e precomputed_sel_op_dc_0, e precomputed_sel_op_dc_1, e precomputed_sel_op_dc_10, e precomputed_sel_op_dc_11, e precomputed_sel_op_dc_12, e precomputed_sel_op_dc_13, e precomputed_sel_op_dc_14, e precomputed_sel_op_dc_15, e precomputed_sel_op_dc_16, e precomputed_sel_op_dc_17, e precomputed_sel_op_dc_2, e precomputed_sel_op_dc_3, e precomputed_sel_op_dc_4, e precomputed_sel_op_dc_5, e precomputed_sel_op_dc_6, e precomputed_sel_op_dc_7, e precomputed_sel_op_dc_8, e precomputed_sel_op_dc_9, e precomputed_sel_op_is_address_0_, e precomputed_sel_op_is_address_1_, e precomputed_sel_op_is_address_2_, e precomputed_sel_op_is_address_3_, e precomputed_sel_op_is_address_4_, e precomputed_sel_op_is_address_5_, e precomputed_sel_op_is_address_6_, e precomputed_sel_p_decomposition, e precomputed_sel_phase, e precomputed_sel_range_16, e precomputed_sel_range_8, e precomputed_sel_revertible_append_l2_l1_msg, e precomputed_sel_revertible_append_note_hash, e precomputed_sel_revertible_append_nullifier, e precomputed_sel_sha256_compression, e precomputed_sel_tag_check_reg_0_, e precomputed_sel_tag_check_reg_1_, e precomputed_sel_tag_check_reg_2_, e precomputed_sel_tag_check_reg_3_, e precomputed_sel_tag_check_reg_4_, e precomputed_sel_tag_check_reg_5_, e precomputed_sel_tag_is_op2, e precomputed_sel_tag_parameters, e precomputed_sel_to_radix_p_limb_counts, e precomputed_sha256_compression_round_constant, e precomputed_subtrace_id, e precomputed_subtrace_operation_id, e precomputed_tag_byte_length, e precomputed_tag_max_bits, e precomputed_tag_max_value, e precomputed_to_radix_num_limbs_for_p, e precomputed_to_radix_safe_limbs, e precomputed_zero, e public_inputs_sel -#define AVM2_WIRE_ENTITIES_E(e) e public_inputs_cols_0_, e public_inputs_cols_1_, e public_inputs_cols_2_, e public_inputs_cols_3_, e address_derivation_address, e address_derivation_address_y, e address_derivation_class_id, e address_derivation_const_four, e address_derivation_const_thirteen, e address_derivation_const_three, e address_derivation_const_two, e address_derivation_deployer_addr, e address_derivation_g1_x, e address_derivation_g1_y, e address_derivation_incoming_viewing_key_x, e address_derivation_incoming_viewing_key_y, e address_derivation_init_hash, e address_derivation_nullifier_key_x, e address_derivation_nullifier_key_y, e address_derivation_outgoing_viewing_key_x, e address_derivation_outgoing_viewing_key_y, e address_derivation_partial_address, e address_derivation_partial_address_domain_separator, e address_derivation_preaddress, e address_derivation_preaddress_domain_separator, e address_derivation_preaddress_public_key_x, e address_derivation_preaddress_public_key_y, e address_derivation_public_keys_hash, e address_derivation_public_keys_hash_domain_separator, e address_derivation_salt, e address_derivation_salted_init_hash, e address_derivation_sel, e address_derivation_tagging_key_x, e address_derivation_tagging_key_y, e alu_a_hi, e alu_a_hi_bits, e alu_a_lo, e alu_a_lo_bits, e alu_ab_diff_inv, e alu_ab_tags_diff_inv, e alu_b_hi, e alu_b_inv, e alu_b_lo, e alu_c_hi, e alu_cf, e alu_constant_64, e alu_gt_input_a, e alu_gt_input_b, e alu_gt_result_c, e alu_helper1, e alu_ia, e alu_ia_tag, e alu_ib, e alu_ib_tag, e alu_ic, e alu_ic_tag, e alu_max_bits, e alu_max_value, e alu_mid, e alu_mid_bits, e alu_op_id, e alu_sel, e alu_sel_ab_tag_mismatch, e alu_sel_decompose_a, e alu_sel_div_0_err, e alu_sel_div_no_err, e alu_sel_err, e alu_sel_ff_gt, e alu_sel_int_gt, e alu_sel_is_ff, e alu_sel_is_u128, e alu_sel_mul_div_u128, e alu_sel_mul_no_err_non_ff, e alu_sel_op_add, e alu_sel_op_div, e alu_sel_op_eq, e alu_sel_op_fdiv, e alu_sel_op_lt, e alu_sel_op_lte, e alu_sel_op_mul, e alu_sel_op_not, e alu_sel_op_shl, e alu_sel_op_shr, e alu_sel_op_sub, e alu_sel_op_truncate, e alu_sel_shift_ops_no_overflow, e alu_sel_tag_err, e alu_sel_trunc_gte_128, e alu_sel_trunc_lt_128, e alu_sel_trunc_non_trivial, e alu_sel_trunc_trivial, e alu_shift_lo_bits, e alu_tag_ff_diff_inv, e alu_tag_u128_diff_inv, e alu_two_pow_shift_lo_bits, e bc_decomposition_bytes_pc_plus_36, e bc_decomposition_bytes_rem_inv, e bc_decomposition_bytes_rem_min_one_inv, e bc_decomposition_bytes_to_read, e bc_decomposition_last_of_contract, e bc_decomposition_next_packed_pc_min_pc_inv, e bc_decomposition_packed_field, e bc_decomposition_sel_packed, e bc_decomposition_sel_packed_read_0_, e bc_decomposition_sel_packed_read_1_, e bc_decomposition_sel_packed_read_2_, e bc_decomposition_sel_windows_eq_remaining, e bc_decomposition_windows_min_remaining_inv, e bc_hashing_input_len, e bc_hashing_latch, e bc_hashing_output_hash, e bc_hashing_packed_fields_0, e bc_hashing_packed_fields_1, e bc_hashing_packed_fields_2, e bc_hashing_pc_at_final_field, e bc_hashing_pc_index_1, e bc_hashing_pc_index_2, e bc_hashing_sel_not_padding_1, e bc_hashing_sel_not_padding_2, e bc_hashing_sel_not_start, e bc_hashing_size_in_bytes, e bc_retrieval_address, e bc_retrieval_artifact_hash, e bc_retrieval_bytecode_id, e bc_retrieval_current_class_id, e bc_retrieval_error, e bc_retrieval_instance_exists, e bc_retrieval_is_new_class, e bc_retrieval_next_retrieved_bytecodes_tree_root, e bc_retrieval_next_retrieved_bytecodes_tree_size, e bc_retrieval_no_remaining_bytecodes, e bc_retrieval_nullifier_tree_root, e bc_retrieval_prev_retrieved_bytecodes_tree_root, e bc_retrieval_prev_retrieved_bytecodes_tree_size, e bc_retrieval_private_functions_root, e bc_retrieval_public_data_tree_root, e bc_retrieval_remaining_bytecodes_inv, e bc_retrieval_should_retrieve, e bitwise_ctr_min_one_inv, e bitwise_end, e bitwise_err, e bitwise_ia_byte, e bitwise_ib_byte, e bitwise_ic_byte, e bitwise_output_and, e bitwise_output_or, e bitwise_output_xor, e bitwise_sel_and, e bitwise_sel_compute, e bitwise_sel_get_ctr, e bitwise_sel_or, e bitwise_sel_tag_ff_err, e bitwise_sel_tag_mismatch_err, e bitwise_sel_xor, e bitwise_start_keccak, e bitwise_start_sha256, e bitwise_tag_a, e bitwise_tag_a_inv, e bitwise_tag_ab_diff_inv, e bitwise_tag_b, e bitwise_tag_c, e calldata_diff_context_id, e calldata_hashing_index_1_, e calldata_hashing_index_2_, e calldata_hashing_input_0_, e calldata_hashing_input_1_, e calldata_hashing_input_2_, e calldata_hashing_input_len, e calldata_hashing_latch, e calldata_hashing_sel_not_padding_1, e calldata_hashing_sel_not_padding_2, e calldata_hashing_sel_not_start, e calldata_latch, e calldata_value, e class_id_derivation_artifact_hash, e class_id_derivation_class_id, e class_id_derivation_const_four, e class_id_derivation_gen_index_contract_class_id, e class_id_derivation_private_functions_root, e class_id_derivation_public_bytecode_commitment, e class_id_derivation_sel, e context_stack_bytecode_id, e context_stack_context_id, e context_stack_contract_address, e context_stack_entered_context_id, e context_stack_internal_call_id, e context_stack_internal_call_return_id, e context_stack_is_static, e context_stack_msg_sender, e context_stack_next_internal_call_id, e context_stack_next_pc, e context_stack_note_hash_tree_root, e context_stack_note_hash_tree_size, e context_stack_nullifier_tree_root, e context_stack_nullifier_tree_size, e context_stack_num_l2_to_l1_messages, e context_stack_num_note_hashes_emitted, e context_stack_num_nullifiers_emitted, e context_stack_num_public_log_fields, e context_stack_parent_calldata_addr, e context_stack_parent_calldata_size, e context_stack_parent_da_gas_limit, e context_stack_parent_da_gas_used, e context_stack_parent_id, e context_stack_parent_l2_gas_limit, e context_stack_parent_l2_gas_used, e context_stack_public_data_tree_root, e context_stack_public_data_tree_size, e context_stack_sel, e context_stack_written_public_data_slots_tree_root, e context_stack_written_public_data_slots_tree_size, e contract_instance_retrieval_address, e contract_instance_retrieval_address_sub_one, e contract_instance_retrieval_current_class_id, e contract_instance_retrieval_deployer_addr, e contract_instance_retrieval_deployer_protocol_contract_address, e contract_instance_retrieval_derived_address, e contract_instance_retrieval_derived_address_pi_index, e contract_instance_retrieval_exists, e contract_instance_retrieval_incoming_viewing_key_x, e contract_instance_retrieval_incoming_viewing_key_y, e contract_instance_retrieval_init_hash, e contract_instance_retrieval_is_protocol_contract, e contract_instance_retrieval_max_protocol_contracts, e contract_instance_retrieval_nullifier_key_x, e contract_instance_retrieval_nullifier_key_y, e contract_instance_retrieval_nullifier_tree_root, e contract_instance_retrieval_original_class_id, e contract_instance_retrieval_outgoing_viewing_key_x, e contract_instance_retrieval_outgoing_viewing_key_y, e contract_instance_retrieval_protocol_contract_derived_address_inv, e contract_instance_retrieval_public_data_tree_root, e contract_instance_retrieval_salt, e contract_instance_retrieval_sel, e contract_instance_retrieval_should_check_for_update, e contract_instance_retrieval_should_check_nullifier, e contract_instance_retrieval_tagging_key_x, e contract_instance_retrieval_tagging_key_y, e data_copy_cd_copy_col_read, e data_copy_data_index_upper_bound, e data_copy_data_index_upper_bound_gt_offset, e data_copy_dst_out_of_range_err, e data_copy_err, e data_copy_is_top_level, e data_copy_mem_size, e data_copy_offset, e data_copy_offset_plus_size, e data_copy_offset_plus_size_is_gt, e data_copy_parent_id_inv, e data_copy_read_addr_plus_one, e data_copy_read_addr_upper_bound, e data_copy_reads_left_inv, e data_copy_sel_cd_copy_start, e data_copy_sel_end, e data_copy_sel_mem_read, e data_copy_sel_mem_write, e data_copy_sel_rd_copy_start, e data_copy_sel_start_no_err, e data_copy_sel_write_count_is_zero, e data_copy_src_addr, e data_copy_src_data_size, e data_copy_src_out_of_range_err, e data_copy_tag, e data_copy_value, e data_copy_write_addr_upper_bound, e data_copy_write_count_minus_one_inv, e data_copy_write_count_zero_inv, e ecc_add_mem_dst_addr_0_, e ecc_add_mem_dst_addr_1_, e ecc_add_mem_dst_addr_2_, e ecc_add_mem_err, e ecc_add_mem_execution_clk, e ecc_add_mem_max_mem_addr, e ecc_add_mem_p_is_inf, e ecc_add_mem_p_is_on_curve_eqn, e ecc_add_mem_p_is_on_curve_eqn_inv, e ecc_add_mem_p_x, e ecc_add_mem_p_x_n, e ecc_add_mem_p_y, e ecc_add_mem_p_y_n, e ecc_add_mem_q_is_inf, e ecc_add_mem_q_is_on_curve_eqn, e ecc_add_mem_q_is_on_curve_eqn_inv, e ecc_add_mem_q_x, e ecc_add_mem_q_x_n, e ecc_add_mem_q_y, e ecc_add_mem_q_y_n, e ecc_add_mem_res_is_inf, e ecc_add_mem_res_x, e ecc_add_mem_res_y, e ecc_add_mem_sel, e ecc_add_mem_sel_dst_out_of_range_err, e ecc_add_mem_sel_p_not_on_curve_err, e ecc_add_mem_sel_q_not_on_curve_err, e ecc_add_mem_sel_should_exec, e ecc_add_mem_space_id, e ecc_add_op, e ecc_double_op, e ecc_inv_2_p_y, e ecc_inv_x_diff, e ecc_inv_y_diff, e ecc_lambda, e ecc_p_is_inf, e ecc_p_x, e ecc_p_y, e ecc_q_is_inf, e ecc_q_x, e ecc_q_y, e ecc_r_is_inf, e ecc_r_x, e ecc_r_y, e ecc_result_infinity, e ecc_sel, e ecc_use_computed_result, e ecc_x_match, e ecc_y_match, e emit_public_log_discard, e emit_public_log_end, e emit_public_log_end_log_address_upper_bound, e emit_public_log_error, e emit_public_log_error_too_many_log_fields, e emit_public_log_expected_next_log_fields, e emit_public_log_is_static, e emit_public_log_log_size, e emit_public_log_max_mem_size, e emit_public_log_max_public_logs_payload_length, e emit_public_log_next_num_public_log_fields, e emit_public_log_prev_num_public_log_fields, e emit_public_log_public_inputs_value, e emit_public_log_remaining_rows_inv, e emit_public_log_sel_read_memory, e emit_public_log_tag, e emit_public_log_tag_inv, e emit_public_log_value, e execution_addressing_error_collection_inv, e execution_addressing_gas, e execution_addressing_mode, e execution_base_address_tag, e execution_base_address_tag_diff_inv, e execution_base_address_val, e execution_base_da_gas, e execution_batched_tags_diff_inv, e execution_batched_tags_diff_inv_reg, e execution_da_gas_left, e execution_da_gas_used, e execution_dying_context_diff_inv, e execution_dying_context_id_inv, e execution_dyn_gas_id, e execution_dynamic_da_gas, e execution_dynamic_da_gas_factor, e execution_dynamic_l2_gas, e execution_dynamic_l2_gas_factor, e execution_enqueued_call_end, e execution_envvar_pi_row_idx, e execution_ex_opcode, e execution_expected_tag_reg_0_, e execution_expected_tag_reg_1_, e execution_expected_tag_reg_2_, e execution_expected_tag_reg_3_, e execution_expected_tag_reg_4_, e execution_expected_tag_reg_5_, e execution_has_parent_ctx, e execution_highest_address, e execution_instr_length, e execution_internal_call_return_id_inv, e execution_is_address, e execution_is_da_gas_left_gt_allocated, e execution_is_dagasleft, e execution_is_dying_context, e execution_is_isstaticcall, e execution_is_l2_gas_left_gt_allocated, e execution_is_l2gasleft, e execution_is_parent_id_inv, e execution_is_sender, e execution_is_transactionfee, e execution_l1_to_l2_msg_leaf_in_range, e execution_l1_to_l2_msg_tree_leaf_count, e execution_l2_gas_left, e execution_l2_gas_used, e execution_max_data_writes_reached, e execution_max_eth_address_value, e execution_mem_tag_reg_0_, e execution_mem_tag_reg_1_, e execution_mem_tag_reg_2_, e execution_mem_tag_reg_3_, e execution_mem_tag_reg_4_, e execution_mem_tag_reg_5_, e execution_nested_failure, e execution_nested_return, e execution_next_pc, e execution_note_hash_leaf_in_range, e execution_note_hash_tree_leaf_count, e execution_note_hash_tree_root, e execution_note_hash_tree_size, e execution_nullifier_tree_root, e execution_nullifier_tree_size, e execution_num_l2_to_l1_messages, e execution_num_note_hashes_emitted, e execution_num_nullifiers_emitted, e execution_num_p_limbs, e execution_num_public_log_fields, e execution_num_relative_operands_inv, e execution_op_0_, e execution_op_1_, e execution_op_2_, e execution_op_3_, e execution_op_4_, e execution_op_5_, e execution_op_6_, e execution_op_after_relative_0_, e execution_op_after_relative_1_, e execution_op_after_relative_2_, e execution_op_after_relative_3_, e execution_op_after_relative_4_, e execution_op_after_relative_5_, e execution_op_after_relative_6_, e execution_opcode_gas, e execution_out_of_gas_da, e execution_out_of_gas_l2, e execution_public_data_tree_root, e execution_public_data_tree_size, e execution_public_inputs_index, e execution_register_0_, e execution_register_1_, e execution_register_2_, e execution_register_3_, e execution_register_4_, e execution_register_5_, e execution_remaining_data_writes_inv, e execution_remaining_l2_to_l1_msgs_inv, e execution_remaining_note_hashes_inv, e execution_remaining_nullifiers_inv, e execution_retrieved_bytecodes_tree_root, e execution_retrieved_bytecodes_tree_size, e execution_rop_0_, e execution_rop_1_, e execution_rop_2_, e execution_rop_3_, e execution_rop_4_, e execution_rop_5_, e execution_rop_6_, e execution_rop_tag_0_, e execution_rop_tag_1_, e execution_rop_tag_2_, e execution_rop_tag_3_, e execution_rop_tag_4_, e execution_rop_tag_5_, e execution_rop_tag_6_, e execution_rw_reg_0_, e execution_rw_reg_1_, e execution_rw_reg_2_, e execution_rw_reg_3_, e execution_rw_reg_4_, e execution_rw_reg_5_, e execution_sel_addressing_error, e execution_sel_base_address_failure, e execution_sel_bytecode_retrieval_failure, e execution_sel_bytecode_retrieval_success, e execution_sel_do_base_check, e execution_sel_enter_call, e execution_sel_envvar_pi_lookup_col0, e execution_sel_envvar_pi_lookup_col1, e execution_sel_error, e execution_sel_exec_dispatch_alu, e execution_sel_exec_dispatch_bitwise, e execution_sel_exec_dispatch_calldata_copy, e execution_sel_exec_dispatch_cast, e execution_sel_exec_dispatch_ecc_add, e execution_sel_exec_dispatch_emit_public_log, e execution_sel_exec_dispatch_execution, e execution_sel_exec_dispatch_get_contract_instance, e execution_sel_exec_dispatch_keccakf1600, e execution_sel_exec_dispatch_poseidon2_perm, e execution_sel_exec_dispatch_returndata_copy, e execution_sel_exec_dispatch_set, e execution_sel_exec_dispatch_sha256_compression, e execution_sel_exec_dispatch_to_radix, e execution_sel_execute_call, e execution_sel_execute_debug_log, e execution_sel_execute_emit_notehash, e execution_sel_execute_emit_nullifier, e execution_sel_execute_get_env_var, e execution_sel_execute_internal_call, e execution_sel_execute_internal_return, e execution_sel_execute_jump, e execution_sel_execute_jumpi, e execution_sel_execute_l1_to_l2_message_exists, e execution_sel_execute_mov, e execution_sel_execute_notehash_exists, e execution_sel_execute_nullifier_exists, e execution_sel_execute_return, e execution_sel_execute_returndata_size, e execution_sel_execute_revert, e execution_sel_execute_send_l2_to_l1_msg, e execution_sel_execute_sload, e execution_sel_execute_sstore, e execution_sel_execute_static_call, e execution_sel_execute_success_copy, e execution_sel_exit_call, e execution_sel_failure, e execution_sel_gas_bitwise, e execution_sel_gas_calldata_copy, e execution_sel_gas_emit_public_log, e execution_sel_gas_returndata_copy, e execution_sel_gas_sstore, e execution_sel_gas_to_radix, e execution_sel_instruction_fetching_failure, e execution_sel_instruction_fetching_success, e execution_sel_l2_to_l1_msg_limit_error, e execution_sel_lookup_num_p_limbs, e execution_sel_mem_op_reg_0_, e execution_sel_mem_op_reg_1_, e execution_sel_mem_op_reg_2_, e execution_sel_mem_op_reg_3_, e execution_sel_mem_op_reg_4_, e execution_sel_mem_op_reg_5_, e execution_sel_op_do_overflow_check_0_, e execution_sel_op_do_overflow_check_1_, e execution_sel_op_do_overflow_check_2_, e execution_sel_op_do_overflow_check_3_, e execution_sel_op_do_overflow_check_4_, e execution_sel_op_do_overflow_check_5_, e execution_sel_op_do_overflow_check_6_, e execution_sel_op_is_address_0_, e execution_sel_op_is_address_1_, e execution_sel_op_is_address_2_, e execution_sel_op_is_address_3_, e execution_sel_op_is_address_4_, e execution_sel_op_is_address_5_, e execution_sel_op_is_address_6_, e execution_sel_op_is_indirect_wire_0_, e execution_sel_op_is_indirect_wire_1_, e execution_sel_op_is_indirect_wire_2_, e execution_sel_op_is_indirect_wire_3_, e execution_sel_op_is_indirect_wire_4_, e execution_sel_op_is_indirect_wire_5_, e execution_sel_op_is_indirect_wire_6_, e execution_sel_op_is_indirect_wire_7_, e execution_sel_op_is_relative_wire_0_, e execution_sel_op_is_relative_wire_1_, e execution_sel_op_is_relative_wire_2_, e execution_sel_op_is_relative_wire_3_, e execution_sel_op_is_relative_wire_4_, e execution_sel_op_is_relative_wire_5_, e execution_sel_op_is_relative_wire_6_, e execution_sel_op_is_relative_wire_7_, e execution_sel_op_reg_effective_0_, e execution_sel_op_reg_effective_1_, e execution_sel_op_reg_effective_2_, e execution_sel_op_reg_effective_3_, e execution_sel_op_reg_effective_4_, e execution_sel_op_reg_effective_5_, e execution_sel_opcode_error, e execution_sel_out_of_gas, e execution_sel_radix_gt_256, e execution_sel_reached_max_note_hashes, e execution_sel_reached_max_nullifiers, e execution_sel_read_unwind_call_stack, e execution_sel_register_read_error, e execution_sel_relative_overflow_0_, e execution_sel_relative_overflow_1_, e execution_sel_relative_overflow_2_, e execution_sel_relative_overflow_3_, e execution_sel_relative_overflow_4_, e execution_sel_relative_overflow_5_, e execution_sel_relative_overflow_6_, e execution_sel_should_apply_indirection_0_, e execution_sel_should_apply_indirection_1_, e execution_sel_should_apply_indirection_2_, e execution_sel_should_apply_indirection_3_, e execution_sel_should_apply_indirection_4_, e execution_sel_should_apply_indirection_5_, e execution_sel_should_apply_indirection_6_, e execution_sel_should_check_gas, e execution_sel_should_execute_opcode, e execution_sel_should_read_registers, e execution_sel_should_write_registers, e execution_sel_some_final_check_failed, e execution_sel_tag_check_reg_0_, e execution_sel_tag_check_reg_1_, e execution_sel_tag_check_reg_2_, e execution_sel_tag_check_reg_3_, e execution_sel_tag_check_reg_4_, e execution_sel_tag_check_reg_5_, e execution_sel_too_large_recipient_error, e execution_sel_use_num_limbs, e execution_sel_write_l2_to_l1_msg, e execution_sel_write_note_hash, e execution_sel_write_nullifier, e execution_sel_write_public_data, e execution_subtrace_id, e execution_subtrace_operation_id, e execution_total_gas_da, e execution_total_gas_l2, e execution_two_five_six, e execution_value_from_pi, e execution_written_public_data_slots_tree_root, e execution_written_public_data_slots_tree_size, e ff_gt_a, e ff_gt_b, e ff_gt_borrow, e ff_gt_cmp_rng_ctr_inv, e ff_gt_constant_128, e ff_gt_p_a_borrow, e ff_gt_p_b_borrow, e ff_gt_res_hi, e ff_gt_res_lo, e ff_gt_result, e ff_gt_sel_shift_rng, e get_contract_instance_clk, e get_contract_instance_contract_address, e get_contract_instance_dst_offset, e get_contract_instance_dst_offset_diff_max_inv, e get_contract_instance_exists_tag, e get_contract_instance_instance_exists, e get_contract_instance_is_class_id, e get_contract_instance_is_deployer, e get_contract_instance_is_init_hash, e get_contract_instance_is_valid_member_enum, e get_contract_instance_is_valid_writes_in_bounds, e get_contract_instance_member_enum, e get_contract_instance_member_tag, e get_contract_instance_member_write_offset, e get_contract_instance_nullifier_tree_root, e get_contract_instance_public_data_tree_root, e get_contract_instance_retrieved_class_id, e get_contract_instance_retrieved_deployer_addr, e get_contract_instance_retrieved_init_hash, e get_contract_instance_sel, e get_contract_instance_sel_error, e get_contract_instance_selected_member, e get_contract_instance_space_id, e gt_abs_diff, e gt_input_a, e gt_input_b, e gt_num_bits, e gt_res, e gt_sel, e gt_sel_addressing, e gt_sel_alu, e gt_sel_gas, e gt_sel_others, e gt_sel_sha256, e instr_fetching_addressing_mode, e instr_fetching_bd0, e instr_fetching_bd1, e instr_fetching_bd10, e instr_fetching_bd11, e instr_fetching_bd12, e instr_fetching_bd13, e instr_fetching_bd14, e instr_fetching_bd15, e instr_fetching_bd16, e instr_fetching_bd17, e instr_fetching_bd18, e instr_fetching_bd19, e instr_fetching_bd2, e instr_fetching_bd20, e instr_fetching_bd21, e instr_fetching_bd22, e instr_fetching_bd23, e instr_fetching_bd24, e instr_fetching_bd25, e instr_fetching_bd26, e instr_fetching_bd27, e instr_fetching_bd28, e instr_fetching_bd29, e instr_fetching_bd3, e instr_fetching_bd30, e instr_fetching_bd31, e instr_fetching_bd32, e instr_fetching_bd33, e instr_fetching_bd34, e instr_fetching_bd35, e instr_fetching_bd36, e instr_fetching_bd4, e instr_fetching_bd5, e instr_fetching_bd6, e instr_fetching_bd7, e instr_fetching_bd8, e instr_fetching_bd9, e instr_fetching_bytecode_id, e instr_fetching_bytecode_size, e instr_fetching_bytes_to_read, e instr_fetching_exec_opcode, e instr_fetching_instr_abs_diff, e instr_fetching_instr_out_of_range, e instr_fetching_instr_size, e instr_fetching_op1, e instr_fetching_op2, e instr_fetching_op3, e instr_fetching_op4, e instr_fetching_op5, e instr_fetching_op6, e instr_fetching_op7, e instr_fetching_opcode_out_of_range, e instr_fetching_pc, e instr_fetching_pc_abs_diff, e instr_fetching_pc_out_of_range, e instr_fetching_pc_size_in_bits, e instr_fetching_sel, e instr_fetching_sel_has_tag, e instr_fetching_sel_op_dc_0, e instr_fetching_sel_op_dc_1, e instr_fetching_sel_op_dc_10, e instr_fetching_sel_op_dc_11, e instr_fetching_sel_op_dc_12, e instr_fetching_sel_op_dc_13, e instr_fetching_sel_op_dc_14, e instr_fetching_sel_op_dc_15, e instr_fetching_sel_op_dc_16, e instr_fetching_sel_op_dc_2, e instr_fetching_sel_op_dc_3, e instr_fetching_sel_op_dc_4, e instr_fetching_sel_op_dc_5, e instr_fetching_sel_op_dc_6, e instr_fetching_sel_op_dc_7, e instr_fetching_sel_op_dc_8, e instr_fetching_sel_op_dc_9, e instr_fetching_sel_parsing_err, e instr_fetching_sel_pc_in_range, e instr_fetching_sel_tag_is_op2, e instr_fetching_tag_out_of_range, e instr_fetching_tag_value, e internal_call_stack_call_id, e internal_call_stack_context_id, e internal_call_stack_entered_call_id, e internal_call_stack_return_call_id, e internal_call_stack_return_pc, e internal_call_stack_sel, e keccak_memory_ctr_end, e keccak_memory_ctr_inv, e keccak_memory_last, e keccak_memory_num_rounds, e keccak_memory_single_tag_error, e keccak_memory_state_size_min_ctr_inv, e keccak_memory_tag, e keccak_memory_tag_min_u64_inv, e keccak_memory_val_24_, e keccakf1600_bitwise_and_op_id, e keccakf1600_bitwise_xor_op_id, e keccakf1600_dst_out_of_range_error, e keccakf1600_error, e keccakf1600_highest_slice_address, e keccakf1600_last, e keccakf1600_rot_64_min_len_01, e keccakf1600_rot_64_min_len_03, e keccakf1600_rot_64_min_len_11, e keccakf1600_rot_64_min_len_13, e keccakf1600_rot_64_min_len_20, e keccakf1600_rot_64_min_len_22, e keccakf1600_rot_64_min_len_24, e keccakf1600_rot_64_min_len_31, e keccakf1600_rot_64_min_len_34, e keccakf1600_rot_64_min_len_42, e keccakf1600_rot_len_02, e keccakf1600_rot_len_04, e keccakf1600_rot_len_10, e keccakf1600_rot_len_12, e keccakf1600_rot_len_14, e keccakf1600_rot_len_21, e keccakf1600_rot_len_23, e keccakf1600_rot_len_30, e keccakf1600_rot_len_32, e keccakf1600_rot_len_33, e keccakf1600_rot_len_40, e keccakf1600_rot_len_41, e keccakf1600_rot_len_43, e keccakf1600_rot_len_44, e keccakf1600_round_cst, e keccakf1600_round_inv, e keccakf1600_sel_slice_read, e keccakf1600_sel_slice_write, e keccakf1600_src_addr, e keccakf1600_src_out_of_range_error, e keccakf1600_state_chi_00, e keccakf1600_state_chi_01, e keccakf1600_state_chi_02, e keccakf1600_state_chi_03, e keccakf1600_state_chi_04, e keccakf1600_state_chi_10, e keccakf1600_state_chi_11, e keccakf1600_state_chi_12, e keccakf1600_state_chi_13, e keccakf1600_state_chi_14, e keccakf1600_state_chi_20, e keccakf1600_state_chi_21, e keccakf1600_state_chi_22, e keccakf1600_state_chi_23, e keccakf1600_state_chi_24, e keccakf1600_state_chi_30, e keccakf1600_state_chi_31, e keccakf1600_state_chi_32, e keccakf1600_state_chi_33, e keccakf1600_state_chi_34, e keccakf1600_state_chi_40, e keccakf1600_state_chi_41, e keccakf1600_state_chi_42, e keccakf1600_state_chi_43, e keccakf1600_state_chi_44, e keccakf1600_state_iota_00, e keccakf1600_state_pi_and_00, e keccakf1600_state_pi_and_01, e keccakf1600_state_pi_and_02, e keccakf1600_state_pi_and_03, e keccakf1600_state_pi_and_04, e keccakf1600_state_pi_and_10, e keccakf1600_state_pi_and_11, e keccakf1600_state_pi_and_12, e keccakf1600_state_pi_and_13, e keccakf1600_state_pi_and_14, e keccakf1600_state_pi_and_20, e keccakf1600_state_pi_and_21, e keccakf1600_state_pi_and_22, e keccakf1600_state_pi_and_23, e keccakf1600_state_pi_and_24, e keccakf1600_state_pi_and_30, e keccakf1600_state_pi_and_31, e keccakf1600_state_pi_and_32, e keccakf1600_state_pi_and_33, e keccakf1600_state_pi_and_34, e keccakf1600_state_pi_and_40, e keccakf1600_state_pi_and_41, e keccakf1600_state_pi_and_42, e keccakf1600_state_pi_and_43, e keccakf1600_state_pi_and_44, e keccakf1600_state_pi_not_00, e keccakf1600_state_pi_not_01, e keccakf1600_state_pi_not_02, e keccakf1600_state_pi_not_03, e keccakf1600_state_pi_not_04, e keccakf1600_state_pi_not_10, e keccakf1600_state_pi_not_11, e keccakf1600_state_pi_not_12, e keccakf1600_state_pi_not_13, e keccakf1600_state_pi_not_14, e keccakf1600_state_pi_not_20, e keccakf1600_state_pi_not_21, e keccakf1600_state_pi_not_22, e keccakf1600_state_pi_not_23, e keccakf1600_state_pi_not_24, e keccakf1600_state_pi_not_30, e keccakf1600_state_pi_not_31, e keccakf1600_state_pi_not_32, e keccakf1600_state_pi_not_33, e keccakf1600_state_pi_not_34, e keccakf1600_state_pi_not_40, e keccakf1600_state_pi_not_41, e keccakf1600_state_pi_not_42, e keccakf1600_state_pi_not_43, e keccakf1600_state_pi_not_44, e keccakf1600_state_rho_01, e keccakf1600_state_rho_02, e keccakf1600_state_rho_03, e keccakf1600_state_rho_04, e keccakf1600_state_rho_10, e keccakf1600_state_rho_11, e keccakf1600_state_rho_12, e keccakf1600_state_rho_13, e keccakf1600_state_rho_14, e keccakf1600_state_rho_20, e keccakf1600_state_rho_21, e keccakf1600_state_rho_22, e keccakf1600_state_rho_23, e keccakf1600_state_rho_24, e keccakf1600_state_rho_30, e keccakf1600_state_rho_31, e keccakf1600_state_rho_32, e keccakf1600_state_rho_33, e keccakf1600_state_rho_34, e keccakf1600_state_rho_40, e keccakf1600_state_rho_41, e keccakf1600_state_rho_42, e keccakf1600_state_rho_43, e keccakf1600_state_rho_44, e keccakf1600_state_theta_00, e keccakf1600_state_theta_01, e keccakf1600_state_theta_02, e keccakf1600_state_theta_03, e keccakf1600_state_theta_04, e keccakf1600_state_theta_10, e keccakf1600_state_theta_11, e keccakf1600_state_theta_12, e keccakf1600_state_theta_13, e keccakf1600_state_theta_14, e keccakf1600_state_theta_20, e keccakf1600_state_theta_21, e keccakf1600_state_theta_22, e keccakf1600_state_theta_23, e keccakf1600_state_theta_24, e keccakf1600_state_theta_30, e keccakf1600_state_theta_31, e keccakf1600_state_theta_32, e keccakf1600_state_theta_33, e keccakf1600_state_theta_34, e keccakf1600_state_theta_40, e keccakf1600_state_theta_41, e keccakf1600_state_theta_42, e keccakf1600_state_theta_43, e keccakf1600_state_theta_44, e keccakf1600_state_theta_hi_01, e keccakf1600_state_theta_hi_02, e keccakf1600_state_theta_hi_03, e keccakf1600_state_theta_hi_04, e keccakf1600_state_theta_hi_10, e keccakf1600_state_theta_hi_11, e keccakf1600_state_theta_hi_12, e keccakf1600_state_theta_hi_13, e keccakf1600_state_theta_hi_14, e keccakf1600_state_theta_hi_20, e keccakf1600_state_theta_hi_21, e keccakf1600_state_theta_hi_22, e keccakf1600_state_theta_hi_23, e keccakf1600_state_theta_hi_24, e keccakf1600_state_theta_hi_30, e keccakf1600_state_theta_hi_31, e keccakf1600_state_theta_hi_32, e keccakf1600_state_theta_hi_33, e keccakf1600_state_theta_hi_34, e keccakf1600_state_theta_hi_40, e keccakf1600_state_theta_hi_41, e keccakf1600_state_theta_hi_42, e keccakf1600_state_theta_hi_43, e keccakf1600_state_theta_hi_44, e keccakf1600_state_theta_low_01, e keccakf1600_state_theta_low_02, e keccakf1600_state_theta_low_03, e keccakf1600_state_theta_low_04, e keccakf1600_state_theta_low_10, e keccakf1600_state_theta_low_11, e keccakf1600_state_theta_low_12, e keccakf1600_state_theta_low_13, e keccakf1600_state_theta_low_14, e keccakf1600_state_theta_low_20, e keccakf1600_state_theta_low_21, e keccakf1600_state_theta_low_22, e keccakf1600_state_theta_low_23, e keccakf1600_state_theta_low_24, e keccakf1600_state_theta_low_30, e keccakf1600_state_theta_low_31, e keccakf1600_state_theta_low_32, e keccakf1600_state_theta_low_33, e keccakf1600_state_theta_low_34, e keccakf1600_state_theta_low_40, e keccakf1600_state_theta_low_41, e keccakf1600_state_theta_low_42, e keccakf1600_state_theta_low_43, e keccakf1600_state_theta_low_44, e keccakf1600_tag_error, e keccakf1600_tag_u64, e keccakf1600_theta_combined_xor_0, e keccakf1600_theta_combined_xor_1, e keccakf1600_theta_combined_xor_2, e keccakf1600_theta_combined_xor_3, e keccakf1600_theta_combined_xor_4, e keccakf1600_theta_xor_01, e keccakf1600_theta_xor_02, e keccakf1600_theta_xor_03, e keccakf1600_theta_xor_11, e keccakf1600_theta_xor_12, e keccakf1600_theta_xor_13, e keccakf1600_theta_xor_21, e keccakf1600_theta_xor_22, e keccakf1600_theta_xor_23, e keccakf1600_theta_xor_31, e keccakf1600_theta_xor_32, e keccakf1600_theta_xor_33, e keccakf1600_theta_xor_41, e keccakf1600_theta_xor_42, e keccakf1600_theta_xor_43, e keccakf1600_theta_xor_row_0, e keccakf1600_theta_xor_row_1, e keccakf1600_theta_xor_row_2, e keccakf1600_theta_xor_row_3, e keccakf1600_theta_xor_row_4, e keccakf1600_theta_xor_row_low63_0, e keccakf1600_theta_xor_row_low63_1, e keccakf1600_theta_xor_row_low63_2, e keccakf1600_theta_xor_row_low63_3, e keccakf1600_theta_xor_row_low63_4, e keccakf1600_theta_xor_row_msb_0, e keccakf1600_theta_xor_row_msb_1, e keccakf1600_theta_xor_row_msb_2, e keccakf1600_theta_xor_row_msb_3, e keccakf1600_theta_xor_row_msb_4, e keccakf1600_theta_xor_row_rotl1_0, e keccakf1600_theta_xor_row_rotl1_1, e keccakf1600_theta_xor_row_rotl1_2, e keccakf1600_theta_xor_row_rotl1_3, e keccakf1600_theta_xor_row_rotl1_4, e l1_to_l2_message_tree_check_exists, e l1_to_l2_message_tree_check_l1_to_l2_message_tree_height, e l1_to_l2_message_tree_check_leaf_index, e l1_to_l2_message_tree_check_leaf_value, e l1_to_l2_message_tree_check_leaf_value_msg_hash_diff_inv, e l1_to_l2_message_tree_check_msg_hash, e l1_to_l2_message_tree_check_root, e l1_to_l2_message_tree_check_sel, e memory_address, e memory_clk, e memory_diff, e memory_glob_addr_diff_inv, e memory_last_access, e memory_limb_0_, e memory_limb_1_, e memory_limb_2_, e memory_max_bits, e memory_sel_addressing_base, e memory_sel_addressing_indirect_0_, e memory_sel_addressing_indirect_1_, e memory_sel_addressing_indirect_2_, e memory_sel_addressing_indirect_3_, e memory_sel_addressing_indirect_4_, e memory_sel_addressing_indirect_5_, e memory_sel_addressing_indirect_6_, e memory_sel_data_copy_read, e memory_sel_data_copy_write, e memory_sel_ecc_write_0_, e memory_sel_ecc_write_1_, e memory_sel_ecc_write_2_, e memory_sel_get_contract_instance_exists_write, e memory_sel_get_contract_instance_member_write, e memory_sel_keccak, e memory_sel_poseidon2_read_0_, e memory_sel_poseidon2_read_1_, e memory_sel_poseidon2_read_2_, e memory_sel_poseidon2_read_3_, e memory_sel_poseidon2_write_0_, e memory_sel_poseidon2_write_1_, e memory_sel_poseidon2_write_2_, e memory_sel_poseidon2_write_3_, e memory_sel_public_log_read, e memory_sel_register_op_0_, e memory_sel_register_op_1_, e memory_sel_register_op_2_, e memory_sel_register_op_3_, e memory_sel_register_op_4_, e memory_sel_register_op_5_, e memory_sel_rng_chk, e memory_sel_rng_write, e memory_sel_sha256_op_0_, e memory_sel_sha256_op_1_, e memory_sel_sha256_op_2_, e memory_sel_sha256_op_3_, e memory_sel_sha256_op_4_, e memory_sel_sha256_op_5_, e memory_sel_sha256_op_6_, e memory_sel_sha256_op_7_, e memory_sel_sha256_read, e memory_sel_tag_is_ff, e memory_sel_to_radix_write, e memory_space_id, e memory_tag_ff_diff_inv, e merkle_check_const_two, e merkle_check_end, e merkle_check_index_is_even, e merkle_check_path_len_min_one_inv, e merkle_check_read_left_node, e merkle_check_read_output_hash, e merkle_check_read_right_node, e merkle_check_sibling, e merkle_check_start, e merkle_check_write_left_node, e merkle_check_write_output_hash, e merkle_check_write_right_node, e note_hash_tree_check_address, e note_hash_tree_check_const_three, e note_hash_tree_check_discard, e note_hash_tree_check_exists, e note_hash_tree_check_first_nullifier, e note_hash_tree_check_first_nullifier_pi_index, e note_hash_tree_check_leaf_index, e note_hash_tree_check_next_leaf_value, e note_hash_tree_check_next_root, e note_hash_tree_check_nonce, e note_hash_tree_check_nonce_separator, e note_hash_tree_check_note_hash, e note_hash_tree_check_note_hash_index, e note_hash_tree_check_note_hash_tree_height, e note_hash_tree_check_prev_leaf_value, e note_hash_tree_check_prev_leaf_value_unique_note_hash_diff_inv, e note_hash_tree_check_prev_root, e note_hash_tree_check_public_inputs_index, e note_hash_tree_check_sel, e note_hash_tree_check_sel_silo, e note_hash_tree_check_sel_unique, e note_hash_tree_check_sel_write_to_public_inputs, e note_hash_tree_check_siloed_note_hash, e note_hash_tree_check_siloing_separator, e note_hash_tree_check_unique_note_hash, e note_hash_tree_check_unique_note_hash_separator, e note_hash_tree_check_write, e nullifier_check_address, e nullifier_check_const_three, e nullifier_check_discard, e nullifier_check_exists, e nullifier_check_intermediate_root, e nullifier_check_leaf_not_exists, e nullifier_check_low_leaf_hash, e nullifier_check_low_leaf_index, e nullifier_check_low_leaf_next_index, e nullifier_check_low_leaf_next_nullifier, e nullifier_check_low_leaf_nullifier, e nullifier_check_new_leaf_hash, e nullifier_check_next_nullifier_inv, e nullifier_check_next_nullifier_is_nonzero, e nullifier_check_nullifier, e nullifier_check_nullifier_index, e nullifier_check_nullifier_low_leaf_nullifier_diff_inv, e nullifier_check_public_inputs_index, e nullifier_check_root, e nullifier_check_sel, e nullifier_check_sel_insert, e nullifier_check_sel_silo, e nullifier_check_sel_write_to_public_inputs, e nullifier_check_siloed_nullifier, e nullifier_check_siloing_separator, e nullifier_check_tree_height, e nullifier_check_tree_size_before_write, e nullifier_check_updated_low_leaf_hash, e nullifier_check_updated_low_leaf_next_index, e nullifier_check_updated_low_leaf_next_nullifier, e nullifier_check_write, e nullifier_check_write_root, e poseidon2_hash_b_0, e poseidon2_hash_b_1, e poseidon2_hash_b_2, e poseidon2_hash_b_3, e poseidon2_hash_end, e poseidon2_hash_input_len, e poseidon2_hash_num_perm_rounds_rem_min_one_inv, e poseidon2_hash_padding, e poseidon2_perm_B_10_0, e poseidon2_perm_B_10_1, e poseidon2_perm_B_10_2, e poseidon2_perm_B_10_3, e poseidon2_perm_B_11_0, e poseidon2_perm_B_11_1, e poseidon2_perm_B_11_2, e poseidon2_perm_B_11_3, e poseidon2_perm_B_12_0, e poseidon2_perm_B_12_1, e poseidon2_perm_B_12_2, e poseidon2_perm_B_12_3, e poseidon2_perm_B_13_0, e poseidon2_perm_B_13_1, e poseidon2_perm_B_13_2, e poseidon2_perm_B_13_3, e poseidon2_perm_B_14_0, e poseidon2_perm_B_14_1, e poseidon2_perm_B_14_2, e poseidon2_perm_B_14_3, e poseidon2_perm_B_15_0, e poseidon2_perm_B_15_1, e poseidon2_perm_B_15_2, e poseidon2_perm_B_15_3, e poseidon2_perm_B_16_0, e poseidon2_perm_B_16_1, e poseidon2_perm_B_16_2, e poseidon2_perm_B_16_3, e poseidon2_perm_B_17_0, e poseidon2_perm_B_17_1, e poseidon2_perm_B_17_2, e poseidon2_perm_B_17_3, e poseidon2_perm_B_18_0, e poseidon2_perm_B_18_1, e poseidon2_perm_B_18_2, e poseidon2_perm_B_18_3, e poseidon2_perm_B_19_0, e poseidon2_perm_B_19_1, e poseidon2_perm_B_19_2, e poseidon2_perm_B_19_3, e poseidon2_perm_B_20_0, e poseidon2_perm_B_20_1, e poseidon2_perm_B_20_2, e poseidon2_perm_B_20_3, e poseidon2_perm_B_21_0, e poseidon2_perm_B_21_1, e poseidon2_perm_B_21_2, e poseidon2_perm_B_21_3, e poseidon2_perm_B_22_0, e poseidon2_perm_B_22_1, e poseidon2_perm_B_22_2, e poseidon2_perm_B_22_3, e poseidon2_perm_B_23_0, e poseidon2_perm_B_23_1, e poseidon2_perm_B_23_2, e poseidon2_perm_B_23_3, e poseidon2_perm_B_24_0, e poseidon2_perm_B_24_1, e poseidon2_perm_B_24_2, e poseidon2_perm_B_24_3, e poseidon2_perm_B_25_0, e poseidon2_perm_B_25_1, e poseidon2_perm_B_25_2, e poseidon2_perm_B_25_3, e poseidon2_perm_B_26_0, e poseidon2_perm_B_26_1, e poseidon2_perm_B_26_2, e poseidon2_perm_B_26_3, e poseidon2_perm_B_27_0, e poseidon2_perm_B_27_1, e poseidon2_perm_B_27_2, e poseidon2_perm_B_27_3, e poseidon2_perm_B_28_0, e poseidon2_perm_B_28_1, e poseidon2_perm_B_28_2, e poseidon2_perm_B_28_3, e poseidon2_perm_B_29_0, e poseidon2_perm_B_29_1, e poseidon2_perm_B_29_2, e poseidon2_perm_B_29_3, e poseidon2_perm_B_30_0, e poseidon2_perm_B_30_1, e poseidon2_perm_B_30_2, e poseidon2_perm_B_30_3, e poseidon2_perm_B_31_0, e poseidon2_perm_B_31_1, e poseidon2_perm_B_31_2, e poseidon2_perm_B_31_3, e poseidon2_perm_B_32_0, e poseidon2_perm_B_32_1, e poseidon2_perm_B_32_2, e poseidon2_perm_B_32_3, e poseidon2_perm_B_33_0, e poseidon2_perm_B_33_1, e poseidon2_perm_B_33_2, e poseidon2_perm_B_33_3, e poseidon2_perm_B_34_0, e poseidon2_perm_B_34_1, e poseidon2_perm_B_34_2, e poseidon2_perm_B_34_3, e poseidon2_perm_B_35_0, e poseidon2_perm_B_35_1, e poseidon2_perm_B_35_2, e poseidon2_perm_B_35_3, e poseidon2_perm_B_36_0, e poseidon2_perm_B_36_1, e poseidon2_perm_B_36_2, e poseidon2_perm_B_36_3, e poseidon2_perm_B_37_0, e poseidon2_perm_B_37_1, e poseidon2_perm_B_37_2, e poseidon2_perm_B_37_3, e poseidon2_perm_B_38_0, e poseidon2_perm_B_38_1, e poseidon2_perm_B_38_2, e poseidon2_perm_B_38_3, e poseidon2_perm_B_39_0, e poseidon2_perm_B_39_1, e poseidon2_perm_B_39_2, e poseidon2_perm_B_39_3, e poseidon2_perm_B_40_0, e poseidon2_perm_B_40_1, e poseidon2_perm_B_40_2, e poseidon2_perm_B_40_3, e poseidon2_perm_B_41_0, e poseidon2_perm_B_41_1, e poseidon2_perm_B_41_2, e poseidon2_perm_B_41_3, e poseidon2_perm_B_42_0, e poseidon2_perm_B_42_1, e poseidon2_perm_B_42_2, e poseidon2_perm_B_42_3, e poseidon2_perm_B_43_0, e poseidon2_perm_B_43_1, e poseidon2_perm_B_43_2, e poseidon2_perm_B_43_3, e poseidon2_perm_B_44_0, e poseidon2_perm_B_44_1, e poseidon2_perm_B_44_2, e poseidon2_perm_B_44_3, e poseidon2_perm_B_45_0, e poseidon2_perm_B_45_1, e poseidon2_perm_B_45_2, e poseidon2_perm_B_45_3, e poseidon2_perm_B_46_0, e poseidon2_perm_B_46_1, e poseidon2_perm_B_46_2, e poseidon2_perm_B_46_3, e poseidon2_perm_B_47_0, e poseidon2_perm_B_47_1, e poseidon2_perm_B_47_2, e poseidon2_perm_B_47_3, e poseidon2_perm_B_48_0, e poseidon2_perm_B_48_1, e poseidon2_perm_B_48_2, e poseidon2_perm_B_48_3, e poseidon2_perm_B_49_0, e poseidon2_perm_B_49_1, e poseidon2_perm_B_49_2, e poseidon2_perm_B_49_3, e poseidon2_perm_B_4_0, e poseidon2_perm_B_4_1, e poseidon2_perm_B_4_2, e poseidon2_perm_B_4_3, e poseidon2_perm_B_50_0, e poseidon2_perm_B_50_1, e poseidon2_perm_B_50_2, e poseidon2_perm_B_50_3, e poseidon2_perm_B_51_0, e poseidon2_perm_B_51_1, e poseidon2_perm_B_51_2, e poseidon2_perm_B_51_3, e poseidon2_perm_B_52_0, e poseidon2_perm_B_52_1, e poseidon2_perm_B_52_2, e poseidon2_perm_B_52_3, e poseidon2_perm_B_53_0, e poseidon2_perm_B_53_1, e poseidon2_perm_B_53_2, e poseidon2_perm_B_53_3, e poseidon2_perm_B_54_0, e poseidon2_perm_B_54_1, e poseidon2_perm_B_54_2, e poseidon2_perm_B_54_3, e poseidon2_perm_B_55_0, e poseidon2_perm_B_55_1, e poseidon2_perm_B_55_2, e poseidon2_perm_B_55_3, e poseidon2_perm_B_56_0, e poseidon2_perm_B_56_1, e poseidon2_perm_B_56_2, e poseidon2_perm_B_56_3, e poseidon2_perm_B_57_0, e poseidon2_perm_B_57_1, e poseidon2_perm_B_57_2, e poseidon2_perm_B_57_3, e poseidon2_perm_B_58_0, e poseidon2_perm_B_58_1, e poseidon2_perm_B_58_2, e poseidon2_perm_B_58_3, e poseidon2_perm_B_59_0, e poseidon2_perm_B_59_1, e poseidon2_perm_B_59_2, e poseidon2_perm_B_59_3, e poseidon2_perm_B_5_0, e poseidon2_perm_B_5_1, e poseidon2_perm_B_5_2, e poseidon2_perm_B_5_3, e poseidon2_perm_B_6_0, e poseidon2_perm_B_6_1, e poseidon2_perm_B_6_2, e poseidon2_perm_B_6_3, e poseidon2_perm_B_7_0, e poseidon2_perm_B_7_1, e poseidon2_perm_B_7_2, e poseidon2_perm_B_7_3, e poseidon2_perm_B_8_0, e poseidon2_perm_B_8_1, e poseidon2_perm_B_8_2, e poseidon2_perm_B_8_3, e poseidon2_perm_B_9_0, e poseidon2_perm_B_9_1, e poseidon2_perm_B_9_2, e poseidon2_perm_B_9_3, e poseidon2_perm_EXT_LAYER_4, e poseidon2_perm_EXT_LAYER_5, e poseidon2_perm_EXT_LAYER_6, e poseidon2_perm_EXT_LAYER_7, e poseidon2_perm_T_0_4, e poseidon2_perm_T_0_5, e poseidon2_perm_T_0_6, e poseidon2_perm_T_0_7, e poseidon2_perm_T_1_4, e poseidon2_perm_T_1_5, e poseidon2_perm_T_1_6, e poseidon2_perm_T_1_7, e poseidon2_perm_T_2_4, e poseidon2_perm_T_2_5, e poseidon2_perm_T_2_6, e poseidon2_perm_T_2_7, e poseidon2_perm_T_3_4, e poseidon2_perm_T_3_5, e poseidon2_perm_T_3_6, e poseidon2_perm_T_3_7, e poseidon2_perm_T_60_4, e poseidon2_perm_T_60_5, e poseidon2_perm_T_60_6, e poseidon2_perm_T_60_7, e poseidon2_perm_T_61_4, e poseidon2_perm_T_61_5, e poseidon2_perm_T_61_6, e poseidon2_perm_T_61_7, e poseidon2_perm_T_62_4, e poseidon2_perm_T_62_5, e poseidon2_perm_T_62_6, e poseidon2_perm_T_62_7, e poseidon2_perm_T_63_4, e poseidon2_perm_T_63_5, e poseidon2_perm_T_63_6, e poseidon2_perm_T_63_7, e poseidon2_perm_a_0, e poseidon2_perm_a_1, e poseidon2_perm_a_2, e poseidon2_perm_a_3, e poseidon2_perm_b_0, e poseidon2_perm_b_1, e poseidon2_perm_b_2, e poseidon2_perm_b_3, e poseidon2_perm_mem_batch_tag_inv, e poseidon2_perm_mem_err, e poseidon2_perm_mem_execution_clk, e poseidon2_perm_mem_input_0_, e poseidon2_perm_mem_input_1_, e poseidon2_perm_mem_input_2_, e poseidon2_perm_mem_input_3_, e poseidon2_perm_mem_input_tag_0_, e poseidon2_perm_mem_input_tag_1_, e poseidon2_perm_mem_input_tag_2_, e poseidon2_perm_mem_input_tag_3_, e poseidon2_perm_mem_max_mem_addr, e poseidon2_perm_mem_output_0_, e poseidon2_perm_mem_output_1_, e poseidon2_perm_mem_output_2_, e poseidon2_perm_mem_output_3_, e poseidon2_perm_mem_read_address_0_, e poseidon2_perm_mem_read_address_1_, e poseidon2_perm_mem_read_address_2_, e poseidon2_perm_mem_read_address_3_, e poseidon2_perm_mem_sel, e poseidon2_perm_mem_sel_dst_out_of_range_err, e poseidon2_perm_mem_sel_invalid_tag_err, e poseidon2_perm_mem_sel_should_exec, e poseidon2_perm_mem_sel_should_read_mem, e poseidon2_perm_mem_sel_src_out_of_range_err, e poseidon2_perm_mem_space_id, e poseidon2_perm_mem_write_address_0_, e poseidon2_perm_mem_write_address_1_, e poseidon2_perm_mem_write_address_2_, e poseidon2_perm_mem_write_address_3_, e poseidon2_perm_sel, e public_data_check_address, e public_data_check_clk_diff_hi, e public_data_check_clk_diff_lo, e public_data_check_const_four, e public_data_check_const_three, e public_data_check_discard, e public_data_check_end, e public_data_check_final_value, e public_data_check_intermediate_root, e public_data_check_leaf_not_exists, e public_data_check_leaf_slot, e public_data_check_leaf_slot_low_leaf_slot_diff_inv, e public_data_check_length_pi_idx, e public_data_check_low_leaf_hash, e public_data_check_low_leaf_index, e public_data_check_low_leaf_next_index, e public_data_check_low_leaf_next_slot, e public_data_check_low_leaf_slot, e public_data_check_low_leaf_value, e public_data_check_new_leaf_hash, e public_data_check_next_slot_inv, e public_data_check_next_slot_is_nonzero, e public_data_check_non_discarded_write, e public_data_check_non_protocol_write, e public_data_check_not_end, e public_data_check_protocol_write, e public_data_check_public_data_writes_length, e public_data_check_root, e public_data_check_should_insert, e public_data_check_should_write_to_public_inputs, e public_data_check_siloing_separator, e public_data_check_slot, e public_data_check_tree_height, e public_data_check_tree_size_after_write, e public_data_check_tree_size_before_write, e public_data_check_updated_low_leaf_hash, e public_data_check_updated_low_leaf_next_index, e public_data_check_updated_low_leaf_next_slot, e public_data_check_updated_low_leaf_value, e public_data_check_value, e public_data_check_write, e public_data_check_write_root, e public_data_squash_check_clock, e public_data_squash_clk_diff_hi, e public_data_squash_clk_diff_lo, e public_data_squash_leaf_slot_increase, e public_data_squash_value, e range_check_dyn_diff, e range_check_dyn_rng_chk_bits, e range_check_dyn_rng_chk_pow_2, e range_check_is_lte_u112, e range_check_is_lte_u128, e range_check_is_lte_u16, e range_check_is_lte_u32, e range_check_is_lte_u48, e range_check_is_lte_u64, e range_check_is_lte_u80, e range_check_is_lte_u96, e range_check_rng_chk_bits, e range_check_sel, e range_check_sel_alu, e range_check_sel_gt, e range_check_sel_keccak, e range_check_sel_memory, e range_check_sel_r0_16_bit_rng_lookup, e range_check_sel_r1_16_bit_rng_lookup, e range_check_sel_r2_16_bit_rng_lookup, e range_check_sel_r3_16_bit_rng_lookup, e range_check_sel_r4_16_bit_rng_lookup, e range_check_sel_r5_16_bit_rng_lookup, e range_check_sel_r6_16_bit_rng_lookup, e range_check_u16_r0, e range_check_u16_r1, e range_check_u16_r2, e range_check_u16_r3, e range_check_u16_r4, e range_check_u16_r5, e range_check_u16_r6, e range_check_u16_r7, e range_check_value, e retrieved_bytecodes_tree_check_class_id, e retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv, e retrieved_bytecodes_tree_check_const_three, e retrieved_bytecodes_tree_check_intermediate_root, e retrieved_bytecodes_tree_check_leaf_not_exists, e retrieved_bytecodes_tree_check_low_leaf_class_id, e retrieved_bytecodes_tree_check_low_leaf_hash, e retrieved_bytecodes_tree_check_low_leaf_index, e retrieved_bytecodes_tree_check_low_leaf_next_class_id, e retrieved_bytecodes_tree_check_low_leaf_next_index, e retrieved_bytecodes_tree_check_new_leaf_hash, e retrieved_bytecodes_tree_check_next_class_id_inv, e retrieved_bytecodes_tree_check_next_class_id_is_nonzero, e retrieved_bytecodes_tree_check_root, e retrieved_bytecodes_tree_check_sel, e retrieved_bytecodes_tree_check_should_insert, e retrieved_bytecodes_tree_check_tree_height, e retrieved_bytecodes_tree_check_tree_size_after_write, e retrieved_bytecodes_tree_check_tree_size_before_write, e retrieved_bytecodes_tree_check_updated_low_leaf_hash, e retrieved_bytecodes_tree_check_updated_low_leaf_next_class_id, e retrieved_bytecodes_tree_check_updated_low_leaf_next_index, e retrieved_bytecodes_tree_check_write, e retrieved_bytecodes_tree_check_write_root, e scalar_mul_bit, e scalar_mul_const_two, e scalar_mul_end, e scalar_mul_sel_not_end, e scalar_mul_should_add, e sha256_a_and_b, e sha256_a_and_b_xor_a_and_c, e sha256_a_and_c, e sha256_a_rotr_13, e sha256_a_rotr_2, e sha256_a_rotr_22, e sha256_a_rotr_2_xor_a_rotr_13, e sha256_and_op_id, e sha256_b_and_c, e sha256_batch_tag_inv, e sha256_ch, e sha256_computed_w_lhs, e sha256_computed_w_rhs, e sha256_e_and_f, e sha256_e_rotr_11, e sha256_e_rotr_25, e sha256_e_rotr_6, e sha256_e_rotr_6_xor_e_rotr_11, e sha256_err, e sha256_input, e sha256_input_rounds_rem_inv, e sha256_input_tag, e sha256_input_tag_diff_inv, e sha256_last, e sha256_latch, e sha256_lhs_a_13, e sha256_lhs_a_2, e sha256_lhs_a_22, e sha256_lhs_e_11, e sha256_lhs_e_25, e sha256_lhs_e_6, e sha256_lhs_w_10, e sha256_lhs_w_17, e sha256_lhs_w_18, e sha256_lhs_w_19, e sha256_lhs_w_3, e sha256_lhs_w_7, e sha256_maj, e sha256_max_input_addr, e sha256_max_mem_addr, e sha256_max_output_addr, e sha256_max_state_addr, e sha256_mem_out_of_range_err, e sha256_memory_address_0_, e sha256_memory_address_1_, e sha256_memory_address_2_, e sha256_memory_address_3_, e sha256_memory_address_4_, e sha256_memory_address_5_, e sha256_memory_address_6_, e sha256_memory_address_7_, e sha256_memory_register_0_, e sha256_memory_register_1_, e sha256_memory_register_2_, e sha256_memory_register_3_, e sha256_memory_register_4_, e sha256_memory_register_5_, e sha256_memory_register_6_, e sha256_memory_register_7_, e sha256_memory_tag_0_, e sha256_memory_tag_1_, e sha256_memory_tag_2_, e sha256_memory_tag_3_, e sha256_memory_tag_4_, e sha256_memory_tag_5_, e sha256_memory_tag_6_, e sha256_memory_tag_7_, e sha256_next_a_lhs, e sha256_next_a_rhs, e sha256_next_e_lhs, e sha256_next_e_rhs, e sha256_not_e, e sha256_not_e_and_g, e sha256_output_a_lhs, e sha256_output_a_rhs, e sha256_output_b_lhs, e sha256_output_b_rhs, e sha256_output_c_lhs, e sha256_output_c_rhs, e sha256_output_d_lhs, e sha256_output_d_rhs, e sha256_output_e_lhs, e sha256_output_e_rhs, e sha256_output_f_lhs, e sha256_output_f_rhs, e sha256_output_g_lhs, e sha256_output_g_rhs, e sha256_output_h_lhs, e sha256_output_h_rhs, e sha256_perform_round, e sha256_rhs_a_13, e sha256_rhs_a_2, e sha256_rhs_a_22, e sha256_rhs_e_11, e sha256_rhs_e_25, e sha256_rhs_e_6, e sha256_rhs_w_10, e sha256_rhs_w_17, e sha256_rhs_w_18, e sha256_rhs_w_19, e sha256_rhs_w_3, e sha256_rhs_w_7, e sha256_round_constant, e sha256_round_count, e sha256_rounds_remaining_inv, e sha256_rw, e sha256_s_0, e sha256_s_1, e sha256_sel_compute_w, e sha256_sel_input_out_of_range_err, e sha256_sel_invalid_input_row_tag_err, e sha256_sel_invalid_state_tag_err, e sha256_sel_mem_state_or_output, e sha256_sel_output_out_of_range_err, e sha256_sel_read_input_from_memory, e sha256_sel_state_out_of_range_err, e sha256_state_addr, e sha256_two_pow_10, e sha256_two_pow_11, e sha256_two_pow_13, e sha256_two_pow_17, e sha256_two_pow_18, e sha256_two_pow_19, e sha256_two_pow_2, e sha256_two_pow_22, e sha256_two_pow_25, e sha256_two_pow_3, e sha256_two_pow_32, e sha256_two_pow_6, e sha256_two_pow_7, e sha256_u32_tag, e sha256_w, e sha256_w_15_rotr_18, e sha256_w_15_rotr_7, e sha256_w_15_rotr_7_xor_w_15_rotr_18, e sha256_w_15_rshift_3, e sha256_w_2_rotr_17, e sha256_w_2_rotr_17_xor_w_2_rotr_19, e sha256_w_2_rotr_19, e sha256_w_2_rshift_10, e sha256_w_s_0, e sha256_w_s_1, e sha256_xor_op_id, e to_radix_end, e to_radix_found, e to_radix_is_unsafe_limb, e to_radix_limb_p_diff, e to_radix_limb_radix_diff, e to_radix_mem_err, e to_radix_mem_input_validation_error, e to_radix_mem_last, e to_radix_mem_limb_index_to_lookup, e to_radix_mem_limb_value, e to_radix_mem_max_mem_size, e to_radix_mem_num_limbs_inv, e to_radix_mem_num_limbs_minus_one_inv, e to_radix_mem_output_tag, e to_radix_mem_radix_min_two_inv, e to_radix_mem_sel_dst_out_of_range_err, e to_radix_mem_sel_invalid_bitwise_radix, e to_radix_mem_sel_num_limbs_is_zero, e to_radix_mem_sel_radix_eq_2, e to_radix_mem_sel_radix_gt_256_err, e to_radix_mem_sel_radix_lt_2_err, e to_radix_mem_sel_value_is_zero, e to_radix_mem_two, e to_radix_mem_two_five_six, e to_radix_mem_value_found, e to_radix_mem_value_inv, e to_radix_mem_write_addr_upper_bound, e to_radix_p_limb, e to_radix_rem_inverse, e to_radix_safety_diff_inverse, e tx_array_length_l2_to_l1_messages_pi_offset, e tx_array_length_note_hashes_pi_offset, e tx_array_length_nullifiers_pi_offset, e tx_calldata_hash, e tx_calldata_size, e tx_const_three, e tx_contract_addr, e tx_dom_sep_public_storage_map_slot, e tx_effective_fee_per_da_gas, e tx_effective_fee_per_l2_gas, e tx_end_phase, e tx_fee_juice_balance_slot, e tx_fee_juice_balances_slot_constant, e tx_fee_juice_contract_address, e tx_fee_payer, e tx_fee_payer_balance, e tx_fee_payer_new_balance, e tx_fee_payer_pi_offset, e tx_fields_length_public_logs_pi_offset, e tx_gas_limit_pi_offset, e tx_gas_used_pi_offset, e tx_is_cleanup, e tx_is_collect_fee, e tx_is_padded, e tx_is_public_call_request, e tx_is_static, e tx_is_tree_insert_phase, e tx_is_tree_padding, e tx_l1_l2_pi_offset, e tx_l2_l1_msg_content, e tx_l2_l1_msg_contract_address, e tx_l2_l1_msg_recipient, e tx_leaf_value, e tx_msg_sender, e tx_next_da_gas_used, e tx_next_da_gas_used_sent_to_enqueued_call, e tx_next_l2_gas_used, e tx_next_l2_gas_used_sent_to_enqueued_call, e tx_next_note_hash_tree_root, e tx_next_note_hash_tree_size, e tx_next_nullifier_tree_root, e tx_next_nullifier_tree_size, e tx_next_num_l2_to_l1_messages, e tx_next_num_note_hashes_emitted, e tx_next_num_nullifiers_emitted, e tx_next_num_public_log_fields, e tx_next_phase_on_revert, e tx_next_public_data_tree_root, e tx_next_public_data_tree_size, e tx_next_retrieved_bytecodes_tree_root, e tx_next_retrieved_bytecodes_tree_size, e tx_next_written_public_data_slots_tree_root, e tx_next_written_public_data_slots_tree_size, e tx_note_hash_pi_offset, e tx_nullifier_limit_error, e tx_nullifier_pi_offset, e tx_prev_da_gas_used_sent_to_enqueued_call, e tx_prev_l2_gas_used_sent_to_enqueued_call, e tx_public_data_pi_offset, e tx_read_pi_length_offset, e tx_read_pi_start_offset, e tx_remaining_phase_inv, e tx_remaining_phase_minus_one_inv, e tx_remaining_side_effects_inv, e tx_reverted_pi_offset, e tx_sel_non_revertible_append_l2_l1_msg, e tx_sel_non_revertible_append_note_hash, e tx_sel_non_revertible_append_nullifier, e tx_sel_read_phase_length, e tx_sel_read_trees_and_gas_used, e tx_sel_revertible_append_l2_l1_msg, e tx_sel_revertible_append_note_hash, e tx_sel_revertible_append_nullifier, e tx_setup_phase_value, e tx_should_l2_l1_msg_append, e tx_should_note_hash_append, e tx_should_nullifier_append, e tx_should_process_call_request, e tx_should_read_gas_limit, e tx_should_try_l2_l1_msg_append, e tx_should_try_note_hash_append, e tx_should_try_nullifier_append, e tx_uint32_max, e tx_write_pi_offset, e update_check_address, e update_check_const_three, e update_check_current_class_id, e update_check_delayed_public_mutable_hash_slot, e update_check_delayed_public_mutable_slot, e update_check_deployer_protocol_contract_address, e update_check_dom_sep_public_storage_map_slot, e update_check_hash_not_zero, e update_check_original_class_id, e update_check_public_data_tree_root, e update_check_sel, e update_check_timestamp, e update_check_timestamp_is_lt_timestamp_of_change, e update_check_timestamp_of_change, e update_check_timestamp_of_change_bit_size, e update_check_timestamp_pi_offset, e update_check_update_hash, e update_check_update_hash_inv, e update_check_update_hi_metadata, e update_check_update_hi_metadata_bit_size, e update_check_update_post_class_id_is_zero, e update_check_update_post_class_inv, e update_check_update_pre_class_id_is_zero, e update_check_update_pre_class_inv, e update_check_update_preimage_metadata, e update_check_update_preimage_post_class_id, e update_check_update_preimage_pre_class_id, e update_check_updated_class_ids_slot, e written_public_data_slots_tree_check_address, e written_public_data_slots_tree_check_const_three, e written_public_data_slots_tree_check_intermediate_root, e written_public_data_slots_tree_check_leaf_not_exists, e written_public_data_slots_tree_check_leaf_slot, e written_public_data_slots_tree_check_low_leaf_hash, e written_public_data_slots_tree_check_low_leaf_index, e written_public_data_slots_tree_check_low_leaf_next_index, e written_public_data_slots_tree_check_low_leaf_next_slot, e written_public_data_slots_tree_check_low_leaf_slot, e written_public_data_slots_tree_check_new_leaf_hash, e written_public_data_slots_tree_check_next_slot_inv, e written_public_data_slots_tree_check_next_slot_is_nonzero, e written_public_data_slots_tree_check_root, e written_public_data_slots_tree_check_sel, e written_public_data_slots_tree_check_should_insert, e written_public_data_slots_tree_check_siloing_separator, e written_public_data_slots_tree_check_slot, e written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv, e written_public_data_slots_tree_check_tree_height, e written_public_data_slots_tree_check_tree_size_after_write, e written_public_data_slots_tree_check_tree_size_before_write, e written_public_data_slots_tree_check_updated_low_leaf_hash, e written_public_data_slots_tree_check_updated_low_leaf_next_index, e written_public_data_slots_tree_check_updated_low_leaf_next_slot, e written_public_data_slots_tree_check_write, e written_public_data_slots_tree_check_write_root, e lookup_range_check_dyn_rng_chk_pow_2_counts, e lookup_range_check_dyn_diff_is_u16_counts, e lookup_range_check_r0_is_u16_counts, e lookup_range_check_r1_is_u16_counts, e lookup_range_check_r2_is_u16_counts, e lookup_range_check_r3_is_u16_counts, e lookup_range_check_r4_is_u16_counts, e lookup_range_check_r5_is_u16_counts, e lookup_range_check_r6_is_u16_counts, e lookup_range_check_r7_is_u16_counts, e lookup_ff_gt_a_lo_range_counts, e lookup_ff_gt_a_hi_range_counts, e lookup_gt_gt_range_counts, e lookup_alu_tag_max_bits_value_counts, e lookup_alu_range_check_decomposition_a_lo_counts, e lookup_alu_range_check_decomposition_a_hi_counts, e lookup_alu_range_check_decomposition_b_lo_counts, e lookup_alu_range_check_decomposition_b_hi_counts, e lookup_alu_range_check_mul_c_hi_counts, e lookup_alu_ff_gt_counts, e lookup_alu_int_gt_counts, e lookup_alu_shifts_two_pow_counts, e lookup_alu_large_trunc_canonical_dec_counts, e lookup_alu_range_check_trunc_mid_counts, e lookup_bitwise_integral_tag_length_counts, e lookup_bitwise_byte_operations_counts, e lookup_memory_range_check_limb_0_counts, e lookup_memory_range_check_limb_1_counts, e lookup_memory_range_check_limb_2_counts, e lookup_memory_tag_max_bits_counts, e lookup_memory_range_check_write_tagged_value_counts, e lookup_keccakf1600_theta_xor_01_counts, e lookup_keccakf1600_theta_xor_02_counts, e lookup_keccakf1600_theta_xor_03_counts, e lookup_keccakf1600_theta_xor_row_0_counts, e lookup_keccakf1600_theta_xor_11_counts, e lookup_keccakf1600_theta_xor_12_counts, e lookup_keccakf1600_theta_xor_13_counts, e lookup_keccakf1600_theta_xor_row_1_counts, e lookup_keccakf1600_theta_xor_21_counts, e lookup_keccakf1600_theta_xor_22_counts, e lookup_keccakf1600_theta_xor_23_counts, e lookup_keccakf1600_theta_xor_row_2_counts, e lookup_keccakf1600_theta_xor_31_counts, e lookup_keccakf1600_theta_xor_32_counts, e lookup_keccakf1600_theta_xor_33_counts, e lookup_keccakf1600_theta_xor_row_3_counts, e lookup_keccakf1600_theta_xor_41_counts, e lookup_keccakf1600_theta_xor_42_counts, e lookup_keccakf1600_theta_xor_43_counts, e lookup_keccakf1600_theta_xor_row_4_counts, e lookup_keccakf1600_theta_combined_xor_0_counts, e lookup_keccakf1600_theta_combined_xor_1_counts, e lookup_keccakf1600_theta_combined_xor_2_counts, e lookup_keccakf1600_theta_combined_xor_3_counts, e lookup_keccakf1600_theta_combined_xor_4_counts, e lookup_keccakf1600_state_theta_00_counts, e lookup_keccakf1600_state_theta_01_counts, e lookup_keccakf1600_state_theta_02_counts, e lookup_keccakf1600_state_theta_03_counts, e lookup_keccakf1600_state_theta_04_counts, e lookup_keccakf1600_state_theta_10_counts, e lookup_keccakf1600_state_theta_11_counts, e lookup_keccakf1600_state_theta_12_counts, e lookup_keccakf1600_state_theta_13_counts, e lookup_keccakf1600_state_theta_14_counts, e lookup_keccakf1600_state_theta_20_counts, e lookup_keccakf1600_state_theta_21_counts, e lookup_keccakf1600_state_theta_22_counts, e lookup_keccakf1600_state_theta_23_counts, e lookup_keccakf1600_state_theta_24_counts, e lookup_keccakf1600_state_theta_30_counts, e lookup_keccakf1600_state_theta_31_counts, e lookup_keccakf1600_state_theta_32_counts, e lookup_keccakf1600_state_theta_33_counts, e lookup_keccakf1600_state_theta_34_counts, e lookup_keccakf1600_state_theta_40_counts, e lookup_keccakf1600_state_theta_41_counts, e lookup_keccakf1600_state_theta_42_counts, e lookup_keccakf1600_state_theta_43_counts, e lookup_keccakf1600_state_theta_44_counts, e lookup_keccakf1600_theta_limb_02_range_counts, e lookup_keccakf1600_theta_limb_04_range_counts, e lookup_keccakf1600_theta_limb_10_range_counts, e lookup_keccakf1600_theta_limb_12_range_counts, e lookup_keccakf1600_theta_limb_14_range_counts, e lookup_keccakf1600_theta_limb_21_range_counts, e lookup_keccakf1600_theta_limb_23_range_counts, e lookup_keccakf1600_theta_limb_30_range_counts, e lookup_keccakf1600_theta_limb_32_range_counts, e lookup_keccakf1600_theta_limb_33_range_counts, e lookup_keccakf1600_theta_limb_40_range_counts, e lookup_keccakf1600_theta_limb_41_range_counts, e lookup_keccakf1600_theta_limb_43_range_counts, e lookup_keccakf1600_theta_limb_44_range_counts, e lookup_keccakf1600_theta_limb_01_range_counts, e lookup_keccakf1600_theta_limb_03_range_counts, e lookup_keccakf1600_theta_limb_11_range_counts, e lookup_keccakf1600_theta_limb_13_range_counts, e lookup_keccakf1600_theta_limb_20_range_counts, e lookup_keccakf1600_theta_limb_22_range_counts, e lookup_keccakf1600_theta_limb_24_range_counts, e lookup_keccakf1600_theta_limb_31_range_counts, e lookup_keccakf1600_theta_limb_34_range_counts, e lookup_keccakf1600_theta_limb_42_range_counts, e lookup_keccakf1600_state_pi_and_00_counts, e lookup_keccakf1600_state_pi_and_01_counts, e lookup_keccakf1600_state_pi_and_02_counts, e lookup_keccakf1600_state_pi_and_03_counts, e lookup_keccakf1600_state_pi_and_04_counts, e lookup_keccakf1600_state_pi_and_10_counts, e lookup_keccakf1600_state_pi_and_11_counts, e lookup_keccakf1600_state_pi_and_12_counts, e lookup_keccakf1600_state_pi_and_13_counts, e lookup_keccakf1600_state_pi_and_14_counts, e lookup_keccakf1600_state_pi_and_20_counts, e lookup_keccakf1600_state_pi_and_21_counts, e lookup_keccakf1600_state_pi_and_22_counts, e lookup_keccakf1600_state_pi_and_23_counts, e lookup_keccakf1600_state_pi_and_24_counts, e lookup_keccakf1600_state_pi_and_30_counts, e lookup_keccakf1600_state_pi_and_31_counts, e lookup_keccakf1600_state_pi_and_32_counts, e lookup_keccakf1600_state_pi_and_33_counts, e lookup_keccakf1600_state_pi_and_34_counts, e lookup_keccakf1600_state_pi_and_40_counts, e lookup_keccakf1600_state_pi_and_41_counts, e lookup_keccakf1600_state_pi_and_42_counts, e lookup_keccakf1600_state_pi_and_43_counts, e lookup_keccakf1600_state_pi_and_44_counts, e lookup_keccakf1600_state_chi_00_counts, e lookup_keccakf1600_state_chi_01_counts, e lookup_keccakf1600_state_chi_02_counts, e lookup_keccakf1600_state_chi_03_counts, e lookup_keccakf1600_state_chi_04_counts, e lookup_keccakf1600_state_chi_10_counts, e lookup_keccakf1600_state_chi_11_counts, e lookup_keccakf1600_state_chi_12_counts, e lookup_keccakf1600_state_chi_13_counts, e lookup_keccakf1600_state_chi_14_counts, e lookup_keccakf1600_state_chi_20_counts, e lookup_keccakf1600_state_chi_21_counts, e lookup_keccakf1600_state_chi_22_counts, e lookup_keccakf1600_state_chi_23_counts, e lookup_keccakf1600_state_chi_24_counts, e lookup_keccakf1600_state_chi_30_counts, e lookup_keccakf1600_state_chi_31_counts, e lookup_keccakf1600_state_chi_32_counts, e lookup_keccakf1600_state_chi_33_counts, e lookup_keccakf1600_state_chi_34_counts, e lookup_keccakf1600_state_chi_40_counts, e lookup_keccakf1600_state_chi_41_counts, e lookup_keccakf1600_state_chi_42_counts, e lookup_keccakf1600_state_chi_43_counts, e lookup_keccakf1600_state_chi_44_counts, e lookup_keccakf1600_round_cst_counts, e lookup_keccakf1600_state_iota_00_counts, e lookup_keccakf1600_src_out_of_range_toggle_counts, e lookup_keccakf1600_dst_out_of_range_toggle_counts, e lookup_sha256_range_comp_w_lhs_counts, e lookup_sha256_range_comp_w_rhs_counts, e lookup_sha256_range_rhs_w_7_counts, e lookup_sha256_range_rhs_w_18_counts, e lookup_sha256_range_rhs_w_3_counts, e lookup_sha256_w_s_0_xor_0_counts, e lookup_sha256_w_s_0_xor_1_counts, e lookup_sha256_range_rhs_w_17_counts, e lookup_sha256_range_rhs_w_19_counts, e lookup_sha256_range_rhs_w_10_counts, e lookup_sha256_w_s_1_xor_0_counts, e lookup_sha256_w_s_1_xor_1_counts, e lookup_sha256_range_rhs_e_6_counts, e lookup_sha256_range_rhs_e_11_counts, e lookup_sha256_range_rhs_e_25_counts, e lookup_sha256_s_1_xor_0_counts, e lookup_sha256_s_1_xor_1_counts, e lookup_sha256_ch_and_0_counts, e lookup_sha256_ch_and_1_counts, e lookup_sha256_ch_xor_counts, e lookup_sha256_round_constant_counts, e lookup_sha256_range_rhs_a_2_counts, e lookup_sha256_range_rhs_a_13_counts, e lookup_sha256_range_rhs_a_22_counts, e lookup_sha256_s_0_xor_0_counts, e lookup_sha256_s_0_xor_1_counts, e lookup_sha256_maj_and_0_counts, e lookup_sha256_maj_and_1_counts, e lookup_sha256_maj_and_2_counts, e lookup_sha256_maj_xor_0_counts, e lookup_sha256_maj_xor_1_counts, e lookup_sha256_range_comp_next_a_lhs_counts, e lookup_sha256_range_comp_next_a_rhs_counts, e lookup_sha256_range_comp_next_e_lhs_counts, e lookup_sha256_range_comp_next_e_rhs_counts, e lookup_sha256_range_comp_a_lhs_counts, e lookup_sha256_range_comp_a_rhs_counts, e lookup_sha256_range_comp_b_lhs_counts, e lookup_sha256_range_comp_b_rhs_counts, e lookup_sha256_range_comp_c_lhs_counts, e lookup_sha256_range_comp_c_rhs_counts, e lookup_sha256_range_comp_d_lhs_counts, e lookup_sha256_range_comp_d_rhs_counts, e lookup_sha256_range_comp_e_lhs_counts, e lookup_sha256_range_comp_e_rhs_counts, e lookup_sha256_range_comp_f_lhs_counts, e lookup_sha256_range_comp_f_rhs_counts, e lookup_sha256_range_comp_g_lhs_counts, e lookup_sha256_range_comp_g_rhs_counts, e lookup_sha256_range_comp_h_lhs_counts, e lookup_sha256_range_comp_h_rhs_counts, e lookup_sha256_mem_check_state_addr_in_range_counts, e lookup_sha256_mem_check_input_addr_in_range_counts, e lookup_sha256_mem_check_output_addr_in_range_counts, e lookup_ecc_mem_check_dst_addr_in_range_counts, e lookup_ecc_mem_input_output_ecc_add_counts, e lookup_poseidon2_mem_check_src_addr_in_range_counts, e lookup_poseidon2_mem_check_dst_addr_in_range_counts, e lookup_poseidon2_mem_input_output_poseidon2_perm_counts, e lookup_to_radix_limb_range_counts, e lookup_to_radix_limb_less_than_radix_range_counts, e lookup_to_radix_fetch_safe_limbs_counts, e lookup_to_radix_fetch_p_limb_counts, e lookup_to_radix_limb_p_diff_range_counts, e lookup_scalar_mul_to_radix_counts, e lookup_scalar_mul_double_counts, e lookup_scalar_mul_add_counts, e lookup_to_radix_mem_check_dst_addr_in_range_counts, e lookup_to_radix_mem_check_radix_lt_2_counts, e lookup_to_radix_mem_check_radix_gt_256_counts, e lookup_to_radix_mem_input_output_to_radix_counts, e lookup_internal_call_unwind_call_stack_counts, e lookup_context_ctx_stack_rollback_counts, e lookup_context_ctx_stack_return_counts, e lookup_poseidon2_hash_poseidon2_perm_counts, e lookup_calldata_hashing_get_calldata_field_0_counts, e lookup_calldata_hashing_get_calldata_field_1_counts, e lookup_calldata_hashing_get_calldata_field_2_counts, e lookup_calldata_hashing_check_final_size_counts, e lookup_calldata_hashing_poseidon2_hash_counts, e lookup_calldata_range_check_context_id_diff_counts, e lookup_data_copy_offset_plus_size_is_gt_data_size_counts, e lookup_data_copy_check_src_addr_in_range_counts, e lookup_data_copy_check_dst_addr_in_range_counts, e lookup_data_copy_data_index_upper_bound_gt_offset_counts, e lookup_data_copy_col_read_counts, e lookup_addressing_relative_overflow_result_0_counts, e lookup_addressing_relative_overflow_result_1_counts, e lookup_addressing_relative_overflow_result_2_counts, e lookup_addressing_relative_overflow_result_3_counts, e lookup_addressing_relative_overflow_result_4_counts, e lookup_addressing_relative_overflow_result_5_counts, e lookup_addressing_relative_overflow_result_6_counts, e lookup_gas_addressing_gas_read_counts, e lookup_gas_is_out_of_gas_l2_counts, e lookup_gas_is_out_of_gas_da_counts, e lookup_merkle_check_merkle_poseidon2_read_counts, e lookup_merkle_check_merkle_poseidon2_write_counts, e lookup_nullifier_check_silo_poseidon2_counts, e lookup_nullifier_check_low_leaf_nullifier_validation_counts, e lookup_nullifier_check_low_leaf_next_nullifier_validation_counts, e lookup_nullifier_check_low_leaf_poseidon2_counts, e lookup_nullifier_check_updated_low_leaf_poseidon2_counts, e lookup_nullifier_check_low_leaf_merkle_check_counts, e lookup_nullifier_check_new_leaf_poseidon2_counts, e lookup_nullifier_check_new_leaf_merkle_check_counts, e lookup_nullifier_check_write_nullifier_to_public_inputs_counts, e lookup_public_data_squash_leaf_slot_increase_ff_gt_counts, e lookup_public_data_squash_clk_diff_range_lo_counts, e lookup_public_data_squash_clk_diff_range_hi_counts, e lookup_public_data_check_clk_diff_range_lo_counts, e lookup_public_data_check_clk_diff_range_hi_counts, e lookup_public_data_check_silo_poseidon2_counts, e lookup_public_data_check_low_leaf_slot_validation_counts, e lookup_public_data_check_low_leaf_next_slot_validation_counts, e lookup_public_data_check_low_leaf_poseidon2_0_counts, e lookup_public_data_check_low_leaf_poseidon2_1_counts, e lookup_public_data_check_updated_low_leaf_poseidon2_0_counts, e lookup_public_data_check_updated_low_leaf_poseidon2_1_counts, e lookup_public_data_check_low_leaf_merkle_check_counts, e lookup_public_data_check_new_leaf_poseidon2_0_counts, e lookup_public_data_check_new_leaf_poseidon2_1_counts, e lookup_public_data_check_new_leaf_merkle_check_counts, e lookup_public_data_check_write_public_data_to_public_inputs_counts, e lookup_public_data_check_write_writes_length_to_public_inputs_counts, e lookup_written_public_data_slots_tree_check_silo_poseidon2_counts, e lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_counts, e lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_counts, e lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_counts, e lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_counts, e lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_counts, e lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_counts, e lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_counts, e lookup_l1_to_l2_message_tree_check_merkle_check_counts, e lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_counts, e lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_counts, e lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_counts, e lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_counts, e lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_counts, e lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_counts, e lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_counts, e lookup_address_derivation_salted_initialization_hash_poseidon2_0_counts, e lookup_address_derivation_salted_initialization_hash_poseidon2_1_counts, e lookup_address_derivation_partial_address_poseidon2_counts, e lookup_address_derivation_public_keys_hash_poseidon2_0_counts, e lookup_address_derivation_public_keys_hash_poseidon2_1_counts, e lookup_address_derivation_public_keys_hash_poseidon2_2_counts, e lookup_address_derivation_public_keys_hash_poseidon2_3_counts, e lookup_address_derivation_public_keys_hash_poseidon2_4_counts, e lookup_address_derivation_preaddress_poseidon2_counts, e lookup_address_derivation_preaddress_scalar_mul_counts, e lookup_address_derivation_address_ecadd_counts, e lookup_bc_decomposition_bytes_are_bytes_counts, e lookup_bc_hashing_check_final_bytes_remaining_counts, e lookup_bc_hashing_poseidon2_hash_counts, e lookup_update_check_timestamp_from_public_inputs_counts, e lookup_update_check_delayed_public_mutable_slot_poseidon2_counts, e lookup_update_check_update_hash_public_data_read_counts, e lookup_update_check_update_hash_poseidon2_counts, e lookup_update_check_update_hi_metadata_range_counts, e lookup_update_check_update_lo_metadata_range_counts, e lookup_update_check_timestamp_is_lt_timestamp_of_change_counts, e lookup_contract_instance_retrieval_check_protocol_address_range_counts, e lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_counts, e lookup_contract_instance_retrieval_deployment_nullifier_read_counts, e lookup_contract_instance_retrieval_address_derivation_counts, e lookup_contract_instance_retrieval_update_check_counts, e lookup_bc_retrieval_contract_instance_retrieval_counts, e lookup_bc_retrieval_is_new_class_check_counts, e lookup_bc_retrieval_class_id_derivation_counts, e lookup_bc_retrieval_retrieved_bytecodes_insertion_counts, e lookup_instr_fetching_pc_abs_diff_positive_counts, e lookup_instr_fetching_instr_abs_diff_positive_counts, e lookup_instr_fetching_tag_value_validation_counts, e lookup_instr_fetching_bytecode_size_from_bc_dec_counts, e lookup_instr_fetching_bytes_from_bc_dec_counts, e lookup_instr_fetching_wire_instruction_info_counts, e lookup_class_id_derivation_class_id_poseidon2_0_counts, e lookup_class_id_derivation_class_id_poseidon2_1_counts, e lookup_get_env_var_precomputed_info_counts, e lookup_get_env_var_read_from_public_inputs_col0_counts, e lookup_get_env_var_read_from_public_inputs_col1_counts, e lookup_get_contract_instance_precomputed_info_counts, e lookup_get_contract_instance_contract_instance_retrieval_counts, e lookup_external_call_is_l2_gas_left_gt_allocated_counts, e lookup_external_call_is_da_gas_left_gt_allocated_counts, e lookup_sload_storage_read_counts, e lookup_sstore_record_written_storage_slot_counts, e lookup_note_hash_tree_check_silo_poseidon2_counts, e lookup_note_hash_tree_check_read_first_nullifier_counts, e lookup_note_hash_tree_check_nonce_computation_poseidon2_counts, e lookup_note_hash_tree_check_unique_note_hash_poseidon2_counts, e lookup_note_hash_tree_check_merkle_check_counts, e lookup_note_hash_tree_check_write_note_hash_to_public_inputs_counts, e lookup_notehash_exists_note_hash_leaf_index_in_range_counts, e lookup_notehash_exists_note_hash_read_counts, e lookup_emit_notehash_notehash_tree_write_counts, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_leaf_index_in_range_counts, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_read_counts, e lookup_nullifier_exists_nullifier_exists_check_counts, e lookup_emit_nullifier_write_nullifier_counts, e lookup_emit_public_log_check_memory_out_of_bounds_counts, e lookup_emit_public_log_check_log_fields_count_counts, e lookup_emit_public_log_write_data_to_public_inputs_counts, e lookup_send_l2_to_l1_msg_recipient_check_counts, e lookup_send_l2_to_l1_msg_write_l2_to_l1_msg_counts, e lookup_execution_bytecode_retrieval_result_counts, e lookup_execution_instruction_fetching_result_counts, e lookup_execution_instruction_fetching_body_counts, e lookup_execution_exec_spec_read_counts, e lookup_execution_dyn_l2_factor_bitwise_counts, e lookup_execution_check_radix_gt_256_counts, e lookup_execution_get_p_limbs_counts, e lookup_execution_get_max_limbs_counts, e lookup_execution_check_written_storage_slot_counts, e lookup_execution_dispatch_to_alu_counts, e lookup_execution_dispatch_to_bitwise_counts, e lookup_execution_dispatch_to_cast_counts, e lookup_execution_dispatch_to_set_counts, e lookup_tx_context_public_inputs_note_hash_tree_counts, e lookup_tx_context_public_inputs_nullifier_tree_counts, e lookup_tx_context_public_inputs_public_data_tree_counts, e lookup_tx_context_public_inputs_l1_l2_tree_counts, e lookup_tx_context_public_inputs_gas_used_counts, e lookup_tx_context_public_inputs_read_gas_limit_counts, e lookup_tx_context_public_inputs_read_reverted_counts, e lookup_tx_context_restore_state_on_revert_counts, e lookup_tx_context_public_inputs_write_note_hash_count_counts, e lookup_tx_context_public_inputs_write_nullifier_count_counts, e lookup_tx_context_public_inputs_write_l2_to_l1_message_count_counts, e lookup_tx_context_public_inputs_write_public_log_count_counts, e lookup_tx_read_phase_spec_counts, e lookup_tx_read_phase_length_counts, e lookup_tx_read_public_call_request_phase_counts, e lookup_tx_read_tree_insert_value_counts, e lookup_tx_note_hash_append_counts, e lookup_tx_nullifier_append_counts, e lookup_tx_read_l2_l1_msg_counts, e lookup_tx_write_l2_l1_msg_counts, e lookup_tx_read_effective_fee_public_inputs_counts, e lookup_tx_read_fee_payer_public_inputs_counts, e lookup_tx_balance_slot_poseidon2_counts, e lookup_tx_balance_read_counts, e lookup_tx_balance_validation_counts, e lookup_tx_write_fee_public_inputs_counts, e bc_decomposition_bytes, e bc_decomposition_bytes_pc_plus_1, e bc_decomposition_bytes_pc_plus_10, e bc_decomposition_bytes_pc_plus_11, e bc_decomposition_bytes_pc_plus_12, e bc_decomposition_bytes_pc_plus_13, e bc_decomposition_bytes_pc_plus_14, e bc_decomposition_bytes_pc_plus_15, e bc_decomposition_bytes_pc_plus_16, e bc_decomposition_bytes_pc_plus_17, e bc_decomposition_bytes_pc_plus_18, e bc_decomposition_bytes_pc_plus_19, e bc_decomposition_bytes_pc_plus_2, e bc_decomposition_bytes_pc_plus_20, e bc_decomposition_bytes_pc_plus_21, e bc_decomposition_bytes_pc_plus_22, e bc_decomposition_bytes_pc_plus_23, e bc_decomposition_bytes_pc_plus_24, e bc_decomposition_bytes_pc_plus_25, e bc_decomposition_bytes_pc_plus_26, e bc_decomposition_bytes_pc_plus_27, e bc_decomposition_bytes_pc_plus_28, e bc_decomposition_bytes_pc_plus_29, e bc_decomposition_bytes_pc_plus_3, e bc_decomposition_bytes_pc_plus_30, e bc_decomposition_bytes_pc_plus_31, e bc_decomposition_bytes_pc_plus_32, e bc_decomposition_bytes_pc_plus_33, e bc_decomposition_bytes_pc_plus_34, e bc_decomposition_bytes_pc_plus_35, e bc_decomposition_bytes_pc_plus_4, e bc_decomposition_bytes_pc_plus_5, e bc_decomposition_bytes_pc_plus_6, e bc_decomposition_bytes_pc_plus_7, e bc_decomposition_bytes_pc_plus_8, e bc_decomposition_bytes_pc_plus_9, e bc_decomposition_bytes_remaining, e bc_decomposition_id, e bc_decomposition_next_packed_pc, e bc_decomposition_pc, e bc_decomposition_sel, e bc_decomposition_sel_windows_gt_remaining, e bc_decomposition_start, e bc_hashing_bytecode_id, e bc_hashing_pc_index, e bc_hashing_rounds_rem, e bc_hashing_sel, e bc_hashing_start, e bc_retrieval_sel, e bitwise_acc_ia, e bitwise_acc_ib, e bitwise_acc_ic, e bitwise_ctr, e bitwise_op_id, e bitwise_sel, e bitwise_start, e calldata_context_id, e calldata_hashing_calldata_size, e calldata_hashing_context_id, e calldata_hashing_index_0_, e calldata_hashing_output_hash, e calldata_hashing_rounds_rem, e calldata_hashing_sel, e calldata_hashing_start, e calldata_index, e calldata_sel, e data_copy_clk, e data_copy_copy_size, e data_copy_dst_addr, e data_copy_dst_context_id, e data_copy_padding, e data_copy_read_addr, e data_copy_reads_left, e data_copy_sel, e data_copy_sel_cd_copy, e data_copy_sel_start, e data_copy_src_context_id, e emit_public_log_contract_address, e emit_public_log_correct_tag, e emit_public_log_error_out_of_bounds, e emit_public_log_error_tag_mismatch, e emit_public_log_execution_clk, e emit_public_log_is_write_contract_address, e emit_public_log_is_write_memory_value, e emit_public_log_log_address, e emit_public_log_public_inputs_index, e emit_public_log_remaining_rows, e emit_public_log_seen_wrong_tag, e emit_public_log_sel, e emit_public_log_sel_write_to_public_inputs, e emit_public_log_space_id, e emit_public_log_start, e execution_bytecode_id, e execution_clk, e execution_context_id, e execution_contract_address, e execution_da_gas_limit, e execution_discard, e execution_dying_context_id, e execution_enqueued_call_start, e execution_internal_call_id, e execution_internal_call_return_id, e execution_is_static, e execution_l1_l2_tree_root, e execution_l2_gas_limit, e execution_last_child_id, e execution_last_child_returndata_addr, e execution_last_child_returndata_size, e execution_last_child_success, e execution_msg_sender, e execution_next_context_id, e execution_next_internal_call_id, e execution_parent_calldata_addr, e execution_parent_calldata_size, e execution_parent_da_gas_limit, e execution_parent_da_gas_used, e execution_parent_id, e execution_parent_l2_gas_limit, e execution_parent_l2_gas_used, e execution_pc, e execution_prev_da_gas_used, e execution_prev_l2_gas_used, e execution_prev_note_hash_tree_root, e execution_prev_note_hash_tree_size, e execution_prev_nullifier_tree_root, e execution_prev_nullifier_tree_size, e execution_prev_num_l2_to_l1_messages, e execution_prev_num_note_hashes_emitted, e execution_prev_num_nullifiers_emitted, e execution_prev_num_public_log_fields, e execution_prev_public_data_tree_root, e execution_prev_public_data_tree_size, e execution_prev_retrieved_bytecodes_tree_root, e execution_prev_retrieved_bytecodes_tree_size, e execution_prev_written_public_data_slots_tree_root, e execution_prev_written_public_data_slots_tree_size, e execution_sel, e execution_sel_first_row_in_context, e execution_transaction_fee, e ff_gt_a_hi, e ff_gt_a_lo, e ff_gt_b_hi, e ff_gt_b_lo, e ff_gt_cmp_rng_ctr, e ff_gt_p_sub_a_hi, e ff_gt_p_sub_a_lo, e ff_gt_p_sub_b_hi, e ff_gt_p_sub_b_lo, e ff_gt_sel, e ff_gt_sel_dec, e ff_gt_sel_gt, e keccak_memory_addr, e keccak_memory_clk, e keccak_memory_ctr, e keccak_memory_rw, e keccak_memory_sel, e keccak_memory_space_id, e keccak_memory_start_read, e keccak_memory_start_write, e keccak_memory_tag_error, e keccak_memory_val_0_, e keccak_memory_val_10_, e keccak_memory_val_11_, e keccak_memory_val_12_, e keccak_memory_val_13_, e keccak_memory_val_14_, e keccak_memory_val_15_, e keccak_memory_val_16_, e keccak_memory_val_17_, e keccak_memory_val_18_, e keccak_memory_val_19_, e keccak_memory_val_1_, e keccak_memory_val_20_, e keccak_memory_val_21_, e keccak_memory_val_22_, e keccak_memory_val_23_, e keccak_memory_val_2_, e keccak_memory_val_3_, e keccak_memory_val_4_, e keccak_memory_val_5_, e keccak_memory_val_6_, e keccak_memory_val_7_, e keccak_memory_val_8_, e keccak_memory_val_9_, e keccakf1600_clk, e keccakf1600_dst_addr, e keccakf1600_round, e keccakf1600_sel, e keccakf1600_sel_no_error, e keccakf1600_space_id, e keccakf1600_start, e keccakf1600_state_in_00, e keccakf1600_state_in_01, e keccakf1600_state_in_02, e keccakf1600_state_in_03, e keccakf1600_state_in_04, e keccakf1600_state_in_10, e keccakf1600_state_in_11, e keccakf1600_state_in_12, e keccakf1600_state_in_13, e keccakf1600_state_in_14, e keccakf1600_state_in_20, e keccakf1600_state_in_21, e keccakf1600_state_in_22, e keccakf1600_state_in_23, e keccakf1600_state_in_24, e keccakf1600_state_in_30, e keccakf1600_state_in_31, e keccakf1600_state_in_32, e keccakf1600_state_in_33, e keccakf1600_state_in_34, e keccakf1600_state_in_40, e keccakf1600_state_in_41, e keccakf1600_state_in_42, e keccakf1600_state_in_43, e keccakf1600_state_in_44, e memory_global_addr, e memory_rw, e memory_sel, e memory_tag, e memory_timestamp, e memory_value, e merkle_check_index, e merkle_check_path_len, e merkle_check_read_node, e merkle_check_read_root, e merkle_check_sel, e merkle_check_write, e merkle_check_write_node, e merkle_check_write_root, e poseidon2_hash_a_0, e poseidon2_hash_a_1, e poseidon2_hash_a_2, e poseidon2_hash_a_3, e poseidon2_hash_input_0, e poseidon2_hash_input_1, e poseidon2_hash_input_2, e poseidon2_hash_num_perm_rounds_rem, e poseidon2_hash_output, e poseidon2_hash_sel, e poseidon2_hash_start, e public_data_check_clk, e public_data_check_sel, e public_data_check_write_idx, e public_data_squash_clk, e public_data_squash_final_value, e public_data_squash_leaf_slot, e public_data_squash_sel, e public_data_squash_write_to_public_inputs, e scalar_mul_bit_idx, e scalar_mul_point_inf, e scalar_mul_point_x, e scalar_mul_point_y, e scalar_mul_res_inf, e scalar_mul_res_x, e scalar_mul_res_y, e scalar_mul_scalar, e scalar_mul_sel, e scalar_mul_start, e scalar_mul_temp_inf, e scalar_mul_temp_x, e scalar_mul_temp_y, e sha256_a, e sha256_b, e sha256_c, e sha256_d, e sha256_e, e sha256_execution_clk, e sha256_f, e sha256_g, e sha256_h, e sha256_helper_w0, e sha256_helper_w1, e sha256_helper_w10, e sha256_helper_w11, e sha256_helper_w12, e sha256_helper_w13, e sha256_helper_w14, e sha256_helper_w15, e sha256_helper_w2, e sha256_helper_w3, e sha256_helper_w4, e sha256_helper_w5, e sha256_helper_w6, e sha256_helper_w7, e sha256_helper_w8, e sha256_helper_w9, e sha256_init_a, e sha256_init_b, e sha256_init_c, e sha256_init_d, e sha256_init_e, e sha256_init_f, e sha256_init_g, e sha256_init_h, e sha256_input_addr, e sha256_input_rounds_rem, e sha256_output_addr, e sha256_rounds_remaining, e sha256_sel, e sha256_sel_invalid_input_tag_err, e sha256_sel_is_input_round, e sha256_space_id, e sha256_start, e to_radix_acc, e to_radix_acc_under_p, e to_radix_limb, e to_radix_limb_eq_p, e to_radix_limb_index, e to_radix_limb_lt_p, e to_radix_mem_dst_addr, e to_radix_mem_execution_clk, e to_radix_mem_is_output_bits, e to_radix_mem_num_limbs, e to_radix_mem_radix, e to_radix_mem_sel, e to_radix_mem_sel_should_decompose, e to_radix_mem_sel_should_write_mem, e to_radix_mem_space_id, e to_radix_mem_start, e to_radix_mem_value_to_decompose, e to_radix_not_padding_limb, e to_radix_power, e to_radix_radix, e to_radix_safe_limbs, e to_radix_sel, e to_radix_start, e to_radix_value, e tx_da_gas_limit, e tx_discard, e tx_fee, e tx_is_revertible, e tx_is_teardown, e tx_l1_l2_tree_root, e tx_l1_l2_tree_size, e tx_l2_gas_limit, e tx_next_context_id, e tx_phase_value, e tx_prev_da_gas_used, e tx_prev_l2_gas_used, e tx_prev_note_hash_tree_root, e tx_prev_note_hash_tree_size, e tx_prev_nullifier_tree_root, e tx_prev_nullifier_tree_size, e tx_prev_num_l2_to_l1_messages, e tx_prev_num_note_hashes_emitted, e tx_prev_num_nullifiers_emitted, e tx_prev_num_public_log_fields, e tx_prev_public_data_tree_root, e tx_prev_public_data_tree_size, e tx_prev_retrieved_bytecodes_tree_root, e tx_prev_retrieved_bytecodes_tree_size, e tx_prev_written_public_data_slots_tree_root, e tx_prev_written_public_data_slots_tree_size, e tx_read_pi_offset, e tx_remaining_phase_counter, e tx_reverted, e tx_sel, e tx_start_phase, e tx_start_tx, e tx_tx_reverted -#define AVM2_DERIVED_WITNESS_ENTITIES_E(e) e perm_keccak_memory_slice_to_mem_inv, e perm_keccakf1600_read_to_slice_inv, e perm_keccakf1600_write_to_slice_inv, e perm_sha256_mem_mem_op_0_inv, e perm_sha256_mem_mem_op_1_inv, e perm_sha256_mem_mem_op_2_inv, e perm_sha256_mem_mem_op_3_inv, e perm_sha256_mem_mem_op_4_inv, e perm_sha256_mem_mem_op_5_inv, e perm_sha256_mem_mem_op_6_inv, e perm_sha256_mem_mem_op_7_inv, e perm_sha256_mem_mem_input_read_inv, e perm_ecc_mem_write_mem_0_inv, e perm_ecc_mem_write_mem_1_inv, e perm_ecc_mem_write_mem_2_inv, e perm_poseidon2_mem_pos_read_mem_0_inv, e perm_poseidon2_mem_pos_read_mem_1_inv, e perm_poseidon2_mem_pos_read_mem_2_inv, e perm_poseidon2_mem_pos_read_mem_3_inv, e perm_poseidon2_mem_pos_write_mem_0_inv, e perm_poseidon2_mem_pos_write_mem_1_inv, e perm_poseidon2_mem_pos_write_mem_2_inv, e perm_poseidon2_mem_pos_write_mem_3_inv, e perm_to_radix_mem_write_mem_inv, e perm_internal_call_push_call_stack_inv, e perm_context_ctx_stack_call_inv, e perm_data_copy_mem_write_inv, e perm_data_copy_mem_read_inv, e perm_addressing_base_address_from_memory_inv, e perm_addressing_indirect_from_memory_0_inv, e perm_addressing_indirect_from_memory_1_inv, e perm_addressing_indirect_from_memory_2_inv, e perm_addressing_indirect_from_memory_3_inv, e perm_addressing_indirect_from_memory_4_inv, e perm_addressing_indirect_from_memory_5_inv, e perm_addressing_indirect_from_memory_6_inv, e perm_registers_mem_op_0_inv, e perm_registers_mem_op_1_inv, e perm_registers_mem_op_2_inv, e perm_registers_mem_op_3_inv, e perm_registers_mem_op_4_inv, e perm_registers_mem_op_5_inv, e perm_public_data_check_squashing_inv, e perm_bc_hashing_bytecode_length_bytes_inv, e perm_bc_hashing_get_packed_field_0_inv, e perm_bc_hashing_get_packed_field_1_inv, e perm_bc_hashing_get_packed_field_2_inv, e perm_get_contract_instance_mem_write_contract_instance_exists_inv, e perm_get_contract_instance_mem_write_contract_instance_member_inv, e perm_sstore_storage_write_inv, e perm_emit_public_log_read_mem_inv, e perm_execution_dispatch_to_cd_copy_inv, e perm_execution_dispatch_to_rd_copy_inv, e perm_execution_dispatch_to_get_contract_instance_inv, e perm_execution_dispatch_to_emit_public_log_inv, e perm_execution_dispatch_to_poseidon2_perm_inv, e perm_execution_dispatch_to_sha256_compression_inv, e perm_execution_dispatch_to_keccakf1600_inv, e perm_execution_dispatch_to_ecc_add_inv, e perm_execution_dispatch_to_to_radix_inv, e perm_tx_read_calldata_hash_inv, e perm_tx_dispatch_exec_start_inv, e perm_tx_dispatch_exec_end_inv, e perm_tx_balance_update_inv, e lookup_range_check_dyn_rng_chk_pow_2_inv, e lookup_range_check_dyn_diff_is_u16_inv, e lookup_range_check_r0_is_u16_inv, e lookup_range_check_r1_is_u16_inv, e lookup_range_check_r2_is_u16_inv, e lookup_range_check_r3_is_u16_inv, e lookup_range_check_r4_is_u16_inv, e lookup_range_check_r5_is_u16_inv, e lookup_range_check_r6_is_u16_inv, e lookup_range_check_r7_is_u16_inv, e lookup_ff_gt_a_lo_range_inv, e lookup_ff_gt_a_hi_range_inv, e lookup_gt_gt_range_inv, e lookup_alu_tag_max_bits_value_inv, e lookup_alu_range_check_decomposition_a_lo_inv, e lookup_alu_range_check_decomposition_a_hi_inv, e lookup_alu_range_check_decomposition_b_lo_inv, e lookup_alu_range_check_decomposition_b_hi_inv, e lookup_alu_range_check_mul_c_hi_inv, e lookup_alu_ff_gt_inv, e lookup_alu_int_gt_inv, e lookup_alu_shifts_two_pow_inv, e lookup_alu_large_trunc_canonical_dec_inv, e lookup_alu_range_check_trunc_mid_inv, e lookup_bitwise_integral_tag_length_inv, e lookup_bitwise_byte_operations_inv, e lookup_memory_range_check_limb_0_inv, e lookup_memory_range_check_limb_1_inv, e lookup_memory_range_check_limb_2_inv, e lookup_memory_tag_max_bits_inv, e lookup_memory_range_check_write_tagged_value_inv, e lookup_keccakf1600_theta_xor_01_inv, e lookup_keccakf1600_theta_xor_02_inv, e lookup_keccakf1600_theta_xor_03_inv, e lookup_keccakf1600_theta_xor_row_0_inv, e lookup_keccakf1600_theta_xor_11_inv, e lookup_keccakf1600_theta_xor_12_inv, e lookup_keccakf1600_theta_xor_13_inv, e lookup_keccakf1600_theta_xor_row_1_inv, e lookup_keccakf1600_theta_xor_21_inv, e lookup_keccakf1600_theta_xor_22_inv, e lookup_keccakf1600_theta_xor_23_inv, e lookup_keccakf1600_theta_xor_row_2_inv, e lookup_keccakf1600_theta_xor_31_inv, e lookup_keccakf1600_theta_xor_32_inv, e lookup_keccakf1600_theta_xor_33_inv, e lookup_keccakf1600_theta_xor_row_3_inv, e lookup_keccakf1600_theta_xor_41_inv, e lookup_keccakf1600_theta_xor_42_inv, e lookup_keccakf1600_theta_xor_43_inv, e lookup_keccakf1600_theta_xor_row_4_inv, e lookup_keccakf1600_theta_combined_xor_0_inv, e lookup_keccakf1600_theta_combined_xor_1_inv, e lookup_keccakf1600_theta_combined_xor_2_inv, e lookup_keccakf1600_theta_combined_xor_3_inv, e lookup_keccakf1600_theta_combined_xor_4_inv, e lookup_keccakf1600_state_theta_00_inv, e lookup_keccakf1600_state_theta_01_inv, e lookup_keccakf1600_state_theta_02_inv, e lookup_keccakf1600_state_theta_03_inv, e lookup_keccakf1600_state_theta_04_inv, e lookup_keccakf1600_state_theta_10_inv, e lookup_keccakf1600_state_theta_11_inv, e lookup_keccakf1600_state_theta_12_inv, e lookup_keccakf1600_state_theta_13_inv, e lookup_keccakf1600_state_theta_14_inv, e lookup_keccakf1600_state_theta_20_inv, e lookup_keccakf1600_state_theta_21_inv, e lookup_keccakf1600_state_theta_22_inv, e lookup_keccakf1600_state_theta_23_inv, e lookup_keccakf1600_state_theta_24_inv, e lookup_keccakf1600_state_theta_30_inv, e lookup_keccakf1600_state_theta_31_inv, e lookup_keccakf1600_state_theta_32_inv, e lookup_keccakf1600_state_theta_33_inv, e lookup_keccakf1600_state_theta_34_inv, e lookup_keccakf1600_state_theta_40_inv, e lookup_keccakf1600_state_theta_41_inv, e lookup_keccakf1600_state_theta_42_inv, e lookup_keccakf1600_state_theta_43_inv, e lookup_keccakf1600_state_theta_44_inv, e lookup_keccakf1600_theta_limb_02_range_inv, e lookup_keccakf1600_theta_limb_04_range_inv, e lookup_keccakf1600_theta_limb_10_range_inv, e lookup_keccakf1600_theta_limb_12_range_inv, e lookup_keccakf1600_theta_limb_14_range_inv, e lookup_keccakf1600_theta_limb_21_range_inv, e lookup_keccakf1600_theta_limb_23_range_inv, e lookup_keccakf1600_theta_limb_30_range_inv, e lookup_keccakf1600_theta_limb_32_range_inv, e lookup_keccakf1600_theta_limb_33_range_inv, e lookup_keccakf1600_theta_limb_40_range_inv, e lookup_keccakf1600_theta_limb_41_range_inv, e lookup_keccakf1600_theta_limb_43_range_inv, e lookup_keccakf1600_theta_limb_44_range_inv, e lookup_keccakf1600_theta_limb_01_range_inv, e lookup_keccakf1600_theta_limb_03_range_inv, e lookup_keccakf1600_theta_limb_11_range_inv, e lookup_keccakf1600_theta_limb_13_range_inv, e lookup_keccakf1600_theta_limb_20_range_inv, e lookup_keccakf1600_theta_limb_22_range_inv, e lookup_keccakf1600_theta_limb_24_range_inv, e lookup_keccakf1600_theta_limb_31_range_inv, e lookup_keccakf1600_theta_limb_34_range_inv, e lookup_keccakf1600_theta_limb_42_range_inv, e lookup_keccakf1600_state_pi_and_00_inv, e lookup_keccakf1600_state_pi_and_01_inv, e lookup_keccakf1600_state_pi_and_02_inv, e lookup_keccakf1600_state_pi_and_03_inv, e lookup_keccakf1600_state_pi_and_04_inv, e lookup_keccakf1600_state_pi_and_10_inv, e lookup_keccakf1600_state_pi_and_11_inv, e lookup_keccakf1600_state_pi_and_12_inv, e lookup_keccakf1600_state_pi_and_13_inv, e lookup_keccakf1600_state_pi_and_14_inv, e lookup_keccakf1600_state_pi_and_20_inv, e lookup_keccakf1600_state_pi_and_21_inv, e lookup_keccakf1600_state_pi_and_22_inv, e lookup_keccakf1600_state_pi_and_23_inv, e lookup_keccakf1600_state_pi_and_24_inv, e lookup_keccakf1600_state_pi_and_30_inv, e lookup_keccakf1600_state_pi_and_31_inv, e lookup_keccakf1600_state_pi_and_32_inv, e lookup_keccakf1600_state_pi_and_33_inv, e lookup_keccakf1600_state_pi_and_34_inv, e lookup_keccakf1600_state_pi_and_40_inv, e lookup_keccakf1600_state_pi_and_41_inv, e lookup_keccakf1600_state_pi_and_42_inv, e lookup_keccakf1600_state_pi_and_43_inv, e lookup_keccakf1600_state_pi_and_44_inv, e lookup_keccakf1600_state_chi_00_inv, e lookup_keccakf1600_state_chi_01_inv, e lookup_keccakf1600_state_chi_02_inv, e lookup_keccakf1600_state_chi_03_inv, e lookup_keccakf1600_state_chi_04_inv, e lookup_keccakf1600_state_chi_10_inv, e lookup_keccakf1600_state_chi_11_inv, e lookup_keccakf1600_state_chi_12_inv, e lookup_keccakf1600_state_chi_13_inv, e lookup_keccakf1600_state_chi_14_inv, e lookup_keccakf1600_state_chi_20_inv, e lookup_keccakf1600_state_chi_21_inv, e lookup_keccakf1600_state_chi_22_inv, e lookup_keccakf1600_state_chi_23_inv, e lookup_keccakf1600_state_chi_24_inv, e lookup_keccakf1600_state_chi_30_inv, e lookup_keccakf1600_state_chi_31_inv, e lookup_keccakf1600_state_chi_32_inv, e lookup_keccakf1600_state_chi_33_inv, e lookup_keccakf1600_state_chi_34_inv, e lookup_keccakf1600_state_chi_40_inv, e lookup_keccakf1600_state_chi_41_inv, e lookup_keccakf1600_state_chi_42_inv, e lookup_keccakf1600_state_chi_43_inv, e lookup_keccakf1600_state_chi_44_inv, e lookup_keccakf1600_round_cst_inv, e lookup_keccakf1600_state_iota_00_inv, e lookup_keccakf1600_src_out_of_range_toggle_inv, e lookup_keccakf1600_dst_out_of_range_toggle_inv, e lookup_sha256_range_comp_w_lhs_inv, e lookup_sha256_range_comp_w_rhs_inv, e lookup_sha256_range_rhs_w_7_inv, e lookup_sha256_range_rhs_w_18_inv, e lookup_sha256_range_rhs_w_3_inv, e lookup_sha256_w_s_0_xor_0_inv, e lookup_sha256_w_s_0_xor_1_inv, e lookup_sha256_range_rhs_w_17_inv, e lookup_sha256_range_rhs_w_19_inv, e lookup_sha256_range_rhs_w_10_inv, e lookup_sha256_w_s_1_xor_0_inv, e lookup_sha256_w_s_1_xor_1_inv, e lookup_sha256_range_rhs_e_6_inv, e lookup_sha256_range_rhs_e_11_inv, e lookup_sha256_range_rhs_e_25_inv, e lookup_sha256_s_1_xor_0_inv, e lookup_sha256_s_1_xor_1_inv, e lookup_sha256_ch_and_0_inv, e lookup_sha256_ch_and_1_inv, e lookup_sha256_ch_xor_inv, e lookup_sha256_round_constant_inv, e lookup_sha256_range_rhs_a_2_inv, e lookup_sha256_range_rhs_a_13_inv, e lookup_sha256_range_rhs_a_22_inv, e lookup_sha256_s_0_xor_0_inv, e lookup_sha256_s_0_xor_1_inv, e lookup_sha256_maj_and_0_inv, e lookup_sha256_maj_and_1_inv, e lookup_sha256_maj_and_2_inv, e lookup_sha256_maj_xor_0_inv, e lookup_sha256_maj_xor_1_inv, e lookup_sha256_range_comp_next_a_lhs_inv, e lookup_sha256_range_comp_next_a_rhs_inv, e lookup_sha256_range_comp_next_e_lhs_inv, e lookup_sha256_range_comp_next_e_rhs_inv, e lookup_sha256_range_comp_a_lhs_inv, e lookup_sha256_range_comp_a_rhs_inv, e lookup_sha256_range_comp_b_lhs_inv, e lookup_sha256_range_comp_b_rhs_inv, e lookup_sha256_range_comp_c_lhs_inv, e lookup_sha256_range_comp_c_rhs_inv, e lookup_sha256_range_comp_d_lhs_inv, e lookup_sha256_range_comp_d_rhs_inv, e lookup_sha256_range_comp_e_lhs_inv, e lookup_sha256_range_comp_e_rhs_inv, e lookup_sha256_range_comp_f_lhs_inv, e lookup_sha256_range_comp_f_rhs_inv, e lookup_sha256_range_comp_g_lhs_inv, e lookup_sha256_range_comp_g_rhs_inv, e lookup_sha256_range_comp_h_lhs_inv, e lookup_sha256_range_comp_h_rhs_inv, e lookup_sha256_mem_check_state_addr_in_range_inv, e lookup_sha256_mem_check_input_addr_in_range_inv, e lookup_sha256_mem_check_output_addr_in_range_inv, e lookup_ecc_mem_check_dst_addr_in_range_inv, e lookup_ecc_mem_input_output_ecc_add_inv, e lookup_poseidon2_mem_check_src_addr_in_range_inv, e lookup_poseidon2_mem_check_dst_addr_in_range_inv, e lookup_poseidon2_mem_input_output_poseidon2_perm_inv, e lookup_to_radix_limb_range_inv, e lookup_to_radix_limb_less_than_radix_range_inv, e lookup_to_radix_fetch_safe_limbs_inv, e lookup_to_radix_fetch_p_limb_inv, e lookup_to_radix_limb_p_diff_range_inv, e lookup_scalar_mul_to_radix_inv, e lookup_scalar_mul_double_inv, e lookup_scalar_mul_add_inv, e lookup_to_radix_mem_check_dst_addr_in_range_inv, e lookup_to_radix_mem_check_radix_lt_2_inv, e lookup_to_radix_mem_check_radix_gt_256_inv, e lookup_to_radix_mem_input_output_to_radix_inv, e lookup_internal_call_unwind_call_stack_inv, e lookup_context_ctx_stack_rollback_inv, e lookup_context_ctx_stack_return_inv, e lookup_poseidon2_hash_poseidon2_perm_inv, e lookup_calldata_hashing_get_calldata_field_0_inv, e lookup_calldata_hashing_get_calldata_field_1_inv, e lookup_calldata_hashing_get_calldata_field_2_inv, e lookup_calldata_hashing_check_final_size_inv, e lookup_calldata_hashing_poseidon2_hash_inv, e lookup_calldata_range_check_context_id_diff_inv, e lookup_data_copy_offset_plus_size_is_gt_data_size_inv, e lookup_data_copy_check_src_addr_in_range_inv, e lookup_data_copy_check_dst_addr_in_range_inv, e lookup_data_copy_data_index_upper_bound_gt_offset_inv, e lookup_data_copy_col_read_inv, e lookup_addressing_relative_overflow_result_0_inv, e lookup_addressing_relative_overflow_result_1_inv, e lookup_addressing_relative_overflow_result_2_inv, e lookup_addressing_relative_overflow_result_3_inv, e lookup_addressing_relative_overflow_result_4_inv, e lookup_addressing_relative_overflow_result_5_inv, e lookup_addressing_relative_overflow_result_6_inv, e lookup_gas_addressing_gas_read_inv, e lookup_gas_is_out_of_gas_l2_inv, e lookup_gas_is_out_of_gas_da_inv, e lookup_merkle_check_merkle_poseidon2_read_inv, e lookup_merkle_check_merkle_poseidon2_write_inv, e lookup_nullifier_check_silo_poseidon2_inv, e lookup_nullifier_check_low_leaf_nullifier_validation_inv, e lookup_nullifier_check_low_leaf_next_nullifier_validation_inv, e lookup_nullifier_check_low_leaf_poseidon2_inv, e lookup_nullifier_check_updated_low_leaf_poseidon2_inv, e lookup_nullifier_check_low_leaf_merkle_check_inv, e lookup_nullifier_check_new_leaf_poseidon2_inv, e lookup_nullifier_check_new_leaf_merkle_check_inv, e lookup_nullifier_check_write_nullifier_to_public_inputs_inv, e lookup_public_data_squash_leaf_slot_increase_ff_gt_inv, e lookup_public_data_squash_clk_diff_range_lo_inv, e lookup_public_data_squash_clk_diff_range_hi_inv, e lookup_public_data_check_clk_diff_range_lo_inv, e lookup_public_data_check_clk_diff_range_hi_inv, e lookup_public_data_check_silo_poseidon2_inv, e lookup_public_data_check_low_leaf_slot_validation_inv, e lookup_public_data_check_low_leaf_next_slot_validation_inv, e lookup_public_data_check_low_leaf_poseidon2_0_inv, e lookup_public_data_check_low_leaf_poseidon2_1_inv, e lookup_public_data_check_updated_low_leaf_poseidon2_0_inv, e lookup_public_data_check_updated_low_leaf_poseidon2_1_inv, e lookup_public_data_check_low_leaf_merkle_check_inv, e lookup_public_data_check_new_leaf_poseidon2_0_inv, e lookup_public_data_check_new_leaf_poseidon2_1_inv, e lookup_public_data_check_new_leaf_merkle_check_inv, e lookup_public_data_check_write_public_data_to_public_inputs_inv, e lookup_public_data_check_write_writes_length_to_public_inputs_inv, e lookup_written_public_data_slots_tree_check_silo_poseidon2_inv, e lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_inv, e lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_inv, e lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_inv, e lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_inv, e lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_inv, e lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_inv, e lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_inv, e lookup_l1_to_l2_message_tree_check_merkle_check_inv, e lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_inv, e lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_inv, e lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_inv, e lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_inv, e lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_inv, e lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_inv, e lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_inv, e lookup_address_derivation_salted_initialization_hash_poseidon2_0_inv, e lookup_address_derivation_salted_initialization_hash_poseidon2_1_inv, e lookup_address_derivation_partial_address_poseidon2_inv, e lookup_address_derivation_public_keys_hash_poseidon2_0_inv, e lookup_address_derivation_public_keys_hash_poseidon2_1_inv, e lookup_address_derivation_public_keys_hash_poseidon2_2_inv, e lookup_address_derivation_public_keys_hash_poseidon2_3_inv, e lookup_address_derivation_public_keys_hash_poseidon2_4_inv, e lookup_address_derivation_preaddress_poseidon2_inv, e lookup_address_derivation_preaddress_scalar_mul_inv, e lookup_address_derivation_address_ecadd_inv, e lookup_bc_decomposition_bytes_are_bytes_inv, e lookup_bc_hashing_check_final_bytes_remaining_inv, e lookup_bc_hashing_poseidon2_hash_inv, e lookup_update_check_timestamp_from_public_inputs_inv, e lookup_update_check_delayed_public_mutable_slot_poseidon2_inv, e lookup_update_check_update_hash_public_data_read_inv, e lookup_update_check_update_hash_poseidon2_inv, e lookup_update_check_update_hi_metadata_range_inv, e lookup_update_check_update_lo_metadata_range_inv, e lookup_update_check_timestamp_is_lt_timestamp_of_change_inv, e lookup_contract_instance_retrieval_check_protocol_address_range_inv, e lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_inv, e lookup_contract_instance_retrieval_deployment_nullifier_read_inv, e lookup_contract_instance_retrieval_address_derivation_inv, e lookup_contract_instance_retrieval_update_check_inv, e lookup_bc_retrieval_contract_instance_retrieval_inv, e lookup_bc_retrieval_is_new_class_check_inv, e lookup_bc_retrieval_class_id_derivation_inv, e lookup_bc_retrieval_retrieved_bytecodes_insertion_inv, e lookup_instr_fetching_pc_abs_diff_positive_inv, e lookup_instr_fetching_instr_abs_diff_positive_inv, e lookup_instr_fetching_tag_value_validation_inv, e lookup_instr_fetching_bytecode_size_from_bc_dec_inv, e lookup_instr_fetching_bytes_from_bc_dec_inv, e lookup_instr_fetching_wire_instruction_info_inv, e lookup_class_id_derivation_class_id_poseidon2_0_inv, e lookup_class_id_derivation_class_id_poseidon2_1_inv, e lookup_get_env_var_precomputed_info_inv, e lookup_get_env_var_read_from_public_inputs_col0_inv, e lookup_get_env_var_read_from_public_inputs_col1_inv, e lookup_get_contract_instance_precomputed_info_inv, e lookup_get_contract_instance_contract_instance_retrieval_inv, e lookup_external_call_is_l2_gas_left_gt_allocated_inv, e lookup_external_call_is_da_gas_left_gt_allocated_inv, e lookup_sload_storage_read_inv, e lookup_sstore_record_written_storage_slot_inv, e lookup_note_hash_tree_check_silo_poseidon2_inv, e lookup_note_hash_tree_check_read_first_nullifier_inv, e lookup_note_hash_tree_check_nonce_computation_poseidon2_inv, e lookup_note_hash_tree_check_unique_note_hash_poseidon2_inv, e lookup_note_hash_tree_check_merkle_check_inv, e lookup_note_hash_tree_check_write_note_hash_to_public_inputs_inv, e lookup_notehash_exists_note_hash_leaf_index_in_range_inv, e lookup_notehash_exists_note_hash_read_inv, e lookup_emit_notehash_notehash_tree_write_inv, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_leaf_index_in_range_inv, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_read_inv, e lookup_nullifier_exists_nullifier_exists_check_inv, e lookup_emit_nullifier_write_nullifier_inv, e lookup_emit_public_log_check_memory_out_of_bounds_inv, e lookup_emit_public_log_check_log_fields_count_inv, e lookup_emit_public_log_write_data_to_public_inputs_inv, e lookup_send_l2_to_l1_msg_recipient_check_inv, e lookup_send_l2_to_l1_msg_write_l2_to_l1_msg_inv, e lookup_execution_bytecode_retrieval_result_inv, e lookup_execution_instruction_fetching_result_inv, e lookup_execution_instruction_fetching_body_inv, e lookup_execution_exec_spec_read_inv, e lookup_execution_dyn_l2_factor_bitwise_inv, e lookup_execution_check_radix_gt_256_inv, e lookup_execution_get_p_limbs_inv, e lookup_execution_get_max_limbs_inv, e lookup_execution_check_written_storage_slot_inv, e lookup_execution_dispatch_to_alu_inv, e lookup_execution_dispatch_to_bitwise_inv, e lookup_execution_dispatch_to_cast_inv, e lookup_execution_dispatch_to_set_inv, e lookup_tx_context_public_inputs_note_hash_tree_inv, e lookup_tx_context_public_inputs_nullifier_tree_inv, e lookup_tx_context_public_inputs_public_data_tree_inv, e lookup_tx_context_public_inputs_l1_l2_tree_inv, e lookup_tx_context_public_inputs_gas_used_inv, e lookup_tx_context_public_inputs_read_gas_limit_inv, e lookup_tx_context_public_inputs_read_reverted_inv, e lookup_tx_context_restore_state_on_revert_inv, e lookup_tx_context_public_inputs_write_note_hash_count_inv, e lookup_tx_context_public_inputs_write_nullifier_count_inv, e lookup_tx_context_public_inputs_write_l2_to_l1_message_count_inv, e lookup_tx_context_public_inputs_write_public_log_count_inv, e lookup_tx_read_phase_spec_inv, e lookup_tx_read_phase_length_inv, e lookup_tx_read_public_call_request_phase_inv, e lookup_tx_read_tree_insert_value_inv, e lookup_tx_note_hash_append_inv, e lookup_tx_nullifier_append_inv, e lookup_tx_read_l2_l1_msg_inv, e lookup_tx_write_l2_l1_msg_inv, e lookup_tx_read_effective_fee_public_inputs_inv, e lookup_tx_read_fee_payer_public_inputs_inv, e lookup_tx_balance_slot_poseidon2_inv, e lookup_tx_balance_read_inv, e lookup_tx_balance_validation_inv, e lookup_tx_write_fee_public_inputs_inv +#define AVM2_WIRE_ENTITIES_E(e) e public_inputs_cols_0_, e public_inputs_cols_1_, e public_inputs_cols_2_, e public_inputs_cols_3_, e address_derivation_address, e address_derivation_address_y, e address_derivation_class_id, e address_derivation_const_four, e address_derivation_const_thirteen, e address_derivation_const_three, e address_derivation_const_two, e address_derivation_deployer_addr, e address_derivation_g1_x, e address_derivation_g1_y, e address_derivation_incoming_viewing_key_x, e address_derivation_incoming_viewing_key_y, e address_derivation_init_hash, e address_derivation_nullifier_key_x, e address_derivation_nullifier_key_y, e address_derivation_outgoing_viewing_key_x, e address_derivation_outgoing_viewing_key_y, e address_derivation_partial_address, e address_derivation_partial_address_domain_separator, e address_derivation_preaddress, e address_derivation_preaddress_domain_separator, e address_derivation_preaddress_public_key_x, e address_derivation_preaddress_public_key_y, e address_derivation_public_keys_hash, e address_derivation_public_keys_hash_domain_separator, e address_derivation_salt, e address_derivation_salted_init_hash, e address_derivation_sel, e address_derivation_tagging_key_x, e address_derivation_tagging_key_y, e alu_a_hi, e alu_a_hi_bits, e alu_a_lo, e alu_a_lo_bits, e alu_ab_diff_inv, e alu_ab_tags_diff_inv, e alu_b_hi, e alu_b_inv, e alu_b_lo, e alu_c_hi, e alu_cf, e alu_constant_64, e alu_gt_input_a, e alu_gt_input_b, e alu_gt_result_c, e alu_helper1, e alu_ia, e alu_ia_tag, e alu_ib, e alu_ib_tag, e alu_ic, e alu_ic_tag, e alu_max_bits, e alu_max_value, e alu_mid, e alu_mid_bits, e alu_op_id, e alu_sel, e alu_sel_ab_tag_mismatch, e alu_sel_decompose_a, e alu_sel_div_0_err, e alu_sel_div_no_err, e alu_sel_err, e alu_sel_ff_gt, e alu_sel_int_gt, e alu_sel_is_ff, e alu_sel_is_u128, e alu_sel_mul_div_u128, e alu_sel_mul_no_err_non_ff, e alu_sel_op_add, e alu_sel_op_div, e alu_sel_op_eq, e alu_sel_op_fdiv, e alu_sel_op_lt, e alu_sel_op_lte, e alu_sel_op_mul, e alu_sel_op_not, e alu_sel_op_shl, e alu_sel_op_shr, e alu_sel_op_sub, e alu_sel_op_truncate, e alu_sel_shift_ops_no_overflow, e alu_sel_tag_err, e alu_sel_trunc_gte_128, e alu_sel_trunc_lt_128, e alu_sel_trunc_non_trivial, e alu_sel_trunc_trivial, e alu_shift_lo_bits, e alu_tag_ff_diff_inv, e alu_tag_u128_diff_inv, e alu_two_pow_shift_lo_bits, e bc_decomposition_bytes_pc_plus_36, e bc_decomposition_bytes_rem_inv, e bc_decomposition_bytes_rem_min_one_inv, e bc_decomposition_bytes_to_read, e bc_decomposition_last_of_contract, e bc_decomposition_next_packed_pc_min_pc_inv, e bc_decomposition_packed_field, e bc_decomposition_sel_packed, e bc_decomposition_sel_packed_read_0_, e bc_decomposition_sel_packed_read_1_, e bc_decomposition_sel_packed_read_2_, e bc_decomposition_sel_windows_eq_remaining, e bc_decomposition_windows_min_remaining_inv, e bc_hashing_input_len, e bc_hashing_latch, e bc_hashing_output_hash, e bc_hashing_packed_fields_0, e bc_hashing_packed_fields_1, e bc_hashing_packed_fields_2, e bc_hashing_pc_at_final_field, e bc_hashing_pc_index_1, e bc_hashing_pc_index_2, e bc_hashing_sel_not_padding_1, e bc_hashing_sel_not_padding_2, e bc_hashing_sel_not_start, e bc_hashing_size_in_bytes, e bc_retrieval_address, e bc_retrieval_artifact_hash, e bc_retrieval_bytecode_id, e bc_retrieval_current_class_id, e bc_retrieval_error, e bc_retrieval_instance_exists, e bc_retrieval_is_new_class, e bc_retrieval_next_retrieved_bytecodes_tree_root, e bc_retrieval_next_retrieved_bytecodes_tree_size, e bc_retrieval_no_remaining_bytecodes, e bc_retrieval_nullifier_tree_root, e bc_retrieval_prev_retrieved_bytecodes_tree_root, e bc_retrieval_prev_retrieved_bytecodes_tree_size, e bc_retrieval_private_functions_root, e bc_retrieval_public_data_tree_root, e bc_retrieval_remaining_bytecodes_inv, e bc_retrieval_retrieved_bytecodes_tree_height, e bc_retrieval_should_retrieve, e bitwise_ctr_min_one_inv, e bitwise_end, e bitwise_err, e bitwise_ia_byte, e bitwise_ib_byte, e bitwise_ic_byte, e bitwise_output_and, e bitwise_output_or, e bitwise_output_xor, e bitwise_sel_and, e bitwise_sel_compute, e bitwise_sel_get_ctr, e bitwise_sel_or, e bitwise_sel_tag_ff_err, e bitwise_sel_tag_mismatch_err, e bitwise_sel_xor, e bitwise_start_keccak, e bitwise_start_sha256, e bitwise_tag_a, e bitwise_tag_a_inv, e bitwise_tag_ab_diff_inv, e bitwise_tag_b, e bitwise_tag_c, e calldata_diff_context_id, e calldata_hashing_index_1_, e calldata_hashing_index_2_, e calldata_hashing_input_0_, e calldata_hashing_input_1_, e calldata_hashing_input_2_, e calldata_hashing_input_len, e calldata_hashing_latch, e calldata_hashing_sel_not_padding_1, e calldata_hashing_sel_not_padding_2, e calldata_hashing_sel_not_start, e calldata_latch, e calldata_value, e class_id_derivation_artifact_hash, e class_id_derivation_class_id, e class_id_derivation_const_four, e class_id_derivation_gen_index_contract_class_id, e class_id_derivation_private_functions_root, e class_id_derivation_public_bytecode_commitment, e class_id_derivation_sel, e context_stack_bytecode_id, e context_stack_context_id, e context_stack_contract_address, e context_stack_entered_context_id, e context_stack_internal_call_id, e context_stack_internal_call_return_id, e context_stack_is_static, e context_stack_msg_sender, e context_stack_next_internal_call_id, e context_stack_next_pc, e context_stack_note_hash_tree_root, e context_stack_note_hash_tree_size, e context_stack_nullifier_tree_root, e context_stack_nullifier_tree_size, e context_stack_num_l2_to_l1_messages, e context_stack_num_note_hashes_emitted, e context_stack_num_nullifiers_emitted, e context_stack_num_public_log_fields, e context_stack_parent_calldata_addr, e context_stack_parent_calldata_size, e context_stack_parent_da_gas_limit, e context_stack_parent_da_gas_used, e context_stack_parent_id, e context_stack_parent_l2_gas_limit, e context_stack_parent_l2_gas_used, e context_stack_public_data_tree_root, e context_stack_public_data_tree_size, e context_stack_sel, e context_stack_written_public_data_slots_tree_root, e context_stack_written_public_data_slots_tree_size, e contract_instance_retrieval_address, e contract_instance_retrieval_address_sub_one, e contract_instance_retrieval_current_class_id, e contract_instance_retrieval_deployer_addr, e contract_instance_retrieval_deployer_protocol_contract_address, e contract_instance_retrieval_derived_address, e contract_instance_retrieval_derived_address_pi_index, e contract_instance_retrieval_exists, e contract_instance_retrieval_incoming_viewing_key_x, e contract_instance_retrieval_incoming_viewing_key_y, e contract_instance_retrieval_init_hash, e contract_instance_retrieval_is_protocol_contract, e contract_instance_retrieval_max_protocol_contracts, e contract_instance_retrieval_nullifier_key_x, e contract_instance_retrieval_nullifier_key_y, e contract_instance_retrieval_nullifier_tree_height, e contract_instance_retrieval_nullifier_tree_root, e contract_instance_retrieval_original_class_id, e contract_instance_retrieval_outgoing_viewing_key_x, e contract_instance_retrieval_outgoing_viewing_key_y, e contract_instance_retrieval_protocol_contract_derived_address_inv, e contract_instance_retrieval_public_data_tree_root, e contract_instance_retrieval_salt, e contract_instance_retrieval_sel, e contract_instance_retrieval_should_check_for_update, e contract_instance_retrieval_should_check_nullifier, e contract_instance_retrieval_siloing_separator, e contract_instance_retrieval_tagging_key_x, e contract_instance_retrieval_tagging_key_y, e data_copy_cd_copy_col_read, e data_copy_data_index_upper_bound, e data_copy_data_index_upper_bound_gt_offset, e data_copy_dst_out_of_range_err, e data_copy_err, e data_copy_is_top_level, e data_copy_mem_size, e data_copy_offset, e data_copy_offset_plus_size, e data_copy_offset_plus_size_is_gt, e data_copy_parent_id_inv, e data_copy_read_addr_plus_one, e data_copy_read_addr_upper_bound, e data_copy_reads_left_inv, e data_copy_sel_cd_copy_start, e data_copy_sel_end, e data_copy_sel_mem_read, e data_copy_sel_mem_write, e data_copy_sel_rd_copy_start, e data_copy_sel_start_no_err, e data_copy_sel_write_count_is_zero, e data_copy_src_addr, e data_copy_src_data_size, e data_copy_src_out_of_range_err, e data_copy_tag, e data_copy_value, e data_copy_write_addr_upper_bound, e data_copy_write_count_minus_one_inv, e data_copy_write_count_zero_inv, e ecc_add_mem_dst_addr_0_, e ecc_add_mem_dst_addr_1_, e ecc_add_mem_dst_addr_2_, e ecc_add_mem_err, e ecc_add_mem_execution_clk, e ecc_add_mem_max_mem_addr, e ecc_add_mem_p_is_inf, e ecc_add_mem_p_is_on_curve_eqn, e ecc_add_mem_p_is_on_curve_eqn_inv, e ecc_add_mem_p_x, e ecc_add_mem_p_x_n, e ecc_add_mem_p_y, e ecc_add_mem_p_y_n, e ecc_add_mem_q_is_inf, e ecc_add_mem_q_is_on_curve_eqn, e ecc_add_mem_q_is_on_curve_eqn_inv, e ecc_add_mem_q_x, e ecc_add_mem_q_x_n, e ecc_add_mem_q_y, e ecc_add_mem_q_y_n, e ecc_add_mem_res_is_inf, e ecc_add_mem_res_x, e ecc_add_mem_res_y, e ecc_add_mem_sel, e ecc_add_mem_sel_dst_out_of_range_err, e ecc_add_mem_sel_p_not_on_curve_err, e ecc_add_mem_sel_q_not_on_curve_err, e ecc_add_mem_sel_should_exec, e ecc_add_mem_space_id, e ecc_add_op, e ecc_double_op, e ecc_inv_2_p_y, e ecc_inv_x_diff, e ecc_inv_y_diff, e ecc_lambda, e ecc_p_is_inf, e ecc_p_x, e ecc_p_y, e ecc_q_is_inf, e ecc_q_x, e ecc_q_y, e ecc_r_is_inf, e ecc_r_x, e ecc_r_y, e ecc_result_infinity, e ecc_sel, e ecc_use_computed_result, e ecc_x_match, e ecc_y_match, e emit_public_log_discard, e emit_public_log_end, e emit_public_log_end_log_address_upper_bound, e emit_public_log_error, e emit_public_log_error_too_many_log_fields, e emit_public_log_expected_next_log_fields, e emit_public_log_is_static, e emit_public_log_log_size, e emit_public_log_max_mem_size, e emit_public_log_max_public_logs_payload_length, e emit_public_log_next_num_public_log_fields, e emit_public_log_prev_num_public_log_fields, e emit_public_log_public_inputs_value, e emit_public_log_remaining_rows_inv, e emit_public_log_sel_read_memory, e emit_public_log_tag, e emit_public_log_tag_inv, e emit_public_log_value, e execution_addressing_error_collection_inv, e execution_addressing_gas, e execution_addressing_mode, e execution_base_address_tag, e execution_base_address_tag_diff_inv, e execution_base_address_val, e execution_base_da_gas, e execution_batched_tags_diff_inv, e execution_batched_tags_diff_inv_reg, e execution_da_gas_left, e execution_da_gas_used, e execution_dying_context_diff_inv, e execution_dying_context_id_inv, e execution_dyn_gas_id, e execution_dynamic_da_gas, e execution_dynamic_da_gas_factor, e execution_dynamic_l2_gas, e execution_dynamic_l2_gas_factor, e execution_enqueued_call_end, e execution_envvar_pi_row_idx, e execution_ex_opcode, e execution_expected_tag_reg_0_, e execution_expected_tag_reg_1_, e execution_expected_tag_reg_2_, e execution_expected_tag_reg_3_, e execution_expected_tag_reg_4_, e execution_expected_tag_reg_5_, e execution_has_parent_ctx, e execution_highest_address, e execution_instr_length, e execution_internal_call_return_id_inv, e execution_is_address, e execution_is_da_gas_left_gt_allocated, e execution_is_dagasleft, e execution_is_dying_context, e execution_is_isstaticcall, e execution_is_l2_gas_left_gt_allocated, e execution_is_l2gasleft, e execution_is_parent_id_inv, e execution_is_sender, e execution_is_transactionfee, e execution_l1_to_l2_msg_leaf_in_range, e execution_l1_to_l2_msg_tree_leaf_count, e execution_l2_gas_left, e execution_l2_gas_used, e execution_max_data_writes_reached, e execution_max_eth_address_value, e execution_mem_tag_reg_0_, e execution_mem_tag_reg_1_, e execution_mem_tag_reg_2_, e execution_mem_tag_reg_3_, e execution_mem_tag_reg_4_, e execution_mem_tag_reg_5_, e execution_nested_failure, e execution_nested_return, e execution_next_pc, e execution_note_hash_leaf_in_range, e execution_note_hash_tree_leaf_count, e execution_note_hash_tree_root, e execution_note_hash_tree_size, e execution_nullifier_pi_offset, e execution_nullifier_siloing_separator, e execution_nullifier_tree_height, e execution_nullifier_tree_root, e execution_nullifier_tree_size, e execution_num_l2_to_l1_messages, e execution_num_note_hashes_emitted, e execution_num_nullifiers_emitted, e execution_num_p_limbs, e execution_num_public_log_fields, e execution_num_relative_operands_inv, e execution_op_0_, e execution_op_1_, e execution_op_2_, e execution_op_3_, e execution_op_4_, e execution_op_5_, e execution_op_6_, e execution_op_after_relative_0_, e execution_op_after_relative_1_, e execution_op_after_relative_2_, e execution_op_after_relative_3_, e execution_op_after_relative_4_, e execution_op_after_relative_5_, e execution_op_after_relative_6_, e execution_opcode_gas, e execution_out_of_gas_da, e execution_out_of_gas_l2, e execution_public_data_tree_root, e execution_public_data_tree_size, e execution_public_inputs_index, e execution_register_0_, e execution_register_1_, e execution_register_2_, e execution_register_3_, e execution_register_4_, e execution_register_5_, e execution_remaining_data_writes_inv, e execution_remaining_l2_to_l1_msgs_inv, e execution_remaining_note_hashes_inv, e execution_remaining_nullifiers_inv, e execution_retrieved_bytecodes_tree_root, e execution_retrieved_bytecodes_tree_size, e execution_rop_0_, e execution_rop_1_, e execution_rop_2_, e execution_rop_3_, e execution_rop_4_, e execution_rop_5_, e execution_rop_6_, e execution_rop_tag_0_, e execution_rop_tag_1_, e execution_rop_tag_2_, e execution_rop_tag_3_, e execution_rop_tag_4_, e execution_rop_tag_5_, e execution_rop_tag_6_, e execution_rw_reg_0_, e execution_rw_reg_1_, e execution_rw_reg_2_, e execution_rw_reg_3_, e execution_rw_reg_4_, e execution_rw_reg_5_, e execution_sel_addressing_error, e execution_sel_base_address_failure, e execution_sel_bytecode_retrieval_failure, e execution_sel_bytecode_retrieval_success, e execution_sel_do_base_check, e execution_sel_enter_call, e execution_sel_envvar_pi_lookup_col0, e execution_sel_envvar_pi_lookup_col1, e execution_sel_error, e execution_sel_exec_dispatch_alu, e execution_sel_exec_dispatch_bitwise, e execution_sel_exec_dispatch_calldata_copy, e execution_sel_exec_dispatch_cast, e execution_sel_exec_dispatch_ecc_add, e execution_sel_exec_dispatch_emit_public_log, e execution_sel_exec_dispatch_execution, e execution_sel_exec_dispatch_get_contract_instance, e execution_sel_exec_dispatch_keccakf1600, e execution_sel_exec_dispatch_poseidon2_perm, e execution_sel_exec_dispatch_returndata_copy, e execution_sel_exec_dispatch_set, e execution_sel_exec_dispatch_sha256_compression, e execution_sel_exec_dispatch_to_radix, e execution_sel_execute_call, e execution_sel_execute_debug_log, e execution_sel_execute_emit_notehash, e execution_sel_execute_emit_nullifier, e execution_sel_execute_get_env_var, e execution_sel_execute_internal_call, e execution_sel_execute_internal_return, e execution_sel_execute_jump, e execution_sel_execute_jumpi, e execution_sel_execute_l1_to_l2_message_exists, e execution_sel_execute_mov, e execution_sel_execute_notehash_exists, e execution_sel_execute_nullifier_exists, e execution_sel_execute_return, e execution_sel_execute_returndata_size, e execution_sel_execute_revert, e execution_sel_execute_send_l2_to_l1_msg, e execution_sel_execute_sload, e execution_sel_execute_sstore, e execution_sel_execute_static_call, e execution_sel_execute_success_copy, e execution_sel_exit_call, e execution_sel_failure, e execution_sel_gas_bitwise, e execution_sel_gas_calldata_copy, e execution_sel_gas_emit_public_log, e execution_sel_gas_returndata_copy, e execution_sel_gas_sstore, e execution_sel_gas_to_radix, e execution_sel_instruction_fetching_failure, e execution_sel_instruction_fetching_success, e execution_sel_l2_to_l1_msg_limit_error, e execution_sel_lookup_num_p_limbs, e execution_sel_mem_op_reg_0_, e execution_sel_mem_op_reg_1_, e execution_sel_mem_op_reg_2_, e execution_sel_mem_op_reg_3_, e execution_sel_mem_op_reg_4_, e execution_sel_mem_op_reg_5_, e execution_sel_op_do_overflow_check_0_, e execution_sel_op_do_overflow_check_1_, e execution_sel_op_do_overflow_check_2_, e execution_sel_op_do_overflow_check_3_, e execution_sel_op_do_overflow_check_4_, e execution_sel_op_do_overflow_check_5_, e execution_sel_op_do_overflow_check_6_, e execution_sel_op_is_address_0_, e execution_sel_op_is_address_1_, e execution_sel_op_is_address_2_, e execution_sel_op_is_address_3_, e execution_sel_op_is_address_4_, e execution_sel_op_is_address_5_, e execution_sel_op_is_address_6_, e execution_sel_op_is_indirect_wire_0_, e execution_sel_op_is_indirect_wire_1_, e execution_sel_op_is_indirect_wire_2_, e execution_sel_op_is_indirect_wire_3_, e execution_sel_op_is_indirect_wire_4_, e execution_sel_op_is_indirect_wire_5_, e execution_sel_op_is_indirect_wire_6_, e execution_sel_op_is_indirect_wire_7_, e execution_sel_op_is_relative_wire_0_, e execution_sel_op_is_relative_wire_1_, e execution_sel_op_is_relative_wire_2_, e execution_sel_op_is_relative_wire_3_, e execution_sel_op_is_relative_wire_4_, e execution_sel_op_is_relative_wire_5_, e execution_sel_op_is_relative_wire_6_, e execution_sel_op_is_relative_wire_7_, e execution_sel_op_reg_effective_0_, e execution_sel_op_reg_effective_1_, e execution_sel_op_reg_effective_2_, e execution_sel_op_reg_effective_3_, e execution_sel_op_reg_effective_4_, e execution_sel_op_reg_effective_5_, e execution_sel_opcode_error, e execution_sel_out_of_gas, e execution_sel_radix_gt_256, e execution_sel_reached_max_note_hashes, e execution_sel_reached_max_nullifiers, e execution_sel_read_unwind_call_stack, e execution_sel_register_read_error, e execution_sel_relative_overflow_0_, e execution_sel_relative_overflow_1_, e execution_sel_relative_overflow_2_, e execution_sel_relative_overflow_3_, e execution_sel_relative_overflow_4_, e execution_sel_relative_overflow_5_, e execution_sel_relative_overflow_6_, e execution_sel_should_apply_indirection_0_, e execution_sel_should_apply_indirection_1_, e execution_sel_should_apply_indirection_2_, e execution_sel_should_apply_indirection_3_, e execution_sel_should_apply_indirection_4_, e execution_sel_should_apply_indirection_5_, e execution_sel_should_apply_indirection_6_, e execution_sel_should_check_gas, e execution_sel_should_execute_opcode, e execution_sel_should_read_registers, e execution_sel_should_write_registers, e execution_sel_some_final_check_failed, e execution_sel_tag_check_reg_0_, e execution_sel_tag_check_reg_1_, e execution_sel_tag_check_reg_2_, e execution_sel_tag_check_reg_3_, e execution_sel_tag_check_reg_4_, e execution_sel_tag_check_reg_5_, e execution_sel_too_large_recipient_error, e execution_sel_use_num_limbs, e execution_sel_write_l2_to_l1_msg, e execution_sel_write_note_hash, e execution_sel_write_nullifier, e execution_sel_write_public_data, e execution_subtrace_id, e execution_subtrace_operation_id, e execution_total_gas_da, e execution_total_gas_l2, e execution_two_five_six, e execution_value_from_pi, e execution_written_public_data_slots_tree_root, e execution_written_public_data_slots_tree_size, e execution_written_slots_tree_height, e execution_written_slots_tree_siloing_separator, e ff_gt_a, e ff_gt_b, e ff_gt_borrow, e ff_gt_cmp_rng_ctr_inv, e ff_gt_constant_128, e ff_gt_p_a_borrow, e ff_gt_p_b_borrow, e ff_gt_res_hi, e ff_gt_res_lo, e ff_gt_result, e ff_gt_sel_shift_rng, e get_contract_instance_clk, e get_contract_instance_contract_address, e get_contract_instance_dst_offset, e get_contract_instance_dst_offset_diff_max_inv, e get_contract_instance_exists_tag, e get_contract_instance_instance_exists, e get_contract_instance_is_class_id, e get_contract_instance_is_deployer, e get_contract_instance_is_init_hash, e get_contract_instance_is_valid_member_enum, e get_contract_instance_is_valid_writes_in_bounds, e get_contract_instance_member_enum, e get_contract_instance_member_tag, e get_contract_instance_member_write_offset, e get_contract_instance_nullifier_tree_root, e get_contract_instance_public_data_tree_root, e get_contract_instance_retrieved_class_id, e get_contract_instance_retrieved_deployer_addr, e get_contract_instance_retrieved_init_hash, e get_contract_instance_sel, e get_contract_instance_sel_error, e get_contract_instance_selected_member, e get_contract_instance_space_id, e gt_abs_diff, e gt_input_a, e gt_input_b, e gt_num_bits, e gt_res, e gt_sel, e gt_sel_addressing, e gt_sel_alu, e gt_sel_gas, e gt_sel_others, e gt_sel_sha256, e indexed_tree_check_address, e indexed_tree_check_const_three, e indexed_tree_check_discard, e indexed_tree_check_exists, e indexed_tree_check_intermediate_root, e indexed_tree_check_low_leaf_hash, e indexed_tree_check_low_leaf_index, e indexed_tree_check_low_leaf_next_index, e indexed_tree_check_low_leaf_next_value, e indexed_tree_check_low_leaf_value, e indexed_tree_check_new_leaf_hash, e indexed_tree_check_next_value_inv, e indexed_tree_check_next_value_is_nonzero, e indexed_tree_check_not_exists, e indexed_tree_check_public_inputs_index, e indexed_tree_check_root, e indexed_tree_check_sel, e indexed_tree_check_sel_insert, e indexed_tree_check_sel_silo, e indexed_tree_check_sel_write_to_public_inputs, e indexed_tree_check_siloed_value, e indexed_tree_check_siloing_separator, e indexed_tree_check_tree_height, e indexed_tree_check_tree_size_after_write, e indexed_tree_check_tree_size_before_write, e indexed_tree_check_updated_low_leaf_hash, e indexed_tree_check_updated_low_leaf_next_index, e indexed_tree_check_updated_low_leaf_next_value, e indexed_tree_check_value, e indexed_tree_check_value_low_leaf_value_diff_inv, e indexed_tree_check_write, e indexed_tree_check_write_root, e instr_fetching_addressing_mode, e instr_fetching_bd0, e instr_fetching_bd1, e instr_fetching_bd10, e instr_fetching_bd11, e instr_fetching_bd12, e instr_fetching_bd13, e instr_fetching_bd14, e instr_fetching_bd15, e instr_fetching_bd16, e instr_fetching_bd17, e instr_fetching_bd18, e instr_fetching_bd19, e instr_fetching_bd2, e instr_fetching_bd20, e instr_fetching_bd21, e instr_fetching_bd22, e instr_fetching_bd23, e instr_fetching_bd24, e instr_fetching_bd25, e instr_fetching_bd26, e instr_fetching_bd27, e instr_fetching_bd28, e instr_fetching_bd29, e instr_fetching_bd3, e instr_fetching_bd30, e instr_fetching_bd31, e instr_fetching_bd32, e instr_fetching_bd33, e instr_fetching_bd34, e instr_fetching_bd35, e instr_fetching_bd36, e instr_fetching_bd4, e instr_fetching_bd5, e instr_fetching_bd6, e instr_fetching_bd7, e instr_fetching_bd8, e instr_fetching_bd9, e instr_fetching_bytecode_id, e instr_fetching_bytecode_size, e instr_fetching_bytes_to_read, e instr_fetching_exec_opcode, e instr_fetching_instr_abs_diff, e instr_fetching_instr_out_of_range, e instr_fetching_instr_size, e instr_fetching_op1, e instr_fetching_op2, e instr_fetching_op3, e instr_fetching_op4, e instr_fetching_op5, e instr_fetching_op6, e instr_fetching_op7, e instr_fetching_opcode_out_of_range, e instr_fetching_pc, e instr_fetching_pc_abs_diff, e instr_fetching_pc_out_of_range, e instr_fetching_pc_size_in_bits, e instr_fetching_sel, e instr_fetching_sel_has_tag, e instr_fetching_sel_op_dc_0, e instr_fetching_sel_op_dc_1, e instr_fetching_sel_op_dc_10, e instr_fetching_sel_op_dc_11, e instr_fetching_sel_op_dc_12, e instr_fetching_sel_op_dc_13, e instr_fetching_sel_op_dc_14, e instr_fetching_sel_op_dc_15, e instr_fetching_sel_op_dc_16, e instr_fetching_sel_op_dc_2, e instr_fetching_sel_op_dc_3, e instr_fetching_sel_op_dc_4, e instr_fetching_sel_op_dc_5, e instr_fetching_sel_op_dc_6, e instr_fetching_sel_op_dc_7, e instr_fetching_sel_op_dc_8, e instr_fetching_sel_op_dc_9, e instr_fetching_sel_parsing_err, e instr_fetching_sel_pc_in_range, e instr_fetching_sel_tag_is_op2, e instr_fetching_tag_out_of_range, e instr_fetching_tag_value, e internal_call_stack_call_id, e internal_call_stack_context_id, e internal_call_stack_entered_call_id, e internal_call_stack_return_call_id, e internal_call_stack_return_pc, e internal_call_stack_sel, e keccak_memory_ctr_end, e keccak_memory_ctr_inv, e keccak_memory_last, e keccak_memory_num_rounds, e keccak_memory_single_tag_error, e keccak_memory_state_size_min_ctr_inv, e keccak_memory_tag, e keccak_memory_tag_min_u64_inv, e keccak_memory_val_24_, e keccakf1600_bitwise_and_op_id, e keccakf1600_bitwise_xor_op_id, e keccakf1600_dst_out_of_range_error, e keccakf1600_error, e keccakf1600_highest_slice_address, e keccakf1600_last, e keccakf1600_rot_64_min_len_01, e keccakf1600_rot_64_min_len_03, e keccakf1600_rot_64_min_len_11, e keccakf1600_rot_64_min_len_13, e keccakf1600_rot_64_min_len_20, e keccakf1600_rot_64_min_len_22, e keccakf1600_rot_64_min_len_24, e keccakf1600_rot_64_min_len_31, e keccakf1600_rot_64_min_len_34, e keccakf1600_rot_64_min_len_42, e keccakf1600_rot_len_02, e keccakf1600_rot_len_04, e keccakf1600_rot_len_10, e keccakf1600_rot_len_12, e keccakf1600_rot_len_14, e keccakf1600_rot_len_21, e keccakf1600_rot_len_23, e keccakf1600_rot_len_30, e keccakf1600_rot_len_32, e keccakf1600_rot_len_33, e keccakf1600_rot_len_40, e keccakf1600_rot_len_41, e keccakf1600_rot_len_43, e keccakf1600_rot_len_44, e keccakf1600_round_cst, e keccakf1600_round_inv, e keccakf1600_sel_slice_read, e keccakf1600_sel_slice_write, e keccakf1600_src_addr, e keccakf1600_src_out_of_range_error, e keccakf1600_state_chi_00, e keccakf1600_state_chi_01, e keccakf1600_state_chi_02, e keccakf1600_state_chi_03, e keccakf1600_state_chi_04, e keccakf1600_state_chi_10, e keccakf1600_state_chi_11, e keccakf1600_state_chi_12, e keccakf1600_state_chi_13, e keccakf1600_state_chi_14, e keccakf1600_state_chi_20, e keccakf1600_state_chi_21, e keccakf1600_state_chi_22, e keccakf1600_state_chi_23, e keccakf1600_state_chi_24, e keccakf1600_state_chi_30, e keccakf1600_state_chi_31, e keccakf1600_state_chi_32, e keccakf1600_state_chi_33, e keccakf1600_state_chi_34, e keccakf1600_state_chi_40, e keccakf1600_state_chi_41, e keccakf1600_state_chi_42, e keccakf1600_state_chi_43, e keccakf1600_state_chi_44, e keccakf1600_state_iota_00, e keccakf1600_state_pi_and_00, e keccakf1600_state_pi_and_01, e keccakf1600_state_pi_and_02, e keccakf1600_state_pi_and_03, e keccakf1600_state_pi_and_04, e keccakf1600_state_pi_and_10, e keccakf1600_state_pi_and_11, e keccakf1600_state_pi_and_12, e keccakf1600_state_pi_and_13, e keccakf1600_state_pi_and_14, e keccakf1600_state_pi_and_20, e keccakf1600_state_pi_and_21, e keccakf1600_state_pi_and_22, e keccakf1600_state_pi_and_23, e keccakf1600_state_pi_and_24, e keccakf1600_state_pi_and_30, e keccakf1600_state_pi_and_31, e keccakf1600_state_pi_and_32, e keccakf1600_state_pi_and_33, e keccakf1600_state_pi_and_34, e keccakf1600_state_pi_and_40, e keccakf1600_state_pi_and_41, e keccakf1600_state_pi_and_42, e keccakf1600_state_pi_and_43, e keccakf1600_state_pi_and_44, e keccakf1600_state_pi_not_00, e keccakf1600_state_pi_not_01, e keccakf1600_state_pi_not_02, e keccakf1600_state_pi_not_03, e keccakf1600_state_pi_not_04, e keccakf1600_state_pi_not_10, e keccakf1600_state_pi_not_11, e keccakf1600_state_pi_not_12, e keccakf1600_state_pi_not_13, e keccakf1600_state_pi_not_14, e keccakf1600_state_pi_not_20, e keccakf1600_state_pi_not_21, e keccakf1600_state_pi_not_22, e keccakf1600_state_pi_not_23, e keccakf1600_state_pi_not_24, e keccakf1600_state_pi_not_30, e keccakf1600_state_pi_not_31, e keccakf1600_state_pi_not_32, e keccakf1600_state_pi_not_33, e keccakf1600_state_pi_not_34, e keccakf1600_state_pi_not_40, e keccakf1600_state_pi_not_41, e keccakf1600_state_pi_not_42, e keccakf1600_state_pi_not_43, e keccakf1600_state_pi_not_44, e keccakf1600_state_rho_01, e keccakf1600_state_rho_02, e keccakf1600_state_rho_03, e keccakf1600_state_rho_04, e keccakf1600_state_rho_10, e keccakf1600_state_rho_11, e keccakf1600_state_rho_12, e keccakf1600_state_rho_13, e keccakf1600_state_rho_14, e keccakf1600_state_rho_20, e keccakf1600_state_rho_21, e keccakf1600_state_rho_22, e keccakf1600_state_rho_23, e keccakf1600_state_rho_24, e keccakf1600_state_rho_30, e keccakf1600_state_rho_31, e keccakf1600_state_rho_32, e keccakf1600_state_rho_33, e keccakf1600_state_rho_34, e keccakf1600_state_rho_40, e keccakf1600_state_rho_41, e keccakf1600_state_rho_42, e keccakf1600_state_rho_43, e keccakf1600_state_rho_44, e keccakf1600_state_theta_00, e keccakf1600_state_theta_01, e keccakf1600_state_theta_02, e keccakf1600_state_theta_03, e keccakf1600_state_theta_04, e keccakf1600_state_theta_10, e keccakf1600_state_theta_11, e keccakf1600_state_theta_12, e keccakf1600_state_theta_13, e keccakf1600_state_theta_14, e keccakf1600_state_theta_20, e keccakf1600_state_theta_21, e keccakf1600_state_theta_22, e keccakf1600_state_theta_23, e keccakf1600_state_theta_24, e keccakf1600_state_theta_30, e keccakf1600_state_theta_31, e keccakf1600_state_theta_32, e keccakf1600_state_theta_33, e keccakf1600_state_theta_34, e keccakf1600_state_theta_40, e keccakf1600_state_theta_41, e keccakf1600_state_theta_42, e keccakf1600_state_theta_43, e keccakf1600_state_theta_44, e keccakf1600_state_theta_hi_01, e keccakf1600_state_theta_hi_02, e keccakf1600_state_theta_hi_03, e keccakf1600_state_theta_hi_04, e keccakf1600_state_theta_hi_10, e keccakf1600_state_theta_hi_11, e keccakf1600_state_theta_hi_12, e keccakf1600_state_theta_hi_13, e keccakf1600_state_theta_hi_14, e keccakf1600_state_theta_hi_20, e keccakf1600_state_theta_hi_21, e keccakf1600_state_theta_hi_22, e keccakf1600_state_theta_hi_23, e keccakf1600_state_theta_hi_24, e keccakf1600_state_theta_hi_30, e keccakf1600_state_theta_hi_31, e keccakf1600_state_theta_hi_32, e keccakf1600_state_theta_hi_33, e keccakf1600_state_theta_hi_34, e keccakf1600_state_theta_hi_40, e keccakf1600_state_theta_hi_41, e keccakf1600_state_theta_hi_42, e keccakf1600_state_theta_hi_43, e keccakf1600_state_theta_hi_44, e keccakf1600_state_theta_low_01, e keccakf1600_state_theta_low_02, e keccakf1600_state_theta_low_03, e keccakf1600_state_theta_low_04, e keccakf1600_state_theta_low_10, e keccakf1600_state_theta_low_11, e keccakf1600_state_theta_low_12, e keccakf1600_state_theta_low_13, e keccakf1600_state_theta_low_14, e keccakf1600_state_theta_low_20, e keccakf1600_state_theta_low_21, e keccakf1600_state_theta_low_22, e keccakf1600_state_theta_low_23, e keccakf1600_state_theta_low_24, e keccakf1600_state_theta_low_30, e keccakf1600_state_theta_low_31, e keccakf1600_state_theta_low_32, e keccakf1600_state_theta_low_33, e keccakf1600_state_theta_low_34, e keccakf1600_state_theta_low_40, e keccakf1600_state_theta_low_41, e keccakf1600_state_theta_low_42, e keccakf1600_state_theta_low_43, e keccakf1600_state_theta_low_44, e keccakf1600_tag_error, e keccakf1600_tag_u64, e keccakf1600_theta_combined_xor_0, e keccakf1600_theta_combined_xor_1, e keccakf1600_theta_combined_xor_2, e keccakf1600_theta_combined_xor_3, e keccakf1600_theta_combined_xor_4, e keccakf1600_theta_xor_01, e keccakf1600_theta_xor_02, e keccakf1600_theta_xor_03, e keccakf1600_theta_xor_11, e keccakf1600_theta_xor_12, e keccakf1600_theta_xor_13, e keccakf1600_theta_xor_21, e keccakf1600_theta_xor_22, e keccakf1600_theta_xor_23, e keccakf1600_theta_xor_31, e keccakf1600_theta_xor_32, e keccakf1600_theta_xor_33, e keccakf1600_theta_xor_41, e keccakf1600_theta_xor_42, e keccakf1600_theta_xor_43, e keccakf1600_theta_xor_row_0, e keccakf1600_theta_xor_row_1, e keccakf1600_theta_xor_row_2, e keccakf1600_theta_xor_row_3, e keccakf1600_theta_xor_row_4, e keccakf1600_theta_xor_row_low63_0, e keccakf1600_theta_xor_row_low63_1, e keccakf1600_theta_xor_row_low63_2, e keccakf1600_theta_xor_row_low63_3, e keccakf1600_theta_xor_row_low63_4, e keccakf1600_theta_xor_row_msb_0, e keccakf1600_theta_xor_row_msb_1, e keccakf1600_theta_xor_row_msb_2, e keccakf1600_theta_xor_row_msb_3, e keccakf1600_theta_xor_row_msb_4, e keccakf1600_theta_xor_row_rotl1_0, e keccakf1600_theta_xor_row_rotl1_1, e keccakf1600_theta_xor_row_rotl1_2, e keccakf1600_theta_xor_row_rotl1_3, e keccakf1600_theta_xor_row_rotl1_4, e l1_to_l2_message_tree_check_exists, e l1_to_l2_message_tree_check_l1_to_l2_message_tree_height, e l1_to_l2_message_tree_check_leaf_index, e l1_to_l2_message_tree_check_leaf_value, e l1_to_l2_message_tree_check_leaf_value_msg_hash_diff_inv, e l1_to_l2_message_tree_check_msg_hash, e l1_to_l2_message_tree_check_root, e l1_to_l2_message_tree_check_sel, e memory_address, e memory_clk, e memory_diff, e memory_glob_addr_diff_inv, e memory_last_access, e memory_limb_0_, e memory_limb_1_, e memory_limb_2_, e memory_max_bits, e memory_sel_addressing_base, e memory_sel_addressing_indirect_0_, e memory_sel_addressing_indirect_1_, e memory_sel_addressing_indirect_2_, e memory_sel_addressing_indirect_3_, e memory_sel_addressing_indirect_4_, e memory_sel_addressing_indirect_5_, e memory_sel_addressing_indirect_6_, e memory_sel_data_copy_read, e memory_sel_data_copy_write, e memory_sel_ecc_write_0_, e memory_sel_ecc_write_1_, e memory_sel_ecc_write_2_, e memory_sel_get_contract_instance_exists_write, e memory_sel_get_contract_instance_member_write, e memory_sel_keccak, e memory_sel_poseidon2_read_0_, e memory_sel_poseidon2_read_1_, e memory_sel_poseidon2_read_2_, e memory_sel_poseidon2_read_3_, e memory_sel_poseidon2_write_0_, e memory_sel_poseidon2_write_1_, e memory_sel_poseidon2_write_2_, e memory_sel_poseidon2_write_3_, e memory_sel_public_log_read, e memory_sel_register_op_0_, e memory_sel_register_op_1_, e memory_sel_register_op_2_, e memory_sel_register_op_3_, e memory_sel_register_op_4_, e memory_sel_register_op_5_, e memory_sel_rng_chk, e memory_sel_rng_write, e memory_sel_sha256_op_0_, e memory_sel_sha256_op_1_, e memory_sel_sha256_op_2_, e memory_sel_sha256_op_3_, e memory_sel_sha256_op_4_, e memory_sel_sha256_op_5_, e memory_sel_sha256_op_6_, e memory_sel_sha256_op_7_, e memory_sel_sha256_read, e memory_sel_tag_is_ff, e memory_sel_to_radix_write, e memory_space_id, e memory_tag_ff_diff_inv, e merkle_check_const_two, e merkle_check_end, e merkle_check_index_is_even, e merkle_check_path_len_min_one_inv, e merkle_check_read_left_node, e merkle_check_read_output_hash, e merkle_check_read_right_node, e merkle_check_sibling, e merkle_check_start, e merkle_check_write_left_node, e merkle_check_write_output_hash, e merkle_check_write_right_node, e note_hash_tree_check_address, e note_hash_tree_check_const_three, e note_hash_tree_check_discard, e note_hash_tree_check_exists, e note_hash_tree_check_first_nullifier, e note_hash_tree_check_first_nullifier_pi_index, e note_hash_tree_check_leaf_index, e note_hash_tree_check_next_leaf_value, e note_hash_tree_check_next_root, e note_hash_tree_check_nonce, e note_hash_tree_check_nonce_separator, e note_hash_tree_check_note_hash, e note_hash_tree_check_note_hash_index, e note_hash_tree_check_note_hash_tree_height, e note_hash_tree_check_prev_leaf_value, e note_hash_tree_check_prev_leaf_value_unique_note_hash_diff_inv, e note_hash_tree_check_prev_root, e note_hash_tree_check_public_inputs_index, e note_hash_tree_check_sel, e note_hash_tree_check_sel_silo, e note_hash_tree_check_sel_unique, e note_hash_tree_check_sel_write_to_public_inputs, e note_hash_tree_check_siloed_note_hash, e note_hash_tree_check_siloing_separator, e note_hash_tree_check_unique_note_hash, e note_hash_tree_check_unique_note_hash_separator, e note_hash_tree_check_write, e poseidon2_hash_b_0, e poseidon2_hash_b_1, e poseidon2_hash_b_2, e poseidon2_hash_b_3, e poseidon2_hash_end, e poseidon2_hash_input_len, e poseidon2_hash_num_perm_rounds_rem_min_one_inv, e poseidon2_hash_padding, e poseidon2_perm_B_10_0, e poseidon2_perm_B_10_1, e poseidon2_perm_B_10_2, e poseidon2_perm_B_10_3, e poseidon2_perm_B_11_0, e poseidon2_perm_B_11_1, e poseidon2_perm_B_11_2, e poseidon2_perm_B_11_3, e poseidon2_perm_B_12_0, e poseidon2_perm_B_12_1, e poseidon2_perm_B_12_2, e poseidon2_perm_B_12_3, e poseidon2_perm_B_13_0, e poseidon2_perm_B_13_1, e poseidon2_perm_B_13_2, e poseidon2_perm_B_13_3, e poseidon2_perm_B_14_0, e poseidon2_perm_B_14_1, e poseidon2_perm_B_14_2, e poseidon2_perm_B_14_3, e poseidon2_perm_B_15_0, e poseidon2_perm_B_15_1, e poseidon2_perm_B_15_2, e poseidon2_perm_B_15_3, e poseidon2_perm_B_16_0, e poseidon2_perm_B_16_1, e poseidon2_perm_B_16_2, e poseidon2_perm_B_16_3, e poseidon2_perm_B_17_0, e poseidon2_perm_B_17_1, e poseidon2_perm_B_17_2, e poseidon2_perm_B_17_3, e poseidon2_perm_B_18_0, e poseidon2_perm_B_18_1, e poseidon2_perm_B_18_2, e poseidon2_perm_B_18_3, e poseidon2_perm_B_19_0, e poseidon2_perm_B_19_1, e poseidon2_perm_B_19_2, e poseidon2_perm_B_19_3, e poseidon2_perm_B_20_0, e poseidon2_perm_B_20_1, e poseidon2_perm_B_20_2, e poseidon2_perm_B_20_3, e poseidon2_perm_B_21_0, e poseidon2_perm_B_21_1, e poseidon2_perm_B_21_2, e poseidon2_perm_B_21_3, e poseidon2_perm_B_22_0, e poseidon2_perm_B_22_1, e poseidon2_perm_B_22_2, e poseidon2_perm_B_22_3, e poseidon2_perm_B_23_0, e poseidon2_perm_B_23_1, e poseidon2_perm_B_23_2, e poseidon2_perm_B_23_3, e poseidon2_perm_B_24_0, e poseidon2_perm_B_24_1, e poseidon2_perm_B_24_2, e poseidon2_perm_B_24_3, e poseidon2_perm_B_25_0, e poseidon2_perm_B_25_1, e poseidon2_perm_B_25_2, e poseidon2_perm_B_25_3, e poseidon2_perm_B_26_0, e poseidon2_perm_B_26_1, e poseidon2_perm_B_26_2, e poseidon2_perm_B_26_3, e poseidon2_perm_B_27_0, e poseidon2_perm_B_27_1, e poseidon2_perm_B_27_2, e poseidon2_perm_B_27_3, e poseidon2_perm_B_28_0, e poseidon2_perm_B_28_1, e poseidon2_perm_B_28_2, e poseidon2_perm_B_28_3, e poseidon2_perm_B_29_0, e poseidon2_perm_B_29_1, e poseidon2_perm_B_29_2, e poseidon2_perm_B_29_3, e poseidon2_perm_B_30_0, e poseidon2_perm_B_30_1, e poseidon2_perm_B_30_2, e poseidon2_perm_B_30_3, e poseidon2_perm_B_31_0, e poseidon2_perm_B_31_1, e poseidon2_perm_B_31_2, e poseidon2_perm_B_31_3, e poseidon2_perm_B_32_0, e poseidon2_perm_B_32_1, e poseidon2_perm_B_32_2, e poseidon2_perm_B_32_3, e poseidon2_perm_B_33_0, e poseidon2_perm_B_33_1, e poseidon2_perm_B_33_2, e poseidon2_perm_B_33_3, e poseidon2_perm_B_34_0, e poseidon2_perm_B_34_1, e poseidon2_perm_B_34_2, e poseidon2_perm_B_34_3, e poseidon2_perm_B_35_0, e poseidon2_perm_B_35_1, e poseidon2_perm_B_35_2, e poseidon2_perm_B_35_3, e poseidon2_perm_B_36_0, e poseidon2_perm_B_36_1, e poseidon2_perm_B_36_2, e poseidon2_perm_B_36_3, e poseidon2_perm_B_37_0, e poseidon2_perm_B_37_1, e poseidon2_perm_B_37_2, e poseidon2_perm_B_37_3, e poseidon2_perm_B_38_0, e poseidon2_perm_B_38_1, e poseidon2_perm_B_38_2, e poseidon2_perm_B_38_3, e poseidon2_perm_B_39_0, e poseidon2_perm_B_39_1, e poseidon2_perm_B_39_2, e poseidon2_perm_B_39_3, e poseidon2_perm_B_40_0, e poseidon2_perm_B_40_1, e poseidon2_perm_B_40_2, e poseidon2_perm_B_40_3, e poseidon2_perm_B_41_0, e poseidon2_perm_B_41_1, e poseidon2_perm_B_41_2, e poseidon2_perm_B_41_3, e poseidon2_perm_B_42_0, e poseidon2_perm_B_42_1, e poseidon2_perm_B_42_2, e poseidon2_perm_B_42_3, e poseidon2_perm_B_43_0, e poseidon2_perm_B_43_1, e poseidon2_perm_B_43_2, e poseidon2_perm_B_43_3, e poseidon2_perm_B_44_0, e poseidon2_perm_B_44_1, e poseidon2_perm_B_44_2, e poseidon2_perm_B_44_3, e poseidon2_perm_B_45_0, e poseidon2_perm_B_45_1, e poseidon2_perm_B_45_2, e poseidon2_perm_B_45_3, e poseidon2_perm_B_46_0, e poseidon2_perm_B_46_1, e poseidon2_perm_B_46_2, e poseidon2_perm_B_46_3, e poseidon2_perm_B_47_0, e poseidon2_perm_B_47_1, e poseidon2_perm_B_47_2, e poseidon2_perm_B_47_3, e poseidon2_perm_B_48_0, e poseidon2_perm_B_48_1, e poseidon2_perm_B_48_2, e poseidon2_perm_B_48_3, e poseidon2_perm_B_49_0, e poseidon2_perm_B_49_1, e poseidon2_perm_B_49_2, e poseidon2_perm_B_49_3, e poseidon2_perm_B_4_0, e poseidon2_perm_B_4_1, e poseidon2_perm_B_4_2, e poseidon2_perm_B_4_3, e poseidon2_perm_B_50_0, e poseidon2_perm_B_50_1, e poseidon2_perm_B_50_2, e poseidon2_perm_B_50_3, e poseidon2_perm_B_51_0, e poseidon2_perm_B_51_1, e poseidon2_perm_B_51_2, e poseidon2_perm_B_51_3, e poseidon2_perm_B_52_0, e poseidon2_perm_B_52_1, e poseidon2_perm_B_52_2, e poseidon2_perm_B_52_3, e poseidon2_perm_B_53_0, e poseidon2_perm_B_53_1, e poseidon2_perm_B_53_2, e poseidon2_perm_B_53_3, e poseidon2_perm_B_54_0, e poseidon2_perm_B_54_1, e poseidon2_perm_B_54_2, e poseidon2_perm_B_54_3, e poseidon2_perm_B_55_0, e poseidon2_perm_B_55_1, e poseidon2_perm_B_55_2, e poseidon2_perm_B_55_3, e poseidon2_perm_B_56_0, e poseidon2_perm_B_56_1, e poseidon2_perm_B_56_2, e poseidon2_perm_B_56_3, e poseidon2_perm_B_57_0, e poseidon2_perm_B_57_1, e poseidon2_perm_B_57_2, e poseidon2_perm_B_57_3, e poseidon2_perm_B_58_0, e poseidon2_perm_B_58_1, e poseidon2_perm_B_58_2, e poseidon2_perm_B_58_3, e poseidon2_perm_B_59_0, e poseidon2_perm_B_59_1, e poseidon2_perm_B_59_2, e poseidon2_perm_B_59_3, e poseidon2_perm_B_5_0, e poseidon2_perm_B_5_1, e poseidon2_perm_B_5_2, e poseidon2_perm_B_5_3, e poseidon2_perm_B_6_0, e poseidon2_perm_B_6_1, e poseidon2_perm_B_6_2, e poseidon2_perm_B_6_3, e poseidon2_perm_B_7_0, e poseidon2_perm_B_7_1, e poseidon2_perm_B_7_2, e poseidon2_perm_B_7_3, e poseidon2_perm_B_8_0, e poseidon2_perm_B_8_1, e poseidon2_perm_B_8_2, e poseidon2_perm_B_8_3, e poseidon2_perm_B_9_0, e poseidon2_perm_B_9_1, e poseidon2_perm_B_9_2, e poseidon2_perm_B_9_3, e poseidon2_perm_EXT_LAYER_4, e poseidon2_perm_EXT_LAYER_5, e poseidon2_perm_EXT_LAYER_6, e poseidon2_perm_EXT_LAYER_7, e poseidon2_perm_T_0_4, e poseidon2_perm_T_0_5, e poseidon2_perm_T_0_6, e poseidon2_perm_T_0_7, e poseidon2_perm_T_1_4, e poseidon2_perm_T_1_5, e poseidon2_perm_T_1_6, e poseidon2_perm_T_1_7, e poseidon2_perm_T_2_4, e poseidon2_perm_T_2_5, e poseidon2_perm_T_2_6, e poseidon2_perm_T_2_7, e poseidon2_perm_T_3_4, e poseidon2_perm_T_3_5, e poseidon2_perm_T_3_6, e poseidon2_perm_T_3_7, e poseidon2_perm_T_60_4, e poseidon2_perm_T_60_5, e poseidon2_perm_T_60_6, e poseidon2_perm_T_60_7, e poseidon2_perm_T_61_4, e poseidon2_perm_T_61_5, e poseidon2_perm_T_61_6, e poseidon2_perm_T_61_7, e poseidon2_perm_T_62_4, e poseidon2_perm_T_62_5, e poseidon2_perm_T_62_6, e poseidon2_perm_T_62_7, e poseidon2_perm_T_63_4, e poseidon2_perm_T_63_5, e poseidon2_perm_T_63_6, e poseidon2_perm_T_63_7, e poseidon2_perm_a_0, e poseidon2_perm_a_1, e poseidon2_perm_a_2, e poseidon2_perm_a_3, e poseidon2_perm_b_0, e poseidon2_perm_b_1, e poseidon2_perm_b_2, e poseidon2_perm_b_3, e poseidon2_perm_mem_batch_tag_inv, e poseidon2_perm_mem_err, e poseidon2_perm_mem_execution_clk, e poseidon2_perm_mem_input_0_, e poseidon2_perm_mem_input_1_, e poseidon2_perm_mem_input_2_, e poseidon2_perm_mem_input_3_, e poseidon2_perm_mem_input_tag_0_, e poseidon2_perm_mem_input_tag_1_, e poseidon2_perm_mem_input_tag_2_, e poseidon2_perm_mem_input_tag_3_, e poseidon2_perm_mem_max_mem_addr, e poseidon2_perm_mem_output_0_, e poseidon2_perm_mem_output_1_, e poseidon2_perm_mem_output_2_, e poseidon2_perm_mem_output_3_, e poseidon2_perm_mem_read_address_0_, e poseidon2_perm_mem_read_address_1_, e poseidon2_perm_mem_read_address_2_, e poseidon2_perm_mem_read_address_3_, e poseidon2_perm_mem_sel, e poseidon2_perm_mem_sel_dst_out_of_range_err, e poseidon2_perm_mem_sel_invalid_tag_err, e poseidon2_perm_mem_sel_should_exec, e poseidon2_perm_mem_sel_should_read_mem, e poseidon2_perm_mem_sel_src_out_of_range_err, e poseidon2_perm_mem_space_id, e poseidon2_perm_mem_write_address_0_, e poseidon2_perm_mem_write_address_1_, e poseidon2_perm_mem_write_address_2_, e poseidon2_perm_mem_write_address_3_, e poseidon2_perm_sel, e public_data_check_address, e public_data_check_clk_diff_hi, e public_data_check_clk_diff_lo, e public_data_check_const_four, e public_data_check_const_three, e public_data_check_discard, e public_data_check_end, e public_data_check_final_value, e public_data_check_intermediate_root, e public_data_check_leaf_not_exists, e public_data_check_leaf_slot, e public_data_check_leaf_slot_low_leaf_slot_diff_inv, e public_data_check_length_pi_idx, e public_data_check_low_leaf_hash, e public_data_check_low_leaf_index, e public_data_check_low_leaf_next_index, e public_data_check_low_leaf_next_slot, e public_data_check_low_leaf_slot, e public_data_check_low_leaf_value, e public_data_check_new_leaf_hash, e public_data_check_next_slot_inv, e public_data_check_next_slot_is_nonzero, e public_data_check_non_discarded_write, e public_data_check_non_protocol_write, e public_data_check_not_end, e public_data_check_protocol_write, e public_data_check_public_data_writes_length, e public_data_check_root, e public_data_check_should_insert, e public_data_check_should_write_to_public_inputs, e public_data_check_siloing_separator, e public_data_check_slot, e public_data_check_tree_height, e public_data_check_tree_size_after_write, e public_data_check_tree_size_before_write, e public_data_check_updated_low_leaf_hash, e public_data_check_updated_low_leaf_next_index, e public_data_check_updated_low_leaf_next_slot, e public_data_check_updated_low_leaf_value, e public_data_check_value, e public_data_check_write, e public_data_check_write_root, e public_data_squash_check_clock, e public_data_squash_clk_diff_hi, e public_data_squash_clk_diff_lo, e public_data_squash_leaf_slot_increase, e public_data_squash_value, e range_check_dyn_diff, e range_check_dyn_rng_chk_bits, e range_check_dyn_rng_chk_pow_2, e range_check_is_lte_u112, e range_check_is_lte_u128, e range_check_is_lte_u16, e range_check_is_lte_u32, e range_check_is_lte_u48, e range_check_is_lte_u64, e range_check_is_lte_u80, e range_check_is_lte_u96, e range_check_rng_chk_bits, e range_check_sel, e range_check_sel_alu, e range_check_sel_gt, e range_check_sel_keccak, e range_check_sel_memory, e range_check_sel_r0_16_bit_rng_lookup, e range_check_sel_r1_16_bit_rng_lookup, e range_check_sel_r2_16_bit_rng_lookup, e range_check_sel_r3_16_bit_rng_lookup, e range_check_sel_r4_16_bit_rng_lookup, e range_check_sel_r5_16_bit_rng_lookup, e range_check_sel_r6_16_bit_rng_lookup, e range_check_u16_r0, e range_check_u16_r1, e range_check_u16_r2, e range_check_u16_r3, e range_check_u16_r4, e range_check_u16_r5, e range_check_u16_r6, e range_check_u16_r7, e range_check_value, e scalar_mul_bit, e scalar_mul_const_two, e scalar_mul_end, e scalar_mul_sel_not_end, e scalar_mul_should_add, e sha256_a_and_b, e sha256_a_and_b_xor_a_and_c, e sha256_a_and_c, e sha256_a_rotr_13, e sha256_a_rotr_2, e sha256_a_rotr_22, e sha256_a_rotr_2_xor_a_rotr_13, e sha256_and_op_id, e sha256_b_and_c, e sha256_batch_tag_inv, e sha256_ch, e sha256_computed_w_lhs, e sha256_computed_w_rhs, e sha256_e_and_f, e sha256_e_rotr_11, e sha256_e_rotr_25, e sha256_e_rotr_6, e sha256_e_rotr_6_xor_e_rotr_11, e sha256_err, e sha256_input, e sha256_input_rounds_rem_inv, e sha256_input_tag, e sha256_input_tag_diff_inv, e sha256_last, e sha256_latch, e sha256_lhs_a_13, e sha256_lhs_a_2, e sha256_lhs_a_22, e sha256_lhs_e_11, e sha256_lhs_e_25, e sha256_lhs_e_6, e sha256_lhs_w_10, e sha256_lhs_w_17, e sha256_lhs_w_18, e sha256_lhs_w_19, e sha256_lhs_w_3, e sha256_lhs_w_7, e sha256_maj, e sha256_max_input_addr, e sha256_max_mem_addr, e sha256_max_output_addr, e sha256_max_state_addr, e sha256_mem_out_of_range_err, e sha256_memory_address_0_, e sha256_memory_address_1_, e sha256_memory_address_2_, e sha256_memory_address_3_, e sha256_memory_address_4_, e sha256_memory_address_5_, e sha256_memory_address_6_, e sha256_memory_address_7_, e sha256_memory_register_0_, e sha256_memory_register_1_, e sha256_memory_register_2_, e sha256_memory_register_3_, e sha256_memory_register_4_, e sha256_memory_register_5_, e sha256_memory_register_6_, e sha256_memory_register_7_, e sha256_memory_tag_0_, e sha256_memory_tag_1_, e sha256_memory_tag_2_, e sha256_memory_tag_3_, e sha256_memory_tag_4_, e sha256_memory_tag_5_, e sha256_memory_tag_6_, e sha256_memory_tag_7_, e sha256_next_a_lhs, e sha256_next_a_rhs, e sha256_next_e_lhs, e sha256_next_e_rhs, e sha256_not_e, e sha256_not_e_and_g, e sha256_output_a_lhs, e sha256_output_a_rhs, e sha256_output_b_lhs, e sha256_output_b_rhs, e sha256_output_c_lhs, e sha256_output_c_rhs, e sha256_output_d_lhs, e sha256_output_d_rhs, e sha256_output_e_lhs, e sha256_output_e_rhs, e sha256_output_f_lhs, e sha256_output_f_rhs, e sha256_output_g_lhs, e sha256_output_g_rhs, e sha256_output_h_lhs, e sha256_output_h_rhs, e sha256_perform_round, e sha256_rhs_a_13, e sha256_rhs_a_2, e sha256_rhs_a_22, e sha256_rhs_e_11, e sha256_rhs_e_25, e sha256_rhs_e_6, e sha256_rhs_w_10, e sha256_rhs_w_17, e sha256_rhs_w_18, e sha256_rhs_w_19, e sha256_rhs_w_3, e sha256_rhs_w_7, e sha256_round_constant, e sha256_round_count, e sha256_rounds_remaining_inv, e sha256_rw, e sha256_s_0, e sha256_s_1, e sha256_sel_compute_w, e sha256_sel_input_out_of_range_err, e sha256_sel_invalid_input_row_tag_err, e sha256_sel_invalid_state_tag_err, e sha256_sel_mem_state_or_output, e sha256_sel_output_out_of_range_err, e sha256_sel_read_input_from_memory, e sha256_sel_state_out_of_range_err, e sha256_state_addr, e sha256_two_pow_10, e sha256_two_pow_11, e sha256_two_pow_13, e sha256_two_pow_17, e sha256_two_pow_18, e sha256_two_pow_19, e sha256_two_pow_2, e sha256_two_pow_22, e sha256_two_pow_25, e sha256_two_pow_3, e sha256_two_pow_32, e sha256_two_pow_6, e sha256_two_pow_7, e sha256_u32_tag, e sha256_w, e sha256_w_15_rotr_18, e sha256_w_15_rotr_7, e sha256_w_15_rotr_7_xor_w_15_rotr_18, e sha256_w_15_rshift_3, e sha256_w_2_rotr_17, e sha256_w_2_rotr_17_xor_w_2_rotr_19, e sha256_w_2_rotr_19, e sha256_w_2_rshift_10, e sha256_w_s_0, e sha256_w_s_1, e sha256_xor_op_id, e to_radix_end, e to_radix_found, e to_radix_is_unsafe_limb, e to_radix_limb_p_diff, e to_radix_limb_radix_diff, e to_radix_mem_err, e to_radix_mem_input_validation_error, e to_radix_mem_last, e to_radix_mem_limb_index_to_lookup, e to_radix_mem_limb_value, e to_radix_mem_max_mem_size, e to_radix_mem_num_limbs_inv, e to_radix_mem_num_limbs_minus_one_inv, e to_radix_mem_output_tag, e to_radix_mem_radix_min_two_inv, e to_radix_mem_sel_dst_out_of_range_err, e to_radix_mem_sel_invalid_bitwise_radix, e to_radix_mem_sel_num_limbs_is_zero, e to_radix_mem_sel_radix_eq_2, e to_radix_mem_sel_radix_gt_256_err, e to_radix_mem_sel_radix_lt_2_err, e to_radix_mem_sel_value_is_zero, e to_radix_mem_two, e to_radix_mem_two_five_six, e to_radix_mem_value_found, e to_radix_mem_value_inv, e to_radix_mem_write_addr_upper_bound, e to_radix_p_limb, e to_radix_rem_inverse, e to_radix_safety_diff_inverse, e tx_array_length_l2_to_l1_messages_pi_offset, e tx_array_length_note_hashes_pi_offset, e tx_array_length_nullifiers_pi_offset, e tx_calldata_hash, e tx_calldata_size, e tx_const_three, e tx_contract_addr, e tx_dom_sep_public_storage_map_slot, e tx_effective_fee_per_da_gas, e tx_effective_fee_per_l2_gas, e tx_end_phase, e tx_fee_juice_balance_slot, e tx_fee_juice_balances_slot_constant, e tx_fee_juice_contract_address, e tx_fee_payer, e tx_fee_payer_balance, e tx_fee_payer_new_balance, e tx_fee_payer_pi_offset, e tx_fields_length_public_logs_pi_offset, e tx_gas_limit_pi_offset, e tx_gas_used_pi_offset, e tx_is_cleanup, e tx_is_collect_fee, e tx_is_padded, e tx_is_public_call_request, e tx_is_static, e tx_is_tree_insert_phase, e tx_is_tree_padding, e tx_l1_l2_pi_offset, e tx_l2_l1_msg_content, e tx_l2_l1_msg_contract_address, e tx_l2_l1_msg_recipient, e tx_leaf_value, e tx_msg_sender, e tx_next_da_gas_used, e tx_next_da_gas_used_sent_to_enqueued_call, e tx_next_l2_gas_used, e tx_next_l2_gas_used_sent_to_enqueued_call, e tx_next_note_hash_tree_root, e tx_next_note_hash_tree_size, e tx_next_nullifier_tree_root, e tx_next_nullifier_tree_size, e tx_next_num_l2_to_l1_messages, e tx_next_num_note_hashes_emitted, e tx_next_num_nullifiers_emitted, e tx_next_num_public_log_fields, e tx_next_phase_on_revert, e tx_next_public_data_tree_root, e tx_next_public_data_tree_size, e tx_next_retrieved_bytecodes_tree_root, e tx_next_retrieved_bytecodes_tree_size, e tx_next_written_public_data_slots_tree_root, e tx_next_written_public_data_slots_tree_size, e tx_note_hash_pi_offset, e tx_nullifier_limit_error, e tx_nullifier_pi_offset, e tx_nullifier_tree_height, e tx_prev_da_gas_used_sent_to_enqueued_call, e tx_prev_l2_gas_used_sent_to_enqueued_call, e tx_public_data_pi_offset, e tx_read_pi_length_offset, e tx_read_pi_start_offset, e tx_remaining_phase_inv, e tx_remaining_phase_minus_one_inv, e tx_remaining_side_effects_inv, e tx_reverted_pi_offset, e tx_sel_non_revertible_append_l2_l1_msg, e tx_sel_non_revertible_append_note_hash, e tx_sel_non_revertible_append_nullifier, e tx_sel_read_phase_length, e tx_sel_read_trees_and_gas_used, e tx_sel_revertible_append_l2_l1_msg, e tx_sel_revertible_append_note_hash, e tx_sel_revertible_append_nullifier, e tx_setup_phase_value, e tx_should_l2_l1_msg_append, e tx_should_note_hash_append, e tx_should_nullifier_append, e tx_should_process_call_request, e tx_should_read_gas_limit, e tx_should_try_l2_l1_msg_append, e tx_should_try_note_hash_append, e tx_should_try_nullifier_append, e tx_uint32_max, e tx_write_nullifier_pi_offset, e tx_write_pi_offset, e update_check_address, e update_check_const_three, e update_check_current_class_id, e update_check_delayed_public_mutable_hash_slot, e update_check_delayed_public_mutable_slot, e update_check_deployer_protocol_contract_address, e update_check_dom_sep_public_storage_map_slot, e update_check_hash_not_zero, e update_check_original_class_id, e update_check_public_data_tree_root, e update_check_sel, e update_check_timestamp, e update_check_timestamp_is_lt_timestamp_of_change, e update_check_timestamp_of_change, e update_check_timestamp_of_change_bit_size, e update_check_timestamp_pi_offset, e update_check_update_hash, e update_check_update_hash_inv, e update_check_update_hi_metadata, e update_check_update_hi_metadata_bit_size, e update_check_update_post_class_id_is_zero, e update_check_update_post_class_inv, e update_check_update_pre_class_id_is_zero, e update_check_update_pre_class_inv, e update_check_update_preimage_metadata, e update_check_update_preimage_post_class_id, e update_check_update_preimage_pre_class_id, e update_check_updated_class_ids_slot, e lookup_range_check_dyn_rng_chk_pow_2_counts, e lookup_range_check_dyn_diff_is_u16_counts, e lookup_range_check_r0_is_u16_counts, e lookup_range_check_r1_is_u16_counts, e lookup_range_check_r2_is_u16_counts, e lookup_range_check_r3_is_u16_counts, e lookup_range_check_r4_is_u16_counts, e lookup_range_check_r5_is_u16_counts, e lookup_range_check_r6_is_u16_counts, e lookup_range_check_r7_is_u16_counts, e lookup_ff_gt_a_lo_range_counts, e lookup_ff_gt_a_hi_range_counts, e lookup_gt_gt_range_counts, e lookup_alu_tag_max_bits_value_counts, e lookup_alu_range_check_decomposition_a_lo_counts, e lookup_alu_range_check_decomposition_a_hi_counts, e lookup_alu_range_check_decomposition_b_lo_counts, e lookup_alu_range_check_decomposition_b_hi_counts, e lookup_alu_range_check_mul_c_hi_counts, e lookup_alu_ff_gt_counts, e lookup_alu_int_gt_counts, e lookup_alu_shifts_two_pow_counts, e lookup_alu_large_trunc_canonical_dec_counts, e lookup_alu_range_check_trunc_mid_counts, e lookup_bitwise_integral_tag_length_counts, e lookup_bitwise_byte_operations_counts, e lookup_memory_range_check_limb_0_counts, e lookup_memory_range_check_limb_1_counts, e lookup_memory_range_check_limb_2_counts, e lookup_memory_tag_max_bits_counts, e lookup_memory_range_check_write_tagged_value_counts, e lookup_keccakf1600_theta_xor_01_counts, e lookup_keccakf1600_theta_xor_02_counts, e lookup_keccakf1600_theta_xor_03_counts, e lookup_keccakf1600_theta_xor_row_0_counts, e lookup_keccakf1600_theta_xor_11_counts, e lookup_keccakf1600_theta_xor_12_counts, e lookup_keccakf1600_theta_xor_13_counts, e lookup_keccakf1600_theta_xor_row_1_counts, e lookup_keccakf1600_theta_xor_21_counts, e lookup_keccakf1600_theta_xor_22_counts, e lookup_keccakf1600_theta_xor_23_counts, e lookup_keccakf1600_theta_xor_row_2_counts, e lookup_keccakf1600_theta_xor_31_counts, e lookup_keccakf1600_theta_xor_32_counts, e lookup_keccakf1600_theta_xor_33_counts, e lookup_keccakf1600_theta_xor_row_3_counts, e lookup_keccakf1600_theta_xor_41_counts, e lookup_keccakf1600_theta_xor_42_counts, e lookup_keccakf1600_theta_xor_43_counts, e lookup_keccakf1600_theta_xor_row_4_counts, e lookup_keccakf1600_theta_combined_xor_0_counts, e lookup_keccakf1600_theta_combined_xor_1_counts, e lookup_keccakf1600_theta_combined_xor_2_counts, e lookup_keccakf1600_theta_combined_xor_3_counts, e lookup_keccakf1600_theta_combined_xor_4_counts, e lookup_keccakf1600_state_theta_00_counts, e lookup_keccakf1600_state_theta_01_counts, e lookup_keccakf1600_state_theta_02_counts, e lookup_keccakf1600_state_theta_03_counts, e lookup_keccakf1600_state_theta_04_counts, e lookup_keccakf1600_state_theta_10_counts, e lookup_keccakf1600_state_theta_11_counts, e lookup_keccakf1600_state_theta_12_counts, e lookup_keccakf1600_state_theta_13_counts, e lookup_keccakf1600_state_theta_14_counts, e lookup_keccakf1600_state_theta_20_counts, e lookup_keccakf1600_state_theta_21_counts, e lookup_keccakf1600_state_theta_22_counts, e lookup_keccakf1600_state_theta_23_counts, e lookup_keccakf1600_state_theta_24_counts, e lookup_keccakf1600_state_theta_30_counts, e lookup_keccakf1600_state_theta_31_counts, e lookup_keccakf1600_state_theta_32_counts, e lookup_keccakf1600_state_theta_33_counts, e lookup_keccakf1600_state_theta_34_counts, e lookup_keccakf1600_state_theta_40_counts, e lookup_keccakf1600_state_theta_41_counts, e lookup_keccakf1600_state_theta_42_counts, e lookup_keccakf1600_state_theta_43_counts, e lookup_keccakf1600_state_theta_44_counts, e lookup_keccakf1600_theta_limb_02_range_counts, e lookup_keccakf1600_theta_limb_04_range_counts, e lookup_keccakf1600_theta_limb_10_range_counts, e lookup_keccakf1600_theta_limb_12_range_counts, e lookup_keccakf1600_theta_limb_14_range_counts, e lookup_keccakf1600_theta_limb_21_range_counts, e lookup_keccakf1600_theta_limb_23_range_counts, e lookup_keccakf1600_theta_limb_30_range_counts, e lookup_keccakf1600_theta_limb_32_range_counts, e lookup_keccakf1600_theta_limb_33_range_counts, e lookup_keccakf1600_theta_limb_40_range_counts, e lookup_keccakf1600_theta_limb_41_range_counts, e lookup_keccakf1600_theta_limb_43_range_counts, e lookup_keccakf1600_theta_limb_44_range_counts, e lookup_keccakf1600_theta_limb_01_range_counts, e lookup_keccakf1600_theta_limb_03_range_counts, e lookup_keccakf1600_theta_limb_11_range_counts, e lookup_keccakf1600_theta_limb_13_range_counts, e lookup_keccakf1600_theta_limb_20_range_counts, e lookup_keccakf1600_theta_limb_22_range_counts, e lookup_keccakf1600_theta_limb_24_range_counts, e lookup_keccakf1600_theta_limb_31_range_counts, e lookup_keccakf1600_theta_limb_34_range_counts, e lookup_keccakf1600_theta_limb_42_range_counts, e lookup_keccakf1600_state_pi_and_00_counts, e lookup_keccakf1600_state_pi_and_01_counts, e lookup_keccakf1600_state_pi_and_02_counts, e lookup_keccakf1600_state_pi_and_03_counts, e lookup_keccakf1600_state_pi_and_04_counts, e lookup_keccakf1600_state_pi_and_10_counts, e lookup_keccakf1600_state_pi_and_11_counts, e lookup_keccakf1600_state_pi_and_12_counts, e lookup_keccakf1600_state_pi_and_13_counts, e lookup_keccakf1600_state_pi_and_14_counts, e lookup_keccakf1600_state_pi_and_20_counts, e lookup_keccakf1600_state_pi_and_21_counts, e lookup_keccakf1600_state_pi_and_22_counts, e lookup_keccakf1600_state_pi_and_23_counts, e lookup_keccakf1600_state_pi_and_24_counts, e lookup_keccakf1600_state_pi_and_30_counts, e lookup_keccakf1600_state_pi_and_31_counts, e lookup_keccakf1600_state_pi_and_32_counts, e lookup_keccakf1600_state_pi_and_33_counts, e lookup_keccakf1600_state_pi_and_34_counts, e lookup_keccakf1600_state_pi_and_40_counts, e lookup_keccakf1600_state_pi_and_41_counts, e lookup_keccakf1600_state_pi_and_42_counts, e lookup_keccakf1600_state_pi_and_43_counts, e lookup_keccakf1600_state_pi_and_44_counts, e lookup_keccakf1600_state_chi_00_counts, e lookup_keccakf1600_state_chi_01_counts, e lookup_keccakf1600_state_chi_02_counts, e lookup_keccakf1600_state_chi_03_counts, e lookup_keccakf1600_state_chi_04_counts, e lookup_keccakf1600_state_chi_10_counts, e lookup_keccakf1600_state_chi_11_counts, e lookup_keccakf1600_state_chi_12_counts, e lookup_keccakf1600_state_chi_13_counts, e lookup_keccakf1600_state_chi_14_counts, e lookup_keccakf1600_state_chi_20_counts, e lookup_keccakf1600_state_chi_21_counts, e lookup_keccakf1600_state_chi_22_counts, e lookup_keccakf1600_state_chi_23_counts, e lookup_keccakf1600_state_chi_24_counts, e lookup_keccakf1600_state_chi_30_counts, e lookup_keccakf1600_state_chi_31_counts, e lookup_keccakf1600_state_chi_32_counts, e lookup_keccakf1600_state_chi_33_counts, e lookup_keccakf1600_state_chi_34_counts, e lookup_keccakf1600_state_chi_40_counts, e lookup_keccakf1600_state_chi_41_counts, e lookup_keccakf1600_state_chi_42_counts, e lookup_keccakf1600_state_chi_43_counts, e lookup_keccakf1600_state_chi_44_counts, e lookup_keccakf1600_round_cst_counts, e lookup_keccakf1600_state_iota_00_counts, e lookup_keccakf1600_src_out_of_range_toggle_counts, e lookup_keccakf1600_dst_out_of_range_toggle_counts, e lookup_sha256_range_comp_w_lhs_counts, e lookup_sha256_range_comp_w_rhs_counts, e lookup_sha256_range_rhs_w_7_counts, e lookup_sha256_range_rhs_w_18_counts, e lookup_sha256_range_rhs_w_3_counts, e lookup_sha256_w_s_0_xor_0_counts, e lookup_sha256_w_s_0_xor_1_counts, e lookup_sha256_range_rhs_w_17_counts, e lookup_sha256_range_rhs_w_19_counts, e lookup_sha256_range_rhs_w_10_counts, e lookup_sha256_w_s_1_xor_0_counts, e lookup_sha256_w_s_1_xor_1_counts, e lookup_sha256_range_rhs_e_6_counts, e lookup_sha256_range_rhs_e_11_counts, e lookup_sha256_range_rhs_e_25_counts, e lookup_sha256_s_1_xor_0_counts, e lookup_sha256_s_1_xor_1_counts, e lookup_sha256_ch_and_0_counts, e lookup_sha256_ch_and_1_counts, e lookup_sha256_ch_xor_counts, e lookup_sha256_round_constant_counts, e lookup_sha256_range_rhs_a_2_counts, e lookup_sha256_range_rhs_a_13_counts, e lookup_sha256_range_rhs_a_22_counts, e lookup_sha256_s_0_xor_0_counts, e lookup_sha256_s_0_xor_1_counts, e lookup_sha256_maj_and_0_counts, e lookup_sha256_maj_and_1_counts, e lookup_sha256_maj_and_2_counts, e lookup_sha256_maj_xor_0_counts, e lookup_sha256_maj_xor_1_counts, e lookup_sha256_range_comp_next_a_lhs_counts, e lookup_sha256_range_comp_next_a_rhs_counts, e lookup_sha256_range_comp_next_e_lhs_counts, e lookup_sha256_range_comp_next_e_rhs_counts, e lookup_sha256_range_comp_a_lhs_counts, e lookup_sha256_range_comp_a_rhs_counts, e lookup_sha256_range_comp_b_lhs_counts, e lookup_sha256_range_comp_b_rhs_counts, e lookup_sha256_range_comp_c_lhs_counts, e lookup_sha256_range_comp_c_rhs_counts, e lookup_sha256_range_comp_d_lhs_counts, e lookup_sha256_range_comp_d_rhs_counts, e lookup_sha256_range_comp_e_lhs_counts, e lookup_sha256_range_comp_e_rhs_counts, e lookup_sha256_range_comp_f_lhs_counts, e lookup_sha256_range_comp_f_rhs_counts, e lookup_sha256_range_comp_g_lhs_counts, e lookup_sha256_range_comp_g_rhs_counts, e lookup_sha256_range_comp_h_lhs_counts, e lookup_sha256_range_comp_h_rhs_counts, e lookup_sha256_mem_check_state_addr_in_range_counts, e lookup_sha256_mem_check_input_addr_in_range_counts, e lookup_sha256_mem_check_output_addr_in_range_counts, e lookup_ecc_mem_check_dst_addr_in_range_counts, e lookup_ecc_mem_input_output_ecc_add_counts, e lookup_poseidon2_mem_check_src_addr_in_range_counts, e lookup_poseidon2_mem_check_dst_addr_in_range_counts, e lookup_poseidon2_mem_input_output_poseidon2_perm_counts, e lookup_to_radix_limb_range_counts, e lookup_to_radix_limb_less_than_radix_range_counts, e lookup_to_radix_fetch_safe_limbs_counts, e lookup_to_radix_fetch_p_limb_counts, e lookup_to_radix_limb_p_diff_range_counts, e lookup_scalar_mul_to_radix_counts, e lookup_scalar_mul_double_counts, e lookup_scalar_mul_add_counts, e lookup_to_radix_mem_check_dst_addr_in_range_counts, e lookup_to_radix_mem_check_radix_lt_2_counts, e lookup_to_radix_mem_check_radix_gt_256_counts, e lookup_to_radix_mem_input_output_to_radix_counts, e lookup_internal_call_unwind_call_stack_counts, e lookup_context_ctx_stack_rollback_counts, e lookup_context_ctx_stack_return_counts, e lookup_poseidon2_hash_poseidon2_perm_counts, e lookup_calldata_hashing_get_calldata_field_0_counts, e lookup_calldata_hashing_get_calldata_field_1_counts, e lookup_calldata_hashing_get_calldata_field_2_counts, e lookup_calldata_hashing_check_final_size_counts, e lookup_calldata_hashing_poseidon2_hash_counts, e lookup_calldata_range_check_context_id_diff_counts, e lookup_data_copy_offset_plus_size_is_gt_data_size_counts, e lookup_data_copy_check_src_addr_in_range_counts, e lookup_data_copy_check_dst_addr_in_range_counts, e lookup_data_copy_data_index_upper_bound_gt_offset_counts, e lookup_data_copy_col_read_counts, e lookup_addressing_relative_overflow_result_0_counts, e lookup_addressing_relative_overflow_result_1_counts, e lookup_addressing_relative_overflow_result_2_counts, e lookup_addressing_relative_overflow_result_3_counts, e lookup_addressing_relative_overflow_result_4_counts, e lookup_addressing_relative_overflow_result_5_counts, e lookup_addressing_relative_overflow_result_6_counts, e lookup_gas_addressing_gas_read_counts, e lookup_gas_is_out_of_gas_l2_counts, e lookup_gas_is_out_of_gas_da_counts, e lookup_merkle_check_merkle_poseidon2_read_counts, e lookup_merkle_check_merkle_poseidon2_write_counts, e lookup_indexed_tree_check_silo_poseidon2_counts, e lookup_indexed_tree_check_low_leaf_value_validation_counts, e lookup_indexed_tree_check_low_leaf_next_value_validation_counts, e lookup_indexed_tree_check_low_leaf_poseidon2_counts, e lookup_indexed_tree_check_updated_low_leaf_poseidon2_counts, e lookup_indexed_tree_check_low_leaf_merkle_check_counts, e lookup_indexed_tree_check_new_leaf_poseidon2_counts, e lookup_indexed_tree_check_new_leaf_merkle_check_counts, e lookup_indexed_tree_check_write_value_to_public_inputs_counts, e lookup_public_data_squash_leaf_slot_increase_ff_gt_counts, e lookup_public_data_squash_clk_diff_range_lo_counts, e lookup_public_data_squash_clk_diff_range_hi_counts, e lookup_public_data_check_clk_diff_range_lo_counts, e lookup_public_data_check_clk_diff_range_hi_counts, e lookup_public_data_check_silo_poseidon2_counts, e lookup_public_data_check_low_leaf_slot_validation_counts, e lookup_public_data_check_low_leaf_next_slot_validation_counts, e lookup_public_data_check_low_leaf_poseidon2_0_counts, e lookup_public_data_check_low_leaf_poseidon2_1_counts, e lookup_public_data_check_updated_low_leaf_poseidon2_0_counts, e lookup_public_data_check_updated_low_leaf_poseidon2_1_counts, e lookup_public_data_check_low_leaf_merkle_check_counts, e lookup_public_data_check_new_leaf_poseidon2_0_counts, e lookup_public_data_check_new_leaf_poseidon2_1_counts, e lookup_public_data_check_new_leaf_merkle_check_counts, e lookup_public_data_check_write_public_data_to_public_inputs_counts, e lookup_public_data_check_write_writes_length_to_public_inputs_counts, e lookup_l1_to_l2_message_tree_check_merkle_check_counts, e lookup_address_derivation_salted_initialization_hash_poseidon2_0_counts, e lookup_address_derivation_salted_initialization_hash_poseidon2_1_counts, e lookup_address_derivation_partial_address_poseidon2_counts, e lookup_address_derivation_public_keys_hash_poseidon2_0_counts, e lookup_address_derivation_public_keys_hash_poseidon2_1_counts, e lookup_address_derivation_public_keys_hash_poseidon2_2_counts, e lookup_address_derivation_public_keys_hash_poseidon2_3_counts, e lookup_address_derivation_public_keys_hash_poseidon2_4_counts, e lookup_address_derivation_preaddress_poseidon2_counts, e lookup_address_derivation_preaddress_scalar_mul_counts, e lookup_address_derivation_address_ecadd_counts, e lookup_bc_decomposition_bytes_are_bytes_counts, e lookup_bc_hashing_check_final_bytes_remaining_counts, e lookup_bc_hashing_poseidon2_hash_counts, e lookup_update_check_timestamp_from_public_inputs_counts, e lookup_update_check_delayed_public_mutable_slot_poseidon2_counts, e lookup_update_check_update_hash_public_data_read_counts, e lookup_update_check_update_hash_poseidon2_counts, e lookup_update_check_update_hi_metadata_range_counts, e lookup_update_check_update_lo_metadata_range_counts, e lookup_update_check_timestamp_is_lt_timestamp_of_change_counts, e lookup_contract_instance_retrieval_check_protocol_address_range_counts, e lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_counts, e lookup_contract_instance_retrieval_deployment_nullifier_read_counts, e lookup_contract_instance_retrieval_address_derivation_counts, e lookup_contract_instance_retrieval_update_check_counts, e lookup_bc_retrieval_contract_instance_retrieval_counts, e lookup_bc_retrieval_is_new_class_check_counts, e lookup_bc_retrieval_class_id_derivation_counts, e lookup_bc_retrieval_retrieved_bytecodes_insertion_counts, e lookup_instr_fetching_pc_abs_diff_positive_counts, e lookup_instr_fetching_instr_abs_diff_positive_counts, e lookup_instr_fetching_tag_value_validation_counts, e lookup_instr_fetching_bytecode_size_from_bc_dec_counts, e lookup_instr_fetching_bytes_from_bc_dec_counts, e lookup_instr_fetching_wire_instruction_info_counts, e lookup_class_id_derivation_class_id_poseidon2_0_counts, e lookup_class_id_derivation_class_id_poseidon2_1_counts, e lookup_get_env_var_precomputed_info_counts, e lookup_get_env_var_read_from_public_inputs_col0_counts, e lookup_get_env_var_read_from_public_inputs_col1_counts, e lookup_get_contract_instance_precomputed_info_counts, e lookup_get_contract_instance_contract_instance_retrieval_counts, e lookup_external_call_is_l2_gas_left_gt_allocated_counts, e lookup_external_call_is_da_gas_left_gt_allocated_counts, e lookup_sload_storage_read_counts, e lookup_sstore_record_written_storage_slot_counts, e lookup_note_hash_tree_check_silo_poseidon2_counts, e lookup_note_hash_tree_check_read_first_nullifier_counts, e lookup_note_hash_tree_check_nonce_computation_poseidon2_counts, e lookup_note_hash_tree_check_unique_note_hash_poseidon2_counts, e lookup_note_hash_tree_check_merkle_check_counts, e lookup_note_hash_tree_check_write_note_hash_to_public_inputs_counts, e lookup_notehash_exists_note_hash_leaf_index_in_range_counts, e lookup_notehash_exists_note_hash_read_counts, e lookup_emit_notehash_notehash_tree_write_counts, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_leaf_index_in_range_counts, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_read_counts, e lookup_nullifier_exists_nullifier_exists_check_counts, e lookup_emit_nullifier_write_nullifier_counts, e lookup_emit_public_log_check_memory_out_of_bounds_counts, e lookup_emit_public_log_check_log_fields_count_counts, e lookup_emit_public_log_write_data_to_public_inputs_counts, e lookup_send_l2_to_l1_msg_recipient_check_counts, e lookup_send_l2_to_l1_msg_write_l2_to_l1_msg_counts, e lookup_execution_bytecode_retrieval_result_counts, e lookup_execution_instruction_fetching_result_counts, e lookup_execution_instruction_fetching_body_counts, e lookup_execution_exec_spec_read_counts, e lookup_execution_dyn_l2_factor_bitwise_counts, e lookup_execution_check_radix_gt_256_counts, e lookup_execution_get_p_limbs_counts, e lookup_execution_get_max_limbs_counts, e lookup_execution_check_written_storage_slot_counts, e lookup_execution_dispatch_to_alu_counts, e lookup_execution_dispatch_to_bitwise_counts, e lookup_execution_dispatch_to_cast_counts, e lookup_execution_dispatch_to_set_counts, e lookup_tx_context_public_inputs_note_hash_tree_counts, e lookup_tx_context_public_inputs_nullifier_tree_counts, e lookup_tx_context_public_inputs_public_data_tree_counts, e lookup_tx_context_public_inputs_l1_l2_tree_counts, e lookup_tx_context_public_inputs_gas_used_counts, e lookup_tx_context_public_inputs_read_gas_limit_counts, e lookup_tx_context_public_inputs_read_reverted_counts, e lookup_tx_context_restore_state_on_revert_counts, e lookup_tx_context_public_inputs_write_note_hash_count_counts, e lookup_tx_context_public_inputs_write_nullifier_count_counts, e lookup_tx_context_public_inputs_write_l2_to_l1_message_count_counts, e lookup_tx_context_public_inputs_write_public_log_count_counts, e lookup_tx_read_phase_spec_counts, e lookup_tx_read_phase_length_counts, e lookup_tx_read_public_call_request_phase_counts, e lookup_tx_read_tree_insert_value_counts, e lookup_tx_note_hash_append_counts, e lookup_tx_nullifier_append_counts, e lookup_tx_read_l2_l1_msg_counts, e lookup_tx_write_l2_l1_msg_counts, e lookup_tx_read_effective_fee_public_inputs_counts, e lookup_tx_read_fee_payer_public_inputs_counts, e lookup_tx_balance_slot_poseidon2_counts, e lookup_tx_balance_read_counts, e lookup_tx_balance_validation_counts, e lookup_tx_write_fee_public_inputs_counts, e bc_decomposition_bytes, e bc_decomposition_bytes_pc_plus_1, e bc_decomposition_bytes_pc_plus_10, e bc_decomposition_bytes_pc_plus_11, e bc_decomposition_bytes_pc_plus_12, e bc_decomposition_bytes_pc_plus_13, e bc_decomposition_bytes_pc_plus_14, e bc_decomposition_bytes_pc_plus_15, e bc_decomposition_bytes_pc_plus_16, e bc_decomposition_bytes_pc_plus_17, e bc_decomposition_bytes_pc_plus_18, e bc_decomposition_bytes_pc_plus_19, e bc_decomposition_bytes_pc_plus_2, e bc_decomposition_bytes_pc_plus_20, e bc_decomposition_bytes_pc_plus_21, e bc_decomposition_bytes_pc_plus_22, e bc_decomposition_bytes_pc_plus_23, e bc_decomposition_bytes_pc_plus_24, e bc_decomposition_bytes_pc_plus_25, e bc_decomposition_bytes_pc_plus_26, e bc_decomposition_bytes_pc_plus_27, e bc_decomposition_bytes_pc_plus_28, e bc_decomposition_bytes_pc_plus_29, e bc_decomposition_bytes_pc_plus_3, e bc_decomposition_bytes_pc_plus_30, e bc_decomposition_bytes_pc_plus_31, e bc_decomposition_bytes_pc_plus_32, e bc_decomposition_bytes_pc_plus_33, e bc_decomposition_bytes_pc_plus_34, e bc_decomposition_bytes_pc_plus_35, e bc_decomposition_bytes_pc_plus_4, e bc_decomposition_bytes_pc_plus_5, e bc_decomposition_bytes_pc_plus_6, e bc_decomposition_bytes_pc_plus_7, e bc_decomposition_bytes_pc_plus_8, e bc_decomposition_bytes_pc_plus_9, e bc_decomposition_bytes_remaining, e bc_decomposition_id, e bc_decomposition_next_packed_pc, e bc_decomposition_pc, e bc_decomposition_sel, e bc_decomposition_sel_windows_gt_remaining, e bc_decomposition_start, e bc_hashing_bytecode_id, e bc_hashing_pc_index, e bc_hashing_rounds_rem, e bc_hashing_sel, e bc_hashing_start, e bc_retrieval_sel, e bitwise_acc_ia, e bitwise_acc_ib, e bitwise_acc_ic, e bitwise_ctr, e bitwise_op_id, e bitwise_sel, e bitwise_start, e calldata_context_id, e calldata_hashing_calldata_size, e calldata_hashing_context_id, e calldata_hashing_index_0_, e calldata_hashing_output_hash, e calldata_hashing_rounds_rem, e calldata_hashing_sel, e calldata_hashing_start, e calldata_index, e calldata_sel, e data_copy_clk, e data_copy_copy_size, e data_copy_dst_addr, e data_copy_dst_context_id, e data_copy_padding, e data_copy_read_addr, e data_copy_reads_left, e data_copy_sel, e data_copy_sel_cd_copy, e data_copy_sel_start, e data_copy_src_context_id, e emit_public_log_contract_address, e emit_public_log_correct_tag, e emit_public_log_error_out_of_bounds, e emit_public_log_error_tag_mismatch, e emit_public_log_execution_clk, e emit_public_log_is_write_contract_address, e emit_public_log_is_write_memory_value, e emit_public_log_log_address, e emit_public_log_public_inputs_index, e emit_public_log_remaining_rows, e emit_public_log_seen_wrong_tag, e emit_public_log_sel, e emit_public_log_sel_write_to_public_inputs, e emit_public_log_space_id, e emit_public_log_start, e execution_bytecode_id, e execution_clk, e execution_context_id, e execution_contract_address, e execution_da_gas_limit, e execution_discard, e execution_dying_context_id, e execution_enqueued_call_start, e execution_internal_call_id, e execution_internal_call_return_id, e execution_is_static, e execution_l1_l2_tree_root, e execution_l2_gas_limit, e execution_last_child_id, e execution_last_child_returndata_addr, e execution_last_child_returndata_size, e execution_last_child_success, e execution_msg_sender, e execution_next_context_id, e execution_next_internal_call_id, e execution_parent_calldata_addr, e execution_parent_calldata_size, e execution_parent_da_gas_limit, e execution_parent_da_gas_used, e execution_parent_id, e execution_parent_l2_gas_limit, e execution_parent_l2_gas_used, e execution_pc, e execution_prev_da_gas_used, e execution_prev_l2_gas_used, e execution_prev_note_hash_tree_root, e execution_prev_note_hash_tree_size, e execution_prev_nullifier_tree_root, e execution_prev_nullifier_tree_size, e execution_prev_num_l2_to_l1_messages, e execution_prev_num_note_hashes_emitted, e execution_prev_num_nullifiers_emitted, e execution_prev_num_public_log_fields, e execution_prev_public_data_tree_root, e execution_prev_public_data_tree_size, e execution_prev_retrieved_bytecodes_tree_root, e execution_prev_retrieved_bytecodes_tree_size, e execution_prev_written_public_data_slots_tree_root, e execution_prev_written_public_data_slots_tree_size, e execution_sel, e execution_sel_first_row_in_context, e execution_transaction_fee, e ff_gt_a_hi, e ff_gt_a_lo, e ff_gt_b_hi, e ff_gt_b_lo, e ff_gt_cmp_rng_ctr, e ff_gt_p_sub_a_hi, e ff_gt_p_sub_a_lo, e ff_gt_p_sub_b_hi, e ff_gt_p_sub_b_lo, e ff_gt_sel, e ff_gt_sel_dec, e ff_gt_sel_gt, e keccak_memory_addr, e keccak_memory_clk, e keccak_memory_ctr, e keccak_memory_rw, e keccak_memory_sel, e keccak_memory_space_id, e keccak_memory_start_read, e keccak_memory_start_write, e keccak_memory_tag_error, e keccak_memory_val_0_, e keccak_memory_val_10_, e keccak_memory_val_11_, e keccak_memory_val_12_, e keccak_memory_val_13_, e keccak_memory_val_14_, e keccak_memory_val_15_, e keccak_memory_val_16_, e keccak_memory_val_17_, e keccak_memory_val_18_, e keccak_memory_val_19_, e keccak_memory_val_1_, e keccak_memory_val_20_, e keccak_memory_val_21_, e keccak_memory_val_22_, e keccak_memory_val_23_, e keccak_memory_val_2_, e keccak_memory_val_3_, e keccak_memory_val_4_, e keccak_memory_val_5_, e keccak_memory_val_6_, e keccak_memory_val_7_, e keccak_memory_val_8_, e keccak_memory_val_9_, e keccakf1600_clk, e keccakf1600_dst_addr, e keccakf1600_round, e keccakf1600_sel, e keccakf1600_sel_no_error, e keccakf1600_space_id, e keccakf1600_start, e keccakf1600_state_in_00, e keccakf1600_state_in_01, e keccakf1600_state_in_02, e keccakf1600_state_in_03, e keccakf1600_state_in_04, e keccakf1600_state_in_10, e keccakf1600_state_in_11, e keccakf1600_state_in_12, e keccakf1600_state_in_13, e keccakf1600_state_in_14, e keccakf1600_state_in_20, e keccakf1600_state_in_21, e keccakf1600_state_in_22, e keccakf1600_state_in_23, e keccakf1600_state_in_24, e keccakf1600_state_in_30, e keccakf1600_state_in_31, e keccakf1600_state_in_32, e keccakf1600_state_in_33, e keccakf1600_state_in_34, e keccakf1600_state_in_40, e keccakf1600_state_in_41, e keccakf1600_state_in_42, e keccakf1600_state_in_43, e keccakf1600_state_in_44, e memory_global_addr, e memory_rw, e memory_sel, e memory_tag, e memory_timestamp, e memory_value, e merkle_check_index, e merkle_check_path_len, e merkle_check_read_node, e merkle_check_read_root, e merkle_check_sel, e merkle_check_write, e merkle_check_write_node, e merkle_check_write_root, e poseidon2_hash_a_0, e poseidon2_hash_a_1, e poseidon2_hash_a_2, e poseidon2_hash_a_3, e poseidon2_hash_input_0, e poseidon2_hash_input_1, e poseidon2_hash_input_2, e poseidon2_hash_num_perm_rounds_rem, e poseidon2_hash_output, e poseidon2_hash_sel, e poseidon2_hash_start, e public_data_check_clk, e public_data_check_sel, e public_data_check_write_idx, e public_data_squash_clk, e public_data_squash_final_value, e public_data_squash_leaf_slot, e public_data_squash_sel, e public_data_squash_write_to_public_inputs, e scalar_mul_bit_idx, e scalar_mul_point_inf, e scalar_mul_point_x, e scalar_mul_point_y, e scalar_mul_res_inf, e scalar_mul_res_x, e scalar_mul_res_y, e scalar_mul_scalar, e scalar_mul_sel, e scalar_mul_start, e scalar_mul_temp_inf, e scalar_mul_temp_x, e scalar_mul_temp_y, e sha256_a, e sha256_b, e sha256_c, e sha256_d, e sha256_e, e sha256_execution_clk, e sha256_f, e sha256_g, e sha256_h, e sha256_helper_w0, e sha256_helper_w1, e sha256_helper_w10, e sha256_helper_w11, e sha256_helper_w12, e sha256_helper_w13, e sha256_helper_w14, e sha256_helper_w15, e sha256_helper_w2, e sha256_helper_w3, e sha256_helper_w4, e sha256_helper_w5, e sha256_helper_w6, e sha256_helper_w7, e sha256_helper_w8, e sha256_helper_w9, e sha256_init_a, e sha256_init_b, e sha256_init_c, e sha256_init_d, e sha256_init_e, e sha256_init_f, e sha256_init_g, e sha256_init_h, e sha256_input_addr, e sha256_input_rounds_rem, e sha256_output_addr, e sha256_rounds_remaining, e sha256_sel, e sha256_sel_invalid_input_tag_err, e sha256_sel_is_input_round, e sha256_space_id, e sha256_start, e to_radix_acc, e to_radix_acc_under_p, e to_radix_limb, e to_radix_limb_eq_p, e to_radix_limb_index, e to_radix_limb_lt_p, e to_radix_mem_dst_addr, e to_radix_mem_execution_clk, e to_radix_mem_is_output_bits, e to_radix_mem_num_limbs, e to_radix_mem_radix, e to_radix_mem_sel, e to_radix_mem_sel_should_decompose, e to_radix_mem_sel_should_write_mem, e to_radix_mem_space_id, e to_radix_mem_start, e to_radix_mem_value_to_decompose, e to_radix_not_padding_limb, e to_radix_power, e to_radix_radix, e to_radix_safe_limbs, e to_radix_sel, e to_radix_start, e to_radix_value, e tx_da_gas_limit, e tx_discard, e tx_fee, e tx_is_revertible, e tx_is_teardown, e tx_l1_l2_tree_root, e tx_l1_l2_tree_size, e tx_l2_gas_limit, e tx_next_context_id, e tx_phase_value, e tx_prev_da_gas_used, e tx_prev_l2_gas_used, e tx_prev_note_hash_tree_root, e tx_prev_note_hash_tree_size, e tx_prev_nullifier_tree_root, e tx_prev_nullifier_tree_size, e tx_prev_num_l2_to_l1_messages, e tx_prev_num_note_hashes_emitted, e tx_prev_num_nullifiers_emitted, e tx_prev_num_public_log_fields, e tx_prev_public_data_tree_root, e tx_prev_public_data_tree_size, e tx_prev_retrieved_bytecodes_tree_root, e tx_prev_retrieved_bytecodes_tree_size, e tx_prev_written_public_data_slots_tree_root, e tx_prev_written_public_data_slots_tree_size, e tx_read_pi_offset, e tx_remaining_phase_counter, e tx_reverted, e tx_sel, e tx_start_phase, e tx_start_tx, e tx_tx_reverted +#define AVM2_DERIVED_WITNESS_ENTITIES_E(e) e perm_keccak_memory_slice_to_mem_inv, e perm_keccakf1600_read_to_slice_inv, e perm_keccakf1600_write_to_slice_inv, e perm_sha256_mem_mem_op_0_inv, e perm_sha256_mem_mem_op_1_inv, e perm_sha256_mem_mem_op_2_inv, e perm_sha256_mem_mem_op_3_inv, e perm_sha256_mem_mem_op_4_inv, e perm_sha256_mem_mem_op_5_inv, e perm_sha256_mem_mem_op_6_inv, e perm_sha256_mem_mem_op_7_inv, e perm_sha256_mem_mem_input_read_inv, e perm_ecc_mem_write_mem_0_inv, e perm_ecc_mem_write_mem_1_inv, e perm_ecc_mem_write_mem_2_inv, e perm_poseidon2_mem_pos_read_mem_0_inv, e perm_poseidon2_mem_pos_read_mem_1_inv, e perm_poseidon2_mem_pos_read_mem_2_inv, e perm_poseidon2_mem_pos_read_mem_3_inv, e perm_poseidon2_mem_pos_write_mem_0_inv, e perm_poseidon2_mem_pos_write_mem_1_inv, e perm_poseidon2_mem_pos_write_mem_2_inv, e perm_poseidon2_mem_pos_write_mem_3_inv, e perm_to_radix_mem_write_mem_inv, e perm_internal_call_push_call_stack_inv, e perm_context_ctx_stack_call_inv, e perm_data_copy_mem_write_inv, e perm_data_copy_mem_read_inv, e perm_addressing_base_address_from_memory_inv, e perm_addressing_indirect_from_memory_0_inv, e perm_addressing_indirect_from_memory_1_inv, e perm_addressing_indirect_from_memory_2_inv, e perm_addressing_indirect_from_memory_3_inv, e perm_addressing_indirect_from_memory_4_inv, e perm_addressing_indirect_from_memory_5_inv, e perm_addressing_indirect_from_memory_6_inv, e perm_registers_mem_op_0_inv, e perm_registers_mem_op_1_inv, e perm_registers_mem_op_2_inv, e perm_registers_mem_op_3_inv, e perm_registers_mem_op_4_inv, e perm_registers_mem_op_5_inv, e perm_public_data_check_squashing_inv, e perm_bc_hashing_bytecode_length_bytes_inv, e perm_bc_hashing_get_packed_field_0_inv, e perm_bc_hashing_get_packed_field_1_inv, e perm_bc_hashing_get_packed_field_2_inv, e perm_get_contract_instance_mem_write_contract_instance_exists_inv, e perm_get_contract_instance_mem_write_contract_instance_member_inv, e perm_sstore_storage_write_inv, e perm_emit_public_log_read_mem_inv, e perm_execution_dispatch_to_cd_copy_inv, e perm_execution_dispatch_to_rd_copy_inv, e perm_execution_dispatch_to_get_contract_instance_inv, e perm_execution_dispatch_to_emit_public_log_inv, e perm_execution_dispatch_to_poseidon2_perm_inv, e perm_execution_dispatch_to_sha256_compression_inv, e perm_execution_dispatch_to_keccakf1600_inv, e perm_execution_dispatch_to_ecc_add_inv, e perm_execution_dispatch_to_to_radix_inv, e perm_tx_read_calldata_hash_inv, e perm_tx_dispatch_exec_start_inv, e perm_tx_dispatch_exec_end_inv, e perm_tx_balance_update_inv, e lookup_range_check_dyn_rng_chk_pow_2_inv, e lookup_range_check_dyn_diff_is_u16_inv, e lookup_range_check_r0_is_u16_inv, e lookup_range_check_r1_is_u16_inv, e lookup_range_check_r2_is_u16_inv, e lookup_range_check_r3_is_u16_inv, e lookup_range_check_r4_is_u16_inv, e lookup_range_check_r5_is_u16_inv, e lookup_range_check_r6_is_u16_inv, e lookup_range_check_r7_is_u16_inv, e lookup_ff_gt_a_lo_range_inv, e lookup_ff_gt_a_hi_range_inv, e lookup_gt_gt_range_inv, e lookup_alu_tag_max_bits_value_inv, e lookup_alu_range_check_decomposition_a_lo_inv, e lookup_alu_range_check_decomposition_a_hi_inv, e lookup_alu_range_check_decomposition_b_lo_inv, e lookup_alu_range_check_decomposition_b_hi_inv, e lookup_alu_range_check_mul_c_hi_inv, e lookup_alu_ff_gt_inv, e lookup_alu_int_gt_inv, e lookup_alu_shifts_two_pow_inv, e lookup_alu_large_trunc_canonical_dec_inv, e lookup_alu_range_check_trunc_mid_inv, e lookup_bitwise_integral_tag_length_inv, e lookup_bitwise_byte_operations_inv, e lookup_memory_range_check_limb_0_inv, e lookup_memory_range_check_limb_1_inv, e lookup_memory_range_check_limb_2_inv, e lookup_memory_tag_max_bits_inv, e lookup_memory_range_check_write_tagged_value_inv, e lookup_keccakf1600_theta_xor_01_inv, e lookup_keccakf1600_theta_xor_02_inv, e lookup_keccakf1600_theta_xor_03_inv, e lookup_keccakf1600_theta_xor_row_0_inv, e lookup_keccakf1600_theta_xor_11_inv, e lookup_keccakf1600_theta_xor_12_inv, e lookup_keccakf1600_theta_xor_13_inv, e lookup_keccakf1600_theta_xor_row_1_inv, e lookup_keccakf1600_theta_xor_21_inv, e lookup_keccakf1600_theta_xor_22_inv, e lookup_keccakf1600_theta_xor_23_inv, e lookup_keccakf1600_theta_xor_row_2_inv, e lookup_keccakf1600_theta_xor_31_inv, e lookup_keccakf1600_theta_xor_32_inv, e lookup_keccakf1600_theta_xor_33_inv, e lookup_keccakf1600_theta_xor_row_3_inv, e lookup_keccakf1600_theta_xor_41_inv, e lookup_keccakf1600_theta_xor_42_inv, e lookup_keccakf1600_theta_xor_43_inv, e lookup_keccakf1600_theta_xor_row_4_inv, e lookup_keccakf1600_theta_combined_xor_0_inv, e lookup_keccakf1600_theta_combined_xor_1_inv, e lookup_keccakf1600_theta_combined_xor_2_inv, e lookup_keccakf1600_theta_combined_xor_3_inv, e lookup_keccakf1600_theta_combined_xor_4_inv, e lookup_keccakf1600_state_theta_00_inv, e lookup_keccakf1600_state_theta_01_inv, e lookup_keccakf1600_state_theta_02_inv, e lookup_keccakf1600_state_theta_03_inv, e lookup_keccakf1600_state_theta_04_inv, e lookup_keccakf1600_state_theta_10_inv, e lookup_keccakf1600_state_theta_11_inv, e lookup_keccakf1600_state_theta_12_inv, e lookup_keccakf1600_state_theta_13_inv, e lookup_keccakf1600_state_theta_14_inv, e lookup_keccakf1600_state_theta_20_inv, e lookup_keccakf1600_state_theta_21_inv, e lookup_keccakf1600_state_theta_22_inv, e lookup_keccakf1600_state_theta_23_inv, e lookup_keccakf1600_state_theta_24_inv, e lookup_keccakf1600_state_theta_30_inv, e lookup_keccakf1600_state_theta_31_inv, e lookup_keccakf1600_state_theta_32_inv, e lookup_keccakf1600_state_theta_33_inv, e lookup_keccakf1600_state_theta_34_inv, e lookup_keccakf1600_state_theta_40_inv, e lookup_keccakf1600_state_theta_41_inv, e lookup_keccakf1600_state_theta_42_inv, e lookup_keccakf1600_state_theta_43_inv, e lookup_keccakf1600_state_theta_44_inv, e lookup_keccakf1600_theta_limb_02_range_inv, e lookup_keccakf1600_theta_limb_04_range_inv, e lookup_keccakf1600_theta_limb_10_range_inv, e lookup_keccakf1600_theta_limb_12_range_inv, e lookup_keccakf1600_theta_limb_14_range_inv, e lookup_keccakf1600_theta_limb_21_range_inv, e lookup_keccakf1600_theta_limb_23_range_inv, e lookup_keccakf1600_theta_limb_30_range_inv, e lookup_keccakf1600_theta_limb_32_range_inv, e lookup_keccakf1600_theta_limb_33_range_inv, e lookup_keccakf1600_theta_limb_40_range_inv, e lookup_keccakf1600_theta_limb_41_range_inv, e lookup_keccakf1600_theta_limb_43_range_inv, e lookup_keccakf1600_theta_limb_44_range_inv, e lookup_keccakf1600_theta_limb_01_range_inv, e lookup_keccakf1600_theta_limb_03_range_inv, e lookup_keccakf1600_theta_limb_11_range_inv, e lookup_keccakf1600_theta_limb_13_range_inv, e lookup_keccakf1600_theta_limb_20_range_inv, e lookup_keccakf1600_theta_limb_22_range_inv, e lookup_keccakf1600_theta_limb_24_range_inv, e lookup_keccakf1600_theta_limb_31_range_inv, e lookup_keccakf1600_theta_limb_34_range_inv, e lookup_keccakf1600_theta_limb_42_range_inv, e lookup_keccakf1600_state_pi_and_00_inv, e lookup_keccakf1600_state_pi_and_01_inv, e lookup_keccakf1600_state_pi_and_02_inv, e lookup_keccakf1600_state_pi_and_03_inv, e lookup_keccakf1600_state_pi_and_04_inv, e lookup_keccakf1600_state_pi_and_10_inv, e lookup_keccakf1600_state_pi_and_11_inv, e lookup_keccakf1600_state_pi_and_12_inv, e lookup_keccakf1600_state_pi_and_13_inv, e lookup_keccakf1600_state_pi_and_14_inv, e lookup_keccakf1600_state_pi_and_20_inv, e lookup_keccakf1600_state_pi_and_21_inv, e lookup_keccakf1600_state_pi_and_22_inv, e lookup_keccakf1600_state_pi_and_23_inv, e lookup_keccakf1600_state_pi_and_24_inv, e lookup_keccakf1600_state_pi_and_30_inv, e lookup_keccakf1600_state_pi_and_31_inv, e lookup_keccakf1600_state_pi_and_32_inv, e lookup_keccakf1600_state_pi_and_33_inv, e lookup_keccakf1600_state_pi_and_34_inv, e lookup_keccakf1600_state_pi_and_40_inv, e lookup_keccakf1600_state_pi_and_41_inv, e lookup_keccakf1600_state_pi_and_42_inv, e lookup_keccakf1600_state_pi_and_43_inv, e lookup_keccakf1600_state_pi_and_44_inv, e lookup_keccakf1600_state_chi_00_inv, e lookup_keccakf1600_state_chi_01_inv, e lookup_keccakf1600_state_chi_02_inv, e lookup_keccakf1600_state_chi_03_inv, e lookup_keccakf1600_state_chi_04_inv, e lookup_keccakf1600_state_chi_10_inv, e lookup_keccakf1600_state_chi_11_inv, e lookup_keccakf1600_state_chi_12_inv, e lookup_keccakf1600_state_chi_13_inv, e lookup_keccakf1600_state_chi_14_inv, e lookup_keccakf1600_state_chi_20_inv, e lookup_keccakf1600_state_chi_21_inv, e lookup_keccakf1600_state_chi_22_inv, e lookup_keccakf1600_state_chi_23_inv, e lookup_keccakf1600_state_chi_24_inv, e lookup_keccakf1600_state_chi_30_inv, e lookup_keccakf1600_state_chi_31_inv, e lookup_keccakf1600_state_chi_32_inv, e lookup_keccakf1600_state_chi_33_inv, e lookup_keccakf1600_state_chi_34_inv, e lookup_keccakf1600_state_chi_40_inv, e lookup_keccakf1600_state_chi_41_inv, e lookup_keccakf1600_state_chi_42_inv, e lookup_keccakf1600_state_chi_43_inv, e lookup_keccakf1600_state_chi_44_inv, e lookup_keccakf1600_round_cst_inv, e lookup_keccakf1600_state_iota_00_inv, e lookup_keccakf1600_src_out_of_range_toggle_inv, e lookup_keccakf1600_dst_out_of_range_toggle_inv, e lookup_sha256_range_comp_w_lhs_inv, e lookup_sha256_range_comp_w_rhs_inv, e lookup_sha256_range_rhs_w_7_inv, e lookup_sha256_range_rhs_w_18_inv, e lookup_sha256_range_rhs_w_3_inv, e lookup_sha256_w_s_0_xor_0_inv, e lookup_sha256_w_s_0_xor_1_inv, e lookup_sha256_range_rhs_w_17_inv, e lookup_sha256_range_rhs_w_19_inv, e lookup_sha256_range_rhs_w_10_inv, e lookup_sha256_w_s_1_xor_0_inv, e lookup_sha256_w_s_1_xor_1_inv, e lookup_sha256_range_rhs_e_6_inv, e lookup_sha256_range_rhs_e_11_inv, e lookup_sha256_range_rhs_e_25_inv, e lookup_sha256_s_1_xor_0_inv, e lookup_sha256_s_1_xor_1_inv, e lookup_sha256_ch_and_0_inv, e lookup_sha256_ch_and_1_inv, e lookup_sha256_ch_xor_inv, e lookup_sha256_round_constant_inv, e lookup_sha256_range_rhs_a_2_inv, e lookup_sha256_range_rhs_a_13_inv, e lookup_sha256_range_rhs_a_22_inv, e lookup_sha256_s_0_xor_0_inv, e lookup_sha256_s_0_xor_1_inv, e lookup_sha256_maj_and_0_inv, e lookup_sha256_maj_and_1_inv, e lookup_sha256_maj_and_2_inv, e lookup_sha256_maj_xor_0_inv, e lookup_sha256_maj_xor_1_inv, e lookup_sha256_range_comp_next_a_lhs_inv, e lookup_sha256_range_comp_next_a_rhs_inv, e lookup_sha256_range_comp_next_e_lhs_inv, e lookup_sha256_range_comp_next_e_rhs_inv, e lookup_sha256_range_comp_a_lhs_inv, e lookup_sha256_range_comp_a_rhs_inv, e lookup_sha256_range_comp_b_lhs_inv, e lookup_sha256_range_comp_b_rhs_inv, e lookup_sha256_range_comp_c_lhs_inv, e lookup_sha256_range_comp_c_rhs_inv, e lookup_sha256_range_comp_d_lhs_inv, e lookup_sha256_range_comp_d_rhs_inv, e lookup_sha256_range_comp_e_lhs_inv, e lookup_sha256_range_comp_e_rhs_inv, e lookup_sha256_range_comp_f_lhs_inv, e lookup_sha256_range_comp_f_rhs_inv, e lookup_sha256_range_comp_g_lhs_inv, e lookup_sha256_range_comp_g_rhs_inv, e lookup_sha256_range_comp_h_lhs_inv, e lookup_sha256_range_comp_h_rhs_inv, e lookup_sha256_mem_check_state_addr_in_range_inv, e lookup_sha256_mem_check_input_addr_in_range_inv, e lookup_sha256_mem_check_output_addr_in_range_inv, e lookup_ecc_mem_check_dst_addr_in_range_inv, e lookup_ecc_mem_input_output_ecc_add_inv, e lookup_poseidon2_mem_check_src_addr_in_range_inv, e lookup_poseidon2_mem_check_dst_addr_in_range_inv, e lookup_poseidon2_mem_input_output_poseidon2_perm_inv, e lookup_to_radix_limb_range_inv, e lookup_to_radix_limb_less_than_radix_range_inv, e lookup_to_radix_fetch_safe_limbs_inv, e lookup_to_radix_fetch_p_limb_inv, e lookup_to_radix_limb_p_diff_range_inv, e lookup_scalar_mul_to_radix_inv, e lookup_scalar_mul_double_inv, e lookup_scalar_mul_add_inv, e lookup_to_radix_mem_check_dst_addr_in_range_inv, e lookup_to_radix_mem_check_radix_lt_2_inv, e lookup_to_radix_mem_check_radix_gt_256_inv, e lookup_to_radix_mem_input_output_to_radix_inv, e lookup_internal_call_unwind_call_stack_inv, e lookup_context_ctx_stack_rollback_inv, e lookup_context_ctx_stack_return_inv, e lookup_poseidon2_hash_poseidon2_perm_inv, e lookup_calldata_hashing_get_calldata_field_0_inv, e lookup_calldata_hashing_get_calldata_field_1_inv, e lookup_calldata_hashing_get_calldata_field_2_inv, e lookup_calldata_hashing_check_final_size_inv, e lookup_calldata_hashing_poseidon2_hash_inv, e lookup_calldata_range_check_context_id_diff_inv, e lookup_data_copy_offset_plus_size_is_gt_data_size_inv, e lookup_data_copy_check_src_addr_in_range_inv, e lookup_data_copy_check_dst_addr_in_range_inv, e lookup_data_copy_data_index_upper_bound_gt_offset_inv, e lookup_data_copy_col_read_inv, e lookup_addressing_relative_overflow_result_0_inv, e lookup_addressing_relative_overflow_result_1_inv, e lookup_addressing_relative_overflow_result_2_inv, e lookup_addressing_relative_overflow_result_3_inv, e lookup_addressing_relative_overflow_result_4_inv, e lookup_addressing_relative_overflow_result_5_inv, e lookup_addressing_relative_overflow_result_6_inv, e lookup_gas_addressing_gas_read_inv, e lookup_gas_is_out_of_gas_l2_inv, e lookup_gas_is_out_of_gas_da_inv, e lookup_merkle_check_merkle_poseidon2_read_inv, e lookup_merkle_check_merkle_poseidon2_write_inv, e lookup_indexed_tree_check_silo_poseidon2_inv, e lookup_indexed_tree_check_low_leaf_value_validation_inv, e lookup_indexed_tree_check_low_leaf_next_value_validation_inv, e lookup_indexed_tree_check_low_leaf_poseidon2_inv, e lookup_indexed_tree_check_updated_low_leaf_poseidon2_inv, e lookup_indexed_tree_check_low_leaf_merkle_check_inv, e lookup_indexed_tree_check_new_leaf_poseidon2_inv, e lookup_indexed_tree_check_new_leaf_merkle_check_inv, e lookup_indexed_tree_check_write_value_to_public_inputs_inv, e lookup_public_data_squash_leaf_slot_increase_ff_gt_inv, e lookup_public_data_squash_clk_diff_range_lo_inv, e lookup_public_data_squash_clk_diff_range_hi_inv, e lookup_public_data_check_clk_diff_range_lo_inv, e lookup_public_data_check_clk_diff_range_hi_inv, e lookup_public_data_check_silo_poseidon2_inv, e lookup_public_data_check_low_leaf_slot_validation_inv, e lookup_public_data_check_low_leaf_next_slot_validation_inv, e lookup_public_data_check_low_leaf_poseidon2_0_inv, e lookup_public_data_check_low_leaf_poseidon2_1_inv, e lookup_public_data_check_updated_low_leaf_poseidon2_0_inv, e lookup_public_data_check_updated_low_leaf_poseidon2_1_inv, e lookup_public_data_check_low_leaf_merkle_check_inv, e lookup_public_data_check_new_leaf_poseidon2_0_inv, e lookup_public_data_check_new_leaf_poseidon2_1_inv, e lookup_public_data_check_new_leaf_merkle_check_inv, e lookup_public_data_check_write_public_data_to_public_inputs_inv, e lookup_public_data_check_write_writes_length_to_public_inputs_inv, e lookup_l1_to_l2_message_tree_check_merkle_check_inv, e lookup_address_derivation_salted_initialization_hash_poseidon2_0_inv, e lookup_address_derivation_salted_initialization_hash_poseidon2_1_inv, e lookup_address_derivation_partial_address_poseidon2_inv, e lookup_address_derivation_public_keys_hash_poseidon2_0_inv, e lookup_address_derivation_public_keys_hash_poseidon2_1_inv, e lookup_address_derivation_public_keys_hash_poseidon2_2_inv, e lookup_address_derivation_public_keys_hash_poseidon2_3_inv, e lookup_address_derivation_public_keys_hash_poseidon2_4_inv, e lookup_address_derivation_preaddress_poseidon2_inv, e lookup_address_derivation_preaddress_scalar_mul_inv, e lookup_address_derivation_address_ecadd_inv, e lookup_bc_decomposition_bytes_are_bytes_inv, e lookup_bc_hashing_check_final_bytes_remaining_inv, e lookup_bc_hashing_poseidon2_hash_inv, e lookup_update_check_timestamp_from_public_inputs_inv, e lookup_update_check_delayed_public_mutable_slot_poseidon2_inv, e lookup_update_check_update_hash_public_data_read_inv, e lookup_update_check_update_hash_poseidon2_inv, e lookup_update_check_update_hi_metadata_range_inv, e lookup_update_check_update_lo_metadata_range_inv, e lookup_update_check_timestamp_is_lt_timestamp_of_change_inv, e lookup_contract_instance_retrieval_check_protocol_address_range_inv, e lookup_contract_instance_retrieval_read_derived_address_from_public_inputs_inv, e lookup_contract_instance_retrieval_deployment_nullifier_read_inv, e lookup_contract_instance_retrieval_address_derivation_inv, e lookup_contract_instance_retrieval_update_check_inv, e lookup_bc_retrieval_contract_instance_retrieval_inv, e lookup_bc_retrieval_is_new_class_check_inv, e lookup_bc_retrieval_class_id_derivation_inv, e lookup_bc_retrieval_retrieved_bytecodes_insertion_inv, e lookup_instr_fetching_pc_abs_diff_positive_inv, e lookup_instr_fetching_instr_abs_diff_positive_inv, e lookup_instr_fetching_tag_value_validation_inv, e lookup_instr_fetching_bytecode_size_from_bc_dec_inv, e lookup_instr_fetching_bytes_from_bc_dec_inv, e lookup_instr_fetching_wire_instruction_info_inv, e lookup_class_id_derivation_class_id_poseidon2_0_inv, e lookup_class_id_derivation_class_id_poseidon2_1_inv, e lookup_get_env_var_precomputed_info_inv, e lookup_get_env_var_read_from_public_inputs_col0_inv, e lookup_get_env_var_read_from_public_inputs_col1_inv, e lookup_get_contract_instance_precomputed_info_inv, e lookup_get_contract_instance_contract_instance_retrieval_inv, e lookup_external_call_is_l2_gas_left_gt_allocated_inv, e lookup_external_call_is_da_gas_left_gt_allocated_inv, e lookup_sload_storage_read_inv, e lookup_sstore_record_written_storage_slot_inv, e lookup_note_hash_tree_check_silo_poseidon2_inv, e lookup_note_hash_tree_check_read_first_nullifier_inv, e lookup_note_hash_tree_check_nonce_computation_poseidon2_inv, e lookup_note_hash_tree_check_unique_note_hash_poseidon2_inv, e lookup_note_hash_tree_check_merkle_check_inv, e lookup_note_hash_tree_check_write_note_hash_to_public_inputs_inv, e lookup_notehash_exists_note_hash_leaf_index_in_range_inv, e lookup_notehash_exists_note_hash_read_inv, e lookup_emit_notehash_notehash_tree_write_inv, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_leaf_index_in_range_inv, e lookup_l1_to_l2_message_exists_l1_to_l2_msg_read_inv, e lookup_nullifier_exists_nullifier_exists_check_inv, e lookup_emit_nullifier_write_nullifier_inv, e lookup_emit_public_log_check_memory_out_of_bounds_inv, e lookup_emit_public_log_check_log_fields_count_inv, e lookup_emit_public_log_write_data_to_public_inputs_inv, e lookup_send_l2_to_l1_msg_recipient_check_inv, e lookup_send_l2_to_l1_msg_write_l2_to_l1_msg_inv, e lookup_execution_bytecode_retrieval_result_inv, e lookup_execution_instruction_fetching_result_inv, e lookup_execution_instruction_fetching_body_inv, e lookup_execution_exec_spec_read_inv, e lookup_execution_dyn_l2_factor_bitwise_inv, e lookup_execution_check_radix_gt_256_inv, e lookup_execution_get_p_limbs_inv, e lookup_execution_get_max_limbs_inv, e lookup_execution_check_written_storage_slot_inv, e lookup_execution_dispatch_to_alu_inv, e lookup_execution_dispatch_to_bitwise_inv, e lookup_execution_dispatch_to_cast_inv, e lookup_execution_dispatch_to_set_inv, e lookup_tx_context_public_inputs_note_hash_tree_inv, e lookup_tx_context_public_inputs_nullifier_tree_inv, e lookup_tx_context_public_inputs_public_data_tree_inv, e lookup_tx_context_public_inputs_l1_l2_tree_inv, e lookup_tx_context_public_inputs_gas_used_inv, e lookup_tx_context_public_inputs_read_gas_limit_inv, e lookup_tx_context_public_inputs_read_reverted_inv, e lookup_tx_context_restore_state_on_revert_inv, e lookup_tx_context_public_inputs_write_note_hash_count_inv, e lookup_tx_context_public_inputs_write_nullifier_count_inv, e lookup_tx_context_public_inputs_write_l2_to_l1_message_count_inv, e lookup_tx_context_public_inputs_write_public_log_count_inv, e lookup_tx_read_phase_spec_inv, e lookup_tx_read_phase_length_inv, e lookup_tx_read_public_call_request_phase_inv, e lookup_tx_read_tree_insert_value_inv, e lookup_tx_note_hash_append_inv, e lookup_tx_nullifier_append_inv, e lookup_tx_read_l2_l1_msg_inv, e lookup_tx_write_l2_l1_msg_inv, e lookup_tx_read_effective_fee_public_inputs_inv, e lookup_tx_read_fee_payer_public_inputs_inv, e lookup_tx_balance_slot_poseidon2_inv, e lookup_tx_balance_read_inv, e lookup_tx_balance_validation_inv, e lookup_tx_write_fee_public_inputs_inv #define AVM2_SHIFTED_ENTITIES_E(e) e bc_decomposition_bytes_shift, e bc_decomposition_bytes_pc_plus_1_shift, e bc_decomposition_bytes_pc_plus_10_shift, e bc_decomposition_bytes_pc_plus_11_shift, e bc_decomposition_bytes_pc_plus_12_shift, e bc_decomposition_bytes_pc_plus_13_shift, e bc_decomposition_bytes_pc_plus_14_shift, e bc_decomposition_bytes_pc_plus_15_shift, e bc_decomposition_bytes_pc_plus_16_shift, e bc_decomposition_bytes_pc_plus_17_shift, e bc_decomposition_bytes_pc_plus_18_shift, e bc_decomposition_bytes_pc_plus_19_shift, e bc_decomposition_bytes_pc_plus_2_shift, e bc_decomposition_bytes_pc_plus_20_shift, e bc_decomposition_bytes_pc_plus_21_shift, e bc_decomposition_bytes_pc_plus_22_shift, e bc_decomposition_bytes_pc_plus_23_shift, e bc_decomposition_bytes_pc_plus_24_shift, e bc_decomposition_bytes_pc_plus_25_shift, e bc_decomposition_bytes_pc_plus_26_shift, e bc_decomposition_bytes_pc_plus_27_shift, e bc_decomposition_bytes_pc_plus_28_shift, e bc_decomposition_bytes_pc_plus_29_shift, e bc_decomposition_bytes_pc_plus_3_shift, e bc_decomposition_bytes_pc_plus_30_shift, e bc_decomposition_bytes_pc_plus_31_shift, e bc_decomposition_bytes_pc_plus_32_shift, e bc_decomposition_bytes_pc_plus_33_shift, e bc_decomposition_bytes_pc_plus_34_shift, e bc_decomposition_bytes_pc_plus_35_shift, e bc_decomposition_bytes_pc_plus_4_shift, e bc_decomposition_bytes_pc_plus_5_shift, e bc_decomposition_bytes_pc_plus_6_shift, e bc_decomposition_bytes_pc_plus_7_shift, e bc_decomposition_bytes_pc_plus_8_shift, e bc_decomposition_bytes_pc_plus_9_shift, e bc_decomposition_bytes_remaining_shift, e bc_decomposition_id_shift, e bc_decomposition_next_packed_pc_shift, e bc_decomposition_pc_shift, e bc_decomposition_sel_shift, e bc_decomposition_sel_windows_gt_remaining_shift, e bc_decomposition_start_shift, e bc_hashing_bytecode_id_shift, e bc_hashing_pc_index_shift, e bc_hashing_rounds_rem_shift, e bc_hashing_sel_shift, e bc_hashing_start_shift, e bc_retrieval_sel_shift, e bitwise_acc_ia_shift, e bitwise_acc_ib_shift, e bitwise_acc_ic_shift, e bitwise_ctr_shift, e bitwise_op_id_shift, e bitwise_sel_shift, e bitwise_start_shift, e calldata_context_id_shift, e calldata_hashing_calldata_size_shift, e calldata_hashing_context_id_shift, e calldata_hashing_index_0__shift, e calldata_hashing_output_hash_shift, e calldata_hashing_rounds_rem_shift, e calldata_hashing_sel_shift, e calldata_hashing_start_shift, e calldata_index_shift, e calldata_sel_shift, e data_copy_clk_shift, e data_copy_copy_size_shift, e data_copy_dst_addr_shift, e data_copy_dst_context_id_shift, e data_copy_padding_shift, e data_copy_read_addr_shift, e data_copy_reads_left_shift, e data_copy_sel_shift, e data_copy_sel_cd_copy_shift, e data_copy_sel_start_shift, e data_copy_src_context_id_shift, e emit_public_log_contract_address_shift, e emit_public_log_correct_tag_shift, e emit_public_log_error_out_of_bounds_shift, e emit_public_log_error_tag_mismatch_shift, e emit_public_log_execution_clk_shift, e emit_public_log_is_write_contract_address_shift, e emit_public_log_is_write_memory_value_shift, e emit_public_log_log_address_shift, e emit_public_log_public_inputs_index_shift, e emit_public_log_remaining_rows_shift, e emit_public_log_seen_wrong_tag_shift, e emit_public_log_sel_shift, e emit_public_log_sel_write_to_public_inputs_shift, e emit_public_log_space_id_shift, e emit_public_log_start_shift, e execution_bytecode_id_shift, e execution_clk_shift, e execution_context_id_shift, e execution_contract_address_shift, e execution_da_gas_limit_shift, e execution_discard_shift, e execution_dying_context_id_shift, e execution_enqueued_call_start_shift, e execution_internal_call_id_shift, e execution_internal_call_return_id_shift, e execution_is_static_shift, e execution_l1_l2_tree_root_shift, e execution_l2_gas_limit_shift, e execution_last_child_id_shift, e execution_last_child_returndata_addr_shift, e execution_last_child_returndata_size_shift, e execution_last_child_success_shift, e execution_msg_sender_shift, e execution_next_context_id_shift, e execution_next_internal_call_id_shift, e execution_parent_calldata_addr_shift, e execution_parent_calldata_size_shift, e execution_parent_da_gas_limit_shift, e execution_parent_da_gas_used_shift, e execution_parent_id_shift, e execution_parent_l2_gas_limit_shift, e execution_parent_l2_gas_used_shift, e execution_pc_shift, e execution_prev_da_gas_used_shift, e execution_prev_l2_gas_used_shift, e execution_prev_note_hash_tree_root_shift, e execution_prev_note_hash_tree_size_shift, e execution_prev_nullifier_tree_root_shift, e execution_prev_nullifier_tree_size_shift, e execution_prev_num_l2_to_l1_messages_shift, e execution_prev_num_note_hashes_emitted_shift, e execution_prev_num_nullifiers_emitted_shift, e execution_prev_num_public_log_fields_shift, e execution_prev_public_data_tree_root_shift, e execution_prev_public_data_tree_size_shift, e execution_prev_retrieved_bytecodes_tree_root_shift, e execution_prev_retrieved_bytecodes_tree_size_shift, e execution_prev_written_public_data_slots_tree_root_shift, e execution_prev_written_public_data_slots_tree_size_shift, e execution_sel_shift, e execution_sel_first_row_in_context_shift, e execution_transaction_fee_shift, e ff_gt_a_hi_shift, e ff_gt_a_lo_shift, e ff_gt_b_hi_shift, e ff_gt_b_lo_shift, e ff_gt_cmp_rng_ctr_shift, e ff_gt_p_sub_a_hi_shift, e ff_gt_p_sub_a_lo_shift, e ff_gt_p_sub_b_hi_shift, e ff_gt_p_sub_b_lo_shift, e ff_gt_sel_shift, e ff_gt_sel_dec_shift, e ff_gt_sel_gt_shift, e keccak_memory_addr_shift, e keccak_memory_clk_shift, e keccak_memory_ctr_shift, e keccak_memory_rw_shift, e keccak_memory_sel_shift, e keccak_memory_space_id_shift, e keccak_memory_start_read_shift, e keccak_memory_start_write_shift, e keccak_memory_tag_error_shift, e keccak_memory_val_0__shift, e keccak_memory_val_10__shift, e keccak_memory_val_11__shift, e keccak_memory_val_12__shift, e keccak_memory_val_13__shift, e keccak_memory_val_14__shift, e keccak_memory_val_15__shift, e keccak_memory_val_16__shift, e keccak_memory_val_17__shift, e keccak_memory_val_18__shift, e keccak_memory_val_19__shift, e keccak_memory_val_1__shift, e keccak_memory_val_20__shift, e keccak_memory_val_21__shift, e keccak_memory_val_22__shift, e keccak_memory_val_23__shift, e keccak_memory_val_2__shift, e keccak_memory_val_3__shift, e keccak_memory_val_4__shift, e keccak_memory_val_5__shift, e keccak_memory_val_6__shift, e keccak_memory_val_7__shift, e keccak_memory_val_8__shift, e keccak_memory_val_9__shift, e keccakf1600_clk_shift, e keccakf1600_dst_addr_shift, e keccakf1600_round_shift, e keccakf1600_sel_shift, e keccakf1600_sel_no_error_shift, e keccakf1600_space_id_shift, e keccakf1600_start_shift, e keccakf1600_state_in_00_shift, e keccakf1600_state_in_01_shift, e keccakf1600_state_in_02_shift, e keccakf1600_state_in_03_shift, e keccakf1600_state_in_04_shift, e keccakf1600_state_in_10_shift, e keccakf1600_state_in_11_shift, e keccakf1600_state_in_12_shift, e keccakf1600_state_in_13_shift, e keccakf1600_state_in_14_shift, e keccakf1600_state_in_20_shift, e keccakf1600_state_in_21_shift, e keccakf1600_state_in_22_shift, e keccakf1600_state_in_23_shift, e keccakf1600_state_in_24_shift, e keccakf1600_state_in_30_shift, e keccakf1600_state_in_31_shift, e keccakf1600_state_in_32_shift, e keccakf1600_state_in_33_shift, e keccakf1600_state_in_34_shift, e keccakf1600_state_in_40_shift, e keccakf1600_state_in_41_shift, e keccakf1600_state_in_42_shift, e keccakf1600_state_in_43_shift, e keccakf1600_state_in_44_shift, e memory_global_addr_shift, e memory_rw_shift, e memory_sel_shift, e memory_tag_shift, e memory_timestamp_shift, e memory_value_shift, e merkle_check_index_shift, e merkle_check_path_len_shift, e merkle_check_read_node_shift, e merkle_check_read_root_shift, e merkle_check_sel_shift, e merkle_check_write_shift, e merkle_check_write_node_shift, e merkle_check_write_root_shift, e poseidon2_hash_a_0_shift, e poseidon2_hash_a_1_shift, e poseidon2_hash_a_2_shift, e poseidon2_hash_a_3_shift, e poseidon2_hash_input_0_shift, e poseidon2_hash_input_1_shift, e poseidon2_hash_input_2_shift, e poseidon2_hash_num_perm_rounds_rem_shift, e poseidon2_hash_output_shift, e poseidon2_hash_sel_shift, e poseidon2_hash_start_shift, e public_data_check_clk_shift, e public_data_check_sel_shift, e public_data_check_write_idx_shift, e public_data_squash_clk_shift, e public_data_squash_final_value_shift, e public_data_squash_leaf_slot_shift, e public_data_squash_sel_shift, e public_data_squash_write_to_public_inputs_shift, e scalar_mul_bit_idx_shift, e scalar_mul_point_inf_shift, e scalar_mul_point_x_shift, e scalar_mul_point_y_shift, e scalar_mul_res_inf_shift, e scalar_mul_res_x_shift, e scalar_mul_res_y_shift, e scalar_mul_scalar_shift, e scalar_mul_sel_shift, e scalar_mul_start_shift, e scalar_mul_temp_inf_shift, e scalar_mul_temp_x_shift, e scalar_mul_temp_y_shift, e sha256_a_shift, e sha256_b_shift, e sha256_c_shift, e sha256_d_shift, e sha256_e_shift, e sha256_execution_clk_shift, e sha256_f_shift, e sha256_g_shift, e sha256_h_shift, e sha256_helper_w0_shift, e sha256_helper_w1_shift, e sha256_helper_w10_shift, e sha256_helper_w11_shift, e sha256_helper_w12_shift, e sha256_helper_w13_shift, e sha256_helper_w14_shift, e sha256_helper_w15_shift, e sha256_helper_w2_shift, e sha256_helper_w3_shift, e sha256_helper_w4_shift, e sha256_helper_w5_shift, e sha256_helper_w6_shift, e sha256_helper_w7_shift, e sha256_helper_w8_shift, e sha256_helper_w9_shift, e sha256_init_a_shift, e sha256_init_b_shift, e sha256_init_c_shift, e sha256_init_d_shift, e sha256_init_e_shift, e sha256_init_f_shift, e sha256_init_g_shift, e sha256_init_h_shift, e sha256_input_addr_shift, e sha256_input_rounds_rem_shift, e sha256_output_addr_shift, e sha256_rounds_remaining_shift, e sha256_sel_shift, e sha256_sel_invalid_input_tag_err_shift, e sha256_sel_is_input_round_shift, e sha256_space_id_shift, e sha256_start_shift, e to_radix_acc_shift, e to_radix_acc_under_p_shift, e to_radix_limb_shift, e to_radix_limb_eq_p_shift, e to_radix_limb_index_shift, e to_radix_limb_lt_p_shift, e to_radix_mem_dst_addr_shift, e to_radix_mem_execution_clk_shift, e to_radix_mem_is_output_bits_shift, e to_radix_mem_num_limbs_shift, e to_radix_mem_radix_shift, e to_radix_mem_sel_shift, e to_radix_mem_sel_should_decompose_shift, e to_radix_mem_sel_should_write_mem_shift, e to_radix_mem_space_id_shift, e to_radix_mem_start_shift, e to_radix_mem_value_to_decompose_shift, e to_radix_not_padding_limb_shift, e to_radix_power_shift, e to_radix_radix_shift, e to_radix_safe_limbs_shift, e to_radix_sel_shift, e to_radix_start_shift, e to_radix_value_shift, e tx_da_gas_limit_shift, e tx_discard_shift, e tx_fee_shift, e tx_is_revertible_shift, e tx_is_teardown_shift, e tx_l1_l2_tree_root_shift, e tx_l1_l2_tree_size_shift, e tx_l2_gas_limit_shift, e tx_next_context_id_shift, e tx_phase_value_shift, e tx_prev_da_gas_used_shift, e tx_prev_l2_gas_used_shift, e tx_prev_note_hash_tree_root_shift, e tx_prev_note_hash_tree_size_shift, e tx_prev_nullifier_tree_root_shift, e tx_prev_nullifier_tree_size_shift, e tx_prev_num_l2_to_l1_messages_shift, e tx_prev_num_note_hashes_emitted_shift, e tx_prev_num_nullifiers_emitted_shift, e tx_prev_num_public_log_fields_shift, e tx_prev_public_data_tree_root_shift, e tx_prev_public_data_tree_size_shift, e tx_prev_retrieved_bytecodes_tree_root_shift, e tx_prev_retrieved_bytecodes_tree_size_shift, e tx_prev_written_public_data_slots_tree_root_shift, e tx_prev_written_public_data_slots_tree_size_shift, e tx_read_pi_offset_shift, e tx_remaining_phase_counter_shift, e tx_reverted_shift, e tx_sel_shift, e tx_start_phase_shift, e tx_start_tx_shift, e tx_tx_reverted_shift #define AVM2_TO_BE_SHIFTED_E(e) e bc_decomposition_bytes, e bc_decomposition_bytes_pc_plus_1, e bc_decomposition_bytes_pc_plus_10, e bc_decomposition_bytes_pc_plus_11, e bc_decomposition_bytes_pc_plus_12, e bc_decomposition_bytes_pc_plus_13, e bc_decomposition_bytes_pc_plus_14, e bc_decomposition_bytes_pc_plus_15, e bc_decomposition_bytes_pc_plus_16, e bc_decomposition_bytes_pc_plus_17, e bc_decomposition_bytes_pc_plus_18, e bc_decomposition_bytes_pc_plus_19, e bc_decomposition_bytes_pc_plus_2, e bc_decomposition_bytes_pc_plus_20, e bc_decomposition_bytes_pc_plus_21, e bc_decomposition_bytes_pc_plus_22, e bc_decomposition_bytes_pc_plus_23, e bc_decomposition_bytes_pc_plus_24, e bc_decomposition_bytes_pc_plus_25, e bc_decomposition_bytes_pc_plus_26, e bc_decomposition_bytes_pc_plus_27, e bc_decomposition_bytes_pc_plus_28, e bc_decomposition_bytes_pc_plus_29, e bc_decomposition_bytes_pc_plus_3, e bc_decomposition_bytes_pc_plus_30, e bc_decomposition_bytes_pc_plus_31, e bc_decomposition_bytes_pc_plus_32, e bc_decomposition_bytes_pc_plus_33, e bc_decomposition_bytes_pc_plus_34, e bc_decomposition_bytes_pc_plus_35, e bc_decomposition_bytes_pc_plus_4, e bc_decomposition_bytes_pc_plus_5, e bc_decomposition_bytes_pc_plus_6, e bc_decomposition_bytes_pc_plus_7, e bc_decomposition_bytes_pc_plus_8, e bc_decomposition_bytes_pc_plus_9, e bc_decomposition_bytes_remaining, e bc_decomposition_id, e bc_decomposition_next_packed_pc, e bc_decomposition_pc, e bc_decomposition_sel, e bc_decomposition_sel_windows_gt_remaining, e bc_decomposition_start, e bc_hashing_bytecode_id, e bc_hashing_pc_index, e bc_hashing_rounds_rem, e bc_hashing_sel, e bc_hashing_start, e bc_retrieval_sel, e bitwise_acc_ia, e bitwise_acc_ib, e bitwise_acc_ic, e bitwise_ctr, e bitwise_op_id, e bitwise_sel, e bitwise_start, e calldata_context_id, e calldata_hashing_calldata_size, e calldata_hashing_context_id, e calldata_hashing_index_0_, e calldata_hashing_output_hash, e calldata_hashing_rounds_rem, e calldata_hashing_sel, e calldata_hashing_start, e calldata_index, e calldata_sel, e data_copy_clk, e data_copy_copy_size, e data_copy_dst_addr, e data_copy_dst_context_id, e data_copy_padding, e data_copy_read_addr, e data_copy_reads_left, e data_copy_sel, e data_copy_sel_cd_copy, e data_copy_sel_start, e data_copy_src_context_id, e emit_public_log_contract_address, e emit_public_log_correct_tag, e emit_public_log_error_out_of_bounds, e emit_public_log_error_tag_mismatch, e emit_public_log_execution_clk, e emit_public_log_is_write_contract_address, e emit_public_log_is_write_memory_value, e emit_public_log_log_address, e emit_public_log_public_inputs_index, e emit_public_log_remaining_rows, e emit_public_log_seen_wrong_tag, e emit_public_log_sel, e emit_public_log_sel_write_to_public_inputs, e emit_public_log_space_id, e emit_public_log_start, e execution_bytecode_id, e execution_clk, e execution_context_id, e execution_contract_address, e execution_da_gas_limit, e execution_discard, e execution_dying_context_id, e execution_enqueued_call_start, e execution_internal_call_id, e execution_internal_call_return_id, e execution_is_static, e execution_l1_l2_tree_root, e execution_l2_gas_limit, e execution_last_child_id, e execution_last_child_returndata_addr, e execution_last_child_returndata_size, e execution_last_child_success, e execution_msg_sender, e execution_next_context_id, e execution_next_internal_call_id, e execution_parent_calldata_addr, e execution_parent_calldata_size, e execution_parent_da_gas_limit, e execution_parent_da_gas_used, e execution_parent_id, e execution_parent_l2_gas_limit, e execution_parent_l2_gas_used, e execution_pc, e execution_prev_da_gas_used, e execution_prev_l2_gas_used, e execution_prev_note_hash_tree_root, e execution_prev_note_hash_tree_size, e execution_prev_nullifier_tree_root, e execution_prev_nullifier_tree_size, e execution_prev_num_l2_to_l1_messages, e execution_prev_num_note_hashes_emitted, e execution_prev_num_nullifiers_emitted, e execution_prev_num_public_log_fields, e execution_prev_public_data_tree_root, e execution_prev_public_data_tree_size, e execution_prev_retrieved_bytecodes_tree_root, e execution_prev_retrieved_bytecodes_tree_size, e execution_prev_written_public_data_slots_tree_root, e execution_prev_written_public_data_slots_tree_size, e execution_sel, e execution_sel_first_row_in_context, e execution_transaction_fee, e ff_gt_a_hi, e ff_gt_a_lo, e ff_gt_b_hi, e ff_gt_b_lo, e ff_gt_cmp_rng_ctr, e ff_gt_p_sub_a_hi, e ff_gt_p_sub_a_lo, e ff_gt_p_sub_b_hi, e ff_gt_p_sub_b_lo, e ff_gt_sel, e ff_gt_sel_dec, e ff_gt_sel_gt, e keccak_memory_addr, e keccak_memory_clk, e keccak_memory_ctr, e keccak_memory_rw, e keccak_memory_sel, e keccak_memory_space_id, e keccak_memory_start_read, e keccak_memory_start_write, e keccak_memory_tag_error, e keccak_memory_val_0_, e keccak_memory_val_10_, e keccak_memory_val_11_, e keccak_memory_val_12_, e keccak_memory_val_13_, e keccak_memory_val_14_, e keccak_memory_val_15_, e keccak_memory_val_16_, e keccak_memory_val_17_, e keccak_memory_val_18_, e keccak_memory_val_19_, e keccak_memory_val_1_, e keccak_memory_val_20_, e keccak_memory_val_21_, e keccak_memory_val_22_, e keccak_memory_val_23_, e keccak_memory_val_2_, e keccak_memory_val_3_, e keccak_memory_val_4_, e keccak_memory_val_5_, e keccak_memory_val_6_, e keccak_memory_val_7_, e keccak_memory_val_8_, e keccak_memory_val_9_, e keccakf1600_clk, e keccakf1600_dst_addr, e keccakf1600_round, e keccakf1600_sel, e keccakf1600_sel_no_error, e keccakf1600_space_id, e keccakf1600_start, e keccakf1600_state_in_00, e keccakf1600_state_in_01, e keccakf1600_state_in_02, e keccakf1600_state_in_03, e keccakf1600_state_in_04, e keccakf1600_state_in_10, e keccakf1600_state_in_11, e keccakf1600_state_in_12, e keccakf1600_state_in_13, e keccakf1600_state_in_14, e keccakf1600_state_in_20, e keccakf1600_state_in_21, e keccakf1600_state_in_22, e keccakf1600_state_in_23, e keccakf1600_state_in_24, e keccakf1600_state_in_30, e keccakf1600_state_in_31, e keccakf1600_state_in_32, e keccakf1600_state_in_33, e keccakf1600_state_in_34, e keccakf1600_state_in_40, e keccakf1600_state_in_41, e keccakf1600_state_in_42, e keccakf1600_state_in_43, e keccakf1600_state_in_44, e memory_global_addr, e memory_rw, e memory_sel, e memory_tag, e memory_timestamp, e memory_value, e merkle_check_index, e merkle_check_path_len, e merkle_check_read_node, e merkle_check_read_root, e merkle_check_sel, e merkle_check_write, e merkle_check_write_node, e merkle_check_write_root, e poseidon2_hash_a_0, e poseidon2_hash_a_1, e poseidon2_hash_a_2, e poseidon2_hash_a_3, e poseidon2_hash_input_0, e poseidon2_hash_input_1, e poseidon2_hash_input_2, e poseidon2_hash_num_perm_rounds_rem, e poseidon2_hash_output, e poseidon2_hash_sel, e poseidon2_hash_start, e public_data_check_clk, e public_data_check_sel, e public_data_check_write_idx, e public_data_squash_clk, e public_data_squash_final_value, e public_data_squash_leaf_slot, e public_data_squash_sel, e public_data_squash_write_to_public_inputs, e scalar_mul_bit_idx, e scalar_mul_point_inf, e scalar_mul_point_x, e scalar_mul_point_y, e scalar_mul_res_inf, e scalar_mul_res_x, e scalar_mul_res_y, e scalar_mul_scalar, e scalar_mul_sel, e scalar_mul_start, e scalar_mul_temp_inf, e scalar_mul_temp_x, e scalar_mul_temp_y, e sha256_a, e sha256_b, e sha256_c, e sha256_d, e sha256_e, e sha256_execution_clk, e sha256_f, e sha256_g, e sha256_h, e sha256_helper_w0, e sha256_helper_w1, e sha256_helper_w10, e sha256_helper_w11, e sha256_helper_w12, e sha256_helper_w13, e sha256_helper_w14, e sha256_helper_w15, e sha256_helper_w2, e sha256_helper_w3, e sha256_helper_w4, e sha256_helper_w5, e sha256_helper_w6, e sha256_helper_w7, e sha256_helper_w8, e sha256_helper_w9, e sha256_init_a, e sha256_init_b, e sha256_init_c, e sha256_init_d, e sha256_init_e, e sha256_init_f, e sha256_init_g, e sha256_init_h, e sha256_input_addr, e sha256_input_rounds_rem, e sha256_output_addr, e sha256_rounds_remaining, e sha256_sel, e sha256_sel_invalid_input_tag_err, e sha256_sel_is_input_round, e sha256_space_id, e sha256_start, e to_radix_acc, e to_radix_acc_under_p, e to_radix_limb, e to_radix_limb_eq_p, e to_radix_limb_index, e to_radix_limb_lt_p, e to_radix_mem_dst_addr, e to_radix_mem_execution_clk, e to_radix_mem_is_output_bits, e to_radix_mem_num_limbs, e to_radix_mem_radix, e to_radix_mem_sel, e to_radix_mem_sel_should_decompose, e to_radix_mem_sel_should_write_mem, e to_radix_mem_space_id, e to_radix_mem_start, e to_radix_mem_value_to_decompose, e to_radix_not_padding_limb, e to_radix_power, e to_radix_radix, e to_radix_safe_limbs, e to_radix_sel, e to_radix_start, e to_radix_value, e tx_da_gas_limit, e tx_discard, e tx_fee, e tx_is_revertible, e tx_is_teardown, e tx_l1_l2_tree_root, e tx_l1_l2_tree_size, e tx_l2_gas_limit, e tx_next_context_id, e tx_phase_value, e tx_prev_da_gas_used, e tx_prev_l2_gas_used, e tx_prev_note_hash_tree_root, e tx_prev_note_hash_tree_size, e tx_prev_nullifier_tree_root, e tx_prev_nullifier_tree_size, e tx_prev_num_l2_to_l1_messages, e tx_prev_num_note_hashes_emitted, e tx_prev_num_nullifiers_emitted, e tx_prev_num_public_log_fields, e tx_prev_public_data_tree_root, e tx_prev_public_data_tree_size, e tx_prev_retrieved_bytecodes_tree_root, e tx_prev_retrieved_bytecodes_tree_size, e tx_prev_written_public_data_slots_tree_root, e tx_prev_written_public_data_slots_tree_size, e tx_read_pi_offset, e tx_remaining_phase_counter, e tx_reverted, e tx_sel, e tx_start_phase, e tx_start_tx, e tx_tx_reverted #define AVM2_ALL_ENTITIES_E(e) AVM2_PRECOMPUTED_ENTITIES_E(e), AVM2_WIRE_ENTITIES_E(e), AVM2_DERIVED_WITNESS_ENTITIES_E(e), AVM2_SHIFTED_ENTITIES_E(e) @@ -36,16 +36,16 @@ enum class ColumnAndShifts { SENTINEL_DO_NOT_USE, }; -constexpr auto NUM_COLUMNS_WITH_SHIFTS = 3570; -constexpr auto NUM_COLUMNS_WITHOUT_SHIFTS = 3209; +constexpr auto NUM_COLUMNS_WITH_SHIFTS = 3499; +constexpr auto NUM_COLUMNS_WITHOUT_SHIFTS = 3138; constexpr auto NUM_PRECOMPUTED_ENTITIES = 123; -constexpr auto NUM_WIRE_ENTITIES = 2618; -constexpr auto NUM_DERIVED_ENTITIES = 468; +constexpr auto NUM_WIRE_ENTITIES = 2562; +constexpr auto NUM_DERIVED_ENTITIES = 453; constexpr auto NUM_WITNESS_ENTITIES = NUM_WIRE_ENTITIES + NUM_DERIVED_ENTITIES; constexpr auto NUM_WIRES_TO_BE_SHIFTED = 361; constexpr auto NUM_SHIFTED_ENTITIES = 361; constexpr auto NUM_UNSHIFTED_ENTITIES = NUM_COLUMNS_WITHOUT_SHIFTS; -constexpr auto NUM_ALL_ENTITIES = 3570; +constexpr auto NUM_ALL_ENTITIES = 3499; /* * Layout for all entities is: diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_variables.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_variables.hpp index 5ec2e82f4b10..12fc2a0f9e36 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_variables.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_variables.hpp @@ -31,6 +31,7 @@ #include "relations/get_contract_instance.hpp" #include "relations/get_env_var.hpp" #include "relations/gt.hpp" +#include "relations/indexed_tree_check.hpp" #include "relations/instr_fetching.hpp" #include "relations/internal_call.hpp" #include "relations/internal_call_stack.hpp" @@ -42,7 +43,6 @@ #include "relations/merkle_check.hpp" #include "relations/note_hash_tree_check.hpp" #include "relations/notehash_exists.hpp" -#include "relations/nullifier_check.hpp" #include "relations/nullifier_exists.hpp" #include "relations/poseidon2_hash.hpp" #include "relations/poseidon2_mem.hpp" @@ -50,7 +50,6 @@ #include "relations/public_data_squash.hpp" #include "relations/range_check.hpp" #include "relations/registers.hpp" -#include "relations/retrieved_bytecodes_tree_check.hpp" #include "relations/scalar_mul.hpp" #include "relations/send_l2_to_l1_msg.hpp" #include "relations/sha256.hpp" @@ -63,7 +62,6 @@ #include "relations/tx_context.hpp" #include "relations/tx_discard.hpp" #include "relations/update_check.hpp" -#include "relations/written_public_data_slots_tree_check.hpp" // Optimized Relations #include "barretenberg/vm2/optimized/relations/poseidon2_perm.hpp" @@ -93,6 +91,7 @@ #include "relations/lookups_get_contract_instance.hpp" #include "relations/lookups_get_env_var.hpp" #include "relations/lookups_gt.hpp" +#include "relations/lookups_indexed_tree_check.hpp" #include "relations/lookups_instr_fetching.hpp" #include "relations/lookups_internal_call.hpp" #include "relations/lookups_keccakf1600.hpp" @@ -102,14 +101,12 @@ #include "relations/lookups_merkle_check.hpp" #include "relations/lookups_note_hash_tree_check.hpp" #include "relations/lookups_notehash_exists.hpp" -#include "relations/lookups_nullifier_check.hpp" #include "relations/lookups_nullifier_exists.hpp" #include "relations/lookups_poseidon2_hash.hpp" #include "relations/lookups_poseidon2_mem.hpp" #include "relations/lookups_public_data_check.hpp" #include "relations/lookups_public_data_squash.hpp" #include "relations/lookups_range_check.hpp" -#include "relations/lookups_retrieved_bytecodes_tree_check.hpp" #include "relations/lookups_scalar_mul.hpp" #include "relations/lookups_send_l2_to_l1_msg.hpp" #include "relations/lookups_sha256.hpp" @@ -121,7 +118,6 @@ #include "relations/lookups_tx.hpp" #include "relations/lookups_tx_context.hpp" #include "relations/lookups_update_check.hpp" -#include "relations/lookups_written_public_data_slots_tree_check.hpp" #include "relations/perms_addressing.hpp" #include "relations/perms_bc_hashing.hpp" #include "relations/perms_context.hpp" @@ -145,10 +141,10 @@ namespace bb::avm2 { struct AvmFlavorVariables { static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 123; - static constexpr size_t NUM_WITNESS_ENTITIES = 3086; + static constexpr size_t NUM_WITNESS_ENTITIES = 3015; static constexpr size_t NUM_SHIFTED_ENTITIES = 361; - static constexpr size_t NUM_WIRES = 2618; - static constexpr size_t NUM_ALL_ENTITIES = 3570; + static constexpr size_t NUM_WIRES = 2562; + static constexpr size_t NUM_ALL_ENTITIES = 3499; // Need to be templated for recursive verifier template @@ -183,6 +179,7 @@ struct AvmFlavorVariables { avm2::get_contract_instance, avm2::get_env_var, avm2::gt, + avm2::indexed_tree_check, avm2::instr_fetching, avm2::internal_call, avm2::internal_call_stack, @@ -194,7 +191,6 @@ struct AvmFlavorVariables { avm2::merkle_check, avm2::note_hash_tree_check, avm2::notehash_exists, - avm2::nullifier_check, avm2::nullifier_exists, avm2::poseidon2_hash, avm2::poseidon2_mem, @@ -202,7 +198,6 @@ struct AvmFlavorVariables { avm2::public_data_squash, avm2::range_check, avm2::registers, - avm2::retrieved_bytecodes_tree_check, avm2::scalar_mul, avm2::send_l2_to_l1_msg, avm2::sha256, @@ -214,8 +209,7 @@ struct AvmFlavorVariables { avm2::tx, avm2::tx_context, avm2::tx_discard, - avm2::update_check, - avm2::written_public_data_slots_tree_check>; + avm2::update_check>; // Need to be templated for recursive verifier template @@ -312,6 +306,15 @@ struct AvmFlavorVariables { lookup_get_env_var_read_from_public_inputs_col0_relation, lookup_get_env_var_read_from_public_inputs_col1_relation, lookup_gt_gt_range_relation, + lookup_indexed_tree_check_low_leaf_merkle_check_relation, + lookup_indexed_tree_check_low_leaf_next_value_validation_relation, + lookup_indexed_tree_check_low_leaf_poseidon2_relation, + lookup_indexed_tree_check_low_leaf_value_validation_relation, + lookup_indexed_tree_check_new_leaf_merkle_check_relation, + lookup_indexed_tree_check_new_leaf_poseidon2_relation, + lookup_indexed_tree_check_silo_poseidon2_relation, + lookup_indexed_tree_check_updated_low_leaf_poseidon2_relation, + lookup_indexed_tree_check_write_value_to_public_inputs_relation, lookup_instr_fetching_bytecode_size_from_bc_dec_relation, lookup_instr_fetching_bytes_from_bc_dec_relation, lookup_instr_fetching_instr_abs_diff_positive_relation, @@ -465,15 +468,6 @@ struct AvmFlavorVariables { lookup_note_hash_tree_check_write_note_hash_to_public_inputs_relation, lookup_notehash_exists_note_hash_leaf_index_in_range_relation, lookup_notehash_exists_note_hash_read_relation, - lookup_nullifier_check_low_leaf_merkle_check_relation, - lookup_nullifier_check_low_leaf_next_nullifier_validation_relation, - lookup_nullifier_check_low_leaf_nullifier_validation_relation, - lookup_nullifier_check_low_leaf_poseidon2_relation, - lookup_nullifier_check_new_leaf_merkle_check_relation, - lookup_nullifier_check_new_leaf_poseidon2_relation, - lookup_nullifier_check_silo_poseidon2_relation, - lookup_nullifier_check_updated_low_leaf_poseidon2_relation, - lookup_nullifier_check_write_nullifier_to_public_inputs_relation, lookup_nullifier_exists_nullifier_exists_check_relation, lookup_poseidon2_hash_poseidon2_perm_relation, lookup_poseidon2_mem_check_dst_addr_in_range_relation, @@ -507,13 +501,6 @@ struct AvmFlavorVariables { lookup_range_check_r5_is_u16_relation, lookup_range_check_r6_is_u16_relation, lookup_range_check_r7_is_u16_relation, - lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_relation, - lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_relation, - lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_relation, - lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_relation, - lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_relation, - lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_relation, - lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_relation, lookup_scalar_mul_add_relation, lookup_scalar_mul_double_relation, lookup_scalar_mul_to_radix_relation, @@ -617,14 +604,6 @@ struct AvmFlavorVariables { lookup_update_check_update_hash_public_data_read_relation, lookup_update_check_update_hi_metadata_range_relation, lookup_update_check_update_lo_metadata_range_relation, - lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_relation, - lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_relation, - lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_relation, - lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_relation, - lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_relation, - lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_relation, - lookup_written_public_data_slots_tree_check_silo_poseidon2_relation, - lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_relation, perm_addressing_base_address_from_memory_relation, perm_addressing_indirect_from_memory_0_relation, perm_addressing_indirect_from_memory_1_relation, diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval.hpp index 71071533196a..b9536d3aaffe 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval.hpp @@ -14,7 +14,9 @@ template class bc_retrievalImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 4, 3, 3, 5, 3, 5, 3, 4, 3, 3, 3, 3, 3 }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { + 3, 4, 3, 3, 5, 3, 3, 5, 3, 4, 3, 3, 3, 3, 3 + }; template inline static bool skip(const AllEntities& in) { @@ -37,10 +39,10 @@ template class bc_retrieval : public Relation // Subrelation indices constants, to be used in tests. static constexpr size_t SR_TRACE_CONTINUITY = 1; static constexpr size_t SR_NO_REMAINING_BYTECODES = 4; - static constexpr size_t SR_CURRENT_CLASS_ID_IS_ZERO_IF_INSTANCE_DOES_NOT_EXIST = 8; - static constexpr size_t SR_ARTIFACT_HASH_IS_ZERO_IF_ERROR = 9; - static constexpr size_t SR_PRIVATE_FUNCTION_ROOT_IS_ZERO_IF_ERROR = 10; - static constexpr size_t SR_BYTECODE_ID_IS_ZERO_IF_ERROR = 11; + static constexpr size_t SR_CURRENT_CLASS_ID_IS_ZERO_IF_INSTANCE_DOES_NOT_EXIST = 9; + static constexpr size_t SR_ARTIFACT_HASH_IS_ZERO_IF_ERROR = 10; + static constexpr size_t SR_PRIVATE_FUNCTION_ROOT_IS_ZERO_IF_ERROR = 11; + static constexpr size_t SR_BYTECODE_ID_IS_ZERO_IF_ERROR = 12; static std::string get_subrelation_label(size_t index) { diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval_impl.hpp index 6264f33e2ca7..a62b32ea42f1 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval_impl.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/bc_retrieval_impl.hpp @@ -16,6 +16,7 @@ void bc_retrievalImpl::accumulate(ContainerOverSubrelations& evals, using C = ColumnAndShifts; const auto constants_MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS = FF(21); + const auto constants_AVM_RETRIEVED_BYTECODES_TREE_HEIGHT = FF(5); const auto constants_AVM_RETRIEVED_BYTECODES_TREE_INITIAL_SIZE = FF(1); const auto bc_retrieval_REMAINING_BYTECODES = ((constants_MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS + constants_AVM_RETRIEVED_BYTECODES_TREE_INITIAL_SIZE) - @@ -61,63 +62,70 @@ void bc_retrievalImpl::accumulate(ContainerOverSubrelations& evals, } { using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; - auto tmp = (FF(1) - static_cast(in.get(C::bc_retrieval_instance_exists))) * - static_cast(in.get(C::bc_retrieval_is_new_class)); + auto tmp = static_cast(in.get(C::bc_retrieval_instance_exists)) * + (static_cast(in.get(C::bc_retrieval_retrieved_bytecodes_tree_height)) - + CView(constants_AVM_RETRIEVED_BYTECODES_TREE_HEIGHT)); std::get<5>(evals) += (tmp * scaling_factor); } { using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; + auto tmp = (FF(1) - static_cast(in.get(C::bc_retrieval_instance_exists))) * + static_cast(in.get(C::bc_retrieval_is_new_class)); + std::get<6>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_sel)) * (static_cast(in.get(C::bc_retrieval_instance_exists)) * (FF(1) - CView(bc_retrieval_TOO_MANY_BYTECODES)) - (FF(1) - static_cast(in.get(C::bc_retrieval_error)))); - std::get<6>(evals) += (tmp * scaling_factor); + std::get<7>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::bc_retrieval_should_retrieve)) - static_cast(in.get(C::bc_retrieval_sel)) * (FF(1) - static_cast(in.get(C::bc_retrieval_error)))); - std::get<7>(evals) += (tmp * scaling_factor); + std::get<8>(evals) += (tmp * scaling_factor); } { // CURRENT_CLASS_ID_IS_ZERO_IF_INSTANCE_DOES_NOT_EXIST - using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_sel)) * (FF(1) - static_cast(in.get(C::bc_retrieval_instance_exists))) * static_cast(in.get(C::bc_retrieval_current_class_id)); - std::get<8>(evals) += (tmp * scaling_factor); + std::get<9>(evals) += (tmp * scaling_factor); } { // ARTIFACT_HASH_IS_ZERO_IF_ERROR - using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_error)) * static_cast(in.get(C::bc_retrieval_artifact_hash)); - std::get<9>(evals) += (tmp * scaling_factor); + std::get<10>(evals) += (tmp * scaling_factor); } { // PRIVATE_FUNCTION_ROOT_IS_ZERO_IF_ERROR - using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_error)) * static_cast(in.get(C::bc_retrieval_private_functions_root)); - std::get<10>(evals) += (tmp * scaling_factor); + std::get<11>(evals) += (tmp * scaling_factor); } { // BYTECODE_ID_IS_ZERO_IF_ERROR - using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_error)) * static_cast(in.get(C::bc_retrieval_bytecode_id)); - std::get<11>(evals) += (tmp * scaling_factor); + std::get<12>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_error)) * (static_cast(in.get(C::bc_retrieval_next_retrieved_bytecodes_tree_root)) - static_cast(in.get(C::bc_retrieval_prev_retrieved_bytecodes_tree_root))); - std::get<12>(evals) += (tmp * scaling_factor); + std::get<13>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::bc_retrieval_error)) * (static_cast(in.get(C::bc_retrieval_next_retrieved_bytecodes_tree_size)) - static_cast(in.get(C::bc_retrieval_prev_retrieved_bytecodes_tree_size))); - std::get<13>(evals) += (tmp * scaling_factor); + std::get<14>(evals) += (tmp * scaling_factor); } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval.hpp index e7be3be816be..9693648a3c1e 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval.hpp @@ -14,9 +14,8 @@ template class contract_instance_retrievalImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { - 3, 3, 3, 2, 3, 3, 5, 3, 4, 4, 4, 4, 4, 4, 3 - }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 2, 3, 3, 5, 3, 3, + 3, 4, 4, 4, 4, 4, 4, 3 }; template inline static bool skip(const AllEntities& in) { @@ -37,12 +36,12 @@ template class contract_instance_retrieval : public Relation::accumulate(ContainerOverSubrelations& { using C = ColumnAndShifts; + const auto constants_NULLIFIER_TREE_HEIGHT = FF(42); const auto constants_MAX_PROTOCOL_CONTRACTS = FF(11); const auto constants_CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS = FF(2); const auto constants_AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX = FF(8); + const auto constants_DOM_SEP__SILOED_NULLIFIER = FF(57496191); const auto contract_instance_retrieval_NOT_EXISTS = (FF(1) - in.get(C::contract_instance_retrieval_exists)); { @@ -81,55 +83,69 @@ void contract_instance_retrievalImpl::accumulate(ContainerOverSubrelations& (FF(1) - static_cast(in.get(C::contract_instance_retrieval_is_protocol_contract)))); std::get<7>(evals) += (tmp * scaling_factor); } - { // UNCHANGED_ADDRESS_NON_PROTOCOL + { using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::contract_instance_retrieval_should_check_nullifier)) * + (static_cast(in.get(C::contract_instance_retrieval_nullifier_tree_height)) - + CView(constants_NULLIFIER_TREE_HEIGHT)); + std::get<8>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::contract_instance_retrieval_should_check_nullifier)) * + (static_cast(in.get(C::contract_instance_retrieval_siloing_separator)) - + CView(constants_DOM_SEP__SILOED_NULLIFIER)); + std::get<9>(evals) += (tmp * scaling_factor); + } + { // UNCHANGED_ADDRESS_NON_PROTOCOL + using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::contract_instance_retrieval_sel)) * (FF(1) - static_cast(in.get(C::contract_instance_retrieval_is_protocol_contract))) * (static_cast(in.get(C::contract_instance_retrieval_derived_address)) - static_cast(in.get(C::contract_instance_retrieval_address))); - std::get<8>(evals) += (tmp * scaling_factor); + std::get<10>(evals) += (tmp * scaling_factor); } { // INSTANCE_MEMBER_SALT_IS_ZERO_IF_DNE - using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::contract_instance_retrieval_sel)) * (FF(1) - static_cast(in.get(C::contract_instance_retrieval_exists))) * static_cast(in.get(C::contract_instance_retrieval_salt)); - std::get<9>(evals) += (tmp * scaling_factor); + std::get<11>(evals) += (tmp * scaling_factor); } { // INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE - using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::contract_instance_retrieval_sel)) * (FF(1) - static_cast(in.get(C::contract_instance_retrieval_exists))) * static_cast(in.get(C::contract_instance_retrieval_deployer_addr)); - std::get<10>(evals) += (tmp * scaling_factor); + std::get<12>(evals) += (tmp * scaling_factor); } { // INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE - using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::contract_instance_retrieval_sel)) * (FF(1) - static_cast(in.get(C::contract_instance_retrieval_exists))) * static_cast(in.get(C::contract_instance_retrieval_current_class_id)); - std::get<11>(evals) += (tmp * scaling_factor); + std::get<13>(evals) += (tmp * scaling_factor); } { // INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE - using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::contract_instance_retrieval_sel)) * (FF(1) - static_cast(in.get(C::contract_instance_retrieval_exists))) * static_cast(in.get(C::contract_instance_retrieval_original_class_id)); - std::get<12>(evals) += (tmp * scaling_factor); + std::get<14>(evals) += (tmp * scaling_factor); } { // INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE - using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::contract_instance_retrieval_sel)) * (FF(1) - static_cast(in.get(C::contract_instance_retrieval_exists))) * static_cast(in.get(C::contract_instance_retrieval_init_hash)); - std::get<13>(evals) += (tmp * scaling_factor); + std::get<15>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::contract_instance_retrieval_should_check_for_update)) - static_cast(in.get(C::contract_instance_retrieval_should_check_nullifier)) * static_cast(in.get(C::contract_instance_retrieval_exists))); - std::get<14>(evals) += (tmp * scaling_factor); + std::get<16>(evals) += (tmp * scaling_factor); } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier.hpp index 404f8fc8d868..bd160163b701 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier.hpp @@ -14,7 +14,7 @@ template class emit_nullifierImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 5, 4, 4, 4, 4, 4 }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 5, 4, 4, 3, 3, 3, 4, 4, 4 }; template inline static bool skip(const AllEntities& in) { @@ -38,9 +38,9 @@ template class emit_nullifier : public Relation::accumulate(ContainerOverSubrelations& evals, { using C = ColumnAndShifts; + const auto constants_NULLIFIER_TREE_HEIGHT = FF(42); const auto constants_MAX_NULLIFIERS_PER_TX = FF(64); + const auto constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX = FF(450); + const auto constants_DOM_SEP__SILOED_NULLIFIER = FF(57496191); const auto execution_REMAINING_NULLIFIER_WRITES = (constants_MAX_NULLIFIERS_PER_TX - in.get(C::execution_prev_num_nullifiers_emitted)); const auto execution_SUCCESSFUL_WRITE = @@ -53,29 +56,51 @@ void emit_nullifierImpl::accumulate(ContainerOverSubrelations& evals, (FF(1) - static_cast(in.get(C::execution_sel_opcode_error))); std::get<3>(evals) += (tmp * scaling_factor); } - { // EMIT_NULLIFIER_TREE_ROOT_NOT_CHANGED + { using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::execution_sel_write_nullifier)) * + ((CView(constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX) + + static_cast(in.get(C::execution_prev_num_nullifiers_emitted))) - + static_cast(in.get(C::execution_nullifier_pi_offset))); + std::get<4>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; + auto tmp = + static_cast(in.get(C::execution_sel_write_nullifier)) * + (static_cast(in.get(C::execution_nullifier_tree_height)) - CView(constants_NULLIFIER_TREE_HEIGHT)); + std::get<5>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::execution_sel_write_nullifier)) * + (static_cast(in.get(C::execution_nullifier_siloing_separator)) - + CView(constants_DOM_SEP__SILOED_NULLIFIER)); + std::get<6>(evals) += (tmp * scaling_factor); + } + { // EMIT_NULLIFIER_TREE_ROOT_NOT_CHANGED + using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_emit_nullifier)) * static_cast(in.get(C::execution_sel_opcode_error)) * (static_cast(in.get(C::execution_prev_nullifier_tree_root)) - static_cast(in.get(C::execution_nullifier_tree_root))); - std::get<4>(evals) += (tmp * scaling_factor); + std::get<7>(evals) += (tmp * scaling_factor); } { // EMIT_NULLIFIER_TREE_SIZE_INCREASE - using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_emit_nullifier)) * ((static_cast(in.get(C::execution_prev_nullifier_tree_size)) + CView(execution_SUCCESSFUL_WRITE)) - static_cast(in.get(C::execution_nullifier_tree_size))); - std::get<5>(evals) += (tmp * scaling_factor); + std::get<8>(evals) += (tmp * scaling_factor); } { // EMIT_NULLIFIER_NUM_NULLIFIERS_EMITTED_INCREASE - using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_emit_nullifier)) * ((static_cast(in.get(C::execution_prev_num_nullifiers_emitted)) + CView(execution_SUCCESSFUL_WRITE)) - static_cast(in.get(C::execution_num_nullifiers_emitted))); - std::get<6>(evals) += (tmp * scaling_factor); + std::get<9>(evals) += (tmp * scaling_factor); } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp index 8ad93293ddbd..83039a5e64e0 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp @@ -14,9 +14,9 @@ template class executionImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { - 3, 3, 3, 2, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { + 3, 3, 3, 2, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2 }; @@ -49,33 +49,33 @@ template class execution : public Relation> { static constexpr size_t SR_DYN_GAS_ID_DECOMPOSITION = 19; static constexpr size_t SR_NUM_P_LIMBS_CEIL = 22; static constexpr size_t SR_DYN_L2_FACTOR_TO_RADIX_BE = 23; - static constexpr size_t SR_DYN_DA_GAS_IS_ZERO = 26; - static constexpr size_t SR_DYN_L2_GAS_IS_ZERO = 27; - static constexpr size_t SR_SUBTRACE_ID_DECOMPOSITION = 43; - static constexpr size_t SR_EXEC_OP_ID_DECOMPOSITION = 65; - static constexpr size_t SR_PC_NEXT_ROW_INT_CALL_JUMP = 66; - static constexpr size_t SR_PC_NEXT_ROW_JUMPI = 67; - static constexpr size_t SR_MOV_SAME_VALUE = 68; - static constexpr size_t SR_MOV_SAME_TAG = 69; - static constexpr size_t SR_SUCCESS_COPY_WRITE_REG = 70; - static constexpr size_t SR_SUCCESS_COPY_U1_TAG = 71; - static constexpr size_t SR_RETURNDATA_SIZE_WRITE_REG = 72; - static constexpr size_t SR_RETURNDATA_SIZE_U32_TAG = 73; - static constexpr size_t SR_PUBLIC_DATA_TREE_ROOT_NOT_CHANGED = 74; - static constexpr size_t SR_PUBLIC_DATA_TREE_SIZE_NOT_CHANGED = 75; - static constexpr size_t SR_WRITTEN_PUBLIC_DATA_SLOTS_TREE_ROOT_NOT_CHANGED = 76; - static constexpr size_t SR_WRITTEN_PUBLIC_DATA_SLOTS_TREE_SIZE_NOT_CHANGED = 77; - static constexpr size_t SR_NOTE_HASH_TREE_ROOT_NOT_CHANGED = 78; - static constexpr size_t SR_NOTE_HASH_TREE_SIZE_NOT_CHANGED = 79; - static constexpr size_t SR_NUM_NOTE_HASHES_EMITTED_NOT_CHANGED = 80; - static constexpr size_t SR_NULLIFIER_TREE_ROOT_NOT_CHANGED = 81; - static constexpr size_t SR_NULLIFIER_TREE_SIZE_NOT_CHANGED = 82; - static constexpr size_t SR_NUM_NULLIFIERS_EMITTED_NOT_CHANGED = 83; - static constexpr size_t SR_NUM_PUBLIC_LOGS_NOT_CHANGED = 84; - static constexpr size_t SR_NUM_L2_TO_L1_MESSAGES_NOT_CHANGED = 85; - static constexpr size_t SR_RETRIEVED_BYTECODES_TREE_ROOT_NOT_CHANGED = 86; - static constexpr size_t SR_RETRIEVED_BYTECODES_TREE_SIZE_NOT_CHANGED = 87; - static constexpr size_t SR_INFALLIBLE_OPCODES_SUCCESS = 89; + static constexpr size_t SR_DYN_DA_GAS_IS_ZERO = 28; + static constexpr size_t SR_DYN_L2_GAS_IS_ZERO = 29; + static constexpr size_t SR_SUBTRACE_ID_DECOMPOSITION = 45; + static constexpr size_t SR_EXEC_OP_ID_DECOMPOSITION = 67; + static constexpr size_t SR_PC_NEXT_ROW_INT_CALL_JUMP = 68; + static constexpr size_t SR_PC_NEXT_ROW_JUMPI = 69; + static constexpr size_t SR_MOV_SAME_VALUE = 70; + static constexpr size_t SR_MOV_SAME_TAG = 71; + static constexpr size_t SR_SUCCESS_COPY_WRITE_REG = 72; + static constexpr size_t SR_SUCCESS_COPY_U1_TAG = 73; + static constexpr size_t SR_RETURNDATA_SIZE_WRITE_REG = 74; + static constexpr size_t SR_RETURNDATA_SIZE_U32_TAG = 75; + static constexpr size_t SR_PUBLIC_DATA_TREE_ROOT_NOT_CHANGED = 76; + static constexpr size_t SR_PUBLIC_DATA_TREE_SIZE_NOT_CHANGED = 77; + static constexpr size_t SR_WRITTEN_PUBLIC_DATA_SLOTS_TREE_ROOT_NOT_CHANGED = 78; + static constexpr size_t SR_WRITTEN_PUBLIC_DATA_SLOTS_TREE_SIZE_NOT_CHANGED = 79; + static constexpr size_t SR_NOTE_HASH_TREE_ROOT_NOT_CHANGED = 80; + static constexpr size_t SR_NOTE_HASH_TREE_SIZE_NOT_CHANGED = 81; + static constexpr size_t SR_NUM_NOTE_HASHES_EMITTED_NOT_CHANGED = 82; + static constexpr size_t SR_NULLIFIER_TREE_ROOT_NOT_CHANGED = 83; + static constexpr size_t SR_NULLIFIER_TREE_SIZE_NOT_CHANGED = 84; + static constexpr size_t SR_NUM_NULLIFIERS_EMITTED_NOT_CHANGED = 85; + static constexpr size_t SR_NUM_PUBLIC_LOGS_NOT_CHANGED = 86; + static constexpr size_t SR_NUM_L2_TO_L1_MESSAGES_NOT_CHANGED = 87; + static constexpr size_t SR_RETRIEVED_BYTECODES_TREE_ROOT_NOT_CHANGED = 88; + static constexpr size_t SR_RETRIEVED_BYTECODES_TREE_SIZE_NOT_CHANGED = 89; + static constexpr size_t SR_INFALLIBLE_OPCODES_SUCCESS = 91; static std::string get_subrelation_label(size_t index) { diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution_impl.hpp index 8c1160abc506..8ac0a5a9978c 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution_impl.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution_impl.hpp @@ -58,6 +58,8 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, const auto constants_AVM_EXEC_OP_ID_NULLIFIER_EXISTS = FF(262144); const auto constants_AVM_EXEC_OP_ID_EMIT_NULLIFIER = FF(524288); const auto constants_AVM_EXEC_OP_ID_SENDL2TOL1MSG = FF(1048576); + const auto constants_AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT = FF(6); + const auto constants_DOM_SEP__PUBLIC_LEAF_SLOT = FF(1247650290); const auto execution_SEL_SHOULD_RESOLVE_ADDRESS = in.get(C::execution_sel_instruction_fetching_success); { @@ -230,130 +232,144 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, } { using View = typename std::tuple_element_t<24, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::execution_sel_gas_sstore)) * + (static_cast(in.get(C::execution_written_slots_tree_height)) - + CView(constants_AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT)); + std::get<24>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<25, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::execution_sel_gas_sstore)) * + (static_cast(in.get(C::execution_written_slots_tree_siloing_separator)) - + CView(constants_DOM_SEP__PUBLIC_LEAF_SLOT)); + std::get<25>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::execution_sel_gas_emit_public_log)) + static_cast(in.get(C::execution_sel_gas_calldata_copy)) + static_cast(in.get(C::execution_sel_gas_returndata_copy))) * (static_cast(in.get(C::execution_register_0_)) - static_cast(in.get(C::execution_dynamic_l2_gas_factor))); - std::get<24>(evals) += (tmp * scaling_factor); + std::get<26>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<25, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<27, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_gas_emit_public_log)) * (static_cast(in.get(C::execution_register_0_)) - static_cast(in.get(C::execution_dynamic_da_gas_factor))); - std::get<25>(evals) += (tmp * scaling_factor); + std::get<27>(evals) += (tmp * scaling_factor); } { // DYN_DA_GAS_IS_ZERO - using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<28, ContainerOverSubrelations>::View; auto tmp = ((FF(1) - static_cast(in.get(C::execution_sel_gas_sstore))) - static_cast(in.get(C::execution_sel_gas_emit_public_log))) * static_cast(in.get(C::execution_dynamic_da_gas_factor)); - std::get<26>(evals) += (tmp * scaling_factor); + std::get<28>(evals) += (tmp * scaling_factor); } { // DYN_L2_GAS_IS_ZERO - using View = typename std::tuple_element_t<27, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<29, ContainerOverSubrelations>::View; auto tmp = (((((FF(1) - static_cast(in.get(C::execution_sel_gas_bitwise))) - static_cast(in.get(C::execution_sel_gas_to_radix))) - static_cast(in.get(C::execution_sel_gas_emit_public_log))) - static_cast(in.get(C::execution_sel_gas_calldata_copy))) - static_cast(in.get(C::execution_sel_gas_returndata_copy))) * static_cast(in.get(C::execution_dynamic_l2_gas_factor)); - std::get<27>(evals) += (tmp * scaling_factor); + std::get<29>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<28, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<30, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::execution_sel_should_execute_opcode)) - static_cast(in.get(C::execution_sel_should_check_gas)) * (FF(1) - static_cast(in.get(C::execution_sel_out_of_gas)))); - std::get<28>(evals) += (tmp * scaling_factor); + std::get<30>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<29, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<31, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_execution)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_execution))); - std::get<29>(evals) += (tmp * scaling_factor); + std::get<31>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<30, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<32, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_alu)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_alu))); - std::get<30>(evals) += (tmp * scaling_factor); + std::get<32>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<31, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<33, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_bitwise)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_bitwise))); - std::get<31>(evals) += (tmp * scaling_factor); + std::get<33>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<32, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<34, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_cast)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_cast))); - std::get<32>(evals) += (tmp * scaling_factor); + std::get<34>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<33, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_calldata_copy)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_calldata_copy))); - std::get<33>(evals) += (tmp * scaling_factor); + std::get<35>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<34, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<36, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_returndata_copy)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_returndata_copy))); - std::get<34>(evals) += (tmp * scaling_factor); + std::get<36>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<37, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_set)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_set))); - std::get<35>(evals) += (tmp * scaling_factor); + std::get<37>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<36, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<38, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_get_contract_instance)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_get_contract_instance))); - std::get<36>(evals) += (tmp * scaling_factor); + std::get<38>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<37, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<39, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_emit_public_log)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_emit_public_log))); - std::get<37>(evals) += (tmp * scaling_factor); + std::get<39>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<38, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_poseidon2_perm)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_poseidon2_perm))); - std::get<38>(evals) += (tmp * scaling_factor); + std::get<40>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<39, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_sha256_compression)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_sha256_compression))); - std::get<39>(evals) += (tmp * scaling_factor); + std::get<41>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_keccakf1600)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_keccakf1600))); - std::get<40>(evals) += (tmp * scaling_factor); + std::get<42>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_ecc_add)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_ecc_add))); - std::get<41>(evals) += (tmp * scaling_factor); + std::get<43>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_exec_dispatch_to_radix)) * (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_to_radix))); - std::get<42>(evals) += (tmp * scaling_factor); + std::get<44>(evals) += (tmp * scaling_factor); } { // SUBTRACE_ID_DECOMPOSITION - using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View; auto tmp = ((static_cast(in.get(C::execution_sel_exec_dispatch_execution)) * CView(constants_AVM_SUBTRACE_ID_EXECUTION) + @@ -381,136 +397,136 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, CView(constants_AVM_SUBTRACE_ID_TO_RADIX)) - static_cast(in.get(C::execution_sel_should_execute_opcode)) * static_cast(in.get(C::execution_subtrace_id))); - std::get<43>(evals) += (tmp * scaling_factor); + std::get<45>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<46, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_get_env_var)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_get_env_var))); - std::get<44>(evals) += (tmp * scaling_factor); + std::get<46>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<47, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_mov)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_mov))); - std::get<45>(evals) += (tmp * scaling_factor); + std::get<47>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<46, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<48, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_jump)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_jump))); - std::get<46>(evals) += (tmp * scaling_factor); + std::get<48>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<47, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<49, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_jumpi)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_jumpi))); - std::get<47>(evals) += (tmp * scaling_factor); + std::get<49>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<48, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<50, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_call)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_call))); - std::get<48>(evals) += (tmp * scaling_factor); + std::get<50>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<49, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<51, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_static_call)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_static_call))); - std::get<49>(evals) += (tmp * scaling_factor); + std::get<51>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<50, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<52, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_internal_call)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_internal_call))); - std::get<50>(evals) += (tmp * scaling_factor); + std::get<52>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<51, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<53, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_internal_return)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_internal_return))); - std::get<51>(evals) += (tmp * scaling_factor); + std::get<53>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<52, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<54, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_return)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_return))); - std::get<52>(evals) += (tmp * scaling_factor); + std::get<54>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<53, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<55, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_revert)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_revert))); - std::get<53>(evals) += (tmp * scaling_factor); + std::get<55>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<54, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<56, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_success_copy)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_success_copy))); - std::get<54>(evals) += (tmp * scaling_factor); + std::get<56>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<55, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<57, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_returndata_size)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_returndata_size))); - std::get<55>(evals) += (tmp * scaling_factor); + std::get<57>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<56, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<58, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_debug_log)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_debug_log))); - std::get<56>(evals) += (tmp * scaling_factor); + std::get<58>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<57, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<59, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_sload)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_sload))); - std::get<57>(evals) += (tmp * scaling_factor); + std::get<59>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<58, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<60, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_sstore)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_sstore))); - std::get<58>(evals) += (tmp * scaling_factor); + std::get<60>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<59, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<61, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_notehash_exists)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_notehash_exists))); - std::get<59>(evals) += (tmp * scaling_factor); + std::get<61>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<60, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<62, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_emit_notehash)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_notehash))); - std::get<60>(evals) += (tmp * scaling_factor); + std::get<62>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<61, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<63, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_l1_to_l2_message_exists)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_l1_to_l2_message_exists))); - std::get<61>(evals) += (tmp * scaling_factor); + std::get<63>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<62, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<64, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_nullifier_exists)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_nullifier_exists))); - std::get<62>(evals) += (tmp * scaling_factor); + std::get<64>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<63, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<65, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_emit_nullifier)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_nullifier))); - std::get<63>(evals) += (tmp * scaling_factor); + std::get<65>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<64, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<66, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_send_l2_to_l1_msg)) * (FF(1) - static_cast(in.get(C::execution_sel_execute_send_l2_to_l1_msg))); - std::get<64>(evals) += (tmp * scaling_factor); + std::get<66>(evals) += (tmp * scaling_factor); } { // EXEC_OP_ID_DECOMPOSITION - using View = typename std::tuple_element_t<65, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<67, ContainerOverSubrelations>::View; auto tmp = ((static_cast(in.get(C::execution_sel_execute_get_env_var)) * CView(constants_AVM_EXEC_OP_ID_GETENVVAR) + @@ -547,18 +563,18 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, CView(constants_AVM_EXEC_OP_ID_SENDL2TOL1MSG)) - static_cast(in.get(C::execution_sel_exec_dispatch_execution)) * static_cast(in.get(C::execution_subtrace_operation_id))); - std::get<65>(evals) += (tmp * scaling_factor); + std::get<67>(evals) += (tmp * scaling_factor); } { // PC_NEXT_ROW_INT_CALL_JUMP - using View = typename std::tuple_element_t<66, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<68, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_shift)) * (static_cast(in.get(C::execution_sel_execute_internal_call)) + static_cast(in.get(C::execution_sel_execute_jump))) * (static_cast(in.get(C::execution_pc_shift)) - static_cast(in.get(C::execution_rop_0_))); - std::get<66>(evals) += (tmp * scaling_factor); + std::get<68>(evals) += (tmp * scaling_factor); } { // PC_NEXT_ROW_JUMPI - using View = typename std::tuple_element_t<67, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<69, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_shift)) * static_cast(in.get(C::execution_sel_execute_jumpi)) * @@ -566,154 +582,154 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, (static_cast(in.get(C::execution_rop_1_)) - static_cast(in.get(C::execution_next_pc))) + static_cast(in.get(C::execution_next_pc))) - static_cast(in.get(C::execution_pc_shift))); - std::get<67>(evals) += (tmp * scaling_factor); + std::get<69>(evals) += (tmp * scaling_factor); } { // MOV_SAME_VALUE - using View = typename std::tuple_element_t<68, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<70, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_mov)) * (static_cast(in.get(C::execution_register_0_)) - static_cast(in.get(C::execution_register_1_))); - std::get<68>(evals) += (tmp * scaling_factor); + std::get<70>(evals) += (tmp * scaling_factor); } { // MOV_SAME_TAG - using View = typename std::tuple_element_t<69, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<71, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_mov)) * (static_cast(in.get(C::execution_mem_tag_reg_0_)) - static_cast(in.get(C::execution_mem_tag_reg_1_))); - std::get<69>(evals) += (tmp * scaling_factor); + std::get<71>(evals) += (tmp * scaling_factor); } { // SUCCESS_COPY_WRITE_REG - using View = typename std::tuple_element_t<70, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<72, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_success_copy)) * (static_cast(in.get(C::execution_register_0_)) - static_cast(in.get(C::execution_last_child_success))); - std::get<70>(evals) += (tmp * scaling_factor); + std::get<72>(evals) += (tmp * scaling_factor); } { // SUCCESS_COPY_U1_TAG - using View = typename std::tuple_element_t<71, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<73, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_success_copy)) * (static_cast(in.get(C::execution_mem_tag_reg_0_)) - CView(constants_MEM_TAG_U1)); - std::get<71>(evals) += (tmp * scaling_factor); + std::get<73>(evals) += (tmp * scaling_factor); } { // RETURNDATA_SIZE_WRITE_REG - using View = typename std::tuple_element_t<72, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<74, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_returndata_size)) * (static_cast(in.get(C::execution_register_0_)) - static_cast(in.get(C::execution_last_child_returndata_size))); - std::get<72>(evals) += (tmp * scaling_factor); + std::get<74>(evals) += (tmp * scaling_factor); } { // RETURNDATA_SIZE_U32_TAG - using View = typename std::tuple_element_t<73, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<75, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_returndata_size)) * (static_cast(in.get(C::execution_mem_tag_reg_0_)) - CView(constants_MEM_TAG_U32)); - std::get<73>(evals) += (tmp * scaling_factor); + std::get<75>(evals) += (tmp * scaling_factor); } { // PUBLIC_DATA_TREE_ROOT_NOT_CHANGED - using View = typename std::tuple_element_t<74, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<76, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_sstore))) * (static_cast(in.get(C::execution_prev_public_data_tree_root)) - static_cast(in.get(C::execution_public_data_tree_root))); - std::get<74>(evals) += (tmp * scaling_factor); + std::get<76>(evals) += (tmp * scaling_factor); } { // PUBLIC_DATA_TREE_SIZE_NOT_CHANGED - using View = typename std::tuple_element_t<75, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<77, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_sstore))) * (static_cast(in.get(C::execution_prev_public_data_tree_size)) - static_cast(in.get(C::execution_public_data_tree_size))); - std::get<75>(evals) += (tmp * scaling_factor); + std::get<77>(evals) += (tmp * scaling_factor); } { // WRITTEN_PUBLIC_DATA_SLOTS_TREE_ROOT_NOT_CHANGED - using View = typename std::tuple_element_t<76, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<78, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_sstore))) * (static_cast(in.get(C::execution_prev_written_public_data_slots_tree_root)) - static_cast(in.get(C::execution_written_public_data_slots_tree_root))); - std::get<76>(evals) += (tmp * scaling_factor); + std::get<78>(evals) += (tmp * scaling_factor); } { // WRITTEN_PUBLIC_DATA_SLOTS_TREE_SIZE_NOT_CHANGED - using View = typename std::tuple_element_t<77, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<79, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_sstore))) * (static_cast(in.get(C::execution_prev_written_public_data_slots_tree_size)) - static_cast(in.get(C::execution_written_public_data_slots_tree_size))); - std::get<77>(evals) += (tmp * scaling_factor); + std::get<79>(evals) += (tmp * scaling_factor); } { // NOTE_HASH_TREE_ROOT_NOT_CHANGED - using View = typename std::tuple_element_t<78, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<80, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_notehash))) * (static_cast(in.get(C::execution_prev_note_hash_tree_root)) - static_cast(in.get(C::execution_note_hash_tree_root))); - std::get<78>(evals) += (tmp * scaling_factor); + std::get<80>(evals) += (tmp * scaling_factor); } { // NOTE_HASH_TREE_SIZE_NOT_CHANGED - using View = typename std::tuple_element_t<79, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<81, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_notehash))) * (static_cast(in.get(C::execution_prev_note_hash_tree_size)) - static_cast(in.get(C::execution_note_hash_tree_size))); - std::get<79>(evals) += (tmp * scaling_factor); + std::get<81>(evals) += (tmp * scaling_factor); } { // NUM_NOTE_HASHES_EMITTED_NOT_CHANGED - using View = typename std::tuple_element_t<80, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<82, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_notehash))) * (static_cast(in.get(C::execution_prev_num_note_hashes_emitted)) - static_cast(in.get(C::execution_num_note_hashes_emitted))); - std::get<80>(evals) += (tmp * scaling_factor); + std::get<82>(evals) += (tmp * scaling_factor); } { // NULLIFIER_TREE_ROOT_NOT_CHANGED - using View = typename std::tuple_element_t<81, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<83, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_nullifier))) * (static_cast(in.get(C::execution_prev_nullifier_tree_root)) - static_cast(in.get(C::execution_nullifier_tree_root))); - std::get<81>(evals) += (tmp * scaling_factor); + std::get<83>(evals) += (tmp * scaling_factor); } { // NULLIFIER_TREE_SIZE_NOT_CHANGED - using View = typename std::tuple_element_t<82, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<84, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_nullifier))) * (static_cast(in.get(C::execution_prev_nullifier_tree_size)) - static_cast(in.get(C::execution_nullifier_tree_size))); - std::get<82>(evals) += (tmp * scaling_factor); + std::get<84>(evals) += (tmp * scaling_factor); } { // NUM_NULLIFIERS_EMITTED_NOT_CHANGED - using View = typename std::tuple_element_t<83, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<85, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_emit_nullifier))) * (static_cast(in.get(C::execution_prev_num_nullifiers_emitted)) - static_cast(in.get(C::execution_num_nullifiers_emitted))); - std::get<83>(evals) += (tmp * scaling_factor); + std::get<85>(evals) += (tmp * scaling_factor); } { // NUM_PUBLIC_LOGS_NOT_CHANGED - using View = typename std::tuple_element_t<84, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<86, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_exec_dispatch_emit_public_log))) * (static_cast(in.get(C::execution_prev_num_public_log_fields)) - static_cast(in.get(C::execution_num_public_log_fields))); - std::get<84>(evals) += (tmp * scaling_factor); + std::get<86>(evals) += (tmp * scaling_factor); } { // NUM_L2_TO_L1_MESSAGES_NOT_CHANGED - using View = typename std::tuple_element_t<85, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<87, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_execute_send_l2_to_l1_msg))) * (static_cast(in.get(C::execution_prev_num_l2_to_l1_messages)) - static_cast(in.get(C::execution_num_l2_to_l1_messages))); - std::get<85>(evals) += (tmp * scaling_factor); + std::get<87>(evals) += (tmp * scaling_factor); } { // RETRIEVED_BYTECODES_TREE_ROOT_NOT_CHANGED - using View = typename std::tuple_element_t<86, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<88, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_first_row_in_context))) * (static_cast(in.get(C::execution_prev_retrieved_bytecodes_tree_root)) - static_cast(in.get(C::execution_retrieved_bytecodes_tree_root))); - std::get<86>(evals) += (tmp * scaling_factor); + std::get<88>(evals) += (tmp * scaling_factor); } { // RETRIEVED_BYTECODES_TREE_SIZE_NOT_CHANGED - using View = typename std::tuple_element_t<87, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<89, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_first_row_in_context))) * (static_cast(in.get(C::execution_prev_retrieved_bytecodes_tree_size)) - static_cast(in.get(C::execution_retrieved_bytecodes_tree_size))); - std::get<87>(evals) += (tmp * scaling_factor); + std::get<89>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<88, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<90, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_opcode_error)) * (FF(1) - static_cast(in.get(C::execution_sel_opcode_error))); - std::get<88>(evals) += (tmp * scaling_factor); + std::get<90>(evals) += (tmp * scaling_factor); } { // INFALLIBLE_OPCODES_SUCCESS - using View = typename std::tuple_element_t<89, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<91, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::execution_sel_execute_mov)) + static_cast(in.get(C::execution_sel_execute_returndata_size)) + static_cast(in.get(C::execution_sel_execute_jump)) + @@ -730,23 +746,23 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, static_cast(in.get(C::execution_sel_execute_l1_to_l2_message_exists)) + static_cast(in.get(C::execution_sel_execute_nullifier_exists))) * static_cast(in.get(C::execution_sel_opcode_error)); - std::get<89>(evals) += (tmp * scaling_factor); + std::get<91>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<90, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<92, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::execution_sel_should_execute_opcode))) * static_cast(in.get(C::execution_sel_opcode_error)); - std::get<90>(evals) += (tmp * scaling_factor); + std::get<92>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<91, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<93, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::execution_sel_should_write_registers)) - static_cast(in.get(C::execution_sel_should_execute_opcode)) * (FF(1) - static_cast(in.get(C::execution_sel_opcode_error)))); - std::get<91>(evals) += (tmp * scaling_factor); + std::get<93>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<92, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<94, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::execution_sel_error)) - (static_cast(in.get(C::execution_sel_bytecode_retrieval_failure)) + static_cast(in.get(C::execution_sel_instruction_fetching_failure)) + @@ -754,7 +770,7 @@ void executionImpl::accumulate(ContainerOverSubrelations& evals, static_cast(in.get(C::execution_sel_register_read_error)) + static_cast(in.get(C::execution_sel_out_of_gas)) + static_cast(in.get(C::execution_sel_opcode_error)))); - std::get<92>(evals) += (tmp * scaling_factor); + std::get<94>(evals) += (tmp * scaling_factor); } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/indexed_tree_check.cpp similarity index 54% rename from barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.cpp rename to barretenberg/cpp/src/barretenberg/vm2/generated/relations/indexed_tree_check.cpp index a6ff5b76e812..5141076c2836 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/indexed_tree_check.cpp @@ -3,33 +3,27 @@ #include "barretenberg/vm2/constraining/flavor.hpp" #include "barretenberg/vm2/constraining/full_row.hpp" #include "barretenberg/vm2/constraining/recursion/recursive_flavor.hpp" -#include "barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check_impl.hpp" +#include "barretenberg/vm2/generated/relations/indexed_tree_check_impl.hpp" #define AvmCheckCircuitEdge(Flavor) Flavor::PolynomialEntitiesAtFixedRow #define AvmCheckRelationEdge(Flavor) ::bb::avm2::AvmFullRowProxy namespace bb::avm2 { -template class retrieved_bytecodes_tree_checkImpl; -ACCUMULATE(retrieved_bytecodes_tree_checkImpl, - AvmFlavor, - SumcheckTupleOfUnivariatesOverSubrelations, - ExtendedEdge); // Prover. -ACCUMULATE(retrieved_bytecodes_tree_checkImpl, - AvmFlavor, - SumcheckArrayOfValuesOverSubrelations, - EvaluationEdge); // Verifier. -ACCUMULATE(retrieved_bytecodes_tree_checkImpl, +template class indexed_tree_checkImpl; +ACCUMULATE(indexed_tree_checkImpl, AvmFlavor, SumcheckTupleOfUnivariatesOverSubrelations, ExtendedEdge); // Prover. +ACCUMULATE(indexed_tree_checkImpl, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); // Verifier. +ACCUMULATE(indexed_tree_checkImpl, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, AvmCheckCircuitEdge); // Check circuit. -ACCUMULATE(retrieved_bytecodes_tree_checkImpl, +ACCUMULATE(indexed_tree_checkImpl, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, AvmCheckRelationEdge); // Check relation (tests). -template class retrieved_bytecodes_tree_checkImpl; -ACCUMULATE(retrieved_bytecodes_tree_checkImpl, +template class indexed_tree_checkImpl; +ACCUMULATE(indexed_tree_checkImpl, AvmRecursiveFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); // Verifier. diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/indexed_tree_check.hpp similarity index 66% rename from barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check.hpp rename to barretenberg/cpp/src/barretenberg/vm2/generated/relations/indexed_tree_check.hpp index 65dbf6f747ba..8a351ff9ed8c 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/indexed_tree_check.hpp @@ -10,18 +10,18 @@ namespace bb::avm2 { -template class nullifier_checkImpl { +template class indexed_tree_checkImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, - 3, 3, 5, 3, 4, 3, 3, 3, 3, 3 }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 3, + 5, 3, 5, 3, 4, 2, 3, 3, 3 }; template inline static bool skip(const AllEntities& in) { using C = ColumnAndShifts; - return (in.get(C::nullifier_check_sel)).is_zero(); + return (in.get(C::indexed_tree_check_sel)).is_zero(); } template @@ -31,14 +31,14 @@ template class nullifier_checkImpl { [[maybe_unused]] const FF& scaling_factor); }; -template class nullifier_check : public Relation> { +template class indexed_tree_check : public Relation> { public: - static constexpr const std::string_view NAME = "nullifier_check"; + static constexpr const std::string_view NAME = "indexed_tree_check"; // Subrelation indices constants, to be used in tests. - static constexpr size_t SR_PASSTHROUGH_SILOING = 6; + static constexpr size_t SR_PASSTHROUGH_SILOING = 7; static constexpr size_t SR_EXISTS_CHECK = 9; - static constexpr size_t SR_NEXT_NULLIFIER_IS_ZERO_CHECK = 12; + static constexpr size_t SR_NEXT_VALUE_IS_ZERO_CHECK = 11; static std::string get_subrelation_label(size_t index) { @@ -47,8 +47,8 @@ template class nullifier_check : public Relation +template +void indexed_tree_checkImpl::accumulate(ContainerOverSubrelations& evals, + const AllEntities& in, + [[maybe_unused]] const RelationParameters&, + [[maybe_unused]] const FF_& scaling_factor) +{ + using C = ColumnAndShifts; + + const auto indexed_tree_check_VALUE_LOW_LEAF_VALUE_DIFF = + (in.get(C::indexed_tree_check_siloed_value) - in.get(C::indexed_tree_check_low_leaf_value)); + const auto indexed_tree_check_NEXT_VALUE_IS_ZERO = (FF(1) - in.get(C::indexed_tree_check_next_value_is_nonzero)); + + { + using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_sel)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_sel))); + std::get<0>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_write)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_write))); + std::get<1>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_write)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_sel))); + std::get<2>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_exists)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_exists))); + std::get<3>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View; + auto tmp = (static_cast(in.get(C::indexed_tree_check_not_exists)) - + static_cast(in.get(C::indexed_tree_check_sel)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_exists)))); + std::get<4>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_sel_silo)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_sel_silo))); + std::get<5>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_discard)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_discard))); + std::get<6>(evals) += (tmp * scaling_factor); + } + { // PASSTHROUGH_SILOING + using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; + auto tmp = (FF(1) - static_cast(in.get(C::indexed_tree_check_sel_silo))) * + (static_cast(in.get(C::indexed_tree_check_value)) - + static_cast(in.get(C::indexed_tree_check_siloed_value))); + std::get<7>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_sel)) * + (static_cast(in.get(C::indexed_tree_check_const_three)) - FF(3)); + std::get<8>(evals) += (tmp * scaling_factor); + } + { // EXISTS_CHECK + using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_sel)) * + ((CView(indexed_tree_check_VALUE_LOW_LEAF_VALUE_DIFF) * + (static_cast(in.get(C::indexed_tree_check_exists)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_value_low_leaf_value_diff_inv))) + + static_cast(in.get(C::indexed_tree_check_value_low_leaf_value_diff_inv))) - + FF(1)) + + static_cast(in.get(C::indexed_tree_check_exists))); + std::get<9>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_next_value_is_nonzero)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_next_value_is_nonzero))); + std::get<10>(evals) += (tmp * scaling_factor); + } + { // NEXT_VALUE_IS_ZERO_CHECK + using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_not_exists)) * + ((static_cast(in.get(C::indexed_tree_check_low_leaf_next_value)) * + (CView(indexed_tree_check_NEXT_VALUE_IS_ZERO) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_next_value_inv))) + + static_cast(in.get(C::indexed_tree_check_next_value_inv))) - + FF(1)) + + CView(indexed_tree_check_NEXT_VALUE_IS_ZERO)); + std::get<11>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; + auto tmp = (static_cast(in.get(C::indexed_tree_check_sel_insert)) - + static_cast(in.get(C::indexed_tree_check_write)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_exists)))); + std::get<12>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_write)) * + static_cast(in.get(C::indexed_tree_check_exists)) * + (static_cast(in.get(C::indexed_tree_check_root)) - + static_cast(in.get(C::indexed_tree_check_write_root))); + std::get<13>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View; + auto tmp = (static_cast(in.get(C::indexed_tree_check_tree_size_after_write)) - + (static_cast(in.get(C::indexed_tree_check_tree_size_before_write)) + + static_cast(in.get(C::indexed_tree_check_sel_insert)))); + std::get<14>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_sel_insert)) * + (static_cast(in.get(C::indexed_tree_check_tree_size_before_write)) - + static_cast(in.get(C::indexed_tree_check_updated_low_leaf_next_index))); + std::get<15>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::indexed_tree_check_sel_insert)) * + (static_cast(in.get(C::indexed_tree_check_siloed_value)) - + static_cast(in.get(C::indexed_tree_check_updated_low_leaf_next_value))); + std::get<16>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View; + auto tmp = (static_cast(in.get(C::indexed_tree_check_sel_write_to_public_inputs)) - + static_cast(in.get(C::indexed_tree_check_sel_insert)) * + (FF(1) - static_cast(in.get(C::indexed_tree_check_discard)))); + std::get<17>(evals) += (tmp * scaling_factor); + } +} + +} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_bc_retrieval.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_bc_retrieval.hpp index 474f596957ae..b1e063418282 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_bc_retrieval.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_bc_retrieval.hpp @@ -48,20 +48,24 @@ using lookup_bc_retrieval_contract_instance_retrieval_relation = struct lookup_bc_retrieval_is_new_class_check_settings_ { static constexpr std::string_view NAME = "LOOKUP_BC_RETRIEVAL_IS_NEW_CLASS_CHECK"; static constexpr std::string_view RELATION_NAME = "bc_retrieval"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; + static constexpr size_t LOOKUP_TUPLE_SIZE = 5; static constexpr Column SRC_SELECTOR = Column::bc_retrieval_instance_exists; - static constexpr Column DST_SELECTOR = Column::retrieved_bytecodes_tree_check_sel; + static constexpr Column DST_SELECTOR = Column::indexed_tree_check_sel; static constexpr Column COUNTS = Column::lookup_bc_retrieval_is_new_class_check_counts; static constexpr Column INVERSES = Column::lookup_bc_retrieval_is_new_class_check_inv; static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::bc_retrieval_current_class_id, ColumnAndShifts::bc_retrieval_is_new_class, - ColumnAndShifts::bc_retrieval_prev_retrieved_bytecodes_tree_root + ColumnAndShifts::bc_retrieval_current_class_id, + ColumnAndShifts::bc_retrieval_prev_retrieved_bytecodes_tree_root, + ColumnAndShifts::bc_retrieval_retrieved_bytecodes_tree_height, + ColumnAndShifts::precomputed_zero }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_leaf_not_exists, - ColumnAndShifts::retrieved_bytecodes_tree_check_root + ColumnAndShifts::indexed_tree_check_not_exists, + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo }; }; @@ -106,26 +110,28 @@ using lookup_bc_retrieval_class_id_derivation_relation = struct lookup_bc_retrieval_retrieved_bytecodes_insertion_settings_ { static constexpr std::string_view NAME = "LOOKUP_BC_RETRIEVAL_RETRIEVED_BYTECODES_INSERTION"; static constexpr std::string_view RELATION_NAME = "bc_retrieval"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 6; + static constexpr size_t LOOKUP_TUPLE_SIZE = 7; static constexpr Column SRC_SELECTOR = Column::bc_retrieval_should_retrieve; - static constexpr Column DST_SELECTOR = Column::retrieved_bytecodes_tree_check_sel; + static constexpr Column DST_SELECTOR = Column::indexed_tree_check_write; static constexpr Column COUNTS = Column::lookup_bc_retrieval_retrieved_bytecodes_insertion_counts; static constexpr Column INVERSES = Column::lookup_bc_retrieval_retrieved_bytecodes_insertion_inv; static constexpr std::array SRC_COLUMNS = { ColumnAndShifts::bc_retrieval_current_class_id, - ColumnAndShifts::bc_retrieval_should_retrieve, ColumnAndShifts::bc_retrieval_prev_retrieved_bytecodes_tree_root, - ColumnAndShifts::bc_retrieval_prev_retrieved_bytecodes_tree_size, ColumnAndShifts::bc_retrieval_next_retrieved_bytecodes_tree_root, - ColumnAndShifts::bc_retrieval_next_retrieved_bytecodes_tree_size + ColumnAndShifts::bc_retrieval_prev_retrieved_bytecodes_tree_size, + ColumnAndShifts::bc_retrieval_next_retrieved_bytecodes_tree_size, + ColumnAndShifts::bc_retrieval_retrieved_bytecodes_tree_height, + ColumnAndShifts::precomputed_zero }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_write, - ColumnAndShifts::retrieved_bytecodes_tree_check_root, - ColumnAndShifts::retrieved_bytecodes_tree_check_tree_size_before_write, - ColumnAndShifts::retrieved_bytecodes_tree_check_write_root, - ColumnAndShifts::retrieved_bytecodes_tree_check_tree_size_after_write + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_write_root, + ColumnAndShifts::indexed_tree_check_tree_size_before_write, + ColumnAndShifts::indexed_tree_check_tree_size_after_write, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp index 49df34a9c6a5..91e13c3c6473 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_contract_instance_retrieval.hpp @@ -70,24 +70,25 @@ using lookup_contract_instance_retrieval_read_derived_address_from_public_inputs struct lookup_contract_instance_retrieval_deployment_nullifier_read_settings_ { static constexpr std::string_view NAME = "LOOKUP_CONTRACT_INSTANCE_RETRIEVAL_DEPLOYMENT_NULLIFIER_READ"; static constexpr std::string_view RELATION_NAME = "contract_instance_retrieval"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; + static constexpr size_t LOOKUP_TUPLE_SIZE = 7; static constexpr Column SRC_SELECTOR = Column::contract_instance_retrieval_should_check_nullifier; - static constexpr Column DST_SELECTOR = Column::nullifier_check_sel; + static constexpr Column DST_SELECTOR = Column::indexed_tree_check_sel; static constexpr Column COUNTS = Column::lookup_contract_instance_retrieval_deployment_nullifier_read_counts; static constexpr Column INVERSES = Column::lookup_contract_instance_retrieval_deployment_nullifier_read_inv; static constexpr std::array SRC_COLUMNS = { ColumnAndShifts::contract_instance_retrieval_exists, ColumnAndShifts::contract_instance_retrieval_address, ColumnAndShifts::contract_instance_retrieval_nullifier_tree_root, - ColumnAndShifts::contract_instance_retrieval_deployer_protocol_contract_address, - ColumnAndShifts::contract_instance_retrieval_sel + ColumnAndShifts::contract_instance_retrieval_nullifier_tree_height, + ColumnAndShifts::contract_instance_retrieval_sel, + ColumnAndShifts::contract_instance_retrieval_siloing_separator, + ColumnAndShifts::contract_instance_retrieval_deployer_protocol_contract_address }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::nullifier_check_exists, - ColumnAndShifts::nullifier_check_nullifier, - ColumnAndShifts::nullifier_check_root, - ColumnAndShifts::nullifier_check_address, - ColumnAndShifts::nullifier_check_sel_silo + ColumnAndShifts::indexed_tree_check_exists, ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo, ColumnAndShifts::indexed_tree_check_siloing_separator, + ColumnAndShifts::indexed_tree_check_address }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_emit_nullifier.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_emit_nullifier.hpp index 00f042ad731b..358278ed0786 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_emit_nullifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_emit_nullifier.hpp @@ -16,9 +16,9 @@ namespace bb::avm2 { struct lookup_emit_nullifier_write_nullifier_settings_ { static constexpr std::string_view NAME = "LOOKUP_EMIT_NULLIFIER_WRITE_NULLIFIER"; static constexpr std::string_view RELATION_NAME = "emit_nullifier"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 9; + static constexpr size_t LOOKUP_TUPLE_SIZE = 11; static constexpr Column SRC_SELECTOR = Column::execution_sel_write_nullifier; - static constexpr Column DST_SELECTOR = Column::nullifier_check_write; + static constexpr Column DST_SELECTOR = Column::indexed_tree_check_write; static constexpr Column COUNTS = Column::lookup_emit_nullifier_write_nullifier_counts; static constexpr Column INVERSES = Column::lookup_emit_nullifier_write_nullifier_inv; static constexpr std::array SRC_COLUMNS = { @@ -28,20 +28,24 @@ struct lookup_emit_nullifier_write_nullifier_settings_ { ColumnAndShifts::execution_nullifier_tree_root, ColumnAndShifts::execution_prev_nullifier_tree_size, ColumnAndShifts::execution_discard, - ColumnAndShifts::execution_prev_num_nullifiers_emitted, + ColumnAndShifts::execution_nullifier_pi_offset, + ColumnAndShifts::execution_nullifier_tree_height, ColumnAndShifts::execution_sel_write_nullifier, + ColumnAndShifts::execution_nullifier_siloing_separator, ColumnAndShifts::execution_contract_address }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::nullifier_check_nullifier, - ColumnAndShifts::nullifier_check_root, - ColumnAndShifts::nullifier_check_exists, - ColumnAndShifts::nullifier_check_write_root, - ColumnAndShifts::nullifier_check_tree_size_before_write, - ColumnAndShifts::nullifier_check_discard, - ColumnAndShifts::nullifier_check_nullifier_index, - ColumnAndShifts::nullifier_check_sel_silo, - ColumnAndShifts::nullifier_check_address + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_exists, + ColumnAndShifts::indexed_tree_check_write_root, + ColumnAndShifts::indexed_tree_check_tree_size_before_write, + ColumnAndShifts::indexed_tree_check_discard, + ColumnAndShifts::indexed_tree_check_public_inputs_index, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo, + ColumnAndShifts::indexed_tree_check_siloing_separator, + ColumnAndShifts::indexed_tree_check_address }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_execution.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_execution.hpp index cb8438f3883c..4c5f6feb8358 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_execution.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_execution.hpp @@ -323,22 +323,25 @@ using lookup_execution_get_max_limbs_relation = lookup_relation_base SRC_COLUMNS = { - ColumnAndShifts::execution_contract_address, - ColumnAndShifts::execution_register_1_, ColumnAndShifts::execution_dynamic_da_gas_factor, - ColumnAndShifts::execution_prev_written_public_data_slots_tree_root + ColumnAndShifts::execution_register_1_, + ColumnAndShifts::execution_prev_written_public_data_slots_tree_root, + ColumnAndShifts::execution_written_slots_tree_height, + ColumnAndShifts::execution_sel_gas_sstore, + ColumnAndShifts::execution_written_slots_tree_siloing_separator, + ColumnAndShifts::execution_contract_address }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_address, - ColumnAndShifts::written_public_data_slots_tree_check_slot, - ColumnAndShifts::written_public_data_slots_tree_check_leaf_not_exists, - ColumnAndShifts::written_public_data_slots_tree_check_root + ColumnAndShifts::indexed_tree_check_not_exists, ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo, ColumnAndShifts::indexed_tree_check_siloing_separator, + ColumnAndShifts::indexed_tree_check_address }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_indexed_tree_check.cpp similarity index 74% rename from barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_check.cpp rename to barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_indexed_tree_check.cpp index 188e33e96a3e..1824fce8888e 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_check.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_indexed_tree_check.cpp @@ -25,14 +25,14 @@ namespace bb::avm2 { -INSTANTIATE_LOOKUP(lookup_nullifier_check_silo_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_low_leaf_nullifier_validation_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_low_leaf_next_nullifier_validation_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_low_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_updated_low_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_low_leaf_merkle_check_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_new_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_new_leaf_merkle_check_relation); -INSTANTIATE_LOOKUP(lookup_nullifier_check_write_nullifier_to_public_inputs_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_silo_poseidon2_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_low_leaf_value_validation_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_low_leaf_next_value_validation_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_low_leaf_poseidon2_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_updated_low_leaf_poseidon2_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_low_leaf_merkle_check_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_new_leaf_poseidon2_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_new_leaf_merkle_check_relation); +INSTANTIATE_LOOKUP(lookup_indexed_tree_check_write_value_to_public_inputs_relation); } // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_indexed_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_indexed_tree_check.hpp new file mode 100644 index 000000000000..2bc360d57bb1 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_indexed_tree_check.hpp @@ -0,0 +1,281 @@ +// AUTOGENERATED FILE +#pragma once + +#include +#include +#include + +#include "../columns.hpp" +#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" +#include "barretenberg/vm2/constraining/relations/interactions_base.hpp" + +namespace bb::avm2 { + +/////////////////// lookup_indexed_tree_check_silo_poseidon2 /////////////////// + +struct lookup_indexed_tree_check_silo_poseidon2_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_SILO_POSEIDON2"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 5; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel_silo; + static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_silo_poseidon2_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_silo_poseidon2_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_siloing_separator, + ColumnAndShifts::indexed_tree_check_address, + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_siloed_value, + ColumnAndShifts::indexed_tree_check_const_three + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::poseidon2_hash_input_0, + ColumnAndShifts::poseidon2_hash_input_1, + ColumnAndShifts::poseidon2_hash_input_2, + ColumnAndShifts::poseidon2_hash_output, + ColumnAndShifts::poseidon2_hash_input_len + }; +}; + +using lookup_indexed_tree_check_silo_poseidon2_settings = + lookup_settings; +template +using lookup_indexed_tree_check_silo_poseidon2_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_low_leaf_value_validation /////////////////// + +struct lookup_indexed_tree_check_low_leaf_value_validation_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_LOW_LEAF_VALUE_VALIDATION"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 3; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_not_exists; + static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_low_leaf_value_validation_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_low_leaf_value_validation_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_siloed_value, + ColumnAndShifts::indexed_tree_check_low_leaf_value, + ColumnAndShifts::indexed_tree_check_sel + }; + static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, + ColumnAndShifts::ff_gt_b, + ColumnAndShifts::ff_gt_result }; +}; + +using lookup_indexed_tree_check_low_leaf_value_validation_settings = + lookup_settings; +template +using lookup_indexed_tree_check_low_leaf_value_validation_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_low_leaf_next_value_validation /////////////////// + +struct lookup_indexed_tree_check_low_leaf_next_value_validation_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_LOW_LEAF_NEXT_VALUE_VALIDATION"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 3; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_next_value_is_nonzero; + static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_low_leaf_next_value_validation_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_low_leaf_next_value_validation_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_low_leaf_next_value, + ColumnAndShifts::indexed_tree_check_siloed_value, + ColumnAndShifts::indexed_tree_check_sel + }; + static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, + ColumnAndShifts::ff_gt_b, + ColumnAndShifts::ff_gt_result }; +}; + +using lookup_indexed_tree_check_low_leaf_next_value_validation_settings = + lookup_settings; +template +using lookup_indexed_tree_check_low_leaf_next_value_validation_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_low_leaf_poseidon2 /////////////////// + +struct lookup_indexed_tree_check_low_leaf_poseidon2_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_LOW_LEAF_POSEIDON2"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 5; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel; + static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_low_leaf_poseidon2_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_low_leaf_poseidon2_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_low_leaf_value, + ColumnAndShifts::indexed_tree_check_low_leaf_next_value, + ColumnAndShifts::indexed_tree_check_low_leaf_next_index, + ColumnAndShifts::indexed_tree_check_low_leaf_hash, + ColumnAndShifts::indexed_tree_check_const_three + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::poseidon2_hash_input_0, + ColumnAndShifts::poseidon2_hash_input_1, + ColumnAndShifts::poseidon2_hash_input_2, + ColumnAndShifts::poseidon2_hash_output, + ColumnAndShifts::poseidon2_hash_input_len + }; +}; + +using lookup_indexed_tree_check_low_leaf_poseidon2_settings = + lookup_settings; +template +using lookup_indexed_tree_check_low_leaf_poseidon2_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_updated_low_leaf_poseidon2 /////////////////// + +struct lookup_indexed_tree_check_updated_low_leaf_poseidon2_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_UPDATED_LOW_LEAF_POSEIDON2"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 5; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel_insert; + static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_updated_low_leaf_poseidon2_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_updated_low_leaf_poseidon2_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_low_leaf_value, + ColumnAndShifts::indexed_tree_check_updated_low_leaf_next_value, + ColumnAndShifts::indexed_tree_check_updated_low_leaf_next_index, + ColumnAndShifts::indexed_tree_check_updated_low_leaf_hash, + ColumnAndShifts::indexed_tree_check_const_three + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::poseidon2_hash_input_0, + ColumnAndShifts::poseidon2_hash_input_1, + ColumnAndShifts::poseidon2_hash_input_2, + ColumnAndShifts::poseidon2_hash_output, + ColumnAndShifts::poseidon2_hash_input_len + }; +}; + +using lookup_indexed_tree_check_updated_low_leaf_poseidon2_settings = + lookup_settings; +template +using lookup_indexed_tree_check_updated_low_leaf_poseidon2_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_low_leaf_merkle_check /////////////////// + +struct lookup_indexed_tree_check_low_leaf_merkle_check_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_LOW_LEAF_MERKLE_CHECK"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 7; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel; + static constexpr Column DST_SELECTOR = Column::merkle_check_start; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_low_leaf_merkle_check_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_low_leaf_merkle_check_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_sel_insert, + ColumnAndShifts::indexed_tree_check_low_leaf_hash, + ColumnAndShifts::indexed_tree_check_updated_low_leaf_hash, + ColumnAndShifts::indexed_tree_check_low_leaf_index, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_intermediate_root + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, + ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, + ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, + ColumnAndShifts::merkle_check_write_root + }; +}; + +using lookup_indexed_tree_check_low_leaf_merkle_check_settings = + lookup_settings; +template +using lookup_indexed_tree_check_low_leaf_merkle_check_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_new_leaf_poseidon2 /////////////////// + +struct lookup_indexed_tree_check_new_leaf_poseidon2_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_NEW_LEAF_POSEIDON2"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 5; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel_insert; + static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_new_leaf_poseidon2_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_new_leaf_poseidon2_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_siloed_value, + ColumnAndShifts::indexed_tree_check_low_leaf_next_value, + ColumnAndShifts::indexed_tree_check_low_leaf_next_index, + ColumnAndShifts::indexed_tree_check_new_leaf_hash, + ColumnAndShifts::indexed_tree_check_const_three + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::poseidon2_hash_input_0, + ColumnAndShifts::poseidon2_hash_input_1, + ColumnAndShifts::poseidon2_hash_input_2, + ColumnAndShifts::poseidon2_hash_output, + ColumnAndShifts::poseidon2_hash_input_len + }; +}; + +using lookup_indexed_tree_check_new_leaf_poseidon2_settings = + lookup_settings; +template +using lookup_indexed_tree_check_new_leaf_poseidon2_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_new_leaf_merkle_check /////////////////// + +struct lookup_indexed_tree_check_new_leaf_merkle_check_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_NEW_LEAF_MERKLE_CHECK"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 7; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel_insert; + static constexpr Column DST_SELECTOR = Column::merkle_check_start; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_new_leaf_merkle_check_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_new_leaf_merkle_check_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_sel, ColumnAndShifts::precomputed_zero, + ColumnAndShifts::indexed_tree_check_new_leaf_hash, ColumnAndShifts::indexed_tree_check_tree_size_before_write, + ColumnAndShifts::indexed_tree_check_tree_height, ColumnAndShifts::indexed_tree_check_intermediate_root, + ColumnAndShifts::indexed_tree_check_write_root + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, + ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, + ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, + ColumnAndShifts::merkle_check_write_root + }; +}; + +using lookup_indexed_tree_check_new_leaf_merkle_check_settings = + lookup_settings; +template +using lookup_indexed_tree_check_new_leaf_merkle_check_relation = + lookup_relation_base; + +/////////////////// lookup_indexed_tree_check_write_value_to_public_inputs /////////////////// + +struct lookup_indexed_tree_check_write_value_to_public_inputs_settings_ { + static constexpr std::string_view NAME = "LOOKUP_INDEXED_TREE_CHECK_WRITE_VALUE_TO_PUBLIC_INPUTS"; + static constexpr std::string_view RELATION_NAME = "indexed_tree_check"; + static constexpr size_t LOOKUP_TUPLE_SIZE = 2; + static constexpr Column SRC_SELECTOR = Column::indexed_tree_check_sel_write_to_public_inputs; + static constexpr Column DST_SELECTOR = Column::public_inputs_sel; + static constexpr Column COUNTS = Column::lookup_indexed_tree_check_write_value_to_public_inputs_counts; + static constexpr Column INVERSES = Column::lookup_indexed_tree_check_write_value_to_public_inputs_inv; + static constexpr std::array SRC_COLUMNS = { + ColumnAndShifts::indexed_tree_check_public_inputs_index, ColumnAndShifts::indexed_tree_check_siloed_value + }; + static constexpr std::array DST_COLUMNS = { + ColumnAndShifts::precomputed_idx, ColumnAndShifts::public_inputs_cols_0_ + }; +}; + +using lookup_indexed_tree_check_write_value_to_public_inputs_settings = + lookup_settings; +template +using lookup_indexed_tree_check_write_value_to_public_inputs_relation = + lookup_relation_base; + +} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_check.hpp deleted file mode 100644 index 46ed19c985e0..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_check.hpp +++ /dev/null @@ -1,280 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include -#include -#include - -#include "../columns.hpp" -#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" -#include "barretenberg/vm2/constraining/relations/interactions_base.hpp" - -namespace bb::avm2 { - -/////////////////// lookup_nullifier_check_silo_poseidon2 /////////////////// - -struct lookup_nullifier_check_silo_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_SILO_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel_silo; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_nullifier_check_silo_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_silo_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_siloing_separator, - ColumnAndShifts::nullifier_check_address, - ColumnAndShifts::nullifier_check_nullifier, - ColumnAndShifts::nullifier_check_siloed_nullifier, - ColumnAndShifts::nullifier_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_nullifier_check_silo_poseidon2_settings = lookup_settings; -template -using lookup_nullifier_check_silo_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_low_leaf_nullifier_validation /////////////////// - -struct lookup_nullifier_check_low_leaf_nullifier_validation_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_LOW_LEAF_NULLIFIER_VALIDATION"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_leaf_not_exists; - static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; - static constexpr Column COUNTS = Column::lookup_nullifier_check_low_leaf_nullifier_validation_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_low_leaf_nullifier_validation_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_siloed_nullifier, - ColumnAndShifts::nullifier_check_low_leaf_nullifier, - ColumnAndShifts::nullifier_check_sel - }; - static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, - ColumnAndShifts::ff_gt_b, - ColumnAndShifts::ff_gt_result }; -}; - -using lookup_nullifier_check_low_leaf_nullifier_validation_settings = - lookup_settings; -template -using lookup_nullifier_check_low_leaf_nullifier_validation_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_low_leaf_next_nullifier_validation /////////////////// - -struct lookup_nullifier_check_low_leaf_next_nullifier_validation_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_LOW_LEAF_NEXT_NULLIFIER_VALIDATION"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_next_nullifier_is_nonzero; - static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; - static constexpr Column COUNTS = Column::lookup_nullifier_check_low_leaf_next_nullifier_validation_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_low_leaf_next_nullifier_validation_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_low_leaf_next_nullifier, - ColumnAndShifts::nullifier_check_siloed_nullifier, - ColumnAndShifts::nullifier_check_sel - }; - static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, - ColumnAndShifts::ff_gt_b, - ColumnAndShifts::ff_gt_result }; -}; - -using lookup_nullifier_check_low_leaf_next_nullifier_validation_settings = - lookup_settings; -template -using lookup_nullifier_check_low_leaf_next_nullifier_validation_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_low_leaf_poseidon2 /////////////////// - -struct lookup_nullifier_check_low_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_LOW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_nullifier_check_low_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_low_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_low_leaf_nullifier, - ColumnAndShifts::nullifier_check_low_leaf_next_nullifier, - ColumnAndShifts::nullifier_check_low_leaf_next_index, - ColumnAndShifts::nullifier_check_low_leaf_hash, - ColumnAndShifts::nullifier_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_nullifier_check_low_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_nullifier_check_low_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_updated_low_leaf_poseidon2 /////////////////// - -struct lookup_nullifier_check_updated_low_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_UPDATED_LOW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel_insert; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_nullifier_check_updated_low_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_updated_low_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_low_leaf_nullifier, - ColumnAndShifts::nullifier_check_updated_low_leaf_next_nullifier, - ColumnAndShifts::nullifier_check_updated_low_leaf_next_index, - ColumnAndShifts::nullifier_check_updated_low_leaf_hash, - ColumnAndShifts::nullifier_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_nullifier_check_updated_low_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_nullifier_check_updated_low_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_low_leaf_merkle_check /////////////////// - -struct lookup_nullifier_check_low_leaf_merkle_check_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_LOW_LEAF_MERKLE_CHECK"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel; - static constexpr Column DST_SELECTOR = Column::merkle_check_start; - static constexpr Column COUNTS = Column::lookup_nullifier_check_low_leaf_merkle_check_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_low_leaf_merkle_check_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_sel_insert, - ColumnAndShifts::nullifier_check_low_leaf_hash, - ColumnAndShifts::nullifier_check_updated_low_leaf_hash, - ColumnAndShifts::nullifier_check_low_leaf_index, - ColumnAndShifts::nullifier_check_tree_height, - ColumnAndShifts::nullifier_check_root, - ColumnAndShifts::nullifier_check_intermediate_root - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, - ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, - ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, - ColumnAndShifts::merkle_check_write_root - }; -}; - -using lookup_nullifier_check_low_leaf_merkle_check_settings = - lookup_settings; -template -using lookup_nullifier_check_low_leaf_merkle_check_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_new_leaf_poseidon2 /////////////////// - -struct lookup_nullifier_check_new_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_NEW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel_insert; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_nullifier_check_new_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_new_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_siloed_nullifier, - ColumnAndShifts::nullifier_check_low_leaf_next_nullifier, - ColumnAndShifts::nullifier_check_low_leaf_next_index, - ColumnAndShifts::nullifier_check_new_leaf_hash, - ColumnAndShifts::nullifier_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_nullifier_check_new_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_nullifier_check_new_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_new_leaf_merkle_check /////////////////// - -struct lookup_nullifier_check_new_leaf_merkle_check_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_NEW_LEAF_MERKLE_CHECK"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel_insert; - static constexpr Column DST_SELECTOR = Column::merkle_check_start; - static constexpr Column COUNTS = Column::lookup_nullifier_check_new_leaf_merkle_check_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_new_leaf_merkle_check_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_sel, ColumnAndShifts::precomputed_zero, - ColumnAndShifts::nullifier_check_new_leaf_hash, ColumnAndShifts::nullifier_check_tree_size_before_write, - ColumnAndShifts::nullifier_check_tree_height, ColumnAndShifts::nullifier_check_intermediate_root, - ColumnAndShifts::nullifier_check_write_root - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, - ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, - ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, - ColumnAndShifts::merkle_check_write_root - }; -}; - -using lookup_nullifier_check_new_leaf_merkle_check_settings = - lookup_settings; -template -using lookup_nullifier_check_new_leaf_merkle_check_relation = - lookup_relation_base; - -/////////////////// lookup_nullifier_check_write_nullifier_to_public_inputs /////////////////// - -struct lookup_nullifier_check_write_nullifier_to_public_inputs_settings_ { - static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_CHECK_WRITE_NULLIFIER_TO_PUBLIC_INPUTS"; - static constexpr std::string_view RELATION_NAME = "nullifier_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 2; - static constexpr Column SRC_SELECTOR = Column::nullifier_check_sel_write_to_public_inputs; - static constexpr Column DST_SELECTOR = Column::public_inputs_sel; - static constexpr Column COUNTS = Column::lookup_nullifier_check_write_nullifier_to_public_inputs_counts; - static constexpr Column INVERSES = Column::lookup_nullifier_check_write_nullifier_to_public_inputs_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::nullifier_check_public_inputs_index, ColumnAndShifts::nullifier_check_siloed_nullifier - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::precomputed_idx, ColumnAndShifts::public_inputs_cols_0_ - }; -}; - -using lookup_nullifier_check_write_nullifier_to_public_inputs_settings = - lookup_settings; -template -using lookup_nullifier_check_write_nullifier_to_public_inputs_relation = - lookup_relation_base; - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_exists.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_exists.hpp index ce2ef7d10091..6a28818c3b84 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_exists.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_nullifier_exists.hpp @@ -16,22 +16,24 @@ namespace bb::avm2 { struct lookup_nullifier_exists_nullifier_exists_check_settings_ { static constexpr std::string_view NAME = "LOOKUP_NULLIFIER_EXISTS_NULLIFIER_EXISTS_CHECK"; static constexpr std::string_view RELATION_NAME = "nullifier_exists"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 4; + static constexpr size_t LOOKUP_TUPLE_SIZE = 5; static constexpr Column SRC_SELECTOR = Column::execution_sel_execute_nullifier_exists; - static constexpr Column DST_SELECTOR = Column::nullifier_check_sel; + static constexpr Column DST_SELECTOR = Column::indexed_tree_check_sel; static constexpr Column COUNTS = Column::lookup_nullifier_exists_nullifier_exists_check_counts; static constexpr Column INVERSES = Column::lookup_nullifier_exists_nullifier_exists_check_inv; static constexpr std::array SRC_COLUMNS = { ColumnAndShifts::execution_register_1_, ColumnAndShifts::execution_register_0_, ColumnAndShifts::execution_prev_nullifier_tree_root, + ColumnAndShifts::execution_nullifier_tree_height, ColumnAndShifts::precomputed_zero }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::nullifier_check_exists, - ColumnAndShifts::nullifier_check_nullifier, - ColumnAndShifts::nullifier_check_root, - ColumnAndShifts::nullifier_check_sel_silo + ColumnAndShifts::indexed_tree_check_exists, + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.cpp deleted file mode 100644 index 70476a6949e4..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.cpp +++ /dev/null @@ -1,36 +0,0 @@ -// AUTOGENERATED FILE -#include "barretenberg/flavor/relation_definitions.hpp" -#include "barretenberg/vm2/constraining/flavor.hpp" -#include "barretenberg/vm2/constraining/full_row.hpp" -#include "barretenberg/vm2/constraining/recursion/recursive_flavor.hpp" -#include "barretenberg/vm2/constraining/relations/interactions_base_impl.hpp" - -#define AvmCheckCircuitEdge(Flavor) Flavor::PolynomialEntitiesAtFixedRow -#define AvmCheckRelationEdge(Flavor) ::bb::avm2::AvmFullRowProxy - -#define ACCUMULATE_FOR_LOOKUP(...) _ACCUMULATE_FOR_LOOKUP(__VA_ARGS__) -#define _ACCUMULATE_FOR_LOOKUP(RelationName, Flavor, AccumulatorType, EdgeType) \ - template void RelationName::accumulate::AccumulatorType, EdgeType(Flavor)>( \ - RelationName::AccumulatorType&, \ - EdgeType(Flavor) const&, \ - RelationParameters const&, \ - Flavor::FF const&); - -#define INSTANTIATE_LOOKUP(RelationName) \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckTupleOfUnivariatesOverSubrelations, ExtendedEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, AvmCheckCircuitEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, AvmCheckRelationEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmRecursiveFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); - -namespace bb::avm2 { - -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_relation); -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_relation); -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_relation); -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_relation); - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.hpp deleted file mode 100644 index 3f01fb34d540..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.hpp +++ /dev/null @@ -1,230 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include -#include -#include - -#include "../columns.hpp" -#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" -#include "barretenberg/vm2/constraining/relations/interactions_base.hpp" - -namespace bb::avm2 { - -/////////////////// lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2 /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_LOW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_sel; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_next_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_next_index, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_hash, - ColumnAndShifts::retrieved_bytecodes_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_low_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2 /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_UPDATED_LOW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_should_insert; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_updated_low_leaf_next_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_updated_low_leaf_next_index, - ColumnAndShifts::retrieved_bytecodes_tree_check_updated_low_leaf_hash, - ColumnAndShifts::retrieved_bytecodes_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_updated_low_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_LOW_LEAF_MERKLE_CHECK"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_sel; - static constexpr Column DST_SELECTOR = Column::merkle_check_start; - static constexpr Column COUNTS = Column::lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_counts; - static constexpr Column INVERSES = Column::lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_should_insert, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_hash, - ColumnAndShifts::retrieved_bytecodes_tree_check_updated_low_leaf_hash, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_index, - ColumnAndShifts::retrieved_bytecodes_tree_check_tree_height, - ColumnAndShifts::retrieved_bytecodes_tree_check_root, - ColumnAndShifts::retrieved_bytecodes_tree_check_intermediate_root - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, - ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, - ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, - ColumnAndShifts::merkle_check_write_root - }; -}; - -using lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_low_leaf_merkle_check_relation = - lookup_relation_base; - -/////////////////// lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_LOW_LEAF_CLASS_ID_VALIDATION"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_leaf_not_exists; - static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; - static constexpr Column COUNTS = Column::lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_counts; - static constexpr Column INVERSES = Column::lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_sel - }; - static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, - ColumnAndShifts::ff_gt_b, - ColumnAndShifts::ff_gt_result }; -}; - -using lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_low_leaf_class_id_validation_relation = - lookup_relation_base; - -/////////////////// lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_LOW_LEAF_NEXT_CLASS_ID_VALIDATION"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_next_class_id_is_nonzero; - static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; - static constexpr Column COUNTS = - Column::lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_counts; - static constexpr Column INVERSES = - Column::lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_next_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_sel - }; - static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, - ColumnAndShifts::ff_gt_b, - ColumnAndShifts::ff_gt_result }; -}; - -using lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_low_leaf_next_class_id_validation_relation = - lookup_relation_base; - -/////////////////// lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2 /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_NEW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_should_insert; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_next_class_id, - ColumnAndShifts::retrieved_bytecodes_tree_check_low_leaf_next_index, - ColumnAndShifts::retrieved_bytecodes_tree_check_new_leaf_hash, - ColumnAndShifts::retrieved_bytecodes_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_new_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check /////////////////// - -struct lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_settings_ { - static constexpr std::string_view NAME = "LOOKUP_RETRIEVED_BYTECODES_TREE_CHECK_NEW_LEAF_MERKLE_CHECK"; - static constexpr std::string_view RELATION_NAME = "retrieved_bytecodes_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; - static constexpr Column SRC_SELECTOR = Column::retrieved_bytecodes_tree_check_should_insert; - static constexpr Column DST_SELECTOR = Column::merkle_check_start; - static constexpr Column COUNTS = Column::lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_counts; - static constexpr Column INVERSES = Column::lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::retrieved_bytecodes_tree_check_sel, - ColumnAndShifts::precomputed_zero, - ColumnAndShifts::retrieved_bytecodes_tree_check_new_leaf_hash, - ColumnAndShifts::retrieved_bytecodes_tree_check_tree_size_before_write, - ColumnAndShifts::retrieved_bytecodes_tree_check_tree_height, - ColumnAndShifts::retrieved_bytecodes_tree_check_intermediate_root, - ColumnAndShifts::retrieved_bytecodes_tree_check_write_root - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, - ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, - ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, - ColumnAndShifts::merkle_check_write_root - }; -}; - -using lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_settings = - lookup_settings; -template -using lookup_retrieved_bytecodes_tree_check_new_leaf_merkle_check_relation = - lookup_relation_base; - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_sstore.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_sstore.hpp index 3e7189e73400..e1ed25b553cb 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_sstore.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_sstore.hpp @@ -16,28 +16,32 @@ namespace bb::avm2 { struct lookup_sstore_record_written_storage_slot_settings_ { static constexpr std::string_view NAME = "LOOKUP_SSTORE_RECORD_WRITTEN_STORAGE_SLOT"; static constexpr std::string_view RELATION_NAME = "sstore"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; + static constexpr size_t LOOKUP_TUPLE_SIZE = 9; static constexpr Column SRC_SELECTOR = Column::execution_sel_write_public_data; - static constexpr Column DST_SELECTOR = Column::written_public_data_slots_tree_check_sel; + static constexpr Column DST_SELECTOR = Column::indexed_tree_check_write; static constexpr Column COUNTS = Column::lookup_sstore_record_written_storage_slot_counts; static constexpr Column INVERSES = Column::lookup_sstore_record_written_storage_slot_inv; static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::execution_contract_address, ColumnAndShifts::execution_register_1_, - ColumnAndShifts::execution_sel_write_public_data, ColumnAndShifts::execution_prev_written_public_data_slots_tree_root, - ColumnAndShifts::execution_prev_written_public_data_slots_tree_size, ColumnAndShifts::execution_written_public_data_slots_tree_root, - ColumnAndShifts::execution_written_public_data_slots_tree_size + ColumnAndShifts::execution_prev_written_public_data_slots_tree_size, + ColumnAndShifts::execution_written_public_data_slots_tree_size, + ColumnAndShifts::execution_written_slots_tree_height, + ColumnAndShifts::execution_sel_write_public_data, + ColumnAndShifts::execution_written_slots_tree_siloing_separator, + ColumnAndShifts::execution_contract_address }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_address, - ColumnAndShifts::written_public_data_slots_tree_check_slot, - ColumnAndShifts::written_public_data_slots_tree_check_write, - ColumnAndShifts::written_public_data_slots_tree_check_root, - ColumnAndShifts::written_public_data_slots_tree_check_tree_size_before_write, - ColumnAndShifts::written_public_data_slots_tree_check_write_root, - ColumnAndShifts::written_public_data_slots_tree_check_tree_size_after_write + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_write_root, + ColumnAndShifts::indexed_tree_check_tree_size_before_write, + ColumnAndShifts::indexed_tree_check_tree_size_after_write, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo, + ColumnAndShifts::indexed_tree_check_siloing_separator, + ColumnAndShifts::indexed_tree_check_address }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_tx.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_tx.hpp index 6f2ef6cd4fd9..d28c89272a89 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_tx.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_tx.hpp @@ -173,9 +173,9 @@ using lookup_tx_note_hash_append_relation = lookup_relation_base SRC_COLUMNS = { @@ -185,18 +185,20 @@ struct lookup_tx_nullifier_append_settings_ { ColumnAndShifts::tx_next_nullifier_tree_root, ColumnAndShifts::tx_prev_nullifier_tree_size, ColumnAndShifts::tx_discard, - ColumnAndShifts::tx_prev_num_nullifiers_emitted, + ColumnAndShifts::tx_write_nullifier_pi_offset, + ColumnAndShifts::tx_nullifier_tree_height, ColumnAndShifts::precomputed_zero }; static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::nullifier_check_nullifier, - ColumnAndShifts::nullifier_check_root, - ColumnAndShifts::nullifier_check_exists, - ColumnAndShifts::nullifier_check_write_root, - ColumnAndShifts::nullifier_check_tree_size_before_write, - ColumnAndShifts::nullifier_check_discard, - ColumnAndShifts::nullifier_check_nullifier_index, - ColumnAndShifts::nullifier_check_sel_silo + ColumnAndShifts::indexed_tree_check_value, + ColumnAndShifts::indexed_tree_check_root, + ColumnAndShifts::indexed_tree_check_exists, + ColumnAndShifts::indexed_tree_check_write_root, + ColumnAndShifts::indexed_tree_check_tree_size_before_write, + ColumnAndShifts::indexed_tree_check_discard, + ColumnAndShifts::indexed_tree_check_public_inputs_index, + ColumnAndShifts::indexed_tree_check_tree_height, + ColumnAndShifts::indexed_tree_check_sel_silo }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.cpp deleted file mode 100644 index d18e3b654ae3..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.cpp +++ /dev/null @@ -1,37 +0,0 @@ -// AUTOGENERATED FILE -#include "barretenberg/flavor/relation_definitions.hpp" -#include "barretenberg/vm2/constraining/flavor.hpp" -#include "barretenberg/vm2/constraining/full_row.hpp" -#include "barretenberg/vm2/constraining/recursion/recursive_flavor.hpp" -#include "barretenberg/vm2/constraining/relations/interactions_base_impl.hpp" - -#define AvmCheckCircuitEdge(Flavor) Flavor::PolynomialEntitiesAtFixedRow -#define AvmCheckRelationEdge(Flavor) ::bb::avm2::AvmFullRowProxy - -#define ACCUMULATE_FOR_LOOKUP(...) _ACCUMULATE_FOR_LOOKUP(__VA_ARGS__) -#define _ACCUMULATE_FOR_LOOKUP(RelationName, Flavor, AccumulatorType, EdgeType) \ - template void RelationName::accumulate::AccumulatorType, EdgeType(Flavor)>( \ - RelationName::AccumulatorType&, \ - EdgeType(Flavor) const&, \ - RelationParameters const&, \ - Flavor::FF const&); - -#define INSTANTIATE_LOOKUP(RelationName) \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckTupleOfUnivariatesOverSubrelations, ExtendedEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, AvmCheckCircuitEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, AvmCheckRelationEdge); \ - ACCUMULATE_FOR_LOOKUP(RelationName, AvmRecursiveFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); - -namespace bb::avm2 { - -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_silo_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_relation); -INSTANTIATE_LOOKUP(lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_relation); - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.hpp deleted file mode 100644 index b1fcd7b69815..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.hpp +++ /dev/null @@ -1,266 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include -#include -#include - -#include "../columns.hpp" -#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" -#include "barretenberg/vm2/constraining/relations/interactions_base.hpp" - -namespace bb::avm2 { - -/////////////////// lookup_written_public_data_slots_tree_check_silo_poseidon2 /////////////////// - -struct lookup_written_public_data_slots_tree_check_silo_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_SILO_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_sel; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_written_public_data_slots_tree_check_silo_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_written_public_data_slots_tree_check_silo_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_siloing_separator, - ColumnAndShifts::written_public_data_slots_tree_check_address, - ColumnAndShifts::written_public_data_slots_tree_check_slot, - ColumnAndShifts::written_public_data_slots_tree_check_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_written_public_data_slots_tree_check_silo_poseidon2_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_silo_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_low_leaf_poseidon2 /////////////////// - -struct lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_LOW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_sel; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_next_slot, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_next_index, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_hash, - ColumnAndShifts::written_public_data_slots_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_low_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2 /////////////////// - -struct lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_UPDATED_LOW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_should_insert; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = - Column::lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_counts; - static constexpr Column INVERSES = - Column::lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_updated_low_leaf_next_slot, - ColumnAndShifts::written_public_data_slots_tree_check_updated_low_leaf_next_index, - ColumnAndShifts::written_public_data_slots_tree_check_updated_low_leaf_hash, - ColumnAndShifts::written_public_data_slots_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_updated_low_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_low_leaf_merkle_check /////////////////// - -struct lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_LOW_LEAF_MERKLE_CHECK"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_sel; - static constexpr Column DST_SELECTOR = Column::merkle_check_start; - static constexpr Column COUNTS = Column::lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_counts; - static constexpr Column INVERSES = Column::lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_should_insert, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_hash, - ColumnAndShifts::written_public_data_slots_tree_check_updated_low_leaf_hash, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_index, - ColumnAndShifts::written_public_data_slots_tree_check_tree_height, - ColumnAndShifts::written_public_data_slots_tree_check_root, - ColumnAndShifts::written_public_data_slots_tree_check_intermediate_root - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, - ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, - ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, - ColumnAndShifts::merkle_check_write_root - }; -}; - -using lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_low_leaf_merkle_check_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_low_leaf_slot_validation /////////////////// - -struct lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_LOW_LEAF_SLOT_VALIDATION"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_leaf_not_exists; - static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; - static constexpr Column COUNTS = - Column::lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_counts; - static constexpr Column INVERSES = Column::lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_sel - }; - static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, - ColumnAndShifts::ff_gt_b, - ColumnAndShifts::ff_gt_result }; -}; - -using lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_low_leaf_slot_validation_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation /////////////////// - -struct lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_settings_ { - static constexpr std::string_view NAME = - "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_LOW_LEAF_NEXT_SLOT_VALIDATION"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 3; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_next_slot_is_nonzero; - static constexpr Column DST_SELECTOR = Column::ff_gt_sel_gt; - static constexpr Column COUNTS = - Column::lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_counts; - static constexpr Column INVERSES = - Column::lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_next_slot, - ColumnAndShifts::written_public_data_slots_tree_check_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_sel - }; - static constexpr std::array DST_COLUMNS = { ColumnAndShifts::ff_gt_a, - ColumnAndShifts::ff_gt_b, - ColumnAndShifts::ff_gt_result }; -}; - -using lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_low_leaf_next_slot_validation_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_new_leaf_poseidon2 /////////////////// - -struct lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_NEW_LEAF_POSEIDON2"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 5; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_should_insert; - static constexpr Column DST_SELECTOR = Column::poseidon2_hash_start; - static constexpr Column COUNTS = Column::lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_counts; - static constexpr Column INVERSES = Column::lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_leaf_slot, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_next_slot, - ColumnAndShifts::written_public_data_slots_tree_check_low_leaf_next_index, - ColumnAndShifts::written_public_data_slots_tree_check_new_leaf_hash, - ColumnAndShifts::written_public_data_slots_tree_check_const_three - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::poseidon2_hash_input_0, - ColumnAndShifts::poseidon2_hash_input_1, - ColumnAndShifts::poseidon2_hash_input_2, - ColumnAndShifts::poseidon2_hash_output, - ColumnAndShifts::poseidon2_hash_input_len - }; -}; - -using lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_new_leaf_poseidon2_relation = - lookup_relation_base; - -/////////////////// lookup_written_public_data_slots_tree_check_new_leaf_merkle_check /////////////////// - -struct lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_settings_ { - static constexpr std::string_view NAME = "LOOKUP_WRITTEN_PUBLIC_DATA_SLOTS_TREE_CHECK_NEW_LEAF_MERKLE_CHECK"; - static constexpr std::string_view RELATION_NAME = "written_public_data_slots_tree_check"; - static constexpr size_t LOOKUP_TUPLE_SIZE = 7; - static constexpr Column SRC_SELECTOR = Column::written_public_data_slots_tree_check_should_insert; - static constexpr Column DST_SELECTOR = Column::merkle_check_start; - static constexpr Column COUNTS = Column::lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_counts; - static constexpr Column INVERSES = Column::lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_inv; - static constexpr std::array SRC_COLUMNS = { - ColumnAndShifts::written_public_data_slots_tree_check_sel, - ColumnAndShifts::precomputed_zero, - ColumnAndShifts::written_public_data_slots_tree_check_new_leaf_hash, - ColumnAndShifts::written_public_data_slots_tree_check_tree_size_before_write, - ColumnAndShifts::written_public_data_slots_tree_check_tree_height, - ColumnAndShifts::written_public_data_slots_tree_check_intermediate_root, - ColumnAndShifts::written_public_data_slots_tree_check_write_root - }; - static constexpr std::array DST_COLUMNS = { - ColumnAndShifts::merkle_check_write, ColumnAndShifts::merkle_check_read_node, - ColumnAndShifts::merkle_check_write_node, ColumnAndShifts::merkle_check_index, - ColumnAndShifts::merkle_check_path_len, ColumnAndShifts::merkle_check_read_root, - ColumnAndShifts::merkle_check_write_root - }; -}; - -using lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_settings = - lookup_settings; -template -using lookup_written_public_data_slots_tree_check_new_leaf_merkle_check_relation = - lookup_relation_base; - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check.cpp deleted file mode 100644 index 6f2233f9287d..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check.cpp +++ /dev/null @@ -1,28 +0,0 @@ -// AUTOGENERATED FILE -#include "barretenberg/flavor/relation_definitions.hpp" -#include "barretenberg/vm2/constraining/flavor.hpp" -#include "barretenberg/vm2/constraining/full_row.hpp" -#include "barretenberg/vm2/constraining/recursion/recursive_flavor.hpp" -#include "barretenberg/vm2/generated/relations/nullifier_check_impl.hpp" - -#define AvmCheckCircuitEdge(Flavor) Flavor::PolynomialEntitiesAtFixedRow -#define AvmCheckRelationEdge(Flavor) ::bb::avm2::AvmFullRowProxy - -namespace bb::avm2 { - -template class nullifier_checkImpl; -ACCUMULATE(nullifier_checkImpl, AvmFlavor, SumcheckTupleOfUnivariatesOverSubrelations, ExtendedEdge); // Prover. -ACCUMULATE(nullifier_checkImpl, AvmFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); // Verifier. -ACCUMULATE(nullifier_checkImpl, - AvmFlavor, - SumcheckArrayOfValuesOverSubrelations, - AvmCheckCircuitEdge); // Check circuit. -ACCUMULATE(nullifier_checkImpl, - AvmFlavor, - SumcheckArrayOfValuesOverSubrelations, - AvmCheckRelationEdge); // Check relation (tests). - -template class nullifier_checkImpl; -ACCUMULATE(nullifier_checkImpl, AvmRecursiveFlavor, SumcheckArrayOfValuesOverSubrelations, EvaluationEdge); // Verifier. - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check_impl.hpp deleted file mode 100644 index 1b5ef3934d3f..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_check_impl.hpp +++ /dev/null @@ -1,169 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include "barretenberg/vm2/constraining/relations/relation_macros.hpp" -#include "barretenberg/vm2/generated/relations/nullifier_check.hpp" - -namespace bb::avm2 { - -template -template -void nullifier_checkImpl::accumulate(ContainerOverSubrelations& evals, - const AllEntities& in, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF_& scaling_factor) -{ - using C = ColumnAndShifts; - - const auto constants_NULLIFIER_TREE_HEIGHT = FF(42); - const auto constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX = FF(450); - const auto constants_DOM_SEP__SILOED_NULLIFIER = FF(57496191); - const auto nullifier_check_NULLIFIER_LOW_LEAF_NULLIFIER_DIFF = - (in.get(C::nullifier_check_siloed_nullifier) - in.get(C::nullifier_check_low_leaf_nullifier)); - const auto nullifier_check_NEXT_NULLIFIER_IS_ZERO = (FF(1) - in.get(C::nullifier_check_next_nullifier_is_nonzero)); - - { - using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel)) * - (FF(1) - static_cast(in.get(C::nullifier_check_sel))); - std::get<0>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_write)) * - (FF(1) - static_cast(in.get(C::nullifier_check_write))); - std::get<1>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_write)) * - (FF(1) - static_cast(in.get(C::nullifier_check_sel))); - std::get<2>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_exists)) * - (FF(1) - static_cast(in.get(C::nullifier_check_exists))); - std::get<3>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel_silo)) * - (FF(1) - static_cast(in.get(C::nullifier_check_sel_silo))); - std::get<4>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_discard)) * - (FF(1) - static_cast(in.get(C::nullifier_check_discard))); - std::get<5>(evals) += (tmp * scaling_factor); - } - { // PASSTHROUGH_SILOING - using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; - auto tmp = (FF(1) - static_cast(in.get(C::nullifier_check_sel_silo))) * - (static_cast(in.get(C::nullifier_check_nullifier)) - - static_cast(in.get(C::nullifier_check_siloed_nullifier))); - std::get<6>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel)) * - (CView(constants_DOM_SEP__SILOED_NULLIFIER) - - static_cast(in.get(C::nullifier_check_siloing_separator))); - std::get<7>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel)) * - (static_cast(in.get(C::nullifier_check_const_three)) - FF(3)); - std::get<8>(evals) += (tmp * scaling_factor); - } - { // EXISTS_CHECK - using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; - auto tmp = - static_cast(in.get(C::nullifier_check_sel)) * - ((CView(nullifier_check_NULLIFIER_LOW_LEAF_NULLIFIER_DIFF) * - (static_cast(in.get(C::nullifier_check_exists)) * - (FF(1) - static_cast(in.get(C::nullifier_check_nullifier_low_leaf_nullifier_diff_inv))) + - static_cast(in.get(C::nullifier_check_nullifier_low_leaf_nullifier_diff_inv))) - - FF(1)) + - static_cast(in.get(C::nullifier_check_exists))); - std::get<9>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::nullifier_check_leaf_not_exists)) - - static_cast(in.get(C::nullifier_check_sel)) * - (FF(1) - static_cast(in.get(C::nullifier_check_exists)))); - std::get<10>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_next_nullifier_is_nonzero)) * - (FF(1) - static_cast(in.get(C::nullifier_check_next_nullifier_is_nonzero))); - std::get<11>(evals) += (tmp * scaling_factor); - } - { // NEXT_NULLIFIER_IS_ZERO_CHECK - using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_leaf_not_exists)) * - ((static_cast(in.get(C::nullifier_check_low_leaf_next_nullifier)) * - (CView(nullifier_check_NEXT_NULLIFIER_IS_ZERO) * - (FF(1) - static_cast(in.get(C::nullifier_check_next_nullifier_inv))) + - static_cast(in.get(C::nullifier_check_next_nullifier_inv))) - - FF(1)) + - CView(nullifier_check_NEXT_NULLIFIER_IS_ZERO)); - std::get<12>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::nullifier_check_sel_insert)) - - static_cast(in.get(C::nullifier_check_write)) * - (FF(1) - static_cast(in.get(C::nullifier_check_exists)))); - std::get<13>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_write)) * - static_cast(in.get(C::nullifier_check_exists)) * - (static_cast(in.get(C::nullifier_check_root)) - - static_cast(in.get(C::nullifier_check_write_root))); - std::get<14>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel_insert)) * - (static_cast(in.get(C::nullifier_check_tree_size_before_write)) - - static_cast(in.get(C::nullifier_check_updated_low_leaf_next_index))); - std::get<15>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel_insert)) * - (static_cast(in.get(C::nullifier_check_siloed_nullifier)) - - static_cast(in.get(C::nullifier_check_updated_low_leaf_next_nullifier))); - std::get<16>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel)) * - (static_cast(in.get(C::nullifier_check_tree_height)) - CView(constants_NULLIFIER_TREE_HEIGHT)); - std::get<17>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::nullifier_check_sel_write_to_public_inputs)) - - static_cast(in.get(C::nullifier_check_sel_insert)) * - (FF(1) - static_cast(in.get(C::nullifier_check_discard)))); - std::get<18>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::nullifier_check_sel_write_to_public_inputs)) * - ((CView(constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX) + - static_cast(in.get(C::nullifier_check_nullifier_index))) - - static_cast(in.get(C::nullifier_check_public_inputs_index))); - std::get<19>(evals) += (tmp * scaling_factor); - } -} - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_exists.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_exists.hpp index ace228e78830..bcc37d8cbfd3 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_exists.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/nullifier_exists.hpp @@ -14,7 +14,7 @@ template class nullifier_existsImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3 }; + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3 }; template inline static bool skip(const AllEntities& in) { @@ -35,7 +35,7 @@ template class nullifier_exists : public Relation::accumulate(ContainerOverSubrelations& evals, { using C = ColumnAndShifts; + const auto constants_NULLIFIER_TREE_HEIGHT = FF(42); const auto constants_MEM_TAG_U1 = FF(1); - { // NULLIFIER_EXISTS_U1_OUTPUT_TAG + { using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View; + auto tmp = + static_cast(in.get(C::execution_sel_execute_nullifier_exists)) * + (static_cast(in.get(C::execution_nullifier_tree_height)) - CView(constants_NULLIFIER_TREE_HEIGHT)); + std::get<0>(evals) += (tmp * scaling_factor); + } + { // NULLIFIER_EXISTS_U1_OUTPUT_TAG + using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::execution_sel_execute_nullifier_exists)) * (CView(constants_MEM_TAG_U1) - static_cast(in.get(C::execution_mem_tag_reg_1_))); - std::get<0>(evals) += (tmp * scaling_factor); + std::get<1>(evals) += (tmp * scaling_factor); } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/relations_impls.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/relations_impls.hpp index a38ae9b987a5..186a71f52a3c 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/relations_impls.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/relations_impls.hpp @@ -30,6 +30,7 @@ #include "barretenberg/vm2/generated/relations/get_contract_instance_impl.hpp" #include "barretenberg/vm2/generated/relations/get_env_var_impl.hpp" #include "barretenberg/vm2/generated/relations/gt_impl.hpp" +#include "barretenberg/vm2/generated/relations/indexed_tree_check_impl.hpp" #include "barretenberg/vm2/generated/relations/instr_fetching_impl.hpp" #include "barretenberg/vm2/generated/relations/internal_call_impl.hpp" #include "barretenberg/vm2/generated/relations/internal_call_stack_impl.hpp" @@ -41,7 +42,6 @@ #include "barretenberg/vm2/generated/relations/merkle_check_impl.hpp" #include "barretenberg/vm2/generated/relations/note_hash_tree_check_impl.hpp" #include "barretenberg/vm2/generated/relations/notehash_exists_impl.hpp" -#include "barretenberg/vm2/generated/relations/nullifier_check_impl.hpp" #include "barretenberg/vm2/generated/relations/nullifier_exists_impl.hpp" #include "barretenberg/vm2/generated/relations/poseidon2_hash_impl.hpp" #include "barretenberg/vm2/generated/relations/poseidon2_mem_impl.hpp" @@ -49,7 +49,6 @@ #include "barretenberg/vm2/generated/relations/public_data_squash_impl.hpp" #include "barretenberg/vm2/generated/relations/range_check_impl.hpp" #include "barretenberg/vm2/generated/relations/registers_impl.hpp" -#include "barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check_impl.hpp" #include "barretenberg/vm2/generated/relations/scalar_mul_impl.hpp" #include "barretenberg/vm2/generated/relations/send_l2_to_l1_msg_impl.hpp" #include "barretenberg/vm2/generated/relations/sha256_impl.hpp" @@ -62,7 +61,6 @@ #include "barretenberg/vm2/generated/relations/tx_discard_impl.hpp" #include "barretenberg/vm2/generated/relations/tx_impl.hpp" #include "barretenberg/vm2/generated/relations/update_check_impl.hpp" -#include "barretenberg/vm2/generated/relations/written_public_data_slots_tree_check_impl.hpp" // Optimized Relations #include "barretenberg/vm2/optimized/relations/poseidon2_perm_impl.hpp" diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.hpp deleted file mode 100644 index 732330c893da..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.hpp +++ /dev/null @@ -1,53 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include - -#include "barretenberg/common/bb_bench.hpp" -#include "barretenberg/relations/relation_parameters.hpp" -#include "barretenberg/relations/relation_types.hpp" -#include "barretenberg/vm2/generated/columns.hpp" - -namespace bb::avm2 { - -template class retrieved_bytecodes_tree_checkImpl { - public: - using FF = FF_; - - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 4, 2, 3, 3, 3, 3, 5, 3, 5 }; - - template inline static bool skip(const AllEntities& in) - { - using C = ColumnAndShifts; - - return (in.get(C::retrieved_bytecodes_tree_check_sel)).is_zero(); - } - - template - void static accumulate(ContainerOverSubrelations& evals, - const AllEntities& in, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF& scaling_factor); -}; - -template class retrieved_bytecodes_tree_check : public Relation> { - public: - static constexpr const std::string_view NAME = "retrieved_bytecodes_tree_check"; - - // Subrelation indices constants, to be used in tests. - static constexpr size_t SR_EXISTS_CHECK = 10; - static constexpr size_t SR_NEXT_CLASS_ID_IS_ZERO_CHECK = 12; - - static std::string get_subrelation_label(size_t index) - { - switch (index) { - case SR_EXISTS_CHECK: - return "EXISTS_CHECK"; - case SR_NEXT_CLASS_ID_IS_ZERO_CHECK: - return "NEXT_CLASS_ID_IS_ZERO_CHECK"; - } - return std::to_string(index); - } -}; - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check_impl.hpp deleted file mode 100644 index 4a01d375cfad..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check_impl.hpp +++ /dev/null @@ -1,126 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include "barretenberg/vm2/constraining/relations/relation_macros.hpp" -#include "barretenberg/vm2/generated/relations/retrieved_bytecodes_tree_check.hpp" - -namespace bb::avm2 { - -template -template -void retrieved_bytecodes_tree_checkImpl::accumulate(ContainerOverSubrelations& evals, - const AllEntities& in, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF_& scaling_factor) -{ - using C = ColumnAndShifts; - - const auto constants_AVM_RETRIEVED_BYTECODES_TREE_HEIGHT = FF(5); - const auto retrieved_bytecodes_tree_check_EXISTS = - (FF(1) - in.get(C::retrieved_bytecodes_tree_check_leaf_not_exists)); - const auto retrieved_bytecodes_tree_check_CLASS_ID_LOW_LEAF_CLASS_ID_DIFF = - (in.get(C::retrieved_bytecodes_tree_check_class_id) - - in.get(C::retrieved_bytecodes_tree_check_low_leaf_class_id)); - const auto retrieved_bytecodes_tree_check_NEXT_CLASS_ID_IS_ZERO = - (FF(1) - in.get(C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero)); - - { - using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_sel)) * - (FF(1) - static_cast(in.get(C::retrieved_bytecodes_tree_check_sel))); - std::get<0>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_write)) * - (FF(1) - static_cast(in.get(C::retrieved_bytecodes_tree_check_write))); - std::get<1>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_leaf_not_exists)) * - (FF(1) - static_cast(in.get(C::retrieved_bytecodes_tree_check_leaf_not_exists))); - std::get<2>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::retrieved_bytecodes_tree_check_should_insert)) - - static_cast(in.get(C::retrieved_bytecodes_tree_check_write)) * - static_cast(in.get(C::retrieved_bytecodes_tree_check_leaf_not_exists))); - std::get<3>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_write)) * - CView(retrieved_bytecodes_tree_check_EXISTS) * - (static_cast(in.get(C::retrieved_bytecodes_tree_check_root)) - - static_cast(in.get(C::retrieved_bytecodes_tree_check_write_root))); - std::get<4>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::retrieved_bytecodes_tree_check_tree_size_after_write)) - - (static_cast(in.get(C::retrieved_bytecodes_tree_check_tree_size_before_write)) + - static_cast(in.get(C::retrieved_bytecodes_tree_check_should_insert)))); - std::get<5>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_should_insert)) * - (static_cast(in.get(C::retrieved_bytecodes_tree_check_tree_size_before_write)) - - static_cast(in.get(C::retrieved_bytecodes_tree_check_updated_low_leaf_next_index))); - std::get<6>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_should_insert)) * - (static_cast(in.get(C::retrieved_bytecodes_tree_check_class_id)) - - static_cast(in.get(C::retrieved_bytecodes_tree_check_updated_low_leaf_next_class_id))); - std::get<7>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_sel)) * - (CView(constants_AVM_RETRIEVED_BYTECODES_TREE_HEIGHT) - - static_cast(in.get(C::retrieved_bytecodes_tree_check_tree_height))); - std::get<8>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_sel)) * - (static_cast(in.get(C::retrieved_bytecodes_tree_check_const_three)) - FF(3)); - std::get<9>(evals) += (tmp * scaling_factor); - } - { // EXISTS_CHECK - using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; - auto tmp = - static_cast(in.get(C::retrieved_bytecodes_tree_check_sel)) * - ((CView(retrieved_bytecodes_tree_check_CLASS_ID_LOW_LEAF_CLASS_ID_DIFF) * - (CView(retrieved_bytecodes_tree_check_EXISTS) * - (FF(1) - static_cast( - in.get(C::retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv))) + - static_cast(in.get(C::retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv))) - - FF(1)) + - CView(retrieved_bytecodes_tree_check_EXISTS)); - std::get<10>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero)) * - (FF(1) - static_cast(in.get(C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero))); - std::get<11>(evals) += (tmp * scaling_factor); - } - { // NEXT_CLASS_ID_IS_ZERO_CHECK - using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::retrieved_bytecodes_tree_check_leaf_not_exists)) * - ((static_cast(in.get(C::retrieved_bytecodes_tree_check_low_leaf_next_class_id)) * - (CView(retrieved_bytecodes_tree_check_NEXT_CLASS_ID_IS_ZERO) * - (FF(1) - static_cast(in.get(C::retrieved_bytecodes_tree_check_next_class_id_inv))) + - static_cast(in.get(C::retrieved_bytecodes_tree_check_next_class_id_inv))) - - FF(1)) + - CView(retrieved_bytecodes_tree_check_NEXT_CLASS_ID_IS_ZERO)); - std::get<12>(evals) += (tmp * scaling_factor); - } -} - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx.hpp index bf84b131b7bd..672f601e67e6 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx.hpp @@ -14,9 +14,9 @@ template class txImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { - 3, 4, 2, 3, 5, 3, 3, 3, 3, 7, 3, 3, 4, 3, 3, 4, 5, 3, 3, 3, 4, 3, 4, 3, 4, 4, 4, 4, 4, 2, 4, - 5, 3, 3, 3, 4, 3, 5, 4, 3, 4, 4, 4, 5, 4, 3, 4, 3, 2, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { + 3, 4, 2, 3, 5, 3, 3, 3, 3, 7, 3, 3, 4, 3, 3, 4, 5, 3, 3, 3, 4, 3, 4, 3, 4, 4, 4, 4, 4, 2, 4, 5, + 3, 3, 3, 4, 3, 5, 4, 3, 3, 3, 4, 4, 4, 5, 4, 3, 4, 3, 2, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; template inline static bool skip(const AllEntities& in) @@ -57,15 +57,15 @@ template class tx : public Relation> { static constexpr size_t SR_INCR_READ_PI_OFFSET = 22; static constexpr size_t SR_MAX_NOTE_HASH_WRITES_REACHED = 31; static constexpr size_t SR_MAX_NULLIFIER_WRITES_REACHED = 37; - static constexpr size_t SR_MAX_L2_L1_MSG_WRITES_REACHED = 43; - static constexpr size_t SR_UPDATE_NUM_L2_TO_L1_MSGS = 46; - static constexpr size_t SR_SEL_ACTIVE_ON_COLLECT_FEE = 47; - static constexpr size_t SR_COMPUTE_FEE = 49; - static constexpr size_t SR_TEARDOWN_GETS_FEE = 50; - static constexpr size_t SR_FEE_ZERO_UNLESS_COLLECT_FEE_OR_TEARDOWN = 51; - static constexpr size_t SR_PAD_NOTE_HASH_TREE = 59; - static constexpr size_t SR_PAD_NULLIFIER_TREE = 60; - static constexpr size_t SR_SEL_ACTIVE_ON_CLEANUP = 61; + static constexpr size_t SR_MAX_L2_L1_MSG_WRITES_REACHED = 45; + static constexpr size_t SR_UPDATE_NUM_L2_TO_L1_MSGS = 48; + static constexpr size_t SR_SEL_ACTIVE_ON_COLLECT_FEE = 49; + static constexpr size_t SR_COMPUTE_FEE = 51; + static constexpr size_t SR_TEARDOWN_GETS_FEE = 52; + static constexpr size_t SR_FEE_ZERO_UNLESS_COLLECT_FEE_OR_TEARDOWN = 53; + static constexpr size_t SR_PAD_NOTE_HASH_TREE = 61; + static constexpr size_t SR_PAD_NULLIFIER_TREE = 62; + static constexpr size_t SR_SEL_ACTIVE_ON_CLEANUP = 63; static std::string get_subrelation_label(size_t index) { diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx_impl.hpp index 8188cb63e09f..77fcad7a9490 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx_impl.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/tx_impl.hpp @@ -15,6 +15,7 @@ void txImpl::accumulate(ContainerOverSubrelations& evals, { using C = ColumnAndShifts; + const auto constants_NULLIFIER_TREE_HEIGHT = FF(42); const auto constants_MAX_NOTE_HASHES_PER_TX = FF(64); const auto constants_MAX_NULLIFIERS_PER_TX = FF(64); const auto constants_MAX_L2_TO_L1_MSGS_PER_TX = FF(8); @@ -23,6 +24,7 @@ void txImpl::accumulate(ContainerOverSubrelations& evals, const auto constants_AVM_TX_PHASE_VALUE_START = FF(0); const auto constants_AVM_TX_PHASE_VALUE_LAST = FF(11); const auto constants_AVM_PUBLIC_INPUTS_FEE_PAYER_ROW_IDX = FF(29); + const auto constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX = FF(450); const auto constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_L2_TO_L1_MSGS_ROW_IDX = FF(514); const auto constants_AVM_PUBLIC_INPUTS_TRANSACTION_FEE_ROW_IDX = FF(4683); const auto constants_DOM_SEP__PUBLIC_STORAGE_MAP_SLOT = FF(4015149901UL); @@ -325,30 +327,44 @@ void txImpl::accumulate(ContainerOverSubrelations& evals, } { using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::tx_should_nullifier_append)) * + ((CView(constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX) + + static_cast(in.get(C::tx_prev_num_nullifiers_emitted))) - + static_cast(in.get(C::tx_write_nullifier_pi_offset))); + std::get<40>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View; + auto tmp = static_cast(in.get(C::tx_should_nullifier_append)) * + (static_cast(in.get(C::tx_nullifier_tree_height)) - CView(constants_NULLIFIER_TREE_HEIGHT)); + std::get<41>(evals) += (tmp * scaling_factor); + } + { + using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_should_nullifier_append)) * (FF(1) - static_cast(in.get(C::tx_reverted))) * ((static_cast(in.get(C::tx_prev_nullifier_tree_size)) + FF(1)) - static_cast(in.get(C::tx_next_nullifier_tree_size))); - std::get<40>(evals) += (tmp * scaling_factor); + std::get<42>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_should_nullifier_append)) * (FF(1) - static_cast(in.get(C::tx_reverted))) * ((static_cast(in.get(C::tx_prev_num_nullifiers_emitted)) + FF(1)) - static_cast(in.get(C::tx_next_num_nullifiers_emitted))); - std::get<41>(evals) += (tmp * scaling_factor); + std::get<43>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::tx_should_try_l2_l1_msg_append)) - static_cast(in.get(C::tx_sel)) * (FF(1) - static_cast(in.get(C::tx_is_padded))) * (static_cast(in.get(C::tx_sel_revertible_append_l2_l1_msg)) + static_cast(in.get(C::tx_sel_non_revertible_append_l2_l1_msg)))); - std::get<42>(evals) += (tmp * scaling_factor); + std::get<44>(evals) += (tmp * scaling_factor); } { // MAX_L2_L1_MSG_WRITES_REACHED - using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_should_try_l2_l1_msg_append)) * ((CView(tx_REMAINING_L2_TO_L1_MSG_WRITES) * (static_cast(in.get(C::tx_reverted)) * @@ -356,134 +372,134 @@ void txImpl::accumulate(ContainerOverSubrelations& evals, static_cast(in.get(C::tx_remaining_side_effects_inv))) - FF(1)) + static_cast(in.get(C::tx_reverted))); - std::get<43>(evals) += (tmp * scaling_factor); + std::get<45>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<46, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::tx_should_l2_l1_msg_append)) - static_cast(in.get(C::tx_should_try_l2_l1_msg_append)) * (FF(1) - static_cast(in.get(C::tx_reverted))) * (FF(1) - static_cast(in.get(C::tx_discard)))); - std::get<44>(evals) += (tmp * scaling_factor); + std::get<46>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<47, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_should_l2_l1_msg_append)) * ((CView(constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_L2_TO_L1_MSGS_ROW_IDX) + static_cast(in.get(C::tx_prev_num_l2_to_l1_messages))) - static_cast(in.get(C::tx_write_pi_offset))); - std::get<45>(evals) += (tmp * scaling_factor); + std::get<47>(evals) += (tmp * scaling_factor); } { // UPDATE_NUM_L2_TO_L1_MSGS - using View = typename std::tuple_element_t<46, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<48, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_should_try_l2_l1_msg_append)) * (FF(1) - static_cast(in.get(C::tx_reverted))) * ((static_cast(in.get(C::tx_prev_num_l2_to_l1_messages)) + FF(1)) - static_cast(in.get(C::tx_next_num_l2_to_l1_messages))); - std::get<46>(evals) += (tmp * scaling_factor); + std::get<48>(evals) += (tmp * scaling_factor); } { // SEL_ACTIVE_ON_COLLECT_FEE - using View = typename std::tuple_element_t<47, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<49, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (FF(1) - static_cast(in.get(C::tx_sel))); - std::get<47>(evals) += (tmp * scaling_factor); + std::get<49>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<48, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<50, ContainerOverSubrelations>::View; auto tmp = (static_cast(in.get(C::tx_fee_payer_pi_offset)) - static_cast(in.get(C::tx_is_collect_fee)) * CView(constants_AVM_PUBLIC_INPUTS_FEE_PAYER_ROW_IDX)); - std::get<48>(evals) += (tmp * scaling_factor); + std::get<50>(evals) += (tmp * scaling_factor); } { // COMPUTE_FEE - using View = typename std::tuple_element_t<49, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<51, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * ((static_cast(in.get(C::tx_effective_fee_per_da_gas)) * static_cast(in.get(C::tx_prev_da_gas_used)) + static_cast(in.get(C::tx_effective_fee_per_l2_gas)) * static_cast(in.get(C::tx_prev_l2_gas_used))) - static_cast(in.get(C::tx_fee))); - std::get<49>(evals) += (tmp * scaling_factor); + std::get<51>(evals) += (tmp * scaling_factor); } { // TEARDOWN_GETS_FEE - using View = typename std::tuple_element_t<50, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<52, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_teardown)) * (FF(1) - static_cast(in.get(C::tx_is_padded))) * (static_cast(in.get(C::tx_fee_shift)) - static_cast(in.get(C::tx_fee))); - std::get<50>(evals) += (tmp * scaling_factor); + std::get<52>(evals) += (tmp * scaling_factor); } { // FEE_ZERO_UNLESS_COLLECT_FEE_OR_TEARDOWN - using View = typename std::tuple_element_t<51, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<53, ContainerOverSubrelations>::View; auto tmp = (FF(1) - static_cast(in.get(C::tx_is_collect_fee))) * (FF(1) - static_cast(in.get(C::tx_is_teardown))) * static_cast(in.get(C::tx_fee)); - std::get<51>(evals) += (tmp * scaling_factor); + std::get<53>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<52, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<54, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (CView(constants_FEE_JUICE_ADDRESS) - static_cast(in.get(C::tx_fee_juice_contract_address))); - std::get<52>(evals) += (tmp * scaling_factor); + std::get<54>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<53, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<55, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (CView(constants_FEE_JUICE_BALANCES_SLOT) - static_cast(in.get(C::tx_fee_juice_balances_slot_constant))); - std::get<53>(evals) += (tmp * scaling_factor); + std::get<55>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<54, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<56, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (CView(constants_DOM_SEP__PUBLIC_STORAGE_MAP_SLOT) - static_cast(in.get(C::tx_dom_sep_public_storage_map_slot))); - std::get<54>(evals) += (tmp * scaling_factor); + std::get<56>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<55, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<57, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (static_cast(in.get(C::tx_const_three)) - FF(3)); - std::get<55>(evals) += (tmp * scaling_factor); + std::get<57>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<56, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<58, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * ((static_cast(in.get(C::tx_fee_payer_balance)) - static_cast(in.get(C::tx_fee))) - static_cast(in.get(C::tx_fee_payer_new_balance))); - std::get<56>(evals) += (tmp * scaling_factor); + std::get<58>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<57, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<59, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (static_cast(in.get(C::tx_uint32_max)) - FF(4294967295UL)); - std::get<57>(evals) += (tmp * scaling_factor); + std::get<59>(evals) += (tmp * scaling_factor); } { - using View = typename std::tuple_element_t<58, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<60, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_collect_fee)) * (CView(constants_AVM_PUBLIC_INPUTS_TRANSACTION_FEE_ROW_IDX) - static_cast(in.get(C::tx_write_pi_offset))); - std::get<58>(evals) += (tmp * scaling_factor); + std::get<60>(evals) += (tmp * scaling_factor); } { // PAD_NOTE_HASH_TREE - using View = typename std::tuple_element_t<59, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<61, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_tree_padding)) * (((static_cast(in.get(C::tx_prev_note_hash_tree_size)) + CView(constants_MAX_NOTE_HASHES_PER_TX)) - static_cast(in.get(C::tx_prev_num_note_hashes_emitted))) - static_cast(in.get(C::tx_next_note_hash_tree_size))); - std::get<59>(evals) += (tmp * scaling_factor); + std::get<61>(evals) += (tmp * scaling_factor); } { // PAD_NULLIFIER_TREE - using View = typename std::tuple_element_t<60, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<62, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_tree_padding)) * (((static_cast(in.get(C::tx_prev_nullifier_tree_size)) + CView(constants_MAX_NULLIFIERS_PER_TX)) - static_cast(in.get(C::tx_prev_num_nullifiers_emitted))) - static_cast(in.get(C::tx_next_nullifier_tree_size))); - std::get<60>(evals) += (tmp * scaling_factor); + std::get<62>(evals) += (tmp * scaling_factor); } { // SEL_ACTIVE_ON_CLEANUP - using View = typename std::tuple_element_t<61, ContainerOverSubrelations>::View; + using View = typename std::tuple_element_t<63, ContainerOverSubrelations>::View; auto tmp = static_cast(in.get(C::tx_is_cleanup)) * (FF(1) - static_cast(in.get(C::tx_sel))); - std::get<61>(evals) += (tmp * scaling_factor); + std::get<63>(evals) += (tmp * scaling_factor); } } diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.cpp deleted file mode 100644 index 638f4ded4abc..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.cpp +++ /dev/null @@ -1,37 +0,0 @@ -// AUTOGENERATED FILE -#include "barretenberg/flavor/relation_definitions.hpp" -#include "barretenberg/vm2/constraining/flavor.hpp" -#include "barretenberg/vm2/constraining/full_row.hpp" -#include "barretenberg/vm2/constraining/recursion/recursive_flavor.hpp" -#include "barretenberg/vm2/generated/relations/written_public_data_slots_tree_check_impl.hpp" - -#define AvmCheckCircuitEdge(Flavor) Flavor::PolynomialEntitiesAtFixedRow -#define AvmCheckRelationEdge(Flavor) ::bb::avm2::AvmFullRowProxy - -namespace bb::avm2 { - -template class written_public_data_slots_tree_checkImpl; -ACCUMULATE(written_public_data_slots_tree_checkImpl, - AvmFlavor, - SumcheckTupleOfUnivariatesOverSubrelations, - ExtendedEdge); // Prover. -ACCUMULATE(written_public_data_slots_tree_checkImpl, - AvmFlavor, - SumcheckArrayOfValuesOverSubrelations, - EvaluationEdge); // Verifier. -ACCUMULATE(written_public_data_slots_tree_checkImpl, - AvmFlavor, - SumcheckArrayOfValuesOverSubrelations, - AvmCheckCircuitEdge); // Check circuit. -ACCUMULATE(written_public_data_slots_tree_checkImpl, - AvmFlavor, - SumcheckArrayOfValuesOverSubrelations, - AvmCheckRelationEdge); // Check relation (tests). - -template class written_public_data_slots_tree_checkImpl; -ACCUMULATE(written_public_data_slots_tree_checkImpl, - AvmRecursiveFlavor, - SumcheckArrayOfValuesOverSubrelations, - EvaluationEdge); // Verifier. - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.hpp deleted file mode 100644 index 12ef57790ee7..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.hpp +++ /dev/null @@ -1,54 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include - -#include "barretenberg/common/bb_bench.hpp" -#include "barretenberg/relations/relation_parameters.hpp" -#include "barretenberg/relations/relation_types.hpp" -#include "barretenberg/vm2/generated/columns.hpp" - -namespace bb::avm2 { - -template class written_public_data_slots_tree_checkImpl { - public: - using FF = FF_; - - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 4, 2, 3, 3, 3, 5, 3, 5 }; - - template inline static bool skip(const AllEntities& in) - { - using C = ColumnAndShifts; - - return (in.get(C::written_public_data_slots_tree_check_sel)).is_zero(); - } - - template - void static accumulate(ContainerOverSubrelations& evals, - const AllEntities& in, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF& scaling_factor); -}; - -template -class written_public_data_slots_tree_check : public Relation> { - public: - static constexpr const std::string_view NAME = "written_public_data_slots_tree_check"; - - // Subrelation indices constants, to be used in tests. - static constexpr size_t SR_EXISTS_CHECK = 11; - static constexpr size_t SR_NEXT_SLOT_IS_ZERO_CHECK = 13; - - static std::string get_subrelation_label(size_t index) - { - switch (index) { - case SR_EXISTS_CHECK: - return "EXISTS_CHECK"; - case SR_NEXT_SLOT_IS_ZERO_CHECK: - return "NEXT_SLOT_IS_ZERO_CHECK"; - } - return std::to_string(index); - } -}; - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check_impl.hpp deleted file mode 100644 index 464543ad0937..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/written_public_data_slots_tree_check_impl.hpp +++ /dev/null @@ -1,135 +0,0 @@ -// AUTOGENERATED FILE -#pragma once - -#include "barretenberg/vm2/constraining/relations/relation_macros.hpp" -#include "barretenberg/vm2/generated/relations/written_public_data_slots_tree_check.hpp" - -namespace bb::avm2 { - -template -template -void written_public_data_slots_tree_checkImpl::accumulate(ContainerOverSubrelations& evals, - const AllEntities& in, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF_& scaling_factor) -{ - using C = ColumnAndShifts; - - const auto constants_AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT = FF(6); - const auto constants_DOM_SEP__PUBLIC_LEAF_SLOT = FF(1247650290); - const auto written_public_data_slots_tree_check_EXISTS = - (FF(1) - in.get(C::written_public_data_slots_tree_check_leaf_not_exists)); - const auto written_public_data_slots_tree_check_SLOT_LOW_LEAF_SLOT_DIFF = - (in.get(C::written_public_data_slots_tree_check_leaf_slot) - - in.get(C::written_public_data_slots_tree_check_low_leaf_slot)); - const auto written_public_data_slots_tree_check_NEXT_SLOT_IS_ZERO = - (FF(1) - in.get(C::written_public_data_slots_tree_check_next_slot_is_nonzero)); - - { - using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_sel)) * - (FF(1) - static_cast(in.get(C::written_public_data_slots_tree_check_sel))); - std::get<0>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_write)) * - (FF(1) - static_cast(in.get(C::written_public_data_slots_tree_check_write))); - std::get<1>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_leaf_not_exists)) * - (FF(1) - static_cast(in.get(C::written_public_data_slots_tree_check_leaf_not_exists))); - std::get<2>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_sel)) * - (CView(constants_DOM_SEP__PUBLIC_LEAF_SLOT) - - static_cast(in.get(C::written_public_data_slots_tree_check_siloing_separator))); - std::get<3>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_sel)) * - (static_cast(in.get(C::written_public_data_slots_tree_check_const_three)) - FF(3)); - std::get<4>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::written_public_data_slots_tree_check_should_insert)) - - static_cast(in.get(C::written_public_data_slots_tree_check_write)) * - static_cast(in.get(C::written_public_data_slots_tree_check_leaf_not_exists))); - std::get<5>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_write)) * - CView(written_public_data_slots_tree_check_EXISTS) * - (static_cast(in.get(C::written_public_data_slots_tree_check_root)) - - static_cast(in.get(C::written_public_data_slots_tree_check_write_root))); - std::get<6>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View; - auto tmp = (static_cast(in.get(C::written_public_data_slots_tree_check_tree_size_after_write)) - - (static_cast(in.get(C::written_public_data_slots_tree_check_tree_size_before_write)) + - static_cast(in.get(C::written_public_data_slots_tree_check_should_insert)))); - std::get<7>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_should_insert)) * - (static_cast(in.get(C::written_public_data_slots_tree_check_tree_size_before_write)) - - static_cast(in.get(C::written_public_data_slots_tree_check_updated_low_leaf_next_index))); - std::get<8>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_should_insert)) * - (static_cast(in.get(C::written_public_data_slots_tree_check_leaf_slot)) - - static_cast(in.get(C::written_public_data_slots_tree_check_updated_low_leaf_next_slot))); - std::get<9>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_sel)) * - (CView(constants_AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT) - - static_cast(in.get(C::written_public_data_slots_tree_check_tree_height))); - std::get<10>(evals) += (tmp * scaling_factor); - } - { // EXISTS_CHECK - using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View; - auto tmp = - static_cast(in.get(C::written_public_data_slots_tree_check_sel)) * - ((CView(written_public_data_slots_tree_check_SLOT_LOW_LEAF_SLOT_DIFF) * - (CView(written_public_data_slots_tree_check_EXISTS) * - (FF(1) - static_cast( - in.get(C::written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv))) + - static_cast(in.get(C::written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv))) - - FF(1)) + - CView(written_public_data_slots_tree_check_EXISTS)); - std::get<11>(evals) += (tmp * scaling_factor); - } - { - using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View; - auto tmp = static_cast(in.get(C::written_public_data_slots_tree_check_next_slot_is_nonzero)) * - (FF(1) - static_cast(in.get(C::written_public_data_slots_tree_check_next_slot_is_nonzero))); - std::get<12>(evals) += (tmp * scaling_factor); - } - { // NEXT_SLOT_IS_ZERO_CHECK - using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View; - auto tmp = - static_cast(in.get(C::written_public_data_slots_tree_check_leaf_not_exists)) * - ((static_cast(in.get(C::written_public_data_slots_tree_check_low_leaf_next_slot)) * - (CView(written_public_data_slots_tree_check_NEXT_SLOT_IS_ZERO) * - (FF(1) - static_cast(in.get(C::written_public_data_slots_tree_check_next_slot_inv))) + - static_cast(in.get(C::written_public_data_slots_tree_check_next_slot_inv))) - - FF(1)) + - CView(written_public_data_slots_tree_check_NEXT_SLOT_IS_ZERO)); - std::get<13>(evals) += (tmp * scaling_factor); - } -} - -} // namespace bb::avm2 diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp index 0144b7f780dd..a258930756c1 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp @@ -16,22 +16,20 @@ #include "barretenberg/vm2/simulation/events/field_gt_event.hpp" #include "barretenberg/vm2/simulation/events/get_contract_instance_event.hpp" #include "barretenberg/vm2/simulation/events/gt_event.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/internal_call_stack_event.hpp" #include "barretenberg/vm2/simulation/events/keccakf1600_event.hpp" #include "barretenberg/vm2/simulation/events/l1_to_l2_message_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/memory_event.hpp" #include "barretenberg/vm2/simulation/events/merkle_check_event.hpp" #include "barretenberg/vm2/simulation/events/note_hash_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/poseidon2_event.hpp" #include "barretenberg/vm2/simulation/events/public_data_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/range_check_event.hpp" -#include "barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/sha256_event.hpp" #include "barretenberg/vm2/simulation/events/to_radix_event.hpp" #include "barretenberg/vm2/simulation/events/tx_events.hpp" #include "barretenberg/vm2/simulation/events/update_check.hpp" -#include "barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp" namespace bb::avm2::simulation { @@ -64,17 +62,15 @@ struct EventsContainer { EventEmitterInterface::Container context_stack; EventEmitterInterface::Container public_data_tree_check_events; EventEmitterInterface::Container update_check_events; - EventEmitterInterface::Container nullifier_tree_check_events; + EventEmitterInterface::Container indexed_tree_check_events; EventEmitterInterface::Container data_copy_events; EventEmitterInterface::Container calldata_events; EventEmitterInterface::Container internal_call_stack_events; EventEmitterInterface::Container note_hash_tree_check_events; - EventEmitterInterface::Container written_public_data_slots_tree_check_events; EventEmitterInterface::Container contract_instance_retrieval_events; EventEmitterInterface::Container get_contract_instance_events; EventEmitterInterface::Container l1_to_l2_msg_tree_check_events; EventEmitterInterface::Container emit_public_log_events; - EventEmitterInterface::Container retrieved_bytecodes_tree_check_events; }; } // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp new file mode 100644 index 000000000000..93cdf3ac34a7 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp @@ -0,0 +1,66 @@ +#pragma once + +#include "barretenberg/vm2/common/field.hpp" +#include "barretenberg/vm2/simulation/events/checkpoint_event_type.hpp" +#include "barretenberg/vm2/simulation/lib/db_types.hpp" + +#include +#include +#include + +namespace bb::avm2::simulation { + +struct IndexedTreeLeafData { + FF value; + FF next_value; + uint64_t next_index; + + bool operator==(const IndexedTreeLeafData& other) const = default; + + std::vector get_hash_inputs() const { return { value, next_value, next_index }; } +}; + +struct IndexedTreeSiloingParameters { + AztecAddress address; + FF siloing_separator; + + bool operator==(const IndexedTreeSiloingParameters& other) const = default; +}; + +struct IndexedLeafSiloingData { + FF siloed_value; + IndexedTreeSiloingParameters parameters; + + bool operator==(const IndexedLeafSiloingData& other) const = default; +}; + +struct IndexedLeafAppendData { + FF updated_low_leaf_hash; + FF new_leaf_hash; + FF intermediate_root; + + bool operator==(const IndexedLeafAppendData& other) const = default; +}; + +struct IndexedTreeReadWriteEvent { + FF value; + AppendOnlyTreeSnapshot prev_snapshot; + AppendOnlyTreeSnapshot next_snapshot; + uint64_t tree_height; + + IndexedTreeLeafData low_leaf_data; + FF low_leaf_hash; + uint64_t low_leaf_index; + + bool write = false; + std::optional siloing_data = std::nullopt; + std::optional public_inputs_index = std::nullopt; + + std::optional append_data = std::nullopt; + + bool operator==(const IndexedTreeReadWriteEvent& other) const = default; +}; + +using IndexedTreeCheckEvent = std::variant; + +} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp deleted file mode 100644 index d7cae82d09c8..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp +++ /dev/null @@ -1,48 +0,0 @@ -#pragma once - -#include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/events/checkpoint_event_type.hpp" -#include "barretenberg/vm2/simulation/lib/db_types.hpp" - -#include -#include -#include - -namespace bb::avm2::simulation { - -struct NullifierSiloingData { - FF siloed_nullifier; - AztecAddress address; - - bool operator==(const NullifierSiloingData& other) const = default; -}; - -struct NullifierAppendData { - FF updated_low_leaf_hash; - FF new_leaf_hash; - FF intermediate_root; - - bool operator==(const NullifierAppendData& other) const = default; -}; - -struct NullifierTreeReadWriteEvent { - FF nullifier; - AppendOnlyTreeSnapshot prev_snapshot; - AppendOnlyTreeSnapshot next_snapshot; - - NullifierTreeLeafPreimage low_leaf_preimage; - FF low_leaf_hash; - uint64_t low_leaf_index; - - bool write = false; - std::optional siloing_data = std::nullopt; - uint64_t nullifier_counter = 0; - - std::optional append_data = std::nullopt; - - bool operator==(const NullifierTreeReadWriteEvent& other) const = default; -}; - -using NullifierTreeCheckEvent = std::variant; - -} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp deleted file mode 100644 index 48b58ff9884a..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp +++ /dev/null @@ -1,37 +0,0 @@ -#pragma once - -#include -#include - -#include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/events/checkpoint_event_type.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" -#include "barretenberg/vm2/simulation/lib/retrieved_bytecodes_tree.hpp" - -namespace bb::avm2::simulation { - -struct RetrievedBytecodeAppendData { - FF updated_low_leaf_hash; - FF new_leaf_hash; - FF intermediate_root; - - bool operator==(const RetrievedBytecodeAppendData& other) const = default; -}; - -struct RetrievedBytecodesTreeCheckEvent { - FF class_id; - AppendOnlyTreeSnapshot prev_snapshot; - AppendOnlyTreeSnapshot next_snapshot; - - RetrievedBytecodesTreeLeafPreimage low_leaf_preimage; - FF low_leaf_hash; - uint64_t low_leaf_index; - - bool write; - - std::optional append_data; - - bool operator==(const RetrievedBytecodesTreeCheckEvent& other) const = default; -}; - -} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp deleted file mode 100644 index 92af93fffa2e..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp +++ /dev/null @@ -1,39 +0,0 @@ -#pragma once - -#include -#include - -#include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/events/checkpoint_event_type.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" -#include "barretenberg/vm2/simulation/lib/written_slots_tree.hpp" - -namespace bb::avm2::simulation { - -struct SlotAppendData { - FF updated_low_leaf_hash; - FF new_leaf_hash; - FF intermediate_root; - - bool operator==(const SlotAppendData& other) const = default; -}; - -struct WrittenPublicDataSlotsTreeCheckEvent { - AztecAddress contract_address; - FF slot; - FF leaf_slot; - AppendOnlyTreeSnapshot prev_snapshot; - AppendOnlyTreeSnapshot next_snapshot; - - WrittenPublicDataSlotsTreeLeafPreimage low_leaf_preimage; - FF low_leaf_hash; - uint64_t low_leaf_index; - - bool write; - - std::optional append_data; - - bool operator==(const WrittenPublicDataSlotsTreeCheckEvent& other) const = default; -}; - -} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp index c55559064544..482f631b9365 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp @@ -1,6 +1,7 @@ #include "barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp" #include "barretenberg/vm2/common/aztec_types.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/simulation/interfaces/db.hpp" #include "barretenberg/vm2/simulation/lib/merkle.hpp" @@ -145,23 +146,32 @@ bool MerkleDB::siloed_nullifier_exists(const FF& nullifier) const bool MerkleDB::nullifier_exists_internal(std::optional contract_address, const FF& nullifier) const { FF siloed_nullifier = nullifier; + std::optional siloing_params = std::nullopt; if (contract_address.has_value()) { // Unconstrained siloing to fetch the hint, since the hints are keyed by siloed data. // The siloing will later be constrained in the nullifier tree check gadget. siloed_nullifier = unconstrained_silo_nullifier(contract_address.value(), nullifier); + siloing_params = IndexedTreeSiloingParameters{ + .address = contract_address.value(), + .siloing_separator = DOM_SEP__SILOED_NULLIFIER, + }; } auto [present, low_leaf_index] = raw_merkle_db.get_low_indexed_leaf(MerkleTreeId::NULLIFIER_TREE, siloed_nullifier); auto low_leaf_path = raw_merkle_db.get_sibling_path(MerkleTreeId::NULLIFIER_TREE, low_leaf_index); auto low_leaf_preimage = raw_merkle_db.get_leaf_preimage_nullifier_tree(low_leaf_index); - nullifier_tree_check.assert_read(nullifier, - contract_address, - present, - low_leaf_preimage, - low_leaf_index, - low_leaf_path, - raw_merkle_db.get_tree_roots().nullifier_tree); + indexed_tree_check.assert_read(nullifier, + siloing_params, + present, + IndexedTreeLeafData{ + .value = low_leaf_preimage.leaf.nullifier, + .next_value = low_leaf_preimage.nextKey, + .next_index = low_leaf_preimage.nextIndex, + }, + low_leaf_index, + low_leaf_path, + raw_merkle_db.get_tree_roots().nullifier_tree); return present; } @@ -180,10 +190,15 @@ void MerkleDB::nullifier_write_internal(std::optional contract_add { uint32_t nullifier_counter = tree_counters_stack.top().nullifier_counter; FF siloed_nullifier = nullifier; + std::optional siloing_params = std::nullopt; if (contract_address.has_value()) { // Unconstrained siloing to fetch the hint, since the hints are keyed by siloed data. // The siloing will later be constrained in the nullifier tree check gadget. siloed_nullifier = unconstrained_silo_nullifier(contract_address.value(), nullifier); + siloing_params = IndexedTreeSiloingParameters{ + .address = contract_address.value(), + .siloing_separator = DOM_SEP__SILOED_NULLIFIER, + }; } auto [present, low_leaf_index] = raw_merkle_db.get_low_indexed_leaf(MerkleTreeId::NULLIFIER_TREE, siloed_nullifier); @@ -204,14 +219,19 @@ void MerkleDB::nullifier_write_internal(std::optional contract_add insertion_path = insertion_result.insertion_witness_data.at(0).path; } - AppendOnlyTreeSnapshot snapshot_after = nullifier_tree_check.write(nullifier, - contract_address, - nullifier_counter, - low_leaf_preimage, - low_leaf_index, - low_leaf_path, - snapshot_before, - insertion_path); + AppendOnlyTreeSnapshot snapshot_after = + indexed_tree_check.write(nullifier, + siloing_params, + nullifier_counter + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX, + IndexedTreeLeafData{ + .value = low_leaf_preimage.leaf.nullifier, + .next_value = low_leaf_preimage.nextKey, + .next_index = low_leaf_preimage.nextIndex, + }, + low_leaf_index, + low_leaf_path, + snapshot_before, + insertion_path); // This will throw an unexpected exception if it fails. BB_ASSERT_EQ(snapshot_after, raw_merkle_db.get_tree_roots().nullifier_tree, "Snapshot after mismatch"); diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp index ced88e5ea18d..decbd1b926e5 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.hpp @@ -4,9 +4,9 @@ #include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/simulation/gadgets/address_derivation.hpp" #include "barretenberg/vm2/simulation/gadgets/class_id_derivation.hpp" +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/gadgets/l1_to_l2_message_tree_check.hpp" #include "barretenberg/vm2/simulation/gadgets/note_hash_tree_check.hpp" -#include "barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp" #include "barretenberg/vm2/simulation/gadgets/public_data_tree_check.hpp" #include "barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp" #include "barretenberg/vm2/simulation/interfaces/db.hpp" @@ -59,13 +59,13 @@ class MerkleDB final : public HighLevelMerkleDBInterface { public: MerkleDB(LowLevelMerkleDBInterface& raw_merkle_db, PublicDataTreeCheckInterface& public_data_tree_check, - NullifierTreeCheckInterface& nullifier_tree_check, + IndexedTreeCheckInterface& indexed_tree_check, NoteHashTreeCheckInterface& note_hash_tree_check, WrittenPublicDataSlotsInterface& written_public_data_slots, L1ToL2MessageTreeCheckInterface& l1_to_l2_msg_tree_check) : raw_merkle_db(raw_merkle_db) , public_data_tree_check(public_data_tree_check) - , nullifier_tree_check(nullifier_tree_check) + , indexed_tree_check(indexed_tree_check) , note_hash_tree_check(note_hash_tree_check) , written_public_data_slots(written_public_data_slots) , l1_to_l2_msg_tree_check(l1_to_l2_msg_tree_check) @@ -113,7 +113,7 @@ class MerkleDB final : public HighLevelMerkleDBInterface { // TODO: when you have a merkle gadget, consider marking it "mutable" so that read can be const. // It's usually ok for mutexes but a gadget is big... PublicDataTreeCheckInterface& public_data_tree_check; - NullifierTreeCheckInterface& nullifier_tree_check; + IndexedTreeCheckInterface& indexed_tree_check; NoteHashTreeCheckInterface& note_hash_tree_check; WrittenPublicDataSlotsInterface& written_public_data_slots; L1ToL2MessageTreeCheckInterface& l1_to_l2_msg_tree_check; diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.cpp new file mode 100644 index 000000000000..6d3bee2d8897 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.cpp @@ -0,0 +1,233 @@ +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" + +#include + +namespace bb::avm2::simulation { + +/** + * @brief Computes the siloed value by hashing the separator, address, and value via Poseidon2. + * + * Siloing binds a value to its originating contract, preventing cross-contract collisions. + * + * @param value The original (inner) value. + * @param siloing_params The siloing parameters (address and domain separator). + * @return The siloed value: Poseidon2(separator, address, value). + */ +FF IndexedTreeCheck::silo(const FF& value, IndexedTreeSiloingParameters siloing_params) +{ + return poseidon2.hash({ siloing_params.siloing_separator, siloing_params.address, value }); +} + +/** + * @brief Validates the low leaf preimage against the target value for membership/non-membership. + * + * In an indexed tree, the low leaf is the largest leaf whose value is less than (or equal to) the + * target. This function validates the low leaf properties to prove either membership (low leaf + * value equals the target) or non-membership (the target falls between the low leaf value and its + * next value). + * + * For membership ( @p exists = true ): the low leaf's value must equal @p value. + * For non-membership ( @p exists = false ): @p value must be greater than the low leaf's value, + * and (if next_value != 0) less than the low leaf's next_value. + * + * @param value The (possibly siloed) value being checked. + * @param low_leaf_preimage The preimage of the low leaf in the indexed tree. + * @param exists True if proving membership, false if proving non-membership. + * @throws std::runtime_error If validation fails. + */ +void IndexedTreeCheck::validate_low_leaf(const FF& value, const IndexedTreeLeafData& low_leaf_preimage, bool exists) +{ + bool low_leaf_matches = low_leaf_preimage.value == value; + // We base the checking on whether the low leaf matches instead of exists, to match PIL behavior. + if (low_leaf_matches) { + if (!exists) { + throw std::runtime_error("Indexed tree non-membership check failed"); + } + } else { + if (!field_gt.ff_gt(value, low_leaf_preimage.value)) { + throw std::runtime_error("Low leaf value is GTE leaf value"); + } + if (low_leaf_preimage.next_value != 0 && !field_gt.ff_gt(low_leaf_preimage.next_value, value)) { + throw std::runtime_error("Leaf value is GTE low leaf next value"); + } + if (exists) { + throw std::runtime_error("Indexed tree membership check failed"); + } + } +} + +/** + * @brief Performs a membership or non-membership read check on an indexed tree. + * + * Verifies whether a value exists or does not exist in a given indexed tree at a given snapshot, + * using the low-leaf membership proof technique. The value is optionally siloed before checking. + * + * The low leaf is proven to be a member of the tree via Merkle proof, then validated against + * the target value according to indexed tree invariants (see validate_low_leaf). + * + * @param source_value The raw (possibly unsiloed) value to check. + * @param siloing_params If present, the value is siloed with this address and separator before checking. + * @param exists True to prove membership, false to prove non-membership. + * @param low_leaf_preimage The preimage of the low leaf. + * @param low_leaf_index The index of the low leaf in the tree. + * @param sibling_path The Merkle sibling path for the low leaf. + * @param snapshot The tree snapshot to verify against. + * @throws std::runtime_error If validation fails. + */ +void IndexedTreeCheck::assert_read(const FF& source_value, + std::optional siloing_params, + bool exists, + const IndexedTreeLeafData& low_leaf_preimage, + uint64_t low_leaf_index, + std::span sibling_path, + const AppendOnlyTreeSnapshot& snapshot) +{ + FF value = source_value; + std::optional siloing_data = std::nullopt; + if (siloing_params.has_value()) { + value = silo(value, siloing_params.value()); + siloing_data = IndexedLeafSiloingData{ + .siloed_value = value, + .parameters = siloing_params.value(), + }; + } + // Low leaf membership + FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); + merkle_check.assert_membership(low_leaf_hash, low_leaf_index, sibling_path, snapshot.root); + + // Low leaf and value validation + validate_low_leaf(value, low_leaf_preimage, exists); + + events.emit(IndexedTreeReadWriteEvent{ + .value = source_value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf_preimage, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + .siloing_data = siloing_data, + }); +} + +/** + * @brief Writes a value into an indexed tree, or validates it already exists. + * + * Handles both new insertions and duplicate writes. If the value already exists in the tree + * ( @p insertion_sibling_path is nullopt), it validates membership. Otherwise, it performs an + * indexed tree insertion by updating the low leaf's next pointer and appending the new leaf. + * + * The value is optionally siloed before insertion. The low leaf is validated via indexed tree + * invariants. For a new insertion, two Merkle writes occur: + * 1. Update the low leaf to point to the new value. + * 2. Insert the new leaf at the next available index. + * + * @param source_value The raw (possibly unsiloed) value to insert. + * @param siloing_params If present, the value is siloed with these parameters before insertion. + * @param public_inputs_index If present, the index into public inputs for this write. + * @param low_leaf_preimage The preimage of the low leaf. + * @param low_leaf_index The index of the low leaf in the tree. + * @param low_leaf_sibling_path The Merkle sibling path for the low leaf. + * @param prev_snapshot The tree snapshot before the write. + * @param insertion_sibling_path If present, the sibling path for inserting a new leaf. If nullopt, + * the value already exists and no insertion occurs. + * @return The updated tree snapshot after the write (unchanged if value already exists). + * @throws std::runtime_error If validation fails. + */ +AppendOnlyTreeSnapshot IndexedTreeCheck::write(const FF& source_value, + std::optional siloing_params, + std::optional public_inputs_index, + const IndexedTreeLeafData& low_leaf_preimage, + uint64_t low_leaf_index, + std::span low_leaf_sibling_path, + const AppendOnlyTreeSnapshot& prev_snapshot, + std::optional> insertion_sibling_path) +{ + FF value = source_value; + std::optional siloing_data = std::nullopt; + if (siloing_params.has_value()) { + value = silo(value, siloing_params.value()); + siloing_data = IndexedLeafSiloingData{ .siloed_value = value, .parameters = siloing_params.value() }; + } + bool exists = !insertion_sibling_path.has_value(); + + // Low leaf validation + validate_low_leaf(value, low_leaf_preimage, exists); + + AppendOnlyTreeSnapshot next_snapshot = prev_snapshot; + std::optional append_data = std::nullopt; + + FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); + + if (exists) { + merkle_check.assert_membership(low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); + } else { + // Low leaf update + IndexedTreeLeafData updated_low_leaf_preimage = low_leaf_preimage; + updated_low_leaf_preimage.next_index = prev_snapshot.next_available_leaf_index; + updated_low_leaf_preimage.next_value = value; + FF updated_low_leaf_hash = poseidon2.hash(updated_low_leaf_preimage.get_hash_inputs()); + + FF intermediate_root = merkle_check.write( + low_leaf_hash, updated_low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); + + // Insertion + IndexedTreeLeafData new_leaf_preimage = { + .value = value, + .next_value = low_leaf_preimage.next_value, + .next_index = low_leaf_preimage.next_index, + }; + + FF new_leaf_hash = poseidon2.hash(new_leaf_preimage.get_hash_inputs()); + + FF write_root = merkle_check.write(FF(0), + new_leaf_hash, + prev_snapshot.next_available_leaf_index, + insertion_sibling_path.value(), + intermediate_root); + + next_snapshot = AppendOnlyTreeSnapshot{ + .root = write_root, + .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1, + }; + append_data = IndexedLeafAppendData{ + .updated_low_leaf_hash = updated_low_leaf_hash, + .new_leaf_hash = new_leaf_hash, + .intermediate_root = intermediate_root, + }; + } + + events.emit(IndexedTreeReadWriteEvent{ .value = source_value, + .prev_snapshot = prev_snapshot, + .next_snapshot = next_snapshot, + .tree_height = low_leaf_sibling_path.size(), + .low_leaf_data = low_leaf_preimage, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + .write = true, + .siloing_data = siloing_data, + .public_inputs_index = public_inputs_index, + .append_data = append_data }); + + return next_snapshot; +} + +/** @brief Emits a checkpoint creation event for the indexed tree. */ +void IndexedTreeCheck::on_checkpoint_created() +{ + events.emit(CheckPointEventType::CREATE_CHECKPOINT); +} + +/** @brief Emits a checkpoint commit event, finalizing pending indexed tree changes. */ +void IndexedTreeCheck::on_checkpoint_committed() +{ + events.emit(CheckPointEventType::COMMIT_CHECKPOINT); +} + +/** @brief Emits a checkpoint revert event, rolling back pending indexed tree changes. */ +void IndexedTreeCheck::on_checkpoint_reverted() +{ + events.emit(CheckPointEventType::REVERT_CHECKPOINT); +} + +} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp new file mode 100644 index 000000000000..0135ef42bddc --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp @@ -0,0 +1,61 @@ +#pragma once + +#include "barretenberg/vm2/common/field.hpp" +#include "barretenberg/vm2/simulation/events/event_emitter.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" +#include "barretenberg/vm2/simulation/interfaces/db.hpp" +#include "barretenberg/vm2/simulation/interfaces/field_gt.hpp" +#include "barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp" +#include "barretenberg/vm2/simulation/interfaces/merkle_check.hpp" +#include "barretenberg/vm2/simulation/interfaces/poseidon2.hpp" +#include "barretenberg/vm2/simulation/lib/db_types.hpp" + +#include +#include +#include + +namespace bb::avm2::simulation { + +class IndexedTreeCheck : public IndexedTreeCheckInterface, public CheckpointNotifiable { + public: + IndexedTreeCheck(Poseidon2Interface& poseidon2, + MerkleCheckInterface& merkle_check, + FieldGreaterThanInterface& field_gt, + EventEmitterInterface& event_emitter) + : events(event_emitter) + , poseidon2(poseidon2) + , merkle_check(merkle_check) + , field_gt(field_gt) + {} + + void assert_read(const FF& value, + std::optional siloing_params, + bool exists, + const IndexedTreeLeafData& low_leaf_preimage, + uint64_t low_leaf_index, + std::span sibling_path, + const AppendOnlyTreeSnapshot& snapshot) override; + AppendOnlyTreeSnapshot write(const FF& value, + std::optional siloing_params, + std::optional public_inputs_index, + const IndexedTreeLeafData& low_leaf_preimage, + uint64_t low_leaf_index, + std::span low_leaf_sibling_path, + const AppendOnlyTreeSnapshot& prev_snapshot, + std::optional> insertion_sibling_path) override; + + void on_checkpoint_created() override; + void on_checkpoint_committed() override; + void on_checkpoint_reverted() override; + + private: + FF silo(const FF& nullifier, IndexedTreeSiloingParameters siloing_params); + void validate_low_leaf(const FF& value, const IndexedTreeLeafData& low_leaf_preimage, bool exists); + + EventEmitterInterface& events; + Poseidon2Interface& poseidon2; + MerkleCheckInterface& merkle_check; + FieldGreaterThanInterface& field_gt; +}; + +} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.test.cpp new file mode 100644 index 000000000000..0dbb4f80bd80 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/indexed_tree_check.test.cpp @@ -0,0 +1,404 @@ +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" + +#include +#include + +#include "barretenberg/crypto/merkle_tree/memory_tree.hpp" +#include "barretenberg/crypto/poseidon2/poseidon2.hpp" +#include "barretenberg/vm2/common/aztec_types.hpp" +#include "barretenberg/vm2/simulation/events/event_emitter.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" +#include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" +#include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" +#include "barretenberg/vm2/testing/macros.hpp" + +namespace bb::avm2::simulation { + +using ::testing::_; +using ::testing::ElementsAre; +using ::testing::Return; +using ::testing::StrictMock; + +using RawPoseidon2 = crypto::Poseidon2; + +namespace { + +TEST(AvmSimulationIndexedTreeCheck, ReadExists) +{ + StrictMock poseidon2; + StrictMock merkle_check; + StrictMock field_gt; + + EventEmitter event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, event_emitter); + + IndexedTreeLeafData low_leaf = { .value = 42, .next_value = 0, .next_index = 0 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 30; + std::vector sibling_path = { 1, 2, 3, 4, 5 }; + AppendOnlyTreeSnapshot snapshot = { .root = 123456, .next_available_leaf_index = 128 }; + + FF value = 42; + + EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(low_leaf_hash)); + EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) + .WillRepeatedly(Return()); + + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot); + + IndexedTreeReadWriteEvent expect_event = { + .value = value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + }; + EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + + // Negative test: value does not exist + EXPECT_THROW_WITH_MESSAGE( + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, false, low_leaf, low_leaf_index, sibling_path, snapshot), + "non-membership check failed"); +} + +TEST(AvmSimulationIndexedTreeCheck, ReadNotExistsLowPointsToInfinity) +{ + StrictMock poseidon2; + StrictMock merkle_check; + StrictMock field_gt; + + EventEmitter event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, event_emitter); + + IndexedTreeLeafData low_leaf = { .value = 40, .next_value = 0, .next_index = 0 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 30; + std::vector sibling_path = { 1, 2, 3, 4, 5 }; + AppendOnlyTreeSnapshot snapshot = { .root = 123456, .next_available_leaf_index = 128 }; + FF value = 42; + + EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(low_leaf_hash)); + EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) + .WillRepeatedly(Return()); + EXPECT_CALL(field_gt, ff_gt(value, low_leaf.value)).WillRepeatedly(Return(true)); + + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, false, low_leaf, low_leaf_index, sibling_path, snapshot); + IndexedTreeReadWriteEvent expect_event = { + .value = value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + }; + EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + + // Negative test: value exists + EXPECT_THROW_WITH_MESSAGE( + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), + "membership check failed"); + + // Negative test: value not greater than low leaf value + EXPECT_CALL(field_gt, ff_gt(value, low_leaf.value)).WillOnce(Return(false)); + EXPECT_THROW_WITH_MESSAGE( + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), + "Low leaf value is GTE leaf value"); +} + +TEST(AvmSimulationIndexedTreeCheck, ReadNotExistsLowPointsToAnotherLeaf) +{ + StrictMock poseidon2; + StrictMock merkle_check; + StrictMock field_gt; + + EventEmitter event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, event_emitter); + + IndexedTreeLeafData low_leaf = { .value = 40, .next_value = 50, .next_index = 28 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 30; + std::vector sibling_path = { 1, 2, 3, 4, 5 }; + AppendOnlyTreeSnapshot snapshot = { .root = 123456, .next_available_leaf_index = 128 }; + FF value = 42; + + EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(low_leaf_hash)); + EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) + .WillRepeatedly(Return()); + EXPECT_CALL(field_gt, ff_gt(value, low_leaf.value)).WillRepeatedly(Return(true)); + EXPECT_CALL(field_gt, ff_gt(low_leaf.next_value, value)).WillRepeatedly(Return(true)); + + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, false, low_leaf, low_leaf_index, sibling_path, snapshot); + IndexedTreeReadWriteEvent expect_event = { + .value = value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + }; + EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + + // Negative test: value exists + EXPECT_THROW_WITH_MESSAGE( + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), + "membership check failed"); + + // Negative test: next value not greater than value + EXPECT_CALL(field_gt, ff_gt(low_leaf.next_value, value)).WillOnce(Return(false)); + EXPECT_THROW_WITH_MESSAGE( + indexed_tree_check.assert_read( + value, /*siloing_params*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), + "Leaf value is GTE low leaf next value"); +} + +TEST(AvmSimulationIndexedTreeCheck, WriteExists) +{ + StrictMock poseidon2; + StrictMock merkle_check; + StrictMock field_gt; + + EventEmitter event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, event_emitter); + + IndexedTreeLeafData low_leaf = { .value = 42, .next_value = 0, .next_index = 0 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 30; + std::vector sibling_path = { 1, 2, 3, 4, 5 }; + AppendOnlyTreeSnapshot snapshot = { .root = 123456, .next_available_leaf_index = 128 }; + + FF value = 42; + + EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(low_leaf_hash)); + EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) + .WillRepeatedly(Return()); + + AppendOnlyTreeSnapshot result_snapshot = indexed_tree_check.write(value, + /*siloing_params*/ std::nullopt, + 10, + low_leaf, + low_leaf_index, + sibling_path, + snapshot, + /*insertion_path*/ std::nullopt); + + EXPECT_EQ(result_snapshot, snapshot); + + IndexedTreeReadWriteEvent expect_event = { + .value = value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + .write = true, + .public_inputs_index = 10, + }; + EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); +} + +TEST(AvmSimulationIndexedTreeCheck, Siloing) +{ + StrictMock poseidon2; + StrictMock merkle_check; + StrictMock field_gt; + + EventEmitter event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, event_emitter); + + FF value = 42; + FF separator = 99; + AztecAddress address = AztecAddress(1); + IndexedTreeSiloingParameters siloing_params = { .address = address, .siloing_separator = separator }; + std::vector siloed_hash_inputs = { separator, address, value }; + FF siloed_value = RawPoseidon2::hash(siloed_hash_inputs); + + IndexedTreeLeafData low_leaf = { .value = siloed_value, .next_value = 0, .next_index = 0 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 30; + std::vector sibling_path = { 1, 2, 3, 4, 5 }; + AppendOnlyTreeSnapshot snapshot = { .root = 123456, .next_available_leaf_index = 128 }; + + EXPECT_CALL(poseidon2, hash(siloed_hash_inputs)).WillRepeatedly(Return(siloed_value)); + EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(low_leaf_hash)); + EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) + .WillRepeatedly(Return()); + + indexed_tree_check.assert_read(value, siloing_params, true, low_leaf, low_leaf_index, sibling_path, snapshot); + + IndexedLeafSiloingData expected_siloing_data = { .siloed_value = siloed_value, .parameters = siloing_params }; + IndexedTreeReadWriteEvent read_event = { + .value = value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + .siloing_data = expected_siloing_data, + }; + indexed_tree_check.write(value, + siloing_params, + 10, + low_leaf, + low_leaf_index, + sibling_path, + snapshot, + /*insertion_path*/ std::nullopt); + + IndexedTreeReadWriteEvent write_event = { + .value = value, + .prev_snapshot = snapshot, + .next_snapshot = snapshot, + .tree_height = sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + .write = true, + .siloing_data = expected_siloing_data, + .public_inputs_index = 10, + }; + EXPECT_THAT(event_emitter.dump_events(), ElementsAre(read_event, write_event)); +} + +TEST(AvmSimulationIndexedTreeCheck, WriteAppend) +{ + StrictMock poseidon2; + StrictMock merkle_check; + StrictMock field_gt; + + EventEmitter event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, event_emitter); + + FF value = 100; + FF low_value = 40; + + MemoryTree tree(8); + + IndexedTreeLeafData low_leaf = { .value = low_value, .next_value = value + 1, .next_index = 10 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 0; + tree.update_element(low_leaf_index, low_leaf_hash); + + AppendOnlyTreeSnapshot prev_snapshot = { .root = tree.root(), .next_available_leaf_index = 128 }; + std::vector low_leaf_sibling_path = tree.get_sibling_path(low_leaf_index); + + IndexedTreeLeafData updated_low_leaf = { + .value = low_leaf.value, + .next_value = value, + .next_index = prev_snapshot.next_available_leaf_index, + }; + FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); + tree.update_element(low_leaf_index, updated_low_leaf_hash); + + FF intermediate_root = tree.root(); + std::vector insertion_sibling_path = tree.get_sibling_path(prev_snapshot.next_available_leaf_index); + + // The new leaf gets the old low leaf's next pointer. + IndexedTreeLeafData new_leaf = { .value = value, + .next_value = low_leaf.next_value, + .next_index = low_leaf.next_index }; + FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); + tree.update_element(prev_snapshot.next_available_leaf_index, new_leaf_hash); + + AppendOnlyTreeSnapshot next_snapshot = { + .root = tree.root(), + .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1, + }; + + EXPECT_CALL(poseidon2, hash(_)).WillRepeatedly([](const std::vector& input) { + return RawPoseidon2::hash(input); + }); + EXPECT_CALL(merkle_check, write(low_leaf_hash, updated_low_leaf_hash, low_leaf_index, _, prev_snapshot.root)) + .WillRepeatedly(Return(intermediate_root)); + EXPECT_CALL(field_gt, ff_gt(value, low_leaf.value)).WillRepeatedly(Return(true)); + EXPECT_CALL(field_gt, ff_gt(low_leaf.next_value, value)).WillRepeatedly(Return(true)); + EXPECT_CALL(merkle_check, + write(FF(0), new_leaf_hash, prev_snapshot.next_available_leaf_index, _, intermediate_root)) + .WillRepeatedly(Return(next_snapshot.root)); + + AppendOnlyTreeSnapshot result_snapshot = indexed_tree_check.write(value, + /*siloing_params*/ std::nullopt, + std::nullopt, + low_leaf, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path); + + EXPECT_EQ(next_snapshot, result_snapshot); + + IndexedTreeReadWriteEvent expect_event = { + .value = value, + .prev_snapshot = prev_snapshot, + .next_snapshot = next_snapshot, + .tree_height = low_leaf_sibling_path.size(), + .low_leaf_data = low_leaf, + .low_leaf_hash = low_leaf_hash, + .low_leaf_index = low_leaf_index, + .write = true, + .append_data = + IndexedLeafAppendData{ + .updated_low_leaf_hash = updated_low_leaf_hash, + .new_leaf_hash = new_leaf_hash, + .intermediate_root = intermediate_root, + }, + }; + + EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + + // Negative test: value already exists in tree + IndexedTreeLeafData matching_leaf = { .value = value, + .next_value = low_leaf.next_value, + .next_index = low_leaf.next_index }; + EXPECT_THROW_WITH_MESSAGE(indexed_tree_check.write(value, + /*siloing_params*/ std::nullopt, + std::nullopt, + matching_leaf, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path), + "non-membership check failed"); + + // Negative test: value not greater than low leaf value + EXPECT_CALL(field_gt, ff_gt(value, low_leaf.value)).WillOnce(Return(false)); + EXPECT_THROW_WITH_MESSAGE(indexed_tree_check.write(value, + /*siloing_params*/ std::nullopt, + std::nullopt, + low_leaf, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path), + "Low leaf value is GTE leaf value"); + EXPECT_CALL(field_gt, ff_gt(value, low_leaf.value)).WillOnce(Return(true)); + + // Negative test: next value not greater than value + EXPECT_CALL(field_gt, ff_gt(low_leaf.next_value, value)).WillOnce(Return(false)); + EXPECT_THROW_WITH_MESSAGE(indexed_tree_check.write(value, + /*siloing_params*/ std::nullopt, + std::nullopt, + low_leaf, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path), + "Leaf value is GTE low leaf next value"); +} + +} // namespace + +} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.cpp deleted file mode 100644 index ae951e041c9e..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.cpp +++ /dev/null @@ -1,232 +0,0 @@ -#include "barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp" - -#include "barretenberg/vm2/common/constants.hpp" - -#include - -namespace bb::avm2::simulation { - -/** - * @brief Computes the siloed nullifier by hashing the contract address with the nullifier. - * - * Siloing binds a nullifier to its originating contract, preventing cross-contract collisions. - * Uses Poseidon2 with a domain separator for siloed nullifiers. - * - * @param nullifier The original (inner) nullifier. - * @param contract_address The address of the contract that created the nullifier. - * @return The siloed nullifier: Poseidon2(DOM_SEP__SILOED_NULLIFIER, contract_address, nullifier). - */ -FF NullifierTreeCheck::silo_nullifier(const FF& nullifier, AztecAddress contract_address) -{ - return poseidon2.hash({ DOM_SEP__SILOED_NULLIFIER, contract_address, nullifier }); -} - -/** - * @brief Validates the low leaf preimage against the nullifier for membership/non-membership checks. - * - * In an indexed nullifier tree, the low leaf is the largest leaf less than the target nullifier. - * This function validates the low leaf properties to prove either membership (when the low leaf - * equals the nullifier) or non-membership (when the nullifier falls between the low leaf and its - * next key). - * - * For membership ( @p exists = true ): the low leaf's nullifier must equal @p nullifier. - * For non-membership ( @p exists = false ): the nullifier must be greater than the low leaf's - * nullifier and (if nextKey != 0) less than the low leaf's nextKey. - * - * @param nullifier The (possibly siloed) nullifier being checked. - * @param low_leaf_preimage The preimage of the low leaf in the nullifier tree. - * @param exists True if proving membership, false if proving non-membership. - * @throws std::runtime_error If validation fails (e.g., membership check when low leaf doesn't match). - */ -void NullifierTreeCheck::validate_low_leaf(const FF& nullifier, - const NullifierTreeLeafPreimage& low_leaf_preimage, - bool exists) -{ - bool low_leaf_matches = low_leaf_preimage.leaf.nullifier == nullifier; - // We base the checking on whether the low leaf matches instead of exists, to match PIL behavior. - if (low_leaf_matches) { - if (!exists) { - throw std::runtime_error("Nullifier non-membership check failed"); - } - } else { - if (!field_gt.ff_gt(nullifier, low_leaf_preimage.leaf.nullifier)) { - throw std::runtime_error("Low leaf value is GTE leaf value"); - } - if (low_leaf_preimage.nextKey != 0 && !field_gt.ff_gt(low_leaf_preimage.nextKey, nullifier)) { - throw std::runtime_error("Leaf value is GTE low leaf next value"); - } - if (exists) { - throw std::runtime_error("Nullifier membership check failed"); - } - } -} - -/** - * @brief Performs a nullifier membership or non-membership check on the nullifier tree. - * - * This method verifies whether a nullifier exists or does not exist in the nullifier tree at a - * given snapshot, using the indexed tree low-leaf membership proof technique. It optionally silos - * the nullifier with a contract address before checking. - * - * The low leaf must be proven to be a member of the tree via Merkle proof. Then the nullifier is - * validated against the low leaf according to the indexed tree invariants (see validate_low_leaf). - * - * @param source_nullifier The raw (possibly unsiloed) nullifier to check. - * @param contract_address If present, the nullifier is siloed with this address before checking. - * @param exists True to prove membership, false to prove non-membership. - * @param low_leaf_preimage The preimage of the low leaf for the nullifier. - * @param low_leaf_index The index of the low leaf in the tree. - * @param sibling_path The Merkle sibling path for the low leaf. - * @param snapshot The tree snapshot to verify against. - * @throws std::runtime_error If validation fails. - */ -void NullifierTreeCheck::assert_read(const FF& source_nullifier, - std::optional contract_address, - bool exists, - const NullifierTreeLeafPreimage& low_leaf_preimage, - uint64_t low_leaf_index, - std::span sibling_path, - const AppendOnlyTreeSnapshot& snapshot) -{ - FF nullifier = source_nullifier; - std::optional siloing_data = std::nullopt; - if (contract_address.has_value()) { - nullifier = silo_nullifier(nullifier, contract_address.value()); - siloing_data = NullifierSiloingData{ .siloed_nullifier = nullifier, .address = contract_address.value() }; - } - // Low leaf membership - FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); - merkle_check.assert_membership(low_leaf_hash, low_leaf_index, sibling_path, snapshot.root); - - // Low leaf and value validation - validate_low_leaf(nullifier, low_leaf_preimage, exists); - - events.emit(NullifierTreeReadWriteEvent{ - .nullifier = source_nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf_preimage, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .siloing_data = siloing_data, - }); -} - -/** - * @brief Inserts a nullifier into the nullifier tree or verifies it already exists. - * - * This method handles both successful and failing nullifier writes. If the nullifier already - * exists in the tree ( @p insertion_sibling_path is nullopt ), it validates membership. Otherwise, - * it performs an indexed tree insertion by updating the low leaf's next pointer and appending the - * new nullifier as a leaf. - * - * The nullifier is optionally siloed with a contract address before insertion. The low leaf must - * be validated via indexed tree invariants. For a new insertion, two Merkle writes occur: - * 1. Update the low leaf to point to the new nullifier. - * 2. Insert the new nullifier leaf at the next available index. - * - * @param source_nullifier The raw (possibly unsiloed) nullifier to insert. - * @param contract_address If present, the nullifier is siloed with this address before insertion. - * @param nullifier_counter The index of the nullifier within this transaction. - * @param low_leaf_preimage The preimage of the low leaf for the nullifier. - * @param low_leaf_index The index of the low leaf in the tree. - * @param low_leaf_sibling_path The Merkle sibling path for the low leaf. - * @param prev_snapshot The tree snapshot before the write. - * @param insertion_sibling_path If present, the sibling path for inserting a new leaf. If nullopt, - * the nullifier already exists and no insertion occurs. - * @return The updated tree snapshot after the write (unchanged if nullifier already exists). - * @throws std::runtime_error If validation fails. - */ -AppendOnlyTreeSnapshot NullifierTreeCheck::write(const FF& source_nullifier, - std::optional contract_address, - uint64_t nullifier_counter, - const NullifierTreeLeafPreimage& low_leaf_preimage, - uint64_t low_leaf_index, - std::span low_leaf_sibling_path, - const AppendOnlyTreeSnapshot& prev_snapshot, - std::optional> insertion_sibling_path) -{ - FF nullifier = source_nullifier; - std::optional siloing_data = std::nullopt; - if (contract_address.has_value()) { - nullifier = silo_nullifier(nullifier, contract_address.value()); - siloing_data = NullifierSiloingData{ .siloed_nullifier = nullifier, .address = contract_address.value() }; - } - bool exists = !insertion_sibling_path.has_value(); - - // Low leaf validation - validate_low_leaf(nullifier, low_leaf_preimage, exists); - - AppendOnlyTreeSnapshot next_snapshot = prev_snapshot; - std::optional append_data = std::nullopt; - - FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); - - if (exists) { - merkle_check.assert_membership(low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); - } else { - // Low leaf update - NullifierTreeLeafPreimage updated_low_leaf_preimage = low_leaf_preimage; - updated_low_leaf_preimage.nextIndex = prev_snapshot.next_available_leaf_index; - updated_low_leaf_preimage.nextKey = nullifier; - FF updated_low_leaf_hash = poseidon2.hash(updated_low_leaf_preimage.get_hash_inputs()); - - FF intermediate_root = merkle_check.write( - low_leaf_hash, updated_low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); - - // Insertion - NullifierTreeLeafPreimage new_leaf_preimage = NullifierTreeLeafPreimage( - NullifierLeafValue(nullifier), low_leaf_preimage.nextIndex, low_leaf_preimage.nextKey); - - FF new_leaf_hash = poseidon2.hash(new_leaf_preimage.get_hash_inputs()); - - FF write_root = merkle_check.write(FF(0), - new_leaf_hash, - prev_snapshot.next_available_leaf_index, - insertion_sibling_path.value(), - intermediate_root); - - next_snapshot = AppendOnlyTreeSnapshot{ - .root = write_root, - .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1, - }; - append_data = NullifierAppendData{ - .updated_low_leaf_hash = updated_low_leaf_hash, - .new_leaf_hash = new_leaf_hash, - .intermediate_root = intermediate_root, - }; - } - - events.emit(NullifierTreeReadWriteEvent{ .nullifier = source_nullifier, - .prev_snapshot = prev_snapshot, - .next_snapshot = next_snapshot, - .low_leaf_preimage = low_leaf_preimage, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .siloing_data = siloing_data, - .nullifier_counter = nullifier_counter, - .append_data = append_data }); - - return next_snapshot; -} - -/** @brief Emits a checkpoint creation event for the nullifier tree. */ -void NullifierTreeCheck::on_checkpoint_created() -{ - events.emit(CheckPointEventType::CREATE_CHECKPOINT); -} - -/** @brief Emits a checkpoint commit event, finalizing pending nullifier tree changes. */ -void NullifierTreeCheck::on_checkpoint_committed() -{ - events.emit(CheckPointEventType::COMMIT_CHECKPOINT); -} - -/** @brief Emits a checkpoint revert event, rolling back pending nullifier tree changes. */ -void NullifierTreeCheck::on_checkpoint_reverted() -{ - events.emit(CheckPointEventType::REVERT_CHECKPOINT); -} - -} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp deleted file mode 100644 index 1f5ef9dc2c78..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp +++ /dev/null @@ -1,61 +0,0 @@ -#pragma once - -#include "barretenberg/vm2/common/aztec_types.hpp" -#include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" -#include "barretenberg/vm2/simulation/interfaces/nullifier_tree_check.hpp" -#include "barretenberg/vm2/simulation/lib/db_types.hpp" - -#include -#include -#include - -namespace bb::avm2::simulation { - -class NullifierTreeCheck : public NullifierTreeCheckInterface, public CheckpointNotifiable { - public: - NullifierTreeCheck(Poseidon2Interface& poseidon2, - MerkleCheckInterface& merkle_check, - FieldGreaterThanInterface& field_gt, - EventEmitterInterface& event_emitter) - : events(event_emitter) - , poseidon2(poseidon2) - , merkle_check(merkle_check) - , field_gt(field_gt) - {} - - void assert_read(const FF& nullifier, - std::optional contract_address, - bool exists, - const NullifierTreeLeafPreimage& low_leaf_preimage, - uint64_t low_leaf_index, - std::span sibling_path, - const AppendOnlyTreeSnapshot& snapshot) override; - AppendOnlyTreeSnapshot write(const FF& nullifier, - std::optional contract_address, - uint64_t nullifier_counter, - const NullifierTreeLeafPreimage& low_leaf_preimage, - uint64_t low_leaf_index, - std::span low_leaf_sibling_path, - const AppendOnlyTreeSnapshot& prev_snapshot, - std::optional> insertion_sibling_path) override; - - void on_checkpoint_created() override; - void on_checkpoint_committed() override; - void on_checkpoint_reverted() override; - - private: - FF silo_nullifier(const FF& nullifier, AztecAddress contract_address); - void validate_low_leaf(const FF& nullifier, const NullifierTreeLeafPreimage& low_leaf_preimage, bool exists); - - EventEmitterInterface& events; - Poseidon2Interface& poseidon2; - MerkleCheckInterface& merkle_check; - FieldGreaterThanInterface& field_gt; -}; - -} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.test.cpp deleted file mode 100644 index 6fc751e9ab80..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/nullifier_tree_check.test.cpp +++ /dev/null @@ -1,386 +0,0 @@ -#include "barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp" - -#include -#include - -#include "barretenberg/crypto/merkle_tree/memory_tree.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/common/aztec_types.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" -#include "barretenberg/vm2/testing/macros.hpp" - -namespace bb::avm2::simulation { - -using ::testing::_; -using ::testing::ElementsAre; -using ::testing::Return; -using ::testing::StrictMock; - -using RawPoseidon2 = crypto::Poseidon2; - -namespace { - -TEST(AvmSimulationNullifierTree, ReadExists) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, event_emitter); - - NullifierTreeLeafPreimage low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 0, 0); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 30; - std::vector sibling_path = { 1, 2, 3, 4, 5 }; - AppendOnlyTreeSnapshot snapshot = AppendOnlyTreeSnapshot{ .root = 123456, .next_available_leaf_index = 128 }; - - FF nullifier = 42; - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot); - - NullifierTreeReadWriteEvent expect_event = { - .nullifier = nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); - - // Negative test: nullifier does not exist - EXPECT_THROW_WITH_MESSAGE( - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, false, low_leaf, low_leaf_index, sibling_path, snapshot), - "Nullifier non-membership check failed"); -} - -TEST(AvmSimulationNullifierTree, ReadNotExistsLowPointsToInfinity) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, event_emitter); - - NullifierTreeLeafPreimage low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(40), 0, 0); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 30; - std::vector sibling_path = { 1, 2, 3, 4, 5 }; - AppendOnlyTreeSnapshot snapshot = AppendOnlyTreeSnapshot{ .root = 123456, .next_available_leaf_index = 128 }; - FF nullifier = 42; - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - EXPECT_CALL(field_gt, ff_gt(nullifier, low_leaf.leaf.nullifier)).WillRepeatedly(Return(true)); - - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, false, low_leaf, low_leaf_index, sibling_path, snapshot); - NullifierTreeReadWriteEvent expect_event = { - .nullifier = nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); - - // Negative test: nullifier exists - EXPECT_THROW_WITH_MESSAGE( - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), - "Nullifier membership check failed"); - - // Negative test: failed nullifier > low_leaf_preimage.value.nullifier - EXPECT_CALL(field_gt, ff_gt(nullifier, low_leaf.leaf.nullifier)).WillOnce(Return(false)); - EXPECT_THROW_WITH_MESSAGE( - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), - "Low leaf value is GTE leaf value"); -} - -TEST(AvmSimulationNullifierTree, ReadNotExistsLowPointsToAnotherLeaf) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, event_emitter); - - NullifierTreeLeafPreimage low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(40), 28, 50); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 30; - std::vector sibling_path = { 1, 2, 3, 4, 5 }; - AppendOnlyTreeSnapshot snapshot = AppendOnlyTreeSnapshot{ .root = 123456, .next_available_leaf_index = 128 }; - FF nullifier = 42; - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - EXPECT_CALL(field_gt, ff_gt(nullifier, low_leaf.leaf.nullifier)).WillRepeatedly(Return(true)); - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, nullifier)).WillRepeatedly(Return(true)); - - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, false, low_leaf, low_leaf_index, sibling_path, snapshot); - NullifierTreeReadWriteEvent expect_event = { - .nullifier = nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); - - // Negative test: nullifier exists - EXPECT_THROW_WITH_MESSAGE( - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), - "Nullifier membership check failed"); - - // Negative test: failed low_leaf_preimage.nextKey > nullifier - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, nullifier)).WillOnce(Return(false)); - EXPECT_THROW_WITH_MESSAGE( - nullifier_tree_check.assert_read( - nullifier, /*contract_address*/ std::nullopt, true, low_leaf, low_leaf_index, sibling_path, snapshot), - "Leaf value is GTE low leaf next value"); -} - -TEST(AvmSimulationNullifierTree, WriteExists) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, event_emitter); - - NullifierTreeLeafPreimage low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 0, 0); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 30; - std::vector sibling_path = { 1, 2, 3, 4, 5 }; - AppendOnlyTreeSnapshot snapshot = AppendOnlyTreeSnapshot{ .root = 123456, .next_available_leaf_index = 128 }; - - FF nullifier = 42; - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - AppendOnlyTreeSnapshot result_snapshot = nullifier_tree_check.write(nullifier, - /*contract_address*/ std::nullopt, - 10, - low_leaf, - low_leaf_index, - sibling_path, - snapshot, - /*insertion_path*/ std::nullopt); - - EXPECT_EQ(result_snapshot, snapshot); - - NullifierTreeReadWriteEvent expect_event = { - .nullifier = nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .nullifier_counter = 10, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); -} - -TEST(AvmSimulationNullifierTree, Siloing) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, event_emitter); - - FF nullifier = 42; - AztecAddress contract_address = AztecAddress(1); - std::vector siloed_nullifier_hash_inputs = { DOM_SEP__SILOED_NULLIFIER, contract_address, nullifier }; - FF siloed_nullifier = RawPoseidon2::hash(siloed_nullifier_hash_inputs); - - NullifierTreeLeafPreimage low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(siloed_nullifier), 0, 0); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 30; - std::vector sibling_path = { 1, 2, 3, 4, 5 }; - AppendOnlyTreeSnapshot snapshot = AppendOnlyTreeSnapshot{ .root = 123456, .next_available_leaf_index = 128 }; - - EXPECT_CALL(poseidon2, hash(siloed_nullifier_hash_inputs)).WillRepeatedly(Return(FF(siloed_nullifier))); - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - nullifier_tree_check.assert_read(nullifier, contract_address, 10, low_leaf, low_leaf_index, sibling_path, snapshot); - - NullifierTreeReadWriteEvent read_event = { - .nullifier = nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .siloing_data = NullifierSiloingData{ .siloed_nullifier = siloed_nullifier, .address = contract_address }, - }; - nullifier_tree_check.write(nullifier, - contract_address, - 10, - low_leaf, - low_leaf_index, - sibling_path, - snapshot, - /*insertion_path*/ std::nullopt); - - NullifierTreeReadWriteEvent write_event = { - .nullifier = nullifier, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .siloing_data = NullifierSiloingData{ .siloed_nullifier = siloed_nullifier, .address = contract_address }, - .nullifier_counter = 10, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(read_event, write_event)); -} - -TEST(AvmSimulationNullifierTree, WriteAppend) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, event_emitter); - - FF nullifier = 100; - FF low_nullifier = 40; - - MemoryTree nullifier_tree(8); - - NullifierTreeLeafPreimage low_leaf = - NullifierTreeLeafPreimage(NullifierLeafValue(low_nullifier), 10, nullifier + 1); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 0; - nullifier_tree.update_element(low_leaf_index, low_leaf_hash); - - AppendOnlyTreeSnapshot prev_snapshot = - AppendOnlyTreeSnapshot{ .root = nullifier_tree.root(), .next_available_leaf_index = 128 }; - std::vector low_leaf_sibling_path = nullifier_tree.get_sibling_path(low_leaf_index); - - NullifierTreeLeafPreimage updated_low_leaf = low_leaf; - updated_low_leaf.nextIndex = prev_snapshot.next_available_leaf_index; - updated_low_leaf.nextKey = nullifier; - FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); - nullifier_tree.update_element(low_leaf_index, updated_low_leaf_hash); - - FF intermediate_root = nullifier_tree.root(); - std::vector insertion_sibling_path = nullifier_tree.get_sibling_path(prev_snapshot.next_available_leaf_index); - - NullifierTreeLeafPreimage new_leaf = - NullifierTreeLeafPreimage(NullifierLeafValue(nullifier), low_leaf.nextIndex, low_leaf.nextKey); - FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); - nullifier_tree.update_element(prev_snapshot.next_available_leaf_index, new_leaf_hash); - - AppendOnlyTreeSnapshot next_snapshot = - AppendOnlyTreeSnapshot{ .root = nullifier_tree.root(), - .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1 }; - - EXPECT_CALL(poseidon2, hash(_)).WillRepeatedly([](const std::vector& input) { - return RawPoseidon2::hash(input); - }); - EXPECT_CALL(merkle_check, write(low_leaf_hash, updated_low_leaf_hash, low_leaf_index, _, prev_snapshot.root)) - .WillRepeatedly(Return(intermediate_root)); - EXPECT_CALL(field_gt, ff_gt(nullifier, low_leaf.leaf.nullifier)).WillRepeatedly(Return(true)); - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, nullifier)).WillRepeatedly(Return(true)); - EXPECT_CALL(merkle_check, - write(FF(0), new_leaf_hash, prev_snapshot.next_available_leaf_index, _, intermediate_root)) - .WillRepeatedly(Return(next_snapshot.root)); - - AppendOnlyTreeSnapshot result_snapshot = nullifier_tree_check.write(nullifier, - /*contract_address*/ std::nullopt, - 0, - low_leaf, - low_leaf_index, - low_leaf_sibling_path, - prev_snapshot, - insertion_sibling_path); - - EXPECT_EQ(next_snapshot, result_snapshot); - - NullifierTreeReadWriteEvent expect_event = { .nullifier = nullifier, - .prev_snapshot = prev_snapshot, - .next_snapshot = next_snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .append_data = NullifierAppendData{ - .updated_low_leaf_hash = updated_low_leaf_hash, - .new_leaf_hash = new_leaf_hash, - .intermediate_root = intermediate_root, - } }; - - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); - - // Negative test: nullifier exists - low_leaf.leaf.nullifier = nullifier; - EXPECT_THROW_WITH_MESSAGE(nullifier_tree_check.write(nullifier, - /*contract_address*/ std::nullopt, - 0, - low_leaf, - low_leaf_index, - low_leaf_sibling_path, - prev_snapshot, - insertion_sibling_path), - "Nullifier non-membership check failed"); - low_leaf.leaf.nullifier = low_nullifier; - - // Negative test: failed nullifier > low_leaf_preimage.value.nullifier - EXPECT_CALL(field_gt, ff_gt(nullifier, low_leaf.leaf.nullifier)).WillOnce(Return(false)); - EXPECT_THROW_WITH_MESSAGE(nullifier_tree_check.write(nullifier, - /*contract_address*/ std::nullopt, - 0, - low_leaf, - low_leaf_index, - low_leaf_sibling_path, - prev_snapshot, - insertion_sibling_path), - "Low leaf value is GTE leaf value"); - EXPECT_CALL(field_gt, ff_gt(nullifier, low_leaf.leaf.nullifier)).WillOnce(Return(true)); - - // Negative test: failed low_leaf_preimage.nextKey > nullifier - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, nullifier)).WillOnce(Return(false)); - EXPECT_THROW_WITH_MESSAGE(nullifier_tree_check.write(nullifier, - /*contract_address*/ std::nullopt, - 0, - low_leaf, - low_leaf_index, - low_leaf_sibling_path, - prev_snapshot, - insertion_sibling_path), - "Leaf value is GTE low leaf next value"); -} - -} // namespace - -} // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.cpp index 884c90ceecf2..e8c5a1b6f78d 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.cpp @@ -1,22 +1,18 @@ #include "barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.hpp" #include "barretenberg/common/assert.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" -#include "barretenberg/vm2/simulation/lib/merkle.hpp" namespace bb::avm2::simulation { -void RetrievedBytecodesTreeCheck::validate_low_leaf_jumps_over_class_id( - const RetrievedBytecodesTreeLeafPreimage& low_leaf_preimage, const FF& class_id) -{ - if (!field_gt.ff_gt(class_id, low_leaf_preimage.leaf.class_id)) { - throw std::runtime_error("Low leaf class_id is GTE class id"); - } - if (low_leaf_preimage.nextKey != 0 && !field_gt.ff_gt(low_leaf_preimage.nextKey, class_id)) { - throw std::runtime_error("Class id is GTE low leaf next class id"); - } -} - +/** + * @brief Checks whether a contract class ID exists in the retrieved bytecodes tree. + * + * Queries the internal tree for the low leaf, converts it to generic IndexedTreeLeafData, + * and delegates the membership/non-membership proof to the indexed tree check gadget. + * + * @param class_id The contract class ID to look up. + * @return True if the class ID exists in the tree, false otherwise. + */ bool RetrievedBytecodesTreeCheck::contains(const FF& class_id) { const auto snapshot = tree.get_snapshot(); @@ -24,32 +20,29 @@ bool RetrievedBytecodesTreeCheck::contains(const FF& class_id) auto sibling_path = tree.get_sibling_path(low_leaf_index); auto low_leaf_preimage = tree.get_leaf_preimage(low_leaf_index); - // Low leaf membership - FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); - merkle_check.assert_membership(low_leaf_hash, low_leaf_index, sibling_path, snapshot.root); - - if (exists) { - if (low_leaf_preimage.leaf.class_id != class_id) { - throw std::runtime_error("Class id membership check failed"); - } - } else { - validate_low_leaf_jumps_over_class_id(low_leaf_preimage, class_id); - } - - events.emit(RetrievedBytecodesTreeCheckEvent{ - .class_id = class_id, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf_preimage, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = false, - .append_data = std::nullopt, - }); - + indexed_tree_check.assert_read(class_id, + std::nullopt, + exists, + IndexedTreeLeafData{ + .value = low_leaf_preimage.leaf.class_id, + .next_value = low_leaf_preimage.nextKey, + .next_index = low_leaf_preimage.nextIndex, + }, + low_leaf_index, + sibling_path, + snapshot); return exists; } +/** + * @brief Inserts a contract class ID into the retrieved bytecodes tree. + * + * Performs the insertion on the in memory tree, then delegates the constrained write (or + * duplicate detection) to the indexed tree check gadget. No siloing is applied. + * + * @param class_id The contract class ID to insert. + * @throws std::runtime_error If the indexed tree check write returns a snapshot that does not match the internal tree. + */ void RetrievedBytecodesTreeCheck::insert(const FF& class_id) { AppendOnlyTreeSnapshot prev_snapshot = tree.get_snapshot(); @@ -59,62 +52,38 @@ void RetrievedBytecodesTreeCheck::insert(const FF& class_id) bool exists = class_id == low_leaf_preimage.leaf.class_id; - AppendOnlyTreeSnapshot next_snapshot = prev_snapshot; - std::optional append_data = std::nullopt; - - FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); - if (exists) { - merkle_check.assert_membership(low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); - } else { - validate_low_leaf_jumps_over_class_id(low_leaf_preimage, class_id); - // Low leaf update - RetrievedBytecodesTreeLeafPreimage updated_low_leaf_preimage = low_leaf_preimage; - updated_low_leaf_preimage.nextIndex = prev_snapshot.next_available_leaf_index; - updated_low_leaf_preimage.nextKey = class_id; - - FF updated_low_leaf_hash = poseidon2.hash(updated_low_leaf_preimage.get_hash_inputs()); - - FF intermediate_root = merkle_check.write( - low_leaf_hash, updated_low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); - - RetrievedBytecodesTreeLeafPreimage new_leaf_preimage = RetrievedBytecodesTreeLeafPreimage( - ClassIdLeafValue(class_id), low_leaf_preimage.nextIndex, low_leaf_preimage.nextKey); - - FF new_leaf_hash = poseidon2.hash(new_leaf_preimage.get_hash_inputs()); - - FF write_root = merkle_check.write( - FF(0), new_leaf_hash, prev_snapshot.next_available_leaf_index, insertion_sibling_path, intermediate_root); - - next_snapshot = AppendOnlyTreeSnapshot{ - .root = write_root, - .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1, - }; - // This will throw an unexpected exception if it fails. - BB_ASSERT_EQ(next_snapshot, tree.get_snapshot(), "Next snapshot mismatch"); - append_data = RetrievedBytecodeAppendData{ - .updated_low_leaf_hash = updated_low_leaf_hash, - .new_leaf_hash = new_leaf_hash, - .intermediate_root = intermediate_root, - }; - } - - events.emit(RetrievedBytecodesTreeCheckEvent{ - .class_id = class_id, - .prev_snapshot = prev_snapshot, - .next_snapshot = next_snapshot, - .low_leaf_preimage = low_leaf_preimage, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .append_data = append_data, - }); + AppendOnlyTreeSnapshot next_snapshot = + indexed_tree_check.write(class_id, + std::nullopt, + std::nullopt, + IndexedTreeLeafData{ + .value = low_leaf_preimage.leaf.class_id, + .next_value = low_leaf_preimage.nextKey, + .next_index = low_leaf_preimage.nextIndex, + }, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + exists ? std::nullopt : std::optional(insertion_sibling_path)); + + // This will throw an unexpected exception if it fails. + BB_ASSERT_EQ(next_snapshot, tree.get_snapshot(), "Next snapshot mismatch"); } +/** + * @brief Returns the current tree snapshot. + * @return The current tree snapshot. + */ AppendOnlyTreeSnapshot RetrievedBytecodesTreeCheck::get_snapshot() const { return tree.get_snapshot(); } +/** + * @brief Returns the number of retrieved bytecode class IDs in the tree. + * @return The number of class IDs, excluding the prefill leaf at index 0. + * @note Subtracts 1 to account for the prefill leaf at index 0. + */ uint32_t RetrievedBytecodesTreeCheck::size() const { // -1 Since the tree has a prefill leaf at index 0. diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.hpp index dfd35dd63a2f..af0f191484ee 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.hpp @@ -1,15 +1,10 @@ #pragma once -#include +#include #include -#include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" +#include "barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/interfaces/retrieved_bytecodes_tree_check.hpp" #include "barretenberg/vm2/simulation/lib/retrieved_bytecodes_tree.hpp" @@ -17,15 +12,8 @@ namespace bb::avm2::simulation { class RetrievedBytecodesTreeCheck : public RetrievedBytecodesTreeCheckInterface { public: - RetrievedBytecodesTreeCheck(Poseidon2Interface& poseidon2, - MerkleCheckInterface& merkle_check, - FieldGreaterThanInterface& field_gt, - RetrievedBytecodesTree initial_state, - EventEmitterInterface& read_event_emitter) - : events(read_event_emitter) - , poseidon2(poseidon2) - , merkle_check(merkle_check) - , field_gt(field_gt) + RetrievedBytecodesTreeCheck(IndexedTreeCheckInterface& indexed_tree_check, RetrievedBytecodesTree initial_state) + : indexed_tree_check(indexed_tree_check) , tree(std::move(initial_state)) {} @@ -38,15 +26,9 @@ class RetrievedBytecodesTreeCheck : public RetrievedBytecodesTreeCheckInterface uint32_t size() const override; private: - EventEmitterInterface& events; - Poseidon2Interface& poseidon2; - MerkleCheckInterface& merkle_check; - FieldGreaterThanInterface& field_gt; + IndexedTreeCheckInterface& indexed_tree_check; RetrievedBytecodesTree tree; - - void validate_low_leaf_jumps_over_class_id(const RetrievedBytecodesTreeLeafPreimage& low_leaf_preimage, - const FF& class_id); }; } // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.test.cpp index a13cba8a229c..0c6e2dba803c 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/retrieved_bytecodes_tree_check.test.cpp @@ -3,261 +3,105 @@ #include #include -#include "barretenberg/crypto/merkle_tree/memory_tree.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/common/aztec_types.hpp" -#include "barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/lib/merkle.hpp" #include "barretenberg/vm2/simulation/lib/retrieved_bytecodes_tree.hpp" -#include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" -#include "barretenberg/vm2/testing/macros.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" namespace bb::avm2::simulation { using ::testing::_; -using ::testing::ElementsAre; using ::testing::Return; using ::testing::StrictMock; -using RawPoseidon2 = crypto::Poseidon2; +const std::optional NO_SILOING = std::nullopt; +const std::optional NO_PUBLIC_INPUTS_INDEX = std::nullopt; namespace { TEST(AvmSimulationRetrievedBytecodesTreeCheck, ContainsNotExists) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; + StrictMock mock_indexed_tree_check; + RetrievedBytecodesTree tree = build_retrieved_bytecodes_tree(); FF class_id = 42; - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - - // Prefill will point to our new leaf - ASSERT_EQ(initial_state.get_snapshot().next_available_leaf_index, 1); - uint64_t low_leaf_index = 0; - RetrievedBytecodesTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - - auto sibling_path = initial_state.get_sibling_path(0); - auto snapshot = initial_state.get_snapshot(); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - EXPECT_CALL(field_gt, ff_gt(class_id, low_leaf.leaf.class_id)).WillRepeatedly(Return(true)); - - EXPECT_FALSE(retrieved_bytecodes_tree_check.contains(class_id)); - - RetrievedBytecodesTreeCheckEvent expect_event = { - .class_id = class_id, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, + auto snapshot = tree.get_snapshot(); + auto [exists, low_leaf_index] = tree.get_low_indexed_leaf(class_id); + auto low_leaf = tree.get_leaf_preimage(low_leaf_index); + ASSERT_FALSE(exists); + + IndexedTreeLeafData expected_leaf_data = { + .value = low_leaf.leaf.class_id, + .next_value = low_leaf.nextKey, + .next_index = low_leaf.nextIndex, }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); -} - -TEST(AvmSimulationRetrievedBytecodesTree, ContainsExists) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - EventEmitter event_emitter; - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); + EXPECT_CALL(mock_indexed_tree_check, + assert_read(class_id, NO_SILOING, false, expected_leaf_data, low_leaf_index, _, snapshot)); - FF class_id = 42; - - uint64_t low_leaf_index = initial_state.get_snapshot().next_available_leaf_index; - initial_state.insert_indexed_leaves({ { ClassIdLeafValue(class_id) } }); - - RetrievedBytecodesTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - std::vector sibling_path = initial_state.get_sibling_path(low_leaf_index); - auto snapshot = initial_state.get_snapshot(); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - EXPECT_TRUE(retrieved_bytecodes_tree_check.contains(class_id)); - - RetrievedBytecodesTreeCheckEvent expect_event = { - .class_id = class_id, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + RetrievedBytecodesTreeCheck bytecodes_check(mock_indexed_tree_check, tree); + EXPECT_FALSE(bytecodes_check.contains(class_id)); } -TEST(AvmSimulationRetrievedBytecodesTree, ReadNotExistsLowPointsToAnotherLeaf) +TEST(AvmSimulationRetrievedBytecodesTreeCheck, ContainsExists) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - // Prefill now points to leaf MAX - initial_state.insert_indexed_leaves({ { ClassIdLeafValue(FF::neg_one()) } }); + StrictMock mock_indexed_tree_check; + RetrievedBytecodesTree tree = build_retrieved_bytecodes_tree(); + tree.insert_indexed_leaves({ { ClassIdLeafValue(42) } }); FF class_id = 42; + auto snapshot = tree.get_snapshot(); + auto [exists, low_leaf_index] = tree.get_low_indexed_leaf(class_id); + auto low_leaf = tree.get_leaf_preimage(low_leaf_index); + ASSERT_TRUE(exists); + + IndexedTreeLeafData expected_leaf_data = { + .value = low_leaf.leaf.class_id, + .next_value = low_leaf.nextKey, + .next_index = low_leaf.nextIndex, + }; - auto low_leaf = initial_state.get_leaf_preimage(0); - - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 0; - std::vector sibling_path = initial_state.get_sibling_path(low_leaf_index); - AppendOnlyTreeSnapshot snapshot = initial_state.get_snapshot(); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - EXPECT_CALL(field_gt, ff_gt(class_id, low_leaf.leaf.class_id)).WillRepeatedly(Return(true)); - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, class_id)).WillRepeatedly(Return(true)); - - retrieved_bytecodes_tree_check.contains(class_id); + EXPECT_CALL(mock_indexed_tree_check, + assert_read(class_id, NO_SILOING, true, expected_leaf_data, low_leaf_index, _, snapshot)); - RetrievedBytecodesTreeCheckEvent expect_event = { - .class_id = class_id, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + RetrievedBytecodesTreeCheck bytecodes_check(mock_indexed_tree_check, tree); + EXPECT_TRUE(bytecodes_check.contains(class_id)); } -TEST(AvmSimulationRetrievedBytecodesTree, InsertExists) +TEST(AvmSimulationRetrievedBytecodesTreeCheck, InsertExists) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; + StrictMock mock_indexed_tree_check; + RetrievedBytecodesTree tree = build_retrieved_bytecodes_tree(); + tree.insert_indexed_leaves({ { ClassIdLeafValue(42) } }); FF class_id = 42; + auto snapshot = tree.get_snapshot(); - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - uint64_t low_leaf_index = initial_state.get_snapshot().next_available_leaf_index; - initial_state.insert_indexed_leaves({ { ClassIdLeafValue(class_id) } }); - - RetrievedBytecodesTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - std::vector sibling_path = initial_state.get_sibling_path(low_leaf_index); - AppendOnlyTreeSnapshot snapshot = initial_state.get_snapshot(); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - retrieved_bytecodes_tree_check.insert(class_id); - - EXPECT_EQ(retrieved_bytecodes_tree_check.get_snapshot(), snapshot); + EXPECT_CALL(mock_indexed_tree_check, write(class_id, NO_SILOING, NO_PUBLIC_INPUTS_INDEX, _, _, _, snapshot, _)) + .WillOnce(Return(snapshot)); - RetrievedBytecodesTreeCheckEvent expect_event = { - .class_id = class_id, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + RetrievedBytecodesTreeCheck bytecodes_check(mock_indexed_tree_check, tree); + bytecodes_check.insert(class_id); + EXPECT_EQ(bytecodes_check.get_snapshot(), snapshot); } -TEST(AvmSimulationRetrievedBytecodesTree, InsertAppend) +TEST(AvmSimulationRetrievedBytecodesTreeCheck, InsertAppend) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; + StrictMock mock_indexed_tree_check; + RetrievedBytecodesTree tree = build_retrieved_bytecodes_tree(); FF class_id = 100; + auto prev_snapshot = tree.get_snapshot(); - RetrievedBytecodesTree initial_state = build_retrieved_bytecodes_tree(); - // Prefill will point to our new leaf - ASSERT_EQ(initial_state.get_snapshot().next_available_leaf_index, 1); - uint64_t low_leaf_index = 0; - uint64_t new_leaf_index = 1; - RetrievedBytecodesTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - RetrievedBytecodesTree state_after_insert = initial_state; - state_after_insert.insert_indexed_leaves({ { ClassIdLeafValue(class_id) } }); - - std::vector low_leaf_sibling_path = initial_state.get_sibling_path(low_leaf_index); - - RetrievedBytecodesTreeLeafPreimage updated_low_leaf = low_leaf; - updated_low_leaf.nextIndex = new_leaf_index; - updated_low_leaf.nextKey = class_id; - FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); - - FF intermediate_root = unconstrained_root_from_path(updated_low_leaf_hash, low_leaf_index, low_leaf_sibling_path); - std::vector insertion_sibling_path = state_after_insert.get_sibling_path(new_leaf_index); - - RetrievedBytecodesTreeLeafPreimage new_leaf = - RetrievedBytecodesTreeLeafPreimage(ClassIdLeafValue(class_id), low_leaf.nextIndex, low_leaf.nextKey); - FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); - - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(_)).WillRepeatedly([](const std::vector& input) { - return RawPoseidon2::hash(input); - }); - EXPECT_CALL(merkle_check, - write(low_leaf_hash, updated_low_leaf_hash, low_leaf_index, _, initial_state.get_snapshot().root)) - .WillRepeatedly(Return(intermediate_root)); - EXPECT_CALL(field_gt, ff_gt(class_id, low_leaf.leaf.class_id)).WillRepeatedly(Return(true)); - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, class_id)).WillRepeatedly(Return(true)); - EXPECT_CALL(merkle_check, write(FF(0), new_leaf_hash, new_leaf_index, _, intermediate_root)) - .WillRepeatedly(Return(state_after_insert.get_snapshot().root)); - - retrieved_bytecodes_tree_check.insert(class_id); - - EXPECT_EQ(retrieved_bytecodes_tree_check.get_snapshot(), state_after_insert.get_snapshot()); + // Compute expected post-insert state. + RetrievedBytecodesTree tree_after = tree; + tree_after.insert_indexed_leaves({ { ClassIdLeafValue(class_id) } }); + auto next_snapshot = tree_after.get_snapshot(); - RetrievedBytecodesTreeCheckEvent expect_event = { .class_id = class_id, - .prev_snapshot = initial_state.get_snapshot(), - .next_snapshot = state_after_insert.get_snapshot(), - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .append_data = RetrievedBytecodeAppendData{ - .updated_low_leaf_hash = updated_low_leaf_hash, - .new_leaf_hash = new_leaf_hash, - .intermediate_root = intermediate_root, - } }; + EXPECT_CALL(mock_indexed_tree_check, write(class_id, NO_SILOING, NO_PUBLIC_INPUTS_INDEX, _, _, _, prev_snapshot, _)) + .WillOnce(Return(next_snapshot)); - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + RetrievedBytecodesTreeCheck bytecodes_check(mock_indexed_tree_check, tree); + bytecodes_check.insert(class_id); + EXPECT_EQ(bytecodes_check.get_snapshot(), next_snapshot); } } // namespace diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.cpp index fb1102a40bb0..6427e6cb6683 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.cpp @@ -1,30 +1,25 @@ #include "barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp" #include "barretenberg/common/assert.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" +#include "barretenberg/vm2/common/aztec_constants.hpp" #include "barretenberg/vm2/simulation/lib/merkle.hpp" namespace bb::avm2::simulation { -FF WrittenPublicDataSlotsTreeCheck::compute_leaf_slot(const AztecAddress& contract_address, const FF& slot) -{ - return poseidon2.hash({ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot }); -} - -void WrittenPublicDataSlotsTreeCheck::validate_low_leaf_jumps_over_slot( - const WrittenPublicDataSlotsTreeLeafPreimage& low_leaf_preimage, const FF& leaf_slot) -{ - if (!field_gt.ff_gt(leaf_slot, low_leaf_preimage.leaf.slot)) { - throw std::runtime_error("Low leaf slot is GTE leaf slot"); - } - if (low_leaf_preimage.nextKey != 0 && !field_gt.ff_gt(low_leaf_preimage.nextKey, leaf_slot)) { - throw std::runtime_error("Leaf slot is GTE low leaf next slot"); - } -} - +/** + * @brief Checks whether a public data slot exists in the written public data slots tree. + * + * Computes the leaf slot from the contract address and slot, queries the in memory tree for the + * low leaf, converts it to generic IndexedTreeLeafData, and delegates the membership/non-membership + * proof to the indexed tree check gadget. Siloing is applied using the public leaf slot domain separator. + * + * @param contract_address The address of the contract that owns the slot. + * @param slot The public data slot to look up. + * @return True if the slot exists in the tree, false otherwise. + */ bool WrittenPublicDataSlotsTreeCheck::contains(const AztecAddress& contract_address, const FF& slot) { - FF leaf_slot = compute_leaf_slot(contract_address, slot); + FF leaf_slot = unconstrained_compute_leaf_slot(contract_address, slot); const auto& tree = written_public_data_slots_tree_stack.top(); const auto snapshot = tree.get_snapshot(); @@ -32,35 +27,37 @@ bool WrittenPublicDataSlotsTreeCheck::contains(const AztecAddress& contract_addr auto sibling_path = tree.get_sibling_path(low_leaf_index); auto low_leaf_preimage = tree.get_leaf_preimage(low_leaf_index); - // Low leaf membership - FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); - merkle_check.assert_membership(low_leaf_hash, low_leaf_index, sibling_path, snapshot.root); - - if (exists) { - if (low_leaf_preimage.leaf.slot != leaf_slot) { - throw std::runtime_error("Slot membership check failed"); - } - } else { - validate_low_leaf_jumps_over_slot(low_leaf_preimage, leaf_slot); - } - - events.emit(WrittenPublicDataSlotsTreeCheckEvent{ - .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf_preimage, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }); - + indexed_tree_check.assert_read(slot, + IndexedTreeSiloingParameters{ + .address = contract_address, + .siloing_separator = DOM_SEP__PUBLIC_LEAF_SLOT, + }, + exists, + IndexedTreeLeafData{ + .value = low_leaf_preimage.leaf.slot, + .next_value = low_leaf_preimage.nextKey, + .next_index = low_leaf_preimage.nextIndex, + }, + low_leaf_index, + sibling_path, + snapshot); return exists; } +/** + * @brief Inserts a public data slot into the written public data slots tree. + * + * Computes the leaf slot, performs the insertion on the in memory tree, then delegates the constrained + * write (or duplicate detection) to the indexed tree check gadget. Siloing is applied using the + * public leaf slot domain separator. + * + * @param contract_address The address of the contract that owns the slot. + * @param slot The public data slot to insert. + * @throws std::runtime_error If the indexed tree check write returns a snapshot that does not match the in memory tree. + */ void WrittenPublicDataSlotsTreeCheck::insert(const AztecAddress& contract_address, const FF& slot) { - FF leaf_slot = compute_leaf_slot(contract_address, slot); + FF leaf_slot = unconstrained_compute_leaf_slot(contract_address, slot); auto& tree = written_public_data_slots_tree_stack.top(); AppendOnlyTreeSnapshot prev_snapshot = tree.get_snapshot(); @@ -70,64 +67,41 @@ void WrittenPublicDataSlotsTreeCheck::insert(const AztecAddress& contract_addres bool exists = leaf_slot == low_leaf_preimage.leaf.slot; - AppendOnlyTreeSnapshot next_snapshot = prev_snapshot; - std::optional append_data = std::nullopt; - - FF low_leaf_hash = poseidon2.hash(low_leaf_preimage.get_hash_inputs()); - if (exists) { - merkle_check.assert_membership(low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); - } else { - validate_low_leaf_jumps_over_slot(low_leaf_preimage, leaf_slot); - // Low leaf update - WrittenPublicDataSlotsTreeLeafPreimage updated_low_leaf_preimage = low_leaf_preimage; - updated_low_leaf_preimage.nextIndex = prev_snapshot.next_available_leaf_index; - updated_low_leaf_preimage.nextKey = leaf_slot; - - FF updated_low_leaf_hash = poseidon2.hash(updated_low_leaf_preimage.get_hash_inputs()); - - FF intermediate_root = merkle_check.write( - low_leaf_hash, updated_low_leaf_hash, low_leaf_index, low_leaf_sibling_path, prev_snapshot.root); - - WrittenPublicDataSlotsTreeLeafPreimage new_leaf_preimage = WrittenPublicDataSlotsTreeLeafPreimage( - WrittenPublicDataSlotLeafValue(leaf_slot), low_leaf_preimage.nextIndex, low_leaf_preimage.nextKey); - - FF new_leaf_hash = poseidon2.hash(new_leaf_preimage.get_hash_inputs()); - - FF write_root = merkle_check.write( - FF(0), new_leaf_hash, prev_snapshot.next_available_leaf_index, insertion_sibling_path, intermediate_root); - - next_snapshot = AppendOnlyTreeSnapshot{ - .root = write_root, - .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1, - }; - // This will throw an unexpected exception if it fails. - BB_ASSERT_EQ(next_snapshot, tree.get_snapshot(), "Next snapshot mismatch"); - append_data = SlotAppendData{ - .updated_low_leaf_hash = updated_low_leaf_hash, - .new_leaf_hash = new_leaf_hash, - .intermediate_root = intermediate_root, - }; - } - - events.emit(WrittenPublicDataSlotsTreeCheckEvent{ - .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = prev_snapshot, - .next_snapshot = next_snapshot, - .low_leaf_preimage = low_leaf_preimage, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .append_data = append_data, - }); + AppendOnlyTreeSnapshot next_snapshot = + indexed_tree_check.write(slot, + IndexedTreeSiloingParameters{ + .address = contract_address, + .siloing_separator = DOM_SEP__PUBLIC_LEAF_SLOT, + }, + std::nullopt, + IndexedTreeLeafData{ + .value = low_leaf_preimage.leaf.slot, + .next_value = low_leaf_preimage.nextKey, + .next_index = low_leaf_preimage.nextIndex, + }, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + exists ? std::nullopt : std::optional(insertion_sibling_path)); + + // This will throw an unexpected exception if it fails. + BB_ASSERT_EQ(next_snapshot, tree.get_snapshot(), "Next snapshot mismatch"); } +/** + * @brief Returns the current tree snapshot from the top of the checkpoint stack. + * @return The current tree snapshot. + */ AppendOnlyTreeSnapshot WrittenPublicDataSlotsTreeCheck::get_snapshot() const { return written_public_data_slots_tree_stack.top().get_snapshot(); } +/** + * @brief Returns the number of written public data slots in the tree. + * @return The number of slots, excluding the prefill leaf at index 0. + * @note Subtracts 1 to account for the prefill leaf at index 0. + */ uint32_t WrittenPublicDataSlotsTreeCheck::size() const { // -1 Since the tree has a prefill leaf at index 0. @@ -135,12 +109,24 @@ uint32_t WrittenPublicDataSlotsTreeCheck::size() const 1; } +/** + * @brief Creates a checkpoint by pushing a copy of the current tree state onto the stack. + * + * Subsequent writes modify only the top of the stack, allowing the checkpoint to be + * reverted (discarding changes) or committed (propagating changes down). + */ void WrittenPublicDataSlotsTreeCheck::create_checkpoint() { WrittenPublicDataSlotsTree current_tree = written_public_data_slots_tree_stack.top(); written_public_data_slots_tree_stack.push(current_tree); } +/** + * @brief Commits the current checkpoint by replacing the previous tree state with the current one. + * + * Pops the top of the stack and overwrites the new top, finalizing all writes made since + * the last create_checkpoint call. + */ void WrittenPublicDataSlotsTreeCheck::commit_checkpoint() { // Commit the current top of the stack down one level. @@ -149,6 +135,12 @@ void WrittenPublicDataSlotsTreeCheck::commit_checkpoint() written_public_data_slots_tree_stack.top() = std::move(current_tree); } +/** + * @brief Reverts the current checkpoint by discarding the top of the tree state stack. + * + * All writes made since the last create_checkpoint call are discarded, restoring the + * tree to its previous state. + */ void WrittenPublicDataSlotsTreeCheck::revert_checkpoint() { written_public_data_slots_tree_stack.pop(); diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp index 2e050bcdc810..67821b08cd53 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.hpp @@ -1,14 +1,12 @@ #pragma once +#include #include +#include #include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/interfaces/db.hpp" +#include "barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/interfaces/written_public_data_slots_tree_check.hpp" #include "barretenberg/vm2/simulation/lib/written_slots_tree.hpp" @@ -16,15 +14,9 @@ namespace bb::avm2::simulation { class WrittenPublicDataSlotsTreeCheck : public WrittenPublicDataSlotsTreeCheckInterface { public: - WrittenPublicDataSlotsTreeCheck(Poseidon2Interface& poseidon2, - MerkleCheckInterface& merkle_check, - FieldGreaterThanInterface& field_gt, - WrittenPublicDataSlotsTree initial_state, - EventEmitterInterface& read_event_emitter) - : events(read_event_emitter) - , poseidon2(poseidon2) - , merkle_check(merkle_check) - , field_gt(field_gt) + WrittenPublicDataSlotsTreeCheck(IndexedTreeCheckInterface& indexed_tree_check, + WrittenPublicDataSlotsTree initial_state) + : indexed_tree_check(indexed_tree_check) { written_public_data_slots_tree_stack.push(std::move(initial_state)); } @@ -42,16 +34,9 @@ class WrittenPublicDataSlotsTreeCheck : public WrittenPublicDataSlotsTreeCheckIn void revert_checkpoint() override; private: - EventEmitterInterface& events; - Poseidon2Interface& poseidon2; - MerkleCheckInterface& merkle_check; - FieldGreaterThanInterface& field_gt; + IndexedTreeCheckInterface& indexed_tree_check; std::stack written_public_data_slots_tree_stack = {}; - - void validate_low_leaf_jumps_over_slot(const WrittenPublicDataSlotsTreeLeafPreimage& low_leaf_preimage, - const FF& leaf_slot); - FF compute_leaf_slot(const AztecAddress& contract_address, const FF& slot); }; } // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.test.cpp index de9dc06f0665..28b9eae90298 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/written_public_data_slots_tree_check.test.cpp @@ -3,343 +3,180 @@ #include #include -#include "barretenberg/crypto/merkle_tree/memory_tree.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/common/aztec_types.hpp" -#include "barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp" +#include "barretenberg/vm2/common/aztec_constants.hpp" #include "barretenberg/vm2/simulation/lib/merkle.hpp" #include "barretenberg/vm2/simulation/lib/written_slots_tree.hpp" -#include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_poseidon2.hpp" -#include "barretenberg/vm2/testing/macros.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" namespace bb::avm2::simulation { using ::testing::_; -using ::testing::ElementsAre; using ::testing::Return; using ::testing::StrictMock; -using RawPoseidon2 = crypto::Poseidon2; +const std::optional NO_PUBLIC_INPUTS_INDEX = std::nullopt; namespace { -TEST(AvmSimulationWrittenPublicDataSlotsTree, ContainsNotExists) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; +const IndexedTreeSiloingParameters SLOT_SILOING_PARAMS = { + .address = AztecAddress(27), + .siloing_separator = DOM_SEP__PUBLIC_LEAF_SLOT, +}; +const std::optional OPT_SLOT_SILOING_PARAMS = SLOT_SILOING_PARAMS; - EventEmitter event_emitter; +TEST(AvmSimulationWrittenPublicDataSlotsTreeCheck, ContainsNotExists) +{ + StrictMock mock_indexed_tree_check; + WrittenPublicDataSlotsTree tree = build_public_data_slots_tree(); FF slot = 42; - AztecAddress contract_address = AztecAddress(27); - FF leaf_slot = RawPoseidon2::hash({ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot }); - - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - - // Prefill will point to our new leaf - ASSERT_EQ(initial_state.get_snapshot().next_available_leaf_index, 1); - uint64_t low_leaf_index = 0; - WrittenPublicDataSlotsTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - - auto sibling_path = initial_state.get_sibling_path(0); - auto snapshot = initial_state.get_snapshot(); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(std::vector{ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot })) - .WillRepeatedly(Return(FF(leaf_slot))); - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - EXPECT_CALL(field_gt, ff_gt(leaf_slot, low_leaf.leaf.slot)).WillRepeatedly(Return(true)); - - EXPECT_FALSE(written_public_data_slots_tree_check.contains(contract_address, slot)); - - WrittenPublicDataSlotsTreeCheckEvent expect_event = { - .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, + AztecAddress address = SLOT_SILOING_PARAMS.address; + FF leaf_slot = unconstrained_compute_leaf_slot(address, slot); + + auto snapshot = tree.get_snapshot(); + auto [exists, low_leaf_index] = tree.get_low_indexed_leaf(leaf_slot); + auto low_leaf = tree.get_leaf_preimage(low_leaf_index); + ASSERT_FALSE(exists); + + IndexedTreeLeafData expected_leaf_data = { + .value = low_leaf.leaf.slot, + .next_value = low_leaf.nextKey, + .next_index = low_leaf.nextIndex, }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + + EXPECT_CALL(mock_indexed_tree_check, + assert_read(slot, OPT_SLOT_SILOING_PARAMS, false, expected_leaf_data, low_leaf_index, _, snapshot)); + + WrittenPublicDataSlotsTreeCheck slots_check(mock_indexed_tree_check, tree); + EXPECT_FALSE(slots_check.contains(address, slot)); } -TEST(AvmSimulationWrittenPublicDataSlotsTree, ContainsExists) +TEST(AvmSimulationWrittenPublicDataSlotsTreeCheck, ContainsExists) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); + StrictMock mock_indexed_tree_check; + WrittenPublicDataSlotsTree tree = build_public_data_slots_tree(); FF slot = 42; - AztecAddress contract_address = AztecAddress(27); - FF leaf_slot = RawPoseidon2::hash({ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot }); - - uint64_t low_leaf_index = initial_state.get_snapshot().next_available_leaf_index; - initial_state.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); - - WrittenPublicDataSlotsTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - std::vector sibling_path = initial_state.get_sibling_path(low_leaf_index); - auto snapshot = initial_state.get_snapshot(); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(std::vector{ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot })) - .WillRepeatedly(Return(FF(leaf_slot))); - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - EXPECT_TRUE(written_public_data_slots_tree_check.contains(contract_address, slot)); - - WrittenPublicDataSlotsTreeCheckEvent expect_event = { - .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, + AztecAddress address = SLOT_SILOING_PARAMS.address; + FF leaf_slot = unconstrained_compute_leaf_slot(address, slot); + tree.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); + + auto snapshot = tree.get_snapshot(); + auto [exists, low_leaf_index] = tree.get_low_indexed_leaf(leaf_slot); + auto low_leaf = tree.get_leaf_preimage(low_leaf_index); + ASSERT_TRUE(exists); + + IndexedTreeLeafData expected_leaf_data = { + .value = low_leaf.leaf.slot, + .next_value = low_leaf.nextKey, + .next_index = low_leaf.nextIndex, }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); -} -TEST(AvmSimulationWrittenPublicDataSlotsTree, ReadNotExistsLowPointsToAnotherLeaf) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; + EXPECT_CALL(mock_indexed_tree_check, + assert_read(slot, OPT_SLOT_SILOING_PARAMS, true, expected_leaf_data, low_leaf_index, _, snapshot)); - EventEmitter event_emitter; + WrittenPublicDataSlotsTreeCheck slots_check(mock_indexed_tree_check, tree); + EXPECT_TRUE(slots_check.contains(address, slot)); +} - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - // Prefill now points to leaf MAX - initial_state.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(FF::neg_one()) } }); +TEST(AvmSimulationWrittenPublicDataSlotsTreeCheck, InsertExists) +{ + StrictMock mock_indexed_tree_check; + WrittenPublicDataSlotsTree tree = build_public_data_slots_tree(); FF slot = 42; - AztecAddress contract_address = AztecAddress(27); - FF leaf_slot = RawPoseidon2::hash({ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot }); - - auto low_leaf = initial_state.get_leaf_preimage(0); - - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 0; - std::vector sibling_path = initial_state.get_sibling_path(low_leaf_index); - AppendOnlyTreeSnapshot snapshot = initial_state.get_snapshot(); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(std::vector{ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot })) - .WillRepeatedly(Return(FF(leaf_slot))); - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - EXPECT_CALL(field_gt, ff_gt(leaf_slot, low_leaf.leaf.slot)).WillRepeatedly(Return(true)); - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, leaf_slot)).WillRepeatedly(Return(true)); - - written_public_data_slots_tree_check.contains(contract_address, slot); - - WrittenPublicDataSlotsTreeCheckEvent expect_event = { - .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); -} + AztecAddress address = SLOT_SILOING_PARAMS.address; + FF leaf_slot = unconstrained_compute_leaf_slot(address, slot); + tree.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); -TEST(AvmSimulationWrittenPublicDataSlotsTree, InsertExists) -{ - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; + auto snapshot = tree.get_snapshot(); - EventEmitter event_emitter; + EXPECT_CALL(mock_indexed_tree_check, + write(slot, OPT_SLOT_SILOING_PARAMS, NO_PUBLIC_INPUTS_INDEX, _, _, _, snapshot, _)) + .WillOnce(Return(snapshot)); - FF slot = 42; - AztecAddress contract_address = AztecAddress(27); - FF leaf_slot = RawPoseidon2::hash({ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot }); - - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - uint64_t low_leaf_index = initial_state.get_snapshot().next_available_leaf_index; - initial_state.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); - - WrittenPublicDataSlotsTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - std::vector sibling_path = initial_state.get_sibling_path(low_leaf_index); - AppendOnlyTreeSnapshot snapshot = initial_state.get_snapshot(); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(std::vector{ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot })) - .WillRepeatedly(Return(FF(leaf_slot))); - EXPECT_CALL(poseidon2, hash(low_leaf.get_hash_inputs())).WillRepeatedly(Return(FF(low_leaf_hash))); - EXPECT_CALL(merkle_check, assert_membership(low_leaf_hash, low_leaf_index, _, snapshot.root)) - .WillRepeatedly(Return()); - - written_public_data_slots_tree_check.insert(contract_address, slot); - - EXPECT_EQ(written_public_data_slots_tree_check.get_snapshot(), snapshot); - - WrittenPublicDataSlotsTreeCheckEvent expect_event = { - .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = snapshot, - .next_snapshot = snapshot, - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - }; - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + WrittenPublicDataSlotsTreeCheck slots_check(mock_indexed_tree_check, tree); + slots_check.insert(address, slot); + EXPECT_EQ(slots_check.get_snapshot(), snapshot); } -TEST(AvmSimulationWrittenPublicDataSlotsTree, InsertAppend) +TEST(AvmSimulationWrittenPublicDataSlotsTreeCheck, InsertAppend) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; + StrictMock mock_indexed_tree_check; + WrittenPublicDataSlotsTree tree = build_public_data_slots_tree(); FF slot = 100; - AztecAddress contract_address = AztecAddress(27); - FF leaf_slot = RawPoseidon2::hash({ DOM_SEP__PUBLIC_LEAF_SLOT, contract_address, slot }); - - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - // Prefill will point to our new leaf - ASSERT_EQ(initial_state.get_snapshot().next_available_leaf_index, 1); - uint64_t low_leaf_index = 0; - uint64_t new_leaf_index = 1; - WrittenPublicDataSlotsTreeLeafPreimage low_leaf = initial_state.get_leaf_preimage(low_leaf_index); - - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - WrittenPublicDataSlotsTree state_after_insert = initial_state; - state_after_insert.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); - - std::vector low_leaf_sibling_path = initial_state.get_sibling_path(low_leaf_index); - - WrittenPublicDataSlotsTreeLeafPreimage updated_low_leaf = low_leaf; - updated_low_leaf.nextIndex = new_leaf_index; - updated_low_leaf.nextKey = leaf_slot; - FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); - - FF intermediate_root = unconstrained_root_from_path(updated_low_leaf_hash, low_leaf_index, low_leaf_sibling_path); - std::vector insertion_sibling_path = state_after_insert.get_sibling_path(new_leaf_index); - - WrittenPublicDataSlotsTreeLeafPreimage new_leaf = WrittenPublicDataSlotsTreeLeafPreimage( - WrittenPublicDataSlotLeafValue(leaf_slot), low_leaf.nextIndex, low_leaf.nextKey); - FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); - - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); - - EXPECT_CALL(poseidon2, hash(_)).WillRepeatedly([](const std::vector& input) { - return RawPoseidon2::hash(input); - }); - EXPECT_CALL(merkle_check, - write(low_leaf_hash, updated_low_leaf_hash, low_leaf_index, _, initial_state.get_snapshot().root)) - .WillRepeatedly(Return(intermediate_root)); - EXPECT_CALL(field_gt, ff_gt(leaf_slot, low_leaf.leaf.slot)).WillRepeatedly(Return(true)); - EXPECT_CALL(field_gt, ff_gt(low_leaf.nextKey, leaf_slot)).WillRepeatedly(Return(true)); - EXPECT_CALL(merkle_check, write(FF(0), new_leaf_hash, new_leaf_index, _, intermediate_root)) - .WillRepeatedly(Return(state_after_insert.get_snapshot().root)); - - written_public_data_slots_tree_check.insert(contract_address, slot); - - EXPECT_EQ(written_public_data_slots_tree_check.get_snapshot(), state_after_insert.get_snapshot()); - - WrittenPublicDataSlotsTreeCheckEvent expect_event = { .contract_address = contract_address, - .slot = slot, - .leaf_slot = leaf_slot, - .prev_snapshot = initial_state.get_snapshot(), - .next_snapshot = state_after_insert.get_snapshot(), - .low_leaf_preimage = low_leaf, - .low_leaf_hash = low_leaf_hash, - .low_leaf_index = low_leaf_index, - .write = true, - .append_data = SlotAppendData{ - .updated_low_leaf_hash = updated_low_leaf_hash, - .new_leaf_hash = new_leaf_hash, - .intermediate_root = intermediate_root, - } }; - - EXPECT_THAT(event_emitter.dump_events(), ElementsAre(expect_event)); + AztecAddress address = SLOT_SILOING_PARAMS.address; + FF leaf_slot = unconstrained_compute_leaf_slot(address, slot); + auto prev_snapshot = tree.get_snapshot(); + + // Compute expected post-insert state. + WrittenPublicDataSlotsTree tree_after = tree; + tree_after.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); + auto next_snapshot = tree_after.get_snapshot(); + + EXPECT_CALL(mock_indexed_tree_check, + write(slot, OPT_SLOT_SILOING_PARAMS, NO_PUBLIC_INPUTS_INDEX, _, _, _, prev_snapshot, _)) + .WillOnce(Return(next_snapshot)); + + WrittenPublicDataSlotsTreeCheck slots_check(mock_indexed_tree_check, tree); + slots_check.insert(address, slot); + EXPECT_EQ(slots_check.get_snapshot(), next_snapshot); } -TEST(AvmSimulationWrittenPublicDataSlotsTree, CheckpointBehavior) +TEST(AvmSimulationWrittenPublicDataSlotsTreeCheck, CheckpointBehavior) { - StrictMock poseidon2; - StrictMock merkle_check; - StrictMock field_gt; - - EventEmitter event_emitter; - - EXPECT_CALL(poseidon2, hash(_)).WillRepeatedly([](const std::vector& input) { - return RawPoseidon2::hash(input); - }); - EXPECT_CALL(merkle_check, write) - .WillRepeatedly( - [](FF current_leaf, FF new_leaf, uint64_t leaf_index, std::span sibling_path, FF prev_root) { - EXPECT_EQ(unconstrained_root_from_path(current_leaf, leaf_index, sibling_path), prev_root); - return unconstrained_root_from_path(new_leaf, leaf_index, sibling_path); - }); - EXPECT_CALL(merkle_check, assert_membership(_, _, _, _)) - .WillRepeatedly([](FF current_leaf, uint64_t leaf_index, std::span sibling_path, FF prev_root) { - EXPECT_EQ(unconstrained_root_from_path(current_leaf, leaf_index, sibling_path), prev_root); + // Use NiceMock since checkpoint behavior exercises multiple contains/inserts and + // we don't want to specify exact expectations for every internal call. + testing::NiceMock mock_indexed_tree_check; + WrittenPublicDataSlotsTree tree = build_public_data_slots_tree(); + + // Track inserts in a parallel tree so the write mock returns correct snapshots. + WrittenPublicDataSlotsTree parallel_tree = tree; + ON_CALL(mock_indexed_tree_check, write) + .WillByDefault([¶llel_tree](const FF& slot, + std::optional siloing_params, + std::optional, + const IndexedTreeLeafData&, + uint64_t, + std::span, + const AppendOnlyTreeSnapshot&, + std::optional> insertion_path) -> AppendOnlyTreeSnapshot { + if (insertion_path.has_value()) { + FF leaf_slot = unconstrained_compute_leaf_slot(siloing_params.value().address, slot); + parallel_tree.insert_indexed_leaves({ { WrittenPublicDataSlotLeafValue(leaf_slot) } }); + } + return parallel_tree.get_snapshot(); }); - EXPECT_CALL(field_gt, ff_gt(_, _)).WillRepeatedly(Return(true)); - WrittenPublicDataSlotsTree initial_state = build_public_data_slots_tree(); - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check( - poseidon2, merkle_check, field_gt, initial_state, event_emitter); + WrittenPublicDataSlotsTreeCheck slots_check(mock_indexed_tree_check, tree); - EXPECT_EQ(written_public_data_slots_tree_check.size(), 0); - written_public_data_slots_tree_check.create_checkpoint(); + EXPECT_EQ(slots_check.size(), 0); + slots_check.create_checkpoint(); - written_public_data_slots_tree_check.insert(AztecAddress(1), 1); - EXPECT_TRUE(written_public_data_slots_tree_check.contains(AztecAddress(1), 1)); - EXPECT_EQ(written_public_data_slots_tree_check.size(), 1); + AztecAddress address1 = AztecAddress(1); + slots_check.insert(address1, 1); + EXPECT_TRUE(slots_check.contains(address1, 1)); + EXPECT_EQ(slots_check.size(), 1); - // Commit the checkpoint - written_public_data_slots_tree_check.commit_checkpoint(); - EXPECT_TRUE(written_public_data_slots_tree_check.contains(AztecAddress(1), 1)); - EXPECT_EQ(written_public_data_slots_tree_check.size(), 1); + // Commit the checkpoint. + slots_check.commit_checkpoint(); + EXPECT_TRUE(slots_check.contains(address1, 1)); + EXPECT_EQ(slots_check.size(), 1); - // Create another checkpoint - written_public_data_slots_tree_check.create_checkpoint(); + // Create another checkpoint. + slots_check.create_checkpoint(); - // Insert another slot - written_public_data_slots_tree_check.insert(AztecAddress(2), 2); - EXPECT_TRUE(written_public_data_slots_tree_check.contains(AztecAddress(2), 2)); - EXPECT_EQ(written_public_data_slots_tree_check.size(), 2); + // Insert another slot. + AztecAddress address2 = AztecAddress(2); + slots_check.insert(address2, 2); + EXPECT_TRUE(slots_check.contains(address2, 2)); + EXPECT_EQ(slots_check.size(), 2); - // Revert the checkpoint - written_public_data_slots_tree_check.revert_checkpoint(); - EXPECT_TRUE(written_public_data_slots_tree_check.contains(AztecAddress(1), 1)); - EXPECT_EQ(written_public_data_slots_tree_check.size(), 1); + // Revert the checkpoint. + slots_check.revert_checkpoint(); + EXPECT_TRUE(slots_check.contains(address1, 1)); + EXPECT_EQ(slots_check.size(), 1); } } // namespace diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/nullifier_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp similarity index 57% rename from barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/nullifier_tree_check.hpp rename to barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp index 76cfb650f8bc..4ed29f832087 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/nullifier_tree_check.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp @@ -5,24 +5,25 @@ #include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/common/field.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/simulation/lib/db_types.hpp" namespace bb::avm2::simulation { -class NullifierTreeCheckInterface { +class IndexedTreeCheckInterface { public: - virtual ~NullifierTreeCheckInterface() = default; - virtual void assert_read(const FF& nullifier, - std::optional contract_address, + virtual ~IndexedTreeCheckInterface() = default; + virtual void assert_read(const FF& value, + std::optional siloing_params, bool exists, - const NullifierTreeLeafPreimage& low_leaf_preimage, + const IndexedTreeLeafData& low_leaf_preimage, uint64_t low_leaf_index, std::span sibling_path, const AppendOnlyTreeSnapshot& snapshot) = 0; - virtual AppendOnlyTreeSnapshot write(const FF& nullifier, - std::optional contract_address, - uint64_t nullifier_counter, - const NullifierTreeLeafPreimage& low_leaf_preimage, + virtual AppendOnlyTreeSnapshot write(const FF& value, + std::optional siloing_params, + std::optional public_inputs_index, + const IndexedTreeLeafData& low_leaf_preimage, uint64_t low_leaf_index, std::span low_leaf_sibling_path, const AppendOnlyTreeSnapshot& prev_snapshot, diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/retrieved_bytecodes_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/retrieved_bytecodes_tree_check.hpp index 1491233e0430..d578860391e5 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/retrieved_bytecodes_tree_check.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/retrieved_bytecodes_tree_check.hpp @@ -1,5 +1,6 @@ #pragma once +#include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/common/field.hpp" namespace bb::avm2::simulation { diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp similarity index 58% rename from barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp rename to barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp index 71b6bb2f2dd2..f7f9e829bd52 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp @@ -2,7 +2,7 @@ #include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/common/field.hpp" -#include "barretenberg/vm2/simulation/interfaces/nullifier_tree_check.hpp" +#include "barretenberg/vm2/simulation/interfaces/indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/lib/db_types.hpp" #include @@ -12,17 +12,17 @@ namespace bb::avm2::simulation { -class MockNullifierTreeCheck : public NullifierTreeCheckInterface { +class MockIndexedTreeCheck : public IndexedTreeCheckInterface { public: - MockNullifierTreeCheck(); - ~MockNullifierTreeCheck() override; + MockIndexedTreeCheck(); + ~MockIndexedTreeCheck() override; MOCK_METHOD(void, assert_read, - (const FF& nullifier, - std::optional contract_address, + (const FF& value, + std::optional siloing_params, bool exists, - const NullifierTreeLeafPreimage& low_leaf_preimage, + const IndexedTreeLeafData& low_leaf_preimage, uint64_t low_leaf_index, std::span sibling_path, const AppendOnlyTreeSnapshot& snapshot), @@ -30,13 +30,14 @@ class MockNullifierTreeCheck : public NullifierTreeCheckInterface { MOCK_METHOD(AppendOnlyTreeSnapshot, write, - (const FF& nullifier, - std::optional contract_address, - uint64_t nullifier_counter, - const NullifierTreeLeafPreimage& low_leaf_preimage, + (const FF& value, + std::optional siloing_params, + std::optional public_inputs_index, + const IndexedTreeLeafData& low_leaf_preimage, uint64_t low_leaf_index, std::span low_leaf_sibling_path, const AppendOnlyTreeSnapshot& prev_snapshot, + // Null if this is a failing write. std::optional> insertion_sibling_path), (override)); }; diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_indexed_tree_check.test.cpp similarity index 51% rename from barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.test.cpp rename to barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_indexed_tree_check.test.cpp index 3e896d49bb8a..4f1f1f720a1c 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_indexed_tree_check.test.cpp @@ -1,9 +1,9 @@ // This is not a test file but we need to use .test.cpp so that it is not included in non-test builds. -#include "mock_nullifier_tree_check.hpp" +#include "mock_indexed_tree_check.hpp" namespace bb::avm2::simulation { -MockNullifierTreeCheck::MockNullifierTreeCheck() = default; -MockNullifierTreeCheck::~MockNullifierTreeCheck() = default; +MockIndexedTreeCheck::MockIndexedTreeCheck() = default; +MockIndexedTreeCheck::~MockIndexedTreeCheck() = default; } // namespace bb::avm2::simulation diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp index 5e410c269b21..b2468f74de92 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp @@ -34,10 +34,10 @@ #include "barretenberg/vm2/simulation/events/execution_event.hpp" #include "barretenberg/vm2/simulation/events/field_gt_event.hpp" #include "barretenberg/vm2/simulation/events/get_contract_instance_event.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/keccakf1600_event.hpp" #include "barretenberg/vm2/simulation/events/memory_event.hpp" #include "barretenberg/vm2/simulation/events/merkle_check_event.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/public_data_tree_check_event.hpp" #include "barretenberg/vm2/simulation/events/range_check_event.hpp" #include "barretenberg/vm2/simulation/events/sha256_event.hpp" @@ -163,18 +163,16 @@ std::tuple AvmSimulationHelper::simulate_fo DefaultEventEmitter context_stack_emitter; DefaultEventEmitter public_data_tree_check_emitter; DefaultEventEmitter update_check_emitter; - DefaultEventEmitter nullifier_tree_check_emitter; + DefaultEventEmitter indexed_tree_check_emitter; DefaultEventEmitter tx_event_emitter; DefaultEventEmitter calldata_emitter; DefaultEventEmitter internal_call_stack_emitter; DefaultEventEmitter note_hash_tree_check_emitter; - DefaultEventEmitter written_public_data_slots_tree_check_emitter; DefaultDeduplicatingEventEmitter greater_than_emitter; DefaultEventEmitter contract_instance_retrieval_emitter; DefaultEventEmitter get_contract_instance_emitter; DefaultEventEmitter l1_to_l2_msg_tree_check_emitter; DefaultEventEmitter emit_public_log_emitter; - DefaultEventEmitter retrieved_bytecodes_tree_check_emitter; ExecutionIdManager execution_id_manager(1); RangeCheck range_check(range_check_emitter); @@ -186,14 +184,11 @@ std::tuple AvmSimulationHelper::simulate_fo MerkleCheck merkle_check(poseidon2, merkle_check_emitter); PublicDataTreeCheck public_data_tree_check( poseidon2, merkle_check, field_gt, execution_id_manager, public_data_tree_check_emitter); - WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(poseidon2, - merkle_check, - field_gt, - build_public_data_slots_tree(), - written_public_data_slots_tree_check_emitter); - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, build_retrieved_bytecodes_tree(), retrieved_bytecodes_tree_check_emitter); - NullifierTreeCheck nullifier_tree_check(poseidon2, merkle_check, field_gt, nullifier_tree_check_emitter); + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_emitter); + + WrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(indexed_tree_check, + build_public_data_slots_tree()); + RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check(indexed_tree_check, build_retrieved_bytecodes_tree()); // The protocol requires at least one non-revertible nullifier in the transaction (used for uniqueness of note // hashes). @@ -218,12 +213,12 @@ std::tuple AvmSimulationHelper::simulate_fo MerkleDB base_merkle_db(raw_merkle_db, public_data_tree_check, - nullifier_tree_check, + indexed_tree_check, note_hash_tree_check, written_public_data_slots_tree_check, l1_to_l2_msg_tree_check); base_merkle_db.add_checkpoint_listener(note_hash_tree_check); - base_merkle_db.add_checkpoint_listener(nullifier_tree_check); + base_merkle_db.add_checkpoint_listener(indexed_tree_check); base_merkle_db.add_checkpoint_listener(public_data_tree_check); // This one is only needed for events. base_merkle_db.add_checkpoint_listener(emit_public_log_component); @@ -356,17 +351,15 @@ std::tuple AvmSimulationHelper::simulate_fo context_stack_emitter.dump_events(), public_data_tree_check_emitter.dump_events(), update_check_emitter.dump_events(), - nullifier_tree_check_emitter.dump_events(), + indexed_tree_check_emitter.dump_events(), data_copy_emitter.dump_events(), calldata_emitter.dump_events(), internal_call_stack_emitter.dump_events(), note_hash_tree_check_emitter.dump_events(), - written_public_data_slots_tree_check_emitter.dump_events(), contract_instance_retrieval_emitter.dump_events(), get_contract_instance_emitter.dump_events(), l1_to_l2_msg_tree_check_emitter.dump_events(), emit_public_log_emitter.dump_events(), - retrieved_bytecodes_tree_check_emitter.dump_events(), }; TxSimulationResult tx_simulation_result = { @@ -407,8 +400,8 @@ TxSimulationResult AvmSimulationHelper::simulate_fast_internal(ContractDBInterfa NoopEventEmitter contract_instance_retrieval_emitter; NoopEventEmitter get_contract_instance_emitter; NoopEventEmitter emit_public_log_emitter; - NoopEventEmitter retrieved_bytecodes_tree_check_emitter; NoopEventEmitter update_check_emitter; + NoopEventEmitter indexed_tree_check_emitter; ExecutionIdManager execution_id_manager(1); RangeCheck range_check(range_check_emitter); @@ -418,8 +411,8 @@ TxSimulationResult AvmSimulationHelper::simulate_fast_internal(ContractDBInterfa PurePoseidon2 poseidon2; MerkleCheck merkle_check(poseidon2, merkle_check_emitter); PureWrittenPublicDataSlotsTreeCheck written_public_data_slots_tree_check(poseidon2); - RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check( - poseidon2, merkle_check, field_gt, build_retrieved_bytecodes_tree(), retrieved_bytecodes_tree_check_emitter); + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_emitter); + RetrievedBytecodesTreeCheck retrieved_bytecodes_tree_check(indexed_tree_check, build_retrieved_bytecodes_tree()); EmitPublicLog emit_public_log_component(execution_id_manager, greater_than, emit_public_log_emitter); PureAlu alu; PureBitwise bitwise; diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp index ca8f7806ddeb..63a05c5bc3df 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp @@ -277,6 +277,7 @@ void BytecodeTraceBuilder::process_retrieval( { C::bc_retrieval_remaining_bytecodes_inv, remaining_bytecodes }, // Will be inverted in batch later. { C::bc_retrieval_is_new_class, event.is_new_class }, { C::bc_retrieval_should_retrieve, !error }, + { C::bc_retrieval_retrieved_bytecodes_tree_height, AVM_RETRIEVED_BYTECODES_TREE_HEIGHT }, // Contract class for bytecode operations { C::bc_retrieval_artifact_hash, event.contract_class.artifact_hash }, diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/contract_instance_retrieval_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/contract_instance_retrieval_trace.cpp index 3b048b8dad57..be96e3e287d4 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/contract_instance_retrieval_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/contract_instance_retrieval_trace.cpp @@ -85,6 +85,8 @@ void ContractInstanceRetrievalTraceBuilder::process( { C::contract_instance_retrieval_derived_address, derived_address }, { C::contract_instance_retrieval_is_protocol_contract, event.is_protocol_contract ? 1 : 0 }, { C::contract_instance_retrieval_should_check_nullifier, !event.is_protocol_contract ? 1 : 0 }, + { C::contract_instance_retrieval_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::contract_instance_retrieval_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, { C::contract_instance_retrieval_should_check_for_update, check_update ? 1 : 0 }, } }); row++; diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp index 14a9be305fac..a2256ccb5d7f 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp @@ -522,6 +522,13 @@ void ExecutionTraceBuilder::process( { C::execution_sel_use_num_limbs, num_limbs > num_p_limbs ? 1 : 0 }, // Don't set dyn gas factor here since already set in process_gas } }); + } else if (*exec_opcode == ExecutionOpCode::SSTORE) { + trace.set(row, + { { + // SSTORE Dynamic Gas + { C::execution_written_slots_tree_height, AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT }, + { C::execution_written_slots_tree_siloing_separator, DOM_SEP__PUBLIC_LEAF_SLOT }, + } }); } } @@ -611,6 +618,8 @@ void ExecutionTraceBuilder::process( { C::execution_remaining_data_writes_inv, remaining_data_writes }, // Will be inverted in batch later. { C::execution_sel_write_public_data, !opcode_execution_failed }, + { C::execution_written_slots_tree_height, AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT }, + { C::execution_written_slots_tree_siloing_separator, DOM_SEP__PUBLIC_LEAF_SLOT }, } }); } else if (*exec_opcode == ExecutionOpCode::NOTEHASHEXISTS) { uint64_t leaf_index = registers[1].as(); @@ -643,20 +652,26 @@ void ExecutionTraceBuilder::process( { C::execution_l1_to_l2_msg_leaf_in_range, l1_to_l2_msg_leaf_in_range }, { C::execution_l1_to_l2_msg_tree_leaf_count, FF(l1_to_l2_msg_tree_leaf_count) }, } }); - //} else if (exec_opcode == ExecutionOpCode::NULLIFIEREXISTS) { - // no custom columns! + } else if (exec_opcode == ExecutionOpCode::NULLIFIEREXISTS) { + trace.set(row, + { { + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + } }); } else if (*exec_opcode == ExecutionOpCode::EMITNULLIFIER) { uint32_t remaining_nullifiers = MAX_NULLIFIERS_PER_TX - ex_event.before_context_event.tree_states.nullifier_tree.counter; trace.set(row, - { { - { C::execution_sel_reached_max_nullifiers, remaining_nullifiers == 0 }, + { { { C::execution_sel_reached_max_nullifiers, remaining_nullifiers == 0 }, { C::execution_remaining_nullifiers_inv, remaining_nullifiers }, // Will be inverted in batch later. { C::execution_sel_write_nullifier, remaining_nullifiers != 0 && !ex_event.before_context_event.is_static }, - } }); + { C::execution_nullifier_pi_offset, + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + + ex_event.before_context_event.tree_states.nullifier_tree.counter }, + { C::execution_nullifier_tree_height, NULLIFIER_TREE_HEIGHT }, + { C::execution_nullifier_siloing_separator, DOM_SEP__SILOED_NULLIFIER } } }); } else if (*exec_opcode == ExecutionOpCode::SENDL2TOL1MSG) { uint32_t remaining_l2_to_l1_msgs = MAX_L2_TO_L1_MSGS_PER_TX - ex_event.before_context_event.numL2ToL1Messages; diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.cpp new file mode 100644 index 000000000000..2b6b711df78f --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.cpp @@ -0,0 +1,130 @@ +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" + +#include + +#include "barretenberg/vm2/common/field.hpp" +#include "barretenberg/vm2/generated/columns.hpp" +#include "barretenberg/vm2/generated/relations/lookups_indexed_tree_check.hpp" +#include "barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp" + +namespace bb::avm2::tracegen { + +/** + * @brief Process generic indexed tree check events and populate the relevant columns in the trace. + * + * The event stream contains both read/write events and checkpoint events (create, commit, revert). + * We use process_with_discard to consume the checkpoint events and reconstruct a discard flag for + * each read/write event, indicating whether it belongs to a reverted checkpoint. Discarded events + * still produce trace rows but are excluded from public input writes. + * + * Each non-checkpoint event produces one trace row covering: siloing, low leaf validation, indexed tree + * membership checks, low leaf updates, new leaf insertion, and Merkle proofs. + * + * @param events The container of indexed tree check events to process. + * @param trace The trace container to populate with indexed tree check rows. + */ +void IndexedTreeCheckTraceBuilder::process( + const simulation::EventEmitterInterface::Container& events, + TraceContainer& trace) +{ + using C = Column; + + uint32_t row = 0; + process_with_discard(events, [&](const simulation::IndexedTreeReadWriteEvent& event, bool discard) { + FF value = event.value; + FF siloed_value = event.value; + FF address = 0; + FF siloing_separator = 0; + + if (event.siloing_data.has_value()) { + siloed_value = event.siloing_data->siloed_value; + address = event.siloing_data->parameters.address; + siloing_separator = event.siloing_data->parameters.siloing_separator; + } + + bool exists = event.low_leaf_data.value == siloed_value; + FF value_low_leaf_value_diff = siloed_value - event.low_leaf_data.value; + + bool next_value_is_nonzero = false; + FF next_value = 0; + if (!exists) { + next_value_is_nonzero = event.low_leaf_data.next_value != 0; + next_value = event.low_leaf_data.next_value; + } + + uint64_t updated_low_leaf_next_index = 0; + FF updated_low_leaf_next_key = 0; + FF updated_low_leaf_hash = 0; + FF new_leaf_hash = 0; + FF intermediate_root = 0; + + bool append = event.append_data.has_value(); + if (append) { + updated_low_leaf_next_key = siloed_value; + updated_low_leaf_next_index = event.prev_snapshot.next_available_leaf_index; + updated_low_leaf_hash = event.append_data->updated_low_leaf_hash; + new_leaf_hash = event.append_data->new_leaf_hash; + intermediate_root = event.append_data->intermediate_root; + } + + trace.set(row, + { { + { C::indexed_tree_check_sel, 1 }, + { C::indexed_tree_check_const_three, 3 }, + { C::indexed_tree_check_write, event.write }, + { C::indexed_tree_check_value, value }, + { C::indexed_tree_check_root, event.prev_snapshot.root }, + { C::indexed_tree_check_exists, exists }, + { C::indexed_tree_check_not_exists, !exists }, + { C::indexed_tree_check_write_root, event.next_snapshot.root }, + { C::indexed_tree_check_tree_size_before_write, event.prev_snapshot.next_available_leaf_index }, + { C::indexed_tree_check_tree_size_after_write, event.next_snapshot.next_available_leaf_index }, + { C::indexed_tree_check_discard, !event.public_inputs_index.has_value() || discard }, + { C::indexed_tree_check_public_inputs_index, event.public_inputs_index.value_or(0) }, + { C::indexed_tree_check_sel_silo, event.siloing_data.has_value() }, + { C::indexed_tree_check_address, address }, + { C::indexed_tree_check_low_leaf_value, event.low_leaf_data.value }, + { C::indexed_tree_check_low_leaf_next_index, event.low_leaf_data.next_index }, + { C::indexed_tree_check_low_leaf_next_value, event.low_leaf_data.next_value }, + { C::indexed_tree_check_updated_low_leaf_next_index, updated_low_leaf_next_index }, + { C::indexed_tree_check_updated_low_leaf_next_value, updated_low_leaf_next_key }, + { C::indexed_tree_check_low_leaf_index, event.low_leaf_index }, + { C::indexed_tree_check_siloed_value, siloed_value }, + { C::indexed_tree_check_siloing_separator, siloing_separator }, + { C::indexed_tree_check_sel_insert, append }, + { C::indexed_tree_check_low_leaf_hash, event.low_leaf_hash }, + { C::indexed_tree_check_intermediate_root, intermediate_root }, + { C::indexed_tree_check_updated_low_leaf_hash, updated_low_leaf_hash }, + { C::indexed_tree_check_tree_height, event.tree_height }, + { C::indexed_tree_check_value_low_leaf_value_diff_inv, + value_low_leaf_value_diff }, // Will be inverted in batch later + { C::indexed_tree_check_next_value_is_nonzero, next_value_is_nonzero }, + { C::indexed_tree_check_next_value_inv, next_value }, // Will be inverted in batch later + { C::indexed_tree_check_new_leaf_hash, new_leaf_hash }, + { C::indexed_tree_check_sel_write_to_public_inputs, + event.public_inputs_index.has_value() && event.append_data.has_value() && !discard }, + } }); + row++; + }); + + // Batch invert the columns. + trace.invert_columns( + { { C::indexed_tree_check_value_low_leaf_value_diff_inv, C::indexed_tree_check_next_value_inv } }); +} + +const InteractionDefinition IndexedTreeCheckTraceBuilder::interactions = + InteractionDefinition() + .add() + .add() + .add() + .add() + .add() // ff_gt deduplicates + .add() // ff_gt deduplicates + .add() + .add() + .add(); + +} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp similarity index 66% rename from barretenberg/cpp/src/barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp rename to barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp index 581cecb27670..e67ab1fd2b0d 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp @@ -1,16 +1,15 @@ #pragma once -#include "barretenberg/vm2/generated/columns.hpp" #include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" #include "barretenberg/vm2/tracegen/lib/interaction_def.hpp" #include "barretenberg/vm2/tracegen/trace_container.hpp" namespace bb::avm2::tracegen { -class NullifierTreeCheckTraceBuilder final { +class IndexedTreeCheckTraceBuilder final { public: - void process(const simulation::EventEmitterInterface::Container& events, + void process(const simulation::EventEmitterInterface::Container& events, TraceContainer& trace); static const InteractionDefinition interactions; diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.test.cpp new file mode 100644 index 000000000000..ce29352647e7 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/indexed_tree_check_trace.test.cpp @@ -0,0 +1,233 @@ +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" + +#include +#include +#include + +#include "barretenberg/crypto/poseidon2/poseidon2.hpp" +#include "barretenberg/vm2/constraining/flavor_settings.hpp" +#include "barretenberg/vm2/constraining/testing/check_relation.hpp" +#include "barretenberg/vm2/generated/relations/lookups_indexed_tree_check.hpp" +#include "barretenberg/vm2/simulation/events/event_emitter.hpp" +#include "barretenberg/vm2/simulation/events/indexed_tree_check_event.hpp" +#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" +#include "barretenberg/vm2/simulation/gadgets/indexed_tree_check.hpp" +#include "barretenberg/vm2/simulation/gadgets/merkle_check.hpp" +#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" +#include "barretenberg/vm2/simulation/lib/merkle.hpp" +#include "barretenberg/vm2/simulation/testing/mock_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" +#include "barretenberg/vm2/testing/fixtures.hpp" +#include "barretenberg/vm2/testing/test_tree.hpp" +#include "barretenberg/vm2/tracegen/field_gt_trace.hpp" +#include "barretenberg/vm2/tracegen/lib/lookup_builder.hpp" +#include "barretenberg/vm2/tracegen/merkle_check_trace.hpp" +#include "barretenberg/vm2/tracegen/poseidon2_trace.hpp" +#include "barretenberg/vm2/tracegen/test_trace_container.hpp" + +namespace bb::avm2::tracegen { +namespace { + +using ::testing::NiceMock; + +using testing::TestMemoryTree; + +using simulation::DeduplicatingEventEmitter; +using simulation::EventEmitter; +using simulation::ExecutionIdManager; +using simulation::FieldGreaterThan; +using simulation::FieldGreaterThanEvent; +using simulation::IndexedTreeCheck; +using simulation::IndexedTreeCheckEvent; +using simulation::IndexedTreeLeafData; +using simulation::IndexedTreeSiloingParameters; +using simulation::MerkleCheck; +using simulation::MerkleCheckEvent; +using simulation::MockGreaterThan; +using simulation::MockRangeCheck; +using simulation::Poseidon2; +using simulation::Poseidon2HashEvent; +using simulation::Poseidon2PermutationEvent; +using simulation::Poseidon2PermutationMemoryEvent; +using simulation::unconstrained_root_from_path; + +using constraining::check_interaction; + +using FF = AvmFlavorSettings::FF; +using C = Column; +using RawPoseidon2 = crypto::Poseidon2; + +constexpr size_t TREE_HEIGHT = 8; + +class IndexedTreeCheckTracegenTest : public ::testing::Test { + protected: + IndexedTreeCheckTracegenTest() + : execution_id_manager(0) {}; + + EventEmitter hash_event_emitter; + EventEmitter perm_event_emitter; + EventEmitter perm_mem_event_emitter; + + ExecutionIdManager execution_id_manager; + NiceMock mock_gt; + Poseidon2 poseidon2 = + Poseidon2(execution_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); +}; + +struct TestParams { + FF value; + bool exists; + IndexedTreeLeafData low_leaf; +}; + +std::vector positive_read_tests = { + // Exists = true, leaf points to infinity + TestParams{ .value = 42, .exists = true, .low_leaf = { .value = 42, .next_value = 0, .next_index = 0 } }, + // Exists = true, leaf points to higher value + TestParams{ .value = 42, .exists = true, .low_leaf = { .value = 42, .next_value = 50, .next_index = 28 } }, + // Exists = false, low leaf points to infinity + TestParams{ .value = 42, .exists = false, .low_leaf = { .value = 10, .next_value = 0, .next_index = 0 } }, + // Exists = false, low leaf points to higher value + TestParams{ .value = 42, .exists = false, .low_leaf = { .value = 10, .next_value = 50, .next_index = 28 } } +}; + +class ReadInteractionsTests : public IndexedTreeCheckTracegenTest, public ::testing::WithParamInterface {}; + +TEST_P(ReadInteractionsTests, PositiveWithInteractions) +{ + const auto& param = GetParam(); + + EventEmitter merkle_event_emitter; + MerkleCheck merkle_check(poseidon2, merkle_event_emitter); + + NiceMock range_check; + + DeduplicatingEventEmitter field_gt_event_emitter; + FieldGreaterThan field_gt(range_check, field_gt_event_emitter); + + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); + + TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); + Poseidon2TraceBuilder poseidon2_builder; + MerkleCheckTraceBuilder merkle_check_builder; + FieldGreaterThanTraceBuilder field_gt_builder; + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; + + FF low_leaf_hash = poseidon2.hash(param.low_leaf.get_hash_inputs()); + uint64_t leaf_index = 30; + std::vector sibling_path; + sibling_path.reserve(TREE_HEIGHT); + for (size_t i = 0; i < TREE_HEIGHT; ++i) { + sibling_path.emplace_back(i); + } + FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); + + indexed_tree_check.assert_read(param.value, + std::nullopt, + param.exists, + param.low_leaf, + leaf_index, + sibling_path, + AppendOnlyTreeSnapshot{ .root = root }); + + poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); + merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); + field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); + indexed_tree_check_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); + + check_interaction(trace); +} + +INSTANTIATE_TEST_SUITE_P(IndexedTreeCheckTracegenTest, ReadInteractionsTests, ::testing::ValuesIn(positive_read_tests)); + +TEST_F(IndexedTreeCheckTracegenTest, WriteWithInteractions) +{ + EventEmitter merkle_event_emitter; + MerkleCheck merkle_check(poseidon2, merkle_event_emitter); + + NiceMock range_check; + + DeduplicatingEventEmitter field_gt_event_emitter; + FieldGreaterThan field_gt(range_check, field_gt_event_emitter); + + EventEmitter indexed_tree_check_event_emitter; + IndexedTreeCheck indexed_tree_check(poseidon2, merkle_check, field_gt, indexed_tree_check_event_emitter); + + TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); + Poseidon2TraceBuilder poseidon2_builder; + MerkleCheckTraceBuilder merkle_check_builder; + FieldGreaterThanTraceBuilder field_gt_builder; + IndexedTreeCheckTraceBuilder indexed_tree_check_builder; + + AztecAddress contract_address = AztecAddress(1); + FF value = 100; + FF siloing_separator = 42; + FF siloed_value = RawPoseidon2::hash({ siloing_separator, contract_address, value }); + FF low_value = 40; + TestMemoryTree tree(8, TREE_HEIGHT); + + IndexedTreeLeafData low_leaf = { .value = low_value, .next_value = siloed_value + 1, .next_index = 10 }; + FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); + uint64_t low_leaf_index = 0; + tree.update_element(low_leaf_index, low_leaf_hash); + + AppendOnlyTreeSnapshot prev_snapshot = + AppendOnlyTreeSnapshot{ .root = tree.root(), .next_available_leaf_index = 128 }; + std::vector low_leaf_sibling_path = tree.get_sibling_path(low_leaf_index); + + IndexedTreeLeafData updated_low_leaf = low_leaf; + updated_low_leaf.next_index = prev_snapshot.next_available_leaf_index; + updated_low_leaf.next_value = siloed_value; + FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); + tree.update_element(low_leaf_index, updated_low_leaf_hash); + + std::vector insertion_sibling_path = tree.get_sibling_path(prev_snapshot.next_available_leaf_index); + + IndexedTreeLeafData new_leaf = { .value = siloed_value, + .next_value = low_leaf.next_value, + .next_index = low_leaf.next_index }; + FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); + tree.update_element(prev_snapshot.next_available_leaf_index, new_leaf_hash); + + IndexedTreeSiloingParameters siloing_params = { + .address = contract_address, + .siloing_separator = siloing_separator, + }; + + indexed_tree_check.write(value, + siloing_params, + 0, + low_leaf, + low_leaf_index, + low_leaf_sibling_path, + prev_snapshot, + insertion_sibling_path); + + poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); + merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); + field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); + indexed_tree_check_builder.process(indexed_tree_check_event_emitter.dump_events(), trace); + + // Not checking all interactions due to the public inputs interaction, which needs to be checked in an e2e test + check_interaction(trace); +} + +} // namespace +} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp index 1772f89df5c8..4dd2f67c2e52 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp @@ -77,7 +77,7 @@ std::unordered_map compute_reverted_in_map(const std::vector::Container& events, - TraceContainer& trace) -{ - using C = Column; - - uint32_t row = 0; - process_with_discard(events, [&](const simulation::NullifierTreeReadWriteEvent& event, bool discard) { - FF nullifier = event.nullifier; - FF siloed_nullifier = event.nullifier; - FF address = 0; - - if (event.siloing_data.has_value()) { - siloed_nullifier = event.siloing_data->siloed_nullifier; - address = event.siloing_data->address; - } - - bool exists = event.low_leaf_preimage.leaf.nullifier == siloed_nullifier; - FF nullifier_low_leaf_nullifier_diff = siloed_nullifier - event.low_leaf_preimage.leaf.nullifier; - - bool next_nullifier_is_nonzero = false; - FF next_nullifier = 0; - if (!exists) { - next_nullifier_is_nonzero = event.low_leaf_preimage.nextKey != 0; - next_nullifier = event.low_leaf_preimage.nextKey; - } - - uint64_t updated_low_leaf_next_index = 0; - FF updated_low_leaf_next_key = 0; - FF updated_low_leaf_hash = 0; - FF new_leaf_hash = 0; - FF intermediate_root = 0; - - bool append = event.append_data.has_value(); - if (append) { - updated_low_leaf_next_key = siloed_nullifier; - updated_low_leaf_next_index = event.prev_snapshot.next_available_leaf_index; - updated_low_leaf_hash = event.append_data->updated_low_leaf_hash; - new_leaf_hash = event.append_data->new_leaf_hash; - intermediate_root = event.append_data->intermediate_root; - } - - trace.set(row, - { { { C::nullifier_check_sel, 1 }, - { C::nullifier_check_const_three, 3 }, - { C::nullifier_check_write, event.write }, - { C::nullifier_check_nullifier, nullifier }, - { C::nullifier_check_root, event.prev_snapshot.root }, - { C::nullifier_check_exists, exists }, - { C::nullifier_check_write_root, event.next_snapshot.root }, - { C::nullifier_check_tree_size_before_write, event.prev_snapshot.next_available_leaf_index }, - { C::nullifier_check_discard, discard }, - { C::nullifier_check_nullifier_index, event.nullifier_counter }, - { C::nullifier_check_sel_silo, event.siloing_data.has_value() }, - { C::nullifier_check_address, address }, - { C::nullifier_check_low_leaf_nullifier, event.low_leaf_preimage.leaf.nullifier }, - { C::nullifier_check_low_leaf_next_index, event.low_leaf_preimage.nextIndex }, - { C::nullifier_check_low_leaf_next_nullifier, event.low_leaf_preimage.nextKey }, - { C::nullifier_check_updated_low_leaf_next_index, updated_low_leaf_next_index }, - { C::nullifier_check_updated_low_leaf_next_nullifier, updated_low_leaf_next_key }, - { C::nullifier_check_low_leaf_index, event.low_leaf_index }, - { C::nullifier_check_siloed_nullifier, siloed_nullifier }, - { C::nullifier_check_siloing_separator, DOM_SEP__SILOED_NULLIFIER }, - { C::nullifier_check_sel_insert, append }, - { C::nullifier_check_low_leaf_hash, event.low_leaf_hash }, - { C::nullifier_check_intermediate_root, intermediate_root }, - { C::nullifier_check_updated_low_leaf_hash, updated_low_leaf_hash }, - { C::nullifier_check_tree_height, NULLIFIER_TREE_HEIGHT }, - { C::nullifier_check_leaf_not_exists, !exists }, - { C::nullifier_check_nullifier_low_leaf_nullifier_diff_inv, - nullifier_low_leaf_nullifier_diff }, // Will be inverted in batch later - { C::nullifier_check_next_nullifier_is_nonzero, next_nullifier_is_nonzero }, - { C::nullifier_check_next_nullifier_inv, next_nullifier }, // Will be inverted in batch later - { C::nullifier_check_new_leaf_hash, new_leaf_hash }, - { C::nullifier_check_sel_write_to_public_inputs, event.append_data.has_value() && !discard }, - { C::nullifier_check_public_inputs_index, - AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + event.nullifier_counter } } }); - row++; - }); - - // Batch invert the columns. - trace.invert_columns( - { { C::nullifier_check_nullifier_low_leaf_nullifier_diff_inv, C::nullifier_check_next_nullifier_inv } }); -} - -const InteractionDefinition NullifierTreeCheckTraceBuilder::interactions = - InteractionDefinition() - .add() - .add() - .add() - .add() - .add() // ff_gt deduplicates - .add() // ff_gt deduplicates - .add() - .add() - .add(); - -} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/nullifier_tree_check_trace.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/nullifier_tree_check_trace.test.cpp deleted file mode 100644 index 68671cb4773d..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/nullifier_tree_check_trace.test.cpp +++ /dev/null @@ -1,236 +0,0 @@ -#include "barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp" - -#include -#include -#include -#include - -#include "barretenberg/crypto/poseidon2/poseidon2.hpp" -#include "barretenberg/vm2/common/avm_io.hpp" -#include "barretenberg/vm2/constraining/flavor_settings.hpp" -#include "barretenberg/vm2/constraining/testing/check_relation.hpp" -#include "barretenberg/vm2/generated/relations/lookups_nullifier_check.hpp" -#include "barretenberg/vm2/generated/relations/merkle_check.hpp" -#include "barretenberg/vm2/generated/relations/nullifier_check.hpp" -#include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/gadgets/field_gt.hpp" -#include "barretenberg/vm2/simulation/gadgets/nullifier_tree_check.hpp" -#include "barretenberg/vm2/simulation/gadgets/poseidon2.hpp" -#include "barretenberg/vm2/simulation/lib/merkle.hpp" -#include "barretenberg/vm2/simulation/testing/mock_gt.hpp" -#include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" -#include "barretenberg/vm2/testing/fixtures.hpp" -#include "barretenberg/vm2/testing/macros.hpp" -#include "barretenberg/vm2/testing/test_tree.hpp" -#include "barretenberg/vm2/tracegen/field_gt_trace.hpp" -#include "barretenberg/vm2/tracegen/lib/lookup_builder.hpp" -#include "barretenberg/vm2/tracegen/merkle_check_trace.hpp" -#include "barretenberg/vm2/tracegen/poseidon2_trace.hpp" -#include "barretenberg/vm2/tracegen/test_trace_container.hpp" - -namespace bb::avm2::tracegen { -namespace { - -using ::testing::NiceMock; - -using testing::TestMemoryTree; - -using simulation::DeduplicatingEventEmitter; -using simulation::EventEmitter; -using simulation::ExecutionIdManager; -using simulation::FieldGreaterThan; -using simulation::FieldGreaterThanEvent; -using simulation::MerkleCheck; -using simulation::MerkleCheckEvent; -using simulation::MockGreaterThan; -using simulation::MockRangeCheck; -using simulation::NullifierTreeCheck; -using simulation::NullifierTreeCheckEvent; -using simulation::NullifierTreeLeafPreimage; -using simulation::Poseidon2; -using simulation::Poseidon2HashEvent; -using simulation::Poseidon2PermutationEvent; -using simulation::Poseidon2PermutationMemoryEvent; -using simulation::unconstrained_root_from_path; - -using constraining::check_interaction; - -using FF = AvmFlavorSettings::FF; -using C = Column; -using RawPoseidon2 = crypto::Poseidon2; -using NullifierLeafValue = crypto::merkle_tree::NullifierLeafValue; - -class NullifierTreeCheckTracegenTest : public ::testing::Test { - protected: - NullifierTreeCheckTracegenTest() - : execution_id_manager(0) {}; - - EventEmitter hash_event_emitter; - EventEmitter perm_event_emitter; - EventEmitter perm_mem_event_emitter; - - ExecutionIdManager execution_id_manager; - NiceMock mock_gt; - Poseidon2 poseidon2 = - Poseidon2(execution_id_manager, mock_gt, hash_event_emitter, perm_event_emitter, perm_mem_event_emitter); -}; - -struct TestParams { - FF nullifier; - bool exists; - NullifierTreeLeafPreimage low_leaf; -}; - -std::vector positive_read_tests = { - // Exists = true, leaf pointers to infinity - TestParams{ .nullifier = 42, .exists = true, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 0, 0) }, - // Exists = true, leaf points to higher value - TestParams{ - .nullifier = 42, .exists = true, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(42), 28, 50) }, - // Exists = false, low leaf points to infinity - TestParams{ .nullifier = 42, .exists = false, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(10), 0, 0) }, - // Exists = false, low leaf points to higher value - TestParams{ - .nullifier = 42, .exists = false, .low_leaf = NullifierTreeLeafPreimage(NullifierLeafValue(10), 28, 50) } -}; - -class NullifierReadInteractionsTests : public NullifierTreeCheckTracegenTest, - public ::testing::WithParamInterface {}; - -TEST_P(NullifierReadInteractionsTests, PositiveWithInteractions) -{ - const auto& param = GetParam(); - - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check_simulator( - poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - NullifierTreeCheckTraceBuilder nullifier_tree_check_builder; - - FF low_leaf_hash = poseidon2.hash(param.low_leaf.get_hash_inputs()); - uint64_t leaf_index = 30; - std::vector sibling_path; - sibling_path.reserve(NULLIFIER_TREE_HEIGHT); - for (size_t i = 0; i < NULLIFIER_TREE_HEIGHT; ++i) { - sibling_path.emplace_back(i); - } - FF root = unconstrained_root_from_path(low_leaf_hash, leaf_index, sibling_path); - - nullifier_tree_check_simulator.assert_read(param.nullifier, - /*contract_address*/ std::nullopt, - param.exists, - param.low_leaf, - leaf_index, - sibling_path, - AppendOnlyTreeSnapshot{ .root = root }); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - nullifier_tree_check_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); - - check_interaction(trace); -} - -INSTANTIATE_TEST_SUITE_P(NullifierTreeCheckTracegenTest, - NullifierReadInteractionsTests, - ::testing::ValuesIn(positive_read_tests)); - -TEST_F(NullifierTreeCheckTracegenTest, WriteWithInteractions) -{ - EventEmitter merkle_event_emitter; - MerkleCheck merkle_check(poseidon2, merkle_event_emitter); - - NiceMock range_check; - - DeduplicatingEventEmitter field_gt_event_emitter; - FieldGreaterThan field_gt(range_check, field_gt_event_emitter); - - EventEmitter nullifier_tree_check_event_emitter; - NullifierTreeCheck nullifier_tree_check_simulator( - poseidon2, merkle_check, field_gt, nullifier_tree_check_event_emitter); - - TestTraceContainer trace({ { { C::precomputed_first_row, 1 } } }); - Poseidon2TraceBuilder poseidon2_builder; - MerkleCheckTraceBuilder merkle_check_builder; - FieldGreaterThanTraceBuilder field_gt_builder; - NullifierTreeCheckTraceBuilder nullifier_tree_check_builder; - - AztecAddress contract_address = AztecAddress(1); - FF nullifier = 100; - FF siloed_nullifier = simulation::unconstrained_silo_nullifier(contract_address, nullifier); - FF low_nullifier = 40; - TestMemoryTree nullifier_tree(8, NULLIFIER_TREE_HEIGHT); - - NullifierTreeLeafPreimage low_leaf = - NullifierTreeLeafPreimage(NullifierLeafValue(low_nullifier), 10, siloed_nullifier + 1); - FF low_leaf_hash = RawPoseidon2::hash(low_leaf.get_hash_inputs()); - uint64_t low_leaf_index = 0; - nullifier_tree.update_element(low_leaf_index, low_leaf_hash); - - AppendOnlyTreeSnapshot prev_snapshot = - AppendOnlyTreeSnapshot{ .root = nullifier_tree.root(), .next_available_leaf_index = 128 }; - std::vector low_leaf_sibling_path = nullifier_tree.get_sibling_path(low_leaf_index); - - NullifierTreeLeafPreimage updated_low_leaf = low_leaf; - updated_low_leaf.nextIndex = prev_snapshot.next_available_leaf_index; - updated_low_leaf.nextKey = siloed_nullifier; - FF updated_low_leaf_hash = RawPoseidon2::hash(updated_low_leaf.get_hash_inputs()); - nullifier_tree.update_element(low_leaf_index, updated_low_leaf_hash); - - std::vector insertion_sibling_path = nullifier_tree.get_sibling_path(prev_snapshot.next_available_leaf_index); - - NullifierTreeLeafPreimage new_leaf = - NullifierTreeLeafPreimage(NullifierLeafValue(siloed_nullifier), low_leaf.nextIndex, low_leaf.nextKey); - FF new_leaf_hash = RawPoseidon2::hash(new_leaf.get_hash_inputs()); - nullifier_tree.update_element(prev_snapshot.next_available_leaf_index, new_leaf_hash); - - nullifier_tree_check_simulator.write(nullifier, - contract_address, - 0, - low_leaf, - low_leaf_index, - low_leaf_sibling_path, - prev_snapshot, - insertion_sibling_path); - - poseidon2_builder.process_hash(hash_event_emitter.dump_events(), trace); - merkle_check_builder.process(merkle_event_emitter.dump_events(), trace); - field_gt_builder.process(field_gt_event_emitter.dump_events(), trace); - nullifier_tree_check_builder.process(nullifier_tree_check_event_emitter.dump_events(), trace); - - // Not checking all interactions due to the public inputs interaction, which needs to be checked in an e2e test - check_interaction(trace); -} - -} // namespace -} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.cpp deleted file mode 100644 index 4516a7d018cd..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.cpp +++ /dev/null @@ -1,99 +0,0 @@ -#include "barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp" - -#include - -#include "barretenberg/vm2/common/aztec_constants.hpp" -#include "barretenberg/vm2/generated/relations/lookups_retrieved_bytecodes_tree_check.hpp" -#include "barretenberg/vm2/tracegen/lib/interaction_def.hpp" - -namespace bb::avm2::tracegen { - -void RetrievedBytecodesTreeCheckTraceBuilder::process( - const simulation::EventEmitterInterface::Container& events, - TraceContainer& trace) -{ - using C = Column; - - uint32_t row = 0; - for (const auto& event : events) { - FF class_id = event.class_id; - - bool exists = event.low_leaf_preimage.leaf.class_id == class_id; - FF class_id_low_leaf_class_id_diff = class_id - event.low_leaf_preimage.leaf.class_id; - - bool next_class_id_is_nonzero = false; - FF next_class_id = 0; - if (!exists) { - next_class_id_is_nonzero = event.low_leaf_preimage.nextKey != 0; - next_class_id = event.low_leaf_preimage.nextKey; - } - - uint64_t updated_low_leaf_next_index = 0; - FF updated_low_leaf_next_key = 0; - FF updated_low_leaf_hash = 0; - FF new_leaf_hash = 0; - FF intermediate_root = 0; - - bool append = event.append_data.has_value(); - if (append) { - updated_low_leaf_next_key = class_id; - updated_low_leaf_next_index = event.prev_snapshot.next_available_leaf_index; - updated_low_leaf_hash = event.append_data->updated_low_leaf_hash; - new_leaf_hash = event.append_data->new_leaf_hash; - intermediate_root = event.append_data->intermediate_root; - } - - trace.set(row, - { { - { C::retrieved_bytecodes_tree_check_sel, 1 }, - { C::retrieved_bytecodes_tree_check_const_three, 3 }, - { C::retrieved_bytecodes_tree_check_write, event.write }, - { C::retrieved_bytecodes_tree_check_class_id, class_id }, - { C::retrieved_bytecodes_tree_check_root, event.prev_snapshot.root }, - { C::retrieved_bytecodes_tree_check_write_root, event.next_snapshot.root }, - { C::retrieved_bytecodes_tree_check_tree_size_before_write, - event.prev_snapshot.next_available_leaf_index }, - { C::retrieved_bytecodes_tree_check_tree_size_after_write, - event.next_snapshot.next_available_leaf_index }, - { C::retrieved_bytecodes_tree_check_low_leaf_class_id, event.low_leaf_preimage.leaf.class_id }, - { C::retrieved_bytecodes_tree_check_low_leaf_next_index, event.low_leaf_preimage.nextIndex }, - { C::retrieved_bytecodes_tree_check_low_leaf_next_class_id, event.low_leaf_preimage.nextKey }, - { C::retrieved_bytecodes_tree_check_updated_low_leaf_next_index, updated_low_leaf_next_index }, - { C::retrieved_bytecodes_tree_check_updated_low_leaf_next_class_id, updated_low_leaf_next_key }, - { C::retrieved_bytecodes_tree_check_low_leaf_index, event.low_leaf_index }, - { C::retrieved_bytecodes_tree_check_should_insert, append }, - { C::retrieved_bytecodes_tree_check_low_leaf_hash, event.low_leaf_hash }, - { C::retrieved_bytecodes_tree_check_intermediate_root, intermediate_root }, - { C::retrieved_bytecodes_tree_check_updated_low_leaf_hash, updated_low_leaf_hash }, - { C::retrieved_bytecodes_tree_check_tree_height, AVM_RETRIEVED_BYTECODES_TREE_HEIGHT }, - { C::retrieved_bytecodes_tree_check_leaf_not_exists, !exists }, - { C::retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv, - class_id_low_leaf_class_id_diff }, // Will be inverted in batch later - { C::retrieved_bytecodes_tree_check_next_class_id_is_nonzero, next_class_id_is_nonzero }, - { C::retrieved_bytecodes_tree_check_next_class_id_inv, - next_class_id }, // Will be inverted in batch later - { C::retrieved_bytecodes_tree_check_new_leaf_hash, new_leaf_hash }, - } }); - row++; - } - - // Batch invert the columns. - trace.invert_columns({ { C::retrieved_bytecodes_tree_check_class_id_low_leaf_class_id_diff_inv, - C::retrieved_bytecodes_tree_check_next_class_id_inv } }); -} - -const InteractionDefinition RetrievedBytecodesTreeCheckTraceBuilder::interactions = - InteractionDefinition() - .add() - .add() - .add() - .add() - .add() - .add() - .add(); -; - -} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp deleted file mode 100644 index 22dbcb373669..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once - -#include - -#include "barretenberg/vm2/generated/columns.hpp" -#include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/events/retrieved_bytecodes_tree_check_event.hpp" -#include "barretenberg/vm2/tracegen/lib/interaction_def.hpp" -#include "barretenberg/vm2/tracegen/trace_container.hpp" - -namespace bb::avm2::tracegen { - -class RetrievedBytecodesTreeCheckTraceBuilder final { - public: - void process( - const simulation::EventEmitterInterface::Container& events, - TraceContainer& trace); - - static const InteractionDefinition interactions; -}; - -} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/tx_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/tx_trace.cpp index 48b3b4514820..b47bf8ea8445 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/tx_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/tx_trace.cpp @@ -9,6 +9,7 @@ #include "barretenberg/common/assert.hpp" #include "barretenberg/common/log.hpp" +#include "barretenberg/vm2/common/aztec_constants.hpp" #include "barretenberg/vm2/common/aztec_types.hpp" #include "barretenberg/vm2/common/field.hpp" #include "barretenberg/vm2/generated/columns.hpp" @@ -370,13 +371,15 @@ std::vector> handle_nullifier_append(const PrivateAppendTreeEve { uint32_t remaining_nullifiers = MAX_NULLIFIERS_PER_TX - state_before.tree_states.nullifier_tree.counter; - return { - { C::tx_leaf_value, event.leaf_value }, - { C::tx_nullifier_limit_error, remaining_nullifiers > 0 ? 0 : 1 }, - { C::tx_remaining_side_effects_inv, remaining_nullifiers }, // Will be inverted in batch later - { C::tx_should_try_nullifier_append, 1 }, - { C::tx_should_nullifier_append, remaining_nullifiers > 0 ? 1 : 0 }, - }; + return { { C::tx_leaf_value, event.leaf_value }, + { C::tx_nullifier_limit_error, remaining_nullifiers > 0 ? 0 : 1 }, + { C::tx_remaining_side_effects_inv, remaining_nullifiers }, // Will be inverted in batch later + { C::tx_should_try_nullifier_append, 1 }, + { C::tx_should_nullifier_append, remaining_nullifiers > 0 ? 1 : 0 }, + { C::tx_write_nullifier_pi_offset, + AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX + + state_before.tree_states.nullifier_tree.counter }, + { C::tx_nullifier_tree_height, NULLIFIER_TREE_HEIGHT } }; } /** diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/update_check_trace.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/update_check_trace.test.cpp index f1bdf5f5fac2..1946d62180e1 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/update_check_trace.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/update_check_trace.test.cpp @@ -19,10 +19,10 @@ #include "barretenberg/vm2/simulation/testing/mock_dbs.hpp" #include "barretenberg/vm2/simulation/testing/mock_field_gt.hpp" #include "barretenberg/vm2/simulation/testing/mock_gt.hpp" +#include "barretenberg/vm2/simulation/testing/mock_indexed_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_l1_to_l2_message_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_merkle_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_note_hash_tree_check.hpp" -#include "barretenberg/vm2/simulation/testing/mock_nullifier_tree_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_range_check.hpp" #include "barretenberg/vm2/simulation/testing/mock_written_public_data_slots_tree_check.hpp" #include "barretenberg/vm2/testing/fixtures.hpp" @@ -54,11 +54,11 @@ using simulation::GreaterThanEvent; using simulation::MerkleDB; using simulation::MockFieldGreaterThan; using simulation::MockGreaterThan; +using simulation::MockIndexedTreeCheck; using simulation::MockL1ToL2MessageTreeCheck; using simulation::MockLowLevelMerkleDB; using simulation::MockMerkleCheck; using simulation::MockNoteHashTreeCheck; -using simulation::MockNullifierTreeCheck; using simulation::MockWrittenPublicDataSlotsTreeCheck; using simulation::NoopEventEmitter; using simulation::Poseidon2; @@ -106,7 +106,7 @@ TEST(UpdateCheckTracegenTest, HashZeroInteractions) NiceMock mock_field_gt; NiceMock mock_merkle_check; - NiceMock mock_nullifier_tree_check; + NiceMock mock_indexed_tree_check; NiceMock mock_note_hash_tree_check; NiceMock mock_written_public_data_slots_tree_check; NiceMock mock_l1_to_l2_message_tree_check; @@ -121,7 +121,7 @@ TEST(UpdateCheckTracegenTest, HashZeroInteractions) MerkleDB merkle_db(mock_low_level_merkle_db, public_data_tree_check, - mock_nullifier_tree_check, + mock_indexed_tree_check, mock_note_hash_tree_check, mock_written_public_data_slots_tree_check, mock_l1_to_l2_message_tree_check); @@ -196,7 +196,7 @@ TEST(UpdateCheckTracegenTest, HashNonzeroInteractions) NiceMock mock_field_gt; NiceMock mock_merkle_check; - NiceMock mock_nullifier_tree_check; + NiceMock mock_indexed_tree_check; NiceMock mock_note_hash_tree_check; NiceMock mock_written_public_data_slots_tree_check; NiceMock mock_l1_to_l2_message_tree_check; @@ -213,7 +213,7 @@ TEST(UpdateCheckTracegenTest, HashNonzeroInteractions) MerkleDB merkle_db(mock_low_level_merkle_db, public_data_tree_check, - mock_nullifier_tree_check, + mock_indexed_tree_check, mock_note_hash_tree_check, mock_written_public_data_slots_tree_check, mock_l1_to_l2_message_tree_check); diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.cpp deleted file mode 100644 index 3898d80700da..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.cpp +++ /dev/null @@ -1,107 +0,0 @@ -#include "barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp" - -#include - -#include "barretenberg/vm2/common/aztec_constants.hpp" -#include "barretenberg/vm2/generated/relations/lookups_written_public_data_slots_tree_check.hpp" -#include "barretenberg/vm2/tracegen/lib/interaction_def.hpp" - -namespace bb::avm2::tracegen { - -void WrittenPublicDataSlotsTreeCheckTraceBuilder::process( - const simulation::EventEmitterInterface::Container& events, - TraceContainer& trace) -{ - using C = Column; - - uint32_t row = 0; - for (const auto& event : events) { - FF slot = event.slot; - FF leaf_slot = event.leaf_slot; - FF address = event.contract_address; - - bool exists = event.low_leaf_preimage.leaf.slot == leaf_slot; - FF slot_low_leaf_slot_diff = leaf_slot - event.low_leaf_preimage.leaf.slot; - - bool next_slot_is_nonzero = false; - FF next_slot = 0; - if (!exists) { - next_slot_is_nonzero = event.low_leaf_preimage.nextKey != 0; - next_slot = event.low_leaf_preimage.nextKey; - } - - uint64_t updated_low_leaf_next_index = 0; - FF updated_low_leaf_next_key = 0; - FF updated_low_leaf_hash = 0; - FF new_leaf_hash = 0; - FF intermediate_root = 0; - - bool append = event.append_data.has_value(); - if (append) { - updated_low_leaf_next_key = leaf_slot; - updated_low_leaf_next_index = event.prev_snapshot.next_available_leaf_index; - updated_low_leaf_hash = event.append_data->updated_low_leaf_hash; - new_leaf_hash = event.append_data->new_leaf_hash; - intermediate_root = event.append_data->intermediate_root; - } - - trace.set( - row, - { { - { C::written_public_data_slots_tree_check_sel, 1 }, - { C::written_public_data_slots_tree_check_const_three, 3 }, - { C::written_public_data_slots_tree_check_write, event.write }, - { C::written_public_data_slots_tree_check_slot, slot }, - { C::written_public_data_slots_tree_check_root, event.prev_snapshot.root }, - { C::written_public_data_slots_tree_check_write_root, event.next_snapshot.root }, - { C::written_public_data_slots_tree_check_tree_size_before_write, - event.prev_snapshot.next_available_leaf_index }, - { C::written_public_data_slots_tree_check_tree_size_after_write, - event.next_snapshot.next_available_leaf_index }, - { C::written_public_data_slots_tree_check_address, address }, - { C::written_public_data_slots_tree_check_low_leaf_slot, event.low_leaf_preimage.leaf.slot }, - { C::written_public_data_slots_tree_check_low_leaf_next_index, event.low_leaf_preimage.nextIndex }, - { C::written_public_data_slots_tree_check_low_leaf_next_slot, event.low_leaf_preimage.nextKey }, - { C::written_public_data_slots_tree_check_updated_low_leaf_next_index, updated_low_leaf_next_index }, - { C::written_public_data_slots_tree_check_updated_low_leaf_next_slot, updated_low_leaf_next_key }, - { C::written_public_data_slots_tree_check_low_leaf_index, event.low_leaf_index }, - { C::written_public_data_slots_tree_check_leaf_slot, leaf_slot }, - { C::written_public_data_slots_tree_check_siloing_separator, DOM_SEP__PUBLIC_LEAF_SLOT }, - { C::written_public_data_slots_tree_check_should_insert, append }, - { C::written_public_data_slots_tree_check_low_leaf_hash, event.low_leaf_hash }, - { C::written_public_data_slots_tree_check_intermediate_root, intermediate_root }, - { C::written_public_data_slots_tree_check_updated_low_leaf_hash, updated_low_leaf_hash }, - { C::written_public_data_slots_tree_check_tree_height, AVM_WRITTEN_PUBLIC_DATA_SLOTS_TREE_HEIGHT }, - { C::written_public_data_slots_tree_check_leaf_not_exists, !exists }, - { C::written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv, - slot_low_leaf_slot_diff }, // Will be inverted in batch later - { C::written_public_data_slots_tree_check_next_slot_is_nonzero, next_slot_is_nonzero }, - { C::written_public_data_slots_tree_check_next_slot_inv, next_slot }, // Will be inverted in batch later - { C::written_public_data_slots_tree_check_new_leaf_hash, new_leaf_hash }, - } }); - row++; - } - - // Batch invert the columns. - trace.invert_columns({ { C::written_public_data_slots_tree_check_slot_low_leaf_slot_diff_inv, - C::written_public_data_slots_tree_check_next_slot_inv } }); -} - -const InteractionDefinition WrittenPublicDataSlotsTreeCheckTraceBuilder::interactions = - InteractionDefinition() - .add() - .add() - .add() - .add() - .add() - .add() - .add() - .add(); -; - -} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp deleted file mode 100644 index 6e9f6e0d84ae..000000000000 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include - -#include "barretenberg/vm2/generated/columns.hpp" -#include "barretenberg/vm2/simulation/events/event_emitter.hpp" -#include "barretenberg/vm2/simulation/events/nullifier_tree_check_event.hpp" -#include "barretenberg/vm2/simulation/events/written_public_data_slot_tree_check_event.hpp" -#include "barretenberg/vm2/tracegen/lib/interaction_def.hpp" -#include "barretenberg/vm2/tracegen/trace_container.hpp" - -namespace bb::avm2::tracegen { - -class WrittenPublicDataSlotsTreeCheckTraceBuilder final { - public: - void process( - const simulation::EventEmitterInterface::Container& events, - TraceContainer& trace); - - static const InteractionDefinition interactions; -}; - -} // namespace bb::avm2::tracegen diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp index 958cc38019f1..eddcb3e4e0d1 100644 --- a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp @@ -28,6 +28,7 @@ #include "barretenberg/vm2/tracegen/execution_trace.hpp" #include "barretenberg/vm2/tracegen/field_gt_trace.hpp" #include "barretenberg/vm2/tracegen/gt_trace.hpp" +#include "barretenberg/vm2/tracegen/indexed_tree_check_trace.hpp" #include "barretenberg/vm2/tracegen/internal_call_stack_trace.hpp" #include "barretenberg/vm2/tracegen/keccakf1600_trace.hpp" #include "barretenberg/vm2/tracegen/l1_to_l2_message_tree_trace.hpp" @@ -36,7 +37,6 @@ #include "barretenberg/vm2/tracegen/memory_trace.hpp" #include "barretenberg/vm2/tracegen/merkle_check_trace.hpp" #include "barretenberg/vm2/tracegen/note_hash_tree_check_trace.hpp" -#include "barretenberg/vm2/tracegen/nullifier_tree_check_trace.hpp" #include "barretenberg/vm2/tracegen/opcodes/emit_public_log_trace.hpp" #include "barretenberg/vm2/tracegen/opcodes/get_contract_instance_trace.hpp" #include "barretenberg/vm2/tracegen/poseidon2_trace.hpp" @@ -44,13 +44,11 @@ #include "barretenberg/vm2/tracegen/public_data_tree_trace.hpp" #include "barretenberg/vm2/tracegen/public_inputs_trace.hpp" #include "barretenberg/vm2/tracegen/range_check_trace.hpp" -#include "barretenberg/vm2/tracegen/retrieved_bytecodes_tree_check.hpp" #include "barretenberg/vm2/tracegen/sha256_trace.hpp" #include "barretenberg/vm2/tracegen/to_radix_trace.hpp" #include "barretenberg/vm2/tracegen/trace_container.hpp" #include "barretenberg/vm2/tracegen/tx_trace.hpp" #include "barretenberg/vm2/tracegen/update_check_trace.hpp" -#include "barretenberg/vm2/tracegen/written_public_data_slots_tree_check_trace.hpp" namespace bb::avm2 { @@ -336,11 +334,10 @@ void AvmTraceGenHelper::fill_trace_columns(TraceContainer& trace, clear_events(events.update_check_events); }, [&]() { - NullifierTreeCheckTraceBuilder nullifier_tree_check_trace_builder; - AVM_TRACK_TIME( - "tracegen/nullifier_tree_check", - nullifier_tree_check_trace_builder.process(events.nullifier_tree_check_events, trace)); - clear_events(events.nullifier_tree_check_events); + IndexedTreeCheckTraceBuilder indexed_tree_check_trace_builder; + AVM_TRACK_TIME("tracegen/indexed_tree_check", + indexed_tree_check_trace_builder.process(events.indexed_tree_check_events, trace)); + clear_events(events.indexed_tree_check_events); }, [&]() { MemoryTraceBuilder memory_trace_builder; @@ -385,13 +382,6 @@ void AvmTraceGenHelper::fill_trace_columns(TraceContainer& trace, note_hash_tree_check_trace_builder.process(events.note_hash_tree_check_events, trace)); clear_events(events.note_hash_tree_check_events); }, - [&]() { - WrittenPublicDataSlotsTreeCheckTraceBuilder written_public_data_slots_tree_check_trace_builder; - AVM_TRACK_TIME("tracegen/written_public_data_slots_tree_check", - written_public_data_slots_tree_check_trace_builder.process( - events.written_public_data_slots_tree_check_events, trace)); - clear_events(events.written_public_data_slots_tree_check_events); - }, [&]() { GreaterThanTraceBuilder gt_builder; AVM_TRACK_TIME("tracegen/gt", gt_builder.process(events.gt_events, trace)); @@ -422,13 +412,6 @@ void AvmTraceGenHelper::fill_trace_columns(TraceContainer& trace, AVM_TRACK_TIME("tracegen/emit_public_log", emit_public_log_builder.process(events.emit_public_log_events, trace)); clear_events(events.emit_public_log_events); - }, - [&]() { - RetrievedBytecodesTreeCheckTraceBuilder retrieved_bytecodes_tree_check_builder; - AVM_TRACK_TIME("tracegen/retrieved_bytecodes_tree_check", - retrieved_bytecodes_tree_check_builder.process( - events.retrieved_bytecodes_tree_check_events, trace)); - clear_events(events.retrieved_bytecodes_tree_check_events); } }); AVM_TRACK_TIME("tracegen/traces", execute_jobs(jobs)); @@ -462,17 +445,15 @@ void AvmTraceGenHelper::fill_trace_interactions(TraceContainer& trace) MerkleCheckTraceBuilder::interactions.get_all_jobs(index_cache), PublicDataTreeTraceBuilder::interactions.get_all_jobs(index_cache), UpdateCheckTraceBuilder::interactions.get_all_jobs(index_cache), - NullifierTreeCheckTraceBuilder::interactions.get_all_jobs(index_cache), + IndexedTreeCheckTraceBuilder::interactions.get_all_jobs(index_cache), DataCopyTraceBuilder::interactions.get_all_jobs(index_cache), CalldataTraceBuilder::interactions.get_all_jobs(index_cache), NoteHashTreeCheckTraceBuilder::interactions.get_all_jobs(index_cache), - WrittenPublicDataSlotsTreeCheckTraceBuilder::interactions.get_all_jobs(index_cache), GreaterThanTraceBuilder::interactions.get_all_jobs(index_cache), ContractInstanceRetrievalTraceBuilder::interactions.get_all_jobs(index_cache), GetContractInstanceTraceBuilder::interactions.get_all_jobs(index_cache), L1ToL2MessageTreeCheckTraceBuilder::interactions.get_all_jobs(index_cache), - EmitPublicLogTraceBuilder::interactions.get_all_jobs(index_cache), - RetrievedBytecodesTreeCheckTraceBuilder::interactions.get_all_jobs(index_cache)); + EmitPublicLogTraceBuilder::interactions.get_all_jobs(index_cache)); // Order jobs to minimize index building contention: // Jobs with unique destination columns come first, then jobs that share destinations with earlier ones.