diff --git a/barretenberg/cpp/pil/vm2/alu.pil b/barretenberg/cpp/pil/vm2/alu.pil
index 49bcce4bcfaa..96322930994c 100644
--- a/barretenberg/cpp/pil/vm2/alu.pil
+++ b/barretenberg/cpp/pil/vm2/alu.pil
@@ -142,10 +142,10 @@ pol commit ic_tag;
 // Common helper selectors
 pol commit sel_is_ff; // @boolean (whether input a is a field)
 pol commit sel_is_u128; // @boolean (whether input a is a u128)
-pol IS_NOT_FF = 1 - sel_is_ff; // @boolean Follows from definition.
-pol IS_NOT_U128 = 1 - sel_is_u128; // @boolean Follows from definition.
-pol SHIFT_OPS = sel_op_shl + sel_op_shr; // @boolean Follows from definition and mutual exclusion.
-pol DIV_OPS = sel_op_div + sel_op_fdiv; // @boolean Follows from definition and mutual exclusion.
+pol IS_NOT_FF = 1 - sel_is_ff; // @boolean (by definition)
+pol IS_NOT_U128 = 1 - sel_is_u128; // @boolean (by definition)
+pol SHIFT_OPS = sel_op_shl + sel_op_shr; // @boolean (by definition and mutual exclusion)
+pol DIV_OPS = sel_op_div + sel_op_fdiv; // @boolean (by definition and mutual exclusion)
 
 // Note that #[OP_ID_CHECK] ensures selectors are mutually exclusive.
 // Therefore, SHIFT_OPS and DIV_OPS are boolean.
@@ -173,8 +173,8 @@ sel * (TAG_U128_DIFF * (sel_is_u128 * (1 - tag_u128_diff_inv) + tag_u128_diff_in
 /******************************************************************************
 * Error Handling
 ******************************************************************************/
-pol commit sel_err; // @boolean Follows from definition (see #[ERR_CHECK]).
-pol commit sel_tag_err; // @boolean Follows from definition (see #[TAG_ERR_CHECK]).
+pol commit sel_err; // @boolean (by definition, see #[ERR_CHECK])
+pol commit sel_tag_err; // @boolean (by definition, see #[TAG_ERR_CHECK])
 pol commit sel_ab_tag_mismatch; // @boolean
 pol commit sel_div_0_err; // @boolean
 
@@ -280,7 +280,7 @@ pol SEL_DIV_U128 = sel_div_no_err * sel_is_u128;
 * BIT DECOMPOSITION (Common helper for MUL, DIV, SHL, SHR)
 ******************************************************************************/
 // We use the below to prove correct decomposition of some values into limbs. Currently used by MUL, DIV, SHL, and SHR.
-pol commit sel_decompose_a; // @boolean by definition and mutual exclusion of opcode selectors.
+pol commit sel_decompose_a; // @boolean (by definition and mutual exclusion of opcode selectors)
 sel_decompose_a = (1 - sel_err) * (sel_mul_div_u128 + SHIFT_OPS);
 // Currently, sel_decompose_b would just equal sel_mul_div_u128, so no need for another column.
 pol commit a_lo, a_hi, b_lo, b_hi; // Limbs of the decomposed value. Range values defined by LIMB_SIZE.
@@ -372,7 +372,7 @@ SEL_MUL_U128 * (
     ) = 0;
 
 // We need to range check c_hi < 2^64 for non-FF values and when there is no error.
-pol commit sel_mul_no_err_non_ff; // @boolean Follows from definition.
+pol commit sel_mul_no_err_non_ff; // @boolean (by definition)
 sel_mul_no_err_non_ff = IS_NOT_FF * (1 - sel_err) * sel_op_mul;
 #[RANGE_CHECK_MUL_C_HI]
 sel_mul_no_err_non_ff { c_hi, constant_64 } in range_check.sel_alu { range_check.value, range_check.rng_chk_bits };
@@ -380,7 +380,7 @@ sel_mul_no_err_non_ff { c_hi, constant_64 } in range_check.sel_alu { range_check
 // ------------------------------------------------------------
 // DIV & FDIV
 // ------------------------------------------------------------
-pol commit sel_div_no_err; // @boolean Follows from definition.
+pol commit sel_div_no_err; // @boolean (by definition)
 sel_div_no_err = sel_op_div * (1 - sel_err);
 // We need to show that remainder < b (remainder stored in helper1)
 // We use #[INT_GT] below (see LT/LTE) by setting gt_input_a = b, gt_input_b = helper1, gt_result_c = 1 (gated by sel_div_no_err).
@@ -388,7 +388,7 @@ sel_div_no_err = sel_op_div * (1 - sel_err);
 // DIV - u128
 
 // Using this to switch on the range checks for decomposed u128 integers (#[OP_ID_CHECK] ensures selectors are mutually exclusive)
-pol commit sel_mul_div_u128; // @boolean Follows from definition.
+pol commit sel_mul_div_u128; // @boolean (by definition)
 // SEL_MUL_U128 || SEL_DIV_U128
 sel_mul_div_u128 = SEL_MUL_U128 + SEL_DIV_U128;
 
@@ -452,11 +452,11 @@ sel_op_eq * (1 - sel_err) * (DIFF * (ic * (1 - ab_diff_inv) + ab_diff_inv) - 1 +
 // ------------------------------------------------------------
 pol SEL_LT_OPS = (1 - sel_err) * (sel_op_lt + sel_op_lte);
 
-pol commit sel_ff_gt; // @boolean Follows from definition.
+pol commit sel_ff_gt; // @boolean (by definition)
 // sel_is_ff & SEL_LT_OPS:
 sel_ff_gt = sel_is_ff * SEL_LT_OPS;
 
-pol commit sel_int_gt; // @boolean Follows from definition.
+pol commit sel_int_gt; // @boolean (by definition)
 // (!sel_is_ff & SEL_LT_OPS) || sel_div_no_err:
 sel_int_gt = IS_NOT_FF * SEL_LT_OPS + sel_div_no_err;
 
@@ -623,7 +623,7 @@ sel_trunc_lt_128 * (1 - sel_trunc_lt_128) = 0;
 
 // Truncation separation case
 // Mutually exclusive due to sel_op_truncate being boolean
-pol commit sel_trunc_non_trivial; // @boolean Follows from definition. TODO: Aliases this once lookups support aliases for selectors.
+pol commit sel_trunc_non_trivial; // @boolean (by definition) TODO: Aliases this once lookups support aliases for selectors.
 
 #[SEL_TRUNC_NON_TRIVIAL]
 sel_trunc_non_trivial = sel_trunc_gte_128 + sel_trunc_lt_128;
diff --git a/barretenberg/cpp/pil/vm2/bitwise.pil b/barretenberg/cpp/pil/vm2/bitwise.pil
index 7f61010ee5b3..e29263bb3ce2 100644
--- a/barretenberg/cpp/pil/vm2/bitwise.pil
+++ b/barretenberg/cpp/pil/vm2/bitwise.pil
@@ -49,7 +49,7 @@ sel * (1 - sel) = 0;
 #[skippable_if]
 sel = 0;
 
-pol commit start; // Identifies when we want to capture the output to the main trace.
+pol commit start; // @boolean Identifies when we want to capture the output to the main trace.
 // Must be constrained as a boolean as any selector used in a lookup/permutation.
 start * (1 - start) = 0;
 
@@ -68,16 +68,16 @@ start_sha256 * (1 - start_sha256) = 0;
 pol commit ctr;
 
 // The error flags for this subtrace
-pol commit sel_tag_ff_err;
+pol commit sel_tag_ff_err; // @boolean
 sel_tag_ff_err * (1 - sel_tag_ff_err) = 0;
-pol commit sel_tag_mismatch_err;
+pol commit sel_tag_mismatch_err; // @boolean
 sel_tag_mismatch_err * (1 - sel_tag_mismatch_err) = 0;
 
 // Consolidated error flag
-pol commit err;
+pol commit err; // @boolean (by definition)
 err = 1 - (1 - sel_tag_mismatch_err) * (1 - sel_tag_ff_err);
 // last is a boolean which serves to mark the end of the computation (end of latch)
-pol commit last;
+pol commit last; // @boolean
 last * (1 - last) = 0;
 #[LAST_ON_ERROR] // last = 1 if err = 1
 err * (last - 1) = 0;
diff --git a/barretenberg/cpp/pil/vm2/bytecode/address_derivation.pil b/barretenberg/cpp/pil/vm2/bytecode/address_derivation.pil
index 280801a61e0f..d120a5bd9555 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/address_derivation.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/address_derivation.pil
@@ -6,7 +6,7 @@ include "../scalar_mul.pil";
 
 namespace address_derivation;
 
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
diff --git a/barretenberg/cpp/pil/vm2/bytecode/bc_decomposition.pil b/barretenberg/cpp/pil/vm2/bytecode/bc_decomposition.pil
index d629be2309a4..504629ef6930 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/bc_decomposition.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/bc_decomposition.pil
@@ -9,7 +9,7 @@ include "../precomputed.pil";
 
 namespace bc_decomposition;
 
-pol commit sel;
+pol commit sel; // @boolean
 sel * (1 - sel) = 0;
 // No relations will be checked if this identity is satisfied.
 #[skippable_if]
@@ -29,7 +29,7 @@ pol commit bytes_remaining;
 
 // This column should be 1 iff the contract is switching, i.e., this row is the last one
 // of a contract bytecode. This is equivalent to bytes_remaining == 1.
-pol commit last_of_contract;
+pol commit last_of_contract; // @boolean
 last_of_contract * (1 - last_of_contract) = 0;
 
 // This is the most important column. It contains the bytecode one byte at a time on each row.
@@ -132,12 +132,12 @@ pol commit bytes_pc_plus_1, bytes_pc_plus_2, bytes_pc_plus_3, bytes_pc_plus_4, b
 //   39 |               1 |             1 |   0xD | 0x0 | 0x0 | ...
 
 pol commit bytes_to_read;
-pol commit sel_windows_gt_remaining;
+pol commit sel_windows_gt_remaining; // @boolean
 sel_windows_gt_remaining * (1 - sel_windows_gt_remaining) = 0;
 // We need to constrain bytes_to_read = min(WINDOW_SIZE, bytes_remaining) which is equal to
 // bytes_remaining if bytes_remaining <= WINDOW_SIZE and WINDOW_SIZE otherwise.
 
-pol commit is_windows_eq_remaining;
+pol commit is_windows_eq_remaining; // @boolean
 pol commit windows_min_remaining_inv;
 is_windows_eq_remaining * (1 - is_windows_eq_remaining) = 0;
 
@@ -224,11 +224,11 @@ bytes_pc_plus_36 = (1 - LATCH_CONDITION) * bytes_pc_plus_35';
 // We will have a selector for the PCs that are packed. This only needs to happen
 // for PCs 0, 31, 62, ...
 
-pol commit sel_packed;
+pol commit sel_packed; // @boolean
 sel_packed * (1 - sel_packed) = 0;
 
 // Permutation selectors (bc_hashing.pil).
-pol commit sel_packed_read[3];
+pol commit sel_packed_read[3]; // @boolean
 sel_packed_read[0] * (1 - sel_packed_read[0]) = 0;
 sel_packed_read[1] * (1 - sel_packed_read[1]) = 0;
 sel_packed_read[2] * (1 - sel_packed_read[2]) = 0;
diff --git a/barretenberg/cpp/pil/vm2/bytecode/bc_hashing.pil b/barretenberg/cpp/pil/vm2/bytecode/bc_hashing.pil
index f2c66bef034f..ccc3f8abd0ca 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/bc_hashing.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/bc_hashing.pil
@@ -47,7 +47,7 @@ include "../constants_gen.pil";
 
 namespace bc_hashing;
 
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     // Skippable
@@ -63,7 +63,7 @@ namespace bc_hashing;
 
     // Triggers the lookup to the address derivation subtrace, signifies the row that contains the final bytecode hash for this id
     // The sequencer can decide where to put this latch.
-    pol commit latch;
+    pol commit latch; // @boolean
     latch * (1 - latch) = 0;
 
     // latch == 1 ==> sel == 1
@@ -75,11 +75,11 @@ namespace bc_hashing;
     pol LATCH_CONDITION = latch + precomputed.first_row;
 
     // The start of a new bytecode id and new set of hashing runs:
-    pol commit start;
+    pol commit start; // @boolean
     start * (1 - start) = 0;
 
     // Needs to be a committed column as it is used in the lookup:
-    pol commit sel_not_start;
+    pol commit sel_not_start; // @boolean (by definition)
     sel_not_start = sel * (1 - start);
 
     // If the current row is a latch or the first row, the next row should be a start (if it's active):
@@ -132,7 +132,8 @@ namespace bc_hashing;
     // Note: packed_fields[0] must never be a padding value and padding can only occur at the last row (i.e. latch = 1).
 
     // Needs to be committed columns as they are used in the lookups
-    pol commit sel_not_padding_1, sel_not_padding_2;
+    pol commit sel_not_padding_1; // @boolean
+    pol commit sel_not_padding_2; // @boolean
     sel_not_padding_1 * (1 - sel_not_padding_1) = 0;
     sel_not_padding_2 * (1 - sel_not_padding_2) = 0;
 
diff --git a/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil b/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil
index c8e100df8f85..2771eb9bac07 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil
@@ -20,7 +20,7 @@ include "../constants_gen.pil";
 
 namespace bc_retrieval;
 
-pol commit sel;
+pol commit sel; // @boolean
 sel * (1 - sel) = 0;
 
 // No relations will be checked if this identity is satisfied.
@@ -68,7 +68,7 @@ pol commit prev_retrieved_bytecodes_tree_size;
 pol commit next_retrieved_bytecodes_tree_root;
 pol commit next_retrieved_bytecodes_tree_size;
 
-pol commit instance_exists;
+pol commit instance_exists; // @boolean
 instance_exists * (1 - instance_exists) = 0;
 
 #[CONTRACT_INSTANCE_RETRIEVAL]
@@ -86,7 +86,7 @@ sel {
     contract_instance_retrieval.nullifier_tree_root
 };
 
-pol commit no_remaining_bytecodes;
+pol commit no_remaining_bytecodes; // @boolean
 no_remaining_bytecodes * (1 - no_remaining_bytecodes) = 0;
 
 // The tree size is 1 (AVM_RETRIEVED_BYTECODES_TREE_INITIAL_SIZE) + retrieved_bytecodes_count
@@ -97,7 +97,7 @@ 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;
+pol commit is_new_class; // @boolean (by lookup into retrieved_bytecodes_tree_check when instance_exists == 1; constrained to 0 when instance_exists == 0)
 
 #[IS_NEW_CLASS_CHECK]
 instance_exists {
@@ -111,14 +111,14 @@ instance_exists {
 };
 
 // Enforce is_new_class == 0 if the instance does not exist.
-sel * (1 - instance_exists) * is_new_class = 0;
+(1 - instance_exists) * is_new_class = 0;
 
 pol TOO_MANY_BYTECODES = no_remaining_bytecodes * is_new_class;
 
 // We error if instance doesn't exist or if we have too many bytecodes.
 sel * (instance_exists * (1 - TOO_MANY_BYTECODES) - (1 - error)) = 0;
 
-pol commit should_retrieve;
+pol commit should_retrieve; // @boolean (by definition; sel gating enforces zero on non-active rows)
 should_retrieve = sel * (1 - error);
 
 // Observe the following also connects the current_class_id of the instance to the class members.
diff --git a/barretenberg/cpp/pil/vm2/bytecode/class_id_derivation.pil b/barretenberg/cpp/pil/vm2/bytecode/class_id_derivation.pil
index e4063ae0db1c..0cd418610a88 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/class_id_derivation.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/class_id_derivation.pil
@@ -6,7 +6,7 @@ include "../precomputed.pil";
 
 namespace class_id_derivation;
 
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
diff --git a/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil b/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil
index 24461879ceee..cc723540df37 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/contract_instance_retrieval.pil
@@ -42,7 +42,7 @@ include "../ff_gt.pil";
  */
 namespace contract_instance_retrieval;
 
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     // No relations will be checked if this identity is satisfied.
@@ -52,7 +52,8 @@ namespace contract_instance_retrieval;
     ////////////////////////////////////////////////////////////////////////////
     // I/O
     pol commit address; // contract address.
-    pol commit exists; // the contract instance exists (its address nullifier exists)
+    pol commit exists; // @boolean the contract instance exists (its address nullifier exists)
+    exists * (1 - exists) = 0;
 
     // address instance members.
     // See barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp
@@ -87,7 +88,8 @@ namespace contract_instance_retrieval;
     sel * (constants.CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS - deployer_protocol_contract_address) = 0;
 
     // Indicates if the instance belongs to a protocol contract
-    pol commit is_protocol_contract;
+    pol commit is_protocol_contract; // @boolean (by lookup on active rows)
+    // TODO: review safety of is_protocol_contract being underconstrained on inactive rows
 
     // Canonical Addresses can be in the range of 1 <= address <= MAX_PROTOCOL_CONTRACTS
     pol commit max_protocol_contracts;
@@ -123,7 +125,7 @@ namespace contract_instance_retrieval;
 
     // Constrain exists and derived address for non-protocol contracts via nullifier check
 
-    pol commit should_check_nullifier;
+    pol commit should_check_nullifier; // @boolean (by definition)
     // Protocol contracts do not have an address nullifier in the nullifier tree.
     should_check_nullifier = sel * (1 - is_protocol_contract);
 
@@ -193,7 +195,7 @@ namespace contract_instance_retrieval;
 
     // Enforce that the class id provided is the _current_ one (only when nullifier exists)
     // If the address nullifier doesn't exist (which excludes protocol contract instances), there is no need to check!
-    pol commit should_check_for_update;
+    pol commit should_check_for_update; // @boolean (by definition)
     should_check_for_update = should_check_nullifier * exists;
     #[UPDATE_CHECK]
     should_check_for_update {
diff --git a/barretenberg/cpp/pil/vm2/bytecode/instr_fetching.pil b/barretenberg/cpp/pil/vm2/bytecode/instr_fetching.pil
index 9736b9944627..8fb60c5fb4ea 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/instr_fetching.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/instr_fetching.pil
@@ -45,7 +45,7 @@ include "../constants_gen.pil";
 
 namespace instr_fetching;
 
-pol commit sel;
+pol commit sel; // @boolean
 sel * (1 - sel) = 0;
 // No relations will be checked if this identity is satisfied.
 #[skippable_if]
@@ -61,26 +61,26 @@ pol commit bytecode_id;
 // ****************************************************************************
 
 // pc out-of-range error boolean
-pol commit pc_out_of_range;
+pol commit pc_out_of_range; // @boolean
 pc_out_of_range * (1 - pc_out_of_range) = 0;
 
 // Instruction out-of-range error boolean (happens iff instr_size > bytes_to_read)
-pol commit instr_out_of_range;
+pol commit instr_out_of_range; // @boolean
 instr_out_of_range * (1 - instr_out_of_range) = 0;
 
 // opcode is out-of-range error boolean
-pol commit opcode_out_of_range; // copied from precomputed.pil
+pol commit opcode_out_of_range; // @boolean
+opcode_out_of_range * (1 - opcode_out_of_range) = 0;
 
 // memory tag is out-of-range error boolean
-pol commit tag_out_of_range; // copied from precomputed.pil
+pol commit tag_out_of_range; // @boolean
+tag_out_of_range * (1 - tag_out_of_range) = 0;
 
 pol PARSING_ERROR_EXCEPT_TAG_ERROR = pc_out_of_range + opcode_out_of_range + instr_out_of_range;
 
 // If any error occurs, we toggle the following boolean:
 pol commit sel_parsing_err;
-// FIXME: constrain this again once all execution opcodes are supported.
-// See InstrDeserializationError::INVALID_EXECUTION_OPCODE.
-// sel_parsing_err = PARSING_ERROR_EXCEPT_TAG_ERROR + tag_out_of_range;
+sel_parsing_err = PARSING_ERROR_EXCEPT_TAG_ERROR + tag_out_of_range;
 sel_parsing_err * (1 - sel_parsing_err) = 0; // enforces disjoint errors
 
 
@@ -139,8 +139,8 @@ sel { instr_abs_diff } in precomputed.sel_range_8 { precomputed.clk };
 // ****************************************************************************
 
 // Retrieved from precomputed.pil (instruction specification)
-pol commit sel_has_tag; // With current instruction specs, tag can appear at op2 (SET_XXX) or op3 (CAST_8, CAST_16)
-pol commit sel_tag_is_op2; // (sel_tag_is_op2 == 0 && sel_has_tag == 1) ==> op3 is a tag
+pol commit sel_has_tag; // @boolean (by lookup only when sel_pc_in_range == 1) - With current instruction specs, tag can appear at op2 (SET_XXX) or op3 (CAST_8, CAST_16)
+pol commit sel_tag_is_op2; // @boolean (by lookup only when sel_pc_in_range == 1) - (sel_tag_is_op2 == 0 && sel_has_tag == 1) ==> op3 is a tag
 
 // Value to validate as tag. According to our instruction specifications, there is a maximum of one tag per instruction
 // and it appears only at op2 or op3.
@@ -175,7 +175,7 @@ pol commit bd0, bd1, bd2, bd3, bd4,
 // Source selector for lookups to bc_decomposition.pil and instruction specifications in precomputed.pil.
 // When the pc is in range, we can at least fetch the byte of the wire opcode which allows to proceed to
 // the next errors checking.
-pol commit sel_pc_in_range;
+pol commit sel_pc_in_range; // @boolean (by definition)
 // Toggled except when pc is out of range.
 sel_pc_in_range = sel * (1 - pc_out_of_range);
 
@@ -213,23 +213,25 @@ pol commit exec_opcode;
 
 // Selectors for operands decomposition into bytes (copied from precomputed.pil)
 // This table is populated by a map generated by a cpp test in op_decomposition.test.cpp.
-pol commit sel_op_dc_0;
-pol commit sel_op_dc_1;
-pol commit sel_op_dc_2;
-pol commit sel_op_dc_3;
-pol commit sel_op_dc_4;
-pol commit sel_op_dc_5;
-pol commit sel_op_dc_6;
-pol commit sel_op_dc_7;
-pol commit sel_op_dc_8;
-pol commit sel_op_dc_9;
-pol commit sel_op_dc_10;
-pol commit sel_op_dc_11;
-pol commit sel_op_dc_12;
-pol commit sel_op_dc_13;
-pol commit sel_op_dc_14;
-pol commit sel_op_dc_15;
-pol commit sel_op_dc_16;
+// Note: These selectors are boolean only when sel_pc_in_range == 1 (constrained by lookup).
+// This is safe because relevant relations are gated by (1 - PARSING_ERROR_EXCEPT_TAG_ERROR).
+pol commit sel_op_dc_0; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_1; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_2; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_3; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_4; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_5; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_6; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_7; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_8; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_9; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_10; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_11; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_12; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_13; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_14; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_15; // @boolean (by lookup only when sel_pc_in_range == 1)
+pol commit sel_op_dc_16; // @boolean (by lookup only when sel_pc_in_range == 1)
 
 #[WIRE_INSTRUCTION_INFO]
 sel_pc_in_range {
diff --git a/barretenberg/cpp/pil/vm2/bytecode/update_check.pil b/barretenberg/cpp/pil/vm2/bytecode/update_check.pil
index 11528e08b199..30dc78bec747 100644
--- a/barretenberg/cpp/pil/vm2/bytecode/update_check.pil
+++ b/barretenberg/cpp/pil/vm2/bytecode/update_check.pil
@@ -27,7 +27,7 @@ include "../trees/public_data_check.pil";
 // in update_check.sel { update_check.address, update_check.current_class_id, update_check.original_class_id, update_check.public_data_tree_root, update_check.timestamp };
 //
 namespace update_check;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
@@ -91,7 +91,7 @@ namespace update_check;
     // ======== DELAYED PUBLIC MUTABLE PREIMAGE CONSTRAINING ========
 
     pol commit update_hash_inv;
-    pol commit hash_not_zero;
+    pol commit hash_not_zero; // @boolean
     hash_not_zero * (1 - hash_not_zero) = 0;
     pol HASH_IS_ZERO = 1 - hash_not_zero;
 
@@ -140,20 +140,20 @@ namespace update_check;
     // ======== CLASS ID CHECK ========
     // We are going to use the gt gadget to compare `timestamp` and `timestamp_of_change` and derive
     // the boolean value of `timestamp_is_lt_timestamp_of_change`.
-    pol commit timestamp_is_lt_timestamp_of_change; // Boolean value enforced by gt gadget (under condition hash_not_zero == 1).
+    pol commit timestamp_is_lt_timestamp_of_change; // @boolean (by lookup) Boolean value enforced by gt gadget (under condition hash_not_zero == 1).
 
     // Equivalent to "timestamp_of_change > timestamp"
     #[TIMESTAMP_IS_LT_TIMESTAMP_OF_CHANGE]
     hash_not_zero { timestamp_of_change, timestamp, timestamp_is_lt_timestamp_of_change }
     in gt.sel_others { gt.input_a, gt.input_b, gt.res };
 
-    pol commit update_pre_class_id_is_zero;
+    pol commit update_pre_class_id_is_zero; // @boolean
     update_pre_class_id_is_zero * (1 - update_pre_class_id_is_zero) = 0;
     pol commit update_pre_class_inv;
     #[UPDATE_PRE_CLASS_IS_ZERO]
     hash_not_zero * (update_preimage_pre_class_id * (update_pre_class_id_is_zero * (1 - update_pre_class_inv) + update_pre_class_inv) - 1 + update_pre_class_id_is_zero) = 0;
 
-    pol commit update_post_class_id_is_zero;
+    pol commit update_post_class_id_is_zero; // @boolean
     update_post_class_id_is_zero * (1 - update_post_class_id_is_zero) = 0;
     pol commit update_post_class_inv;
     #[UPDATE_POST_CLASS_IS_ZERO]
diff --git a/barretenberg/cpp/pil/vm2/calldata.pil b/barretenberg/cpp/pil/vm2/calldata.pil
index b57d13367b3f..d73ffd9f1af2 100644
--- a/barretenberg/cpp/pil/vm2/calldata.pil
+++ b/barretenberg/cpp/pil/vm2/calldata.pil
@@ -50,7 +50,8 @@ namespace calldata;
     #[skippable_if]
     sel = 0;
 
-    pol commit sel;
+    pol commit sel; // @boolean
+    sel * (1 - sel) = 0;
     pol commit value;
     pol commit context_id;
     // **NOTE** The index starts at one in this trace (see above comment for special case of empty calldata and index = 0):
@@ -71,7 +72,7 @@ namespace calldata;
     // size = 0. This is a different case to a calldata of one field of value 0, where index = 1.
     pol commit index;
     // Designates end of calldata for that context_id
-    pol commit latch;
+    pol commit latch; // @boolean
     latch * (1 - latch) = 0;
 
     // latch == 1 ==> sel == 1
diff --git a/barretenberg/cpp/pil/vm2/calldata_hashing.pil b/barretenberg/cpp/pil/vm2/calldata_hashing.pil
index 13bd539aeb32..71eeb9774730 100644
--- a/barretenberg/cpp/pil/vm2/calldata_hashing.pil
+++ b/barretenberg/cpp/pil/vm2/calldata_hashing.pil
@@ -37,12 +37,13 @@ namespace calldata_hashing;
     #[skippable_if]
     sel = 0;
 
-    pol commit sel;
+    pol commit sel; // @boolean
+    sel * (1 - sel) = 0;
     // If sel = 0, sel' != 1
     #[TRACE_CONTINUITY]
     (1 - precomputed.first_row) * (1 - sel) * sel' = 0;
 
-    pol commit latch;
+    pol commit latch; // @boolean
     latch * (1 - latch) = 0;
 
     // latch == 1 ==> sel == 1
@@ -62,11 +63,11 @@ namespace calldata_hashing;
     (1 - LATCH_CONDITION) * (calldata_size' - calldata_size) = 0;
 
     // The start of a new context id and new set of hashing runs:
-    pol commit start;
+    pol commit start; // @boolean
     start * (1 - start) = 0;
 
     // Needs to be a committed column as it is used in the lookup:
-    pol commit sel_not_start;
+    pol commit sel_not_start; // @boolean (by definition)
     sel_not_start = sel * (1 - start);
 
     // If the current row is a latch or the first row, the next row should be a start (if it's active):
@@ -123,7 +124,8 @@ namespace calldata_hashing;
     // Note: input[0] must never be a padding value and padding can only occur at the last row (i.e. latch = 1).
 
     // Needs to be committed columns as they are used in the lookups
-    pol commit sel_not_padding_1, sel_not_padding_2;
+    pol commit sel_not_padding_1; // @boolean
+    pol commit sel_not_padding_2; // @boolean
     sel_not_padding_1 * (1 - sel_not_padding_1) = 0;
     sel_not_padding_2 * (1 - sel_not_padding_2) = 0;
 
diff --git a/barretenberg/cpp/pil/vm2/context.pil b/barretenberg/cpp/pil/vm2/context.pil
index 5bd33a115b05..7342894b9f34 100644
--- a/barretenberg/cpp/pil/vm2/context.pil
+++ b/barretenberg/cpp/pil/vm2/context.pil
@@ -17,7 +17,7 @@ namespace execution;
     // use `sel_failure`.
 
     // Guaranteed to be boolean because sel_execute_call & sel_execute_static_call are mutually exclusive
-    pol commit sel_enter_call;
+    pol commit sel_enter_call; // @boolean (by definition)
     // The following selectors will be 0 if there is an error during execution (before the opcode execution step).
     sel_enter_call = sel_execute_call + sel_execute_static_call;
     // sel_enter_call and precomputed.first_row are mutually exclusive because
@@ -30,7 +30,7 @@ namespace execution;
     // with sel_execute_revert and sel_execute_return. As sel_opcode_error is a specific error of the last temporality
     // group, sel_error is mutually exclusive with sel_execute_revert and sel_execute_return. Namely, if
     // an error occurs earlier neither sel_execute_revert nor sel_execute_return can be activated.
-    pol commit sel_exit_call;
+    pol commit sel_exit_call; // @boolean (by definition)
     sel_exit_call = sel_failure + sel_execute_return; // = sel_execute_revert + sel_error + sel_execute_return
 
     // Context columns
@@ -125,13 +125,13 @@ namespace execution;
 
     pol PC_JUMP = sel_execute_internal_call + sel_execute_internal_return + sel_execute_jump + sel_execute_jumpi;
 
-    pol commit has_parent_ctx; // == 1 if parent_id != 0;
+    pol commit has_parent_ctx; // @boolean - == 1 if parent_id != 0;
     has_parent_ctx * (1 - has_parent_ctx) = 0;
     pol commit is_parent_id_inv; // For zero-check of has_parent_ctx
     parent_id * ((1 - has_parent_ctx) * (1 - is_parent_id_inv) + is_parent_id_inv) - has_parent_ctx = 0;
 
     // We need a flag to indicate when we are exiting a nested context
-    pol commit nested_exit_call;
+    pol commit nested_exit_call; // @boolean (by definition)
     // If we are exiting and we have a parent ctx
     nested_exit_call = has_parent_ctx * sel_exit_call;
 
@@ -224,7 +224,7 @@ namespace execution;
     #[CD_OFFSET_NEXT_ROW]
     NOT_LAST_EXEC * DEFAULT_CTX_ROW * (parent_calldata_addr' - parent_calldata_addr) = 0;
     NOT_LAST_EXEC * sel_enter_call  * (parent_calldata_addr' - rop[4]) = 0;
-    #[CD_SIZE_ENQUEUED_CALL_IS_ZERO]
+    #[CD_ADDR_ENQUEUED_CALL_IS_ZERO]
     enqueued_call_start * parent_calldata_addr = 0;
 
     // enqueued_call_start = 1 ==> parent_calldata_size is constrained in tx.pil (#[DISPATCH_EXEC_START])
@@ -261,7 +261,7 @@ namespace execution;
     #[NEXT_RD_SIZE_IS_ZERO]
     NOT_LAST_EXEC * (sel_enter_call + sel_error) * last_child_returndata_size' = 0;
     #[RD_SIZE_IS_ZERO]
-    enqueued_call_start * last_child_returndata_addr = 0;
+    enqueued_call_start * last_child_returndata_size = 0;
     #[PROPAGATE_RD_SIZE]
     NOT_LAST_EXEC * DEFAULT_CTX_ROW * (last_child_returndata_size' - last_child_returndata_size) = 0;
 
@@ -472,7 +472,7 @@ namespace execution;
         context_stack.num_l2_to_l1_messages
     };
 
-    pol commit nested_return;
+    pol commit nested_return; // @boolean (by definition)
     nested_return = has_parent_ctx * sel_execute_return;
 
     // We restore a partial context on a nested return. We do not restore trees or side effects though,
diff --git a/barretenberg/cpp/pil/vm2/context_stack.pil b/barretenberg/cpp/pil/vm2/context_stack.pil
index e37b309fe4e9..932759b35503 100644
--- a/barretenberg/cpp/pil/vm2/context_stack.pil
+++ b/barretenberg/cpp/pil/vm2/context_stack.pil
@@ -1,5 +1,5 @@
 namespace context_stack;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
diff --git a/barretenberg/cpp/pil/vm2/data_copy.pil b/barretenberg/cpp/pil/vm2/data_copy.pil
index f511bc70e9b2..b9651a06a8bb 100644
--- a/barretenberg/cpp/pil/vm2/data_copy.pil
+++ b/barretenberg/cpp/pil/vm2/data_copy.pil
@@ -133,7 +133,7 @@ include "gt.pil";
  */
 
 namespace data_copy;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
@@ -180,10 +180,10 @@ namespace data_copy;
     ////////////////////////////////////////////////
     // These permutations are defined in execution.pil. See #[DISPATCH_TO_CD_COPY] and #[DISPATCH_TO_RD_COPY].
 
-    pol commit sel_cd_copy_start; // @boolean follows from the definition
+    pol commit sel_cd_copy_start; // @boolean (by definition)
     sel_cd_copy_start = sel_start * sel_cd_copy;
 
-    pol commit sel_rd_copy_start; // @boolean follows from the definition
+    pol commit sel_rd_copy_start; // @boolean (by definition)
     sel_rd_copy_start = sel_start * (1 - sel_cd_copy);
 
     // It follows from the above equations that sel_cd_copy_start and sel_rd_copy_start are mutually exclusive
@@ -217,7 +217,7 @@ namespace data_copy;
     // if (1) then data_index_upper_bound = src_data_size, otherwise data_index_upper_bound = (offset + copy_size)
     pol commit offset_plus_size;
     offset_plus_size = sel_start * (offset + copy_size);
-    pol commit offset_plus_size_is_gt; // @boolean follows from the lookup into gt.
+    pol commit offset_plus_size_is_gt; // @boolean (by lookup into gt)
 
     #[OFFSET_PLUS_SIZE_IS_GT_DATA_SIZE]
     sel_start { offset_plus_size, src_data_size, offset_plus_size_is_gt }
@@ -232,8 +232,8 @@ namespace data_copy;
     // Error Handling
     //////////////////////////////
     // Errors on whether the read or write addresses are out of range in memory. (provided that sel_start == 1).
-    pol commit src_out_of_range_err; // @boolean follows from the lookup into gt.
-    pol commit dst_out_of_range_err; // @boolean follows from the lookup into gt.
+    pol commit src_out_of_range_err; // @boolean (by lookup into gt)
+    pol commit dst_out_of_range_err; // @boolean (by lookup into gt)
 
     // AVM_MEMORY_SIZE == AVM_HIGHEST_MEM_ADDRESS + 1.
     pol commit mem_size; // todo: While we do not support constants
@@ -265,13 +265,13 @@ namespace data_copy;
 
     // Consolidate the errors
     // Underconstrained for non-starting rows (sel_start = 0).
-    pol commit err; // @boolean follows from the definition
+    pol commit err; // @boolean (by definition)
     err = 1 - (1 - dst_out_of_range_err) * (1 - src_out_of_range_err);
 
     //////////////////////////////
     // Control flow management
     //////////////////////////////
-    pol commit sel_start_no_err; // @boolean follows from the definition
+    pol commit sel_start_no_err; // @boolean (by definition)
     sel_start_no_err = sel_start * (1 - err);
 
     pol commit sel_write_count_is_zero; // @boolean
@@ -298,7 +298,7 @@ namespace data_copy;
     // src data elements are read from indices [offset, data_index_upper_bound), therefore reads_left = data_index_upper_bound - offset
     // We need to be careful that data_index_upper_bound - offset does not underflow (i.e. when offset > data_index_upper_bound, reads_left = 0)
     // We test that condition here
-    pol commit data_index_upper_bound_gt_offset; // @boolean follows from the lookup into gt.
+    pol commit data_index_upper_bound_gt_offset; // @boolean (by lookup into gt)
     #[DATA_INDEX_UPPER_BOUND_GT_OFFSET]
     sel_start_no_err { data_index_upper_bound, offset, data_index_upper_bound_gt_offset }
     in
@@ -314,7 +314,7 @@ namespace data_copy;
     //////////////////////////////
     // Most of these relations are either gated explicitly by err, end, or LATCH_CONDITION.
     // ===== Writing to dst_context_id =====
-    pol commit sel_mem_write; // @boolean follows from the definition (see SEL_PERFORM_COPY)
+    pol commit sel_mem_write; // @boolean (by definition, see SEL_PERFORM_COPY)
     sel_mem_write = SEL_PERFORM_COPY; // We write if there is no error and copy_size != 0
 
     // Data copy size decrements for each row until we end
@@ -373,7 +373,7 @@ namespace data_copy;
     // Read from memory if we are not the top level call and not a padding row
     // If the current row is a memory op read, i.e., no error occured, copy_size != 0,
     // it is not a padding row and not a CD_COPY in a top-level call.
-    pol commit sel_mem_read; // @boolean follows from the definition
+    pol commit sel_mem_read; // @boolean (by definition)
     sel_mem_read = SEL_PERFORM_COPY * (1 - is_top_level * sel_cd_copy) * (1 - padding);
 
     // === Value Padding ===
@@ -390,7 +390,7 @@ namespace data_copy;
 
     // ===== Reading cd column for top level cd copy =====
     // Reading from column
-    pol commit cd_copy_col_read; // @boolean follows from the definition
+    pol commit cd_copy_col_read; // @boolean (by definition)
     #[CD_COPY_COLUMN]
     cd_copy_col_read = SEL_PERFORM_COPY * (1 - padding) * is_top_level * sel_cd_copy;
 
diff --git a/barretenberg/cpp/pil/vm2/ecc.pil b/barretenberg/cpp/pil/vm2/ecc.pil
index 60c835475665..1b16643cad97 100644
--- a/barretenberg/cpp/pil/vm2/ecc.pil
+++ b/barretenberg/cpp/pil/vm2/ecc.pil
@@ -11,14 +11,14 @@ namespace ecc;
     pol INFINITY_Y = 0;
 
     // This is the selector with which other subtraces will reference
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
     #[skippable_if]
     sel = 0;
 
-    pol commit double_op;
+    pol commit double_op; // @boolean
     double_op * (1 - double_op) = 0;
-    pol commit add_op;
+    pol commit add_op; // @boolean
     add_op * (1 - add_op) = 0;
 
     // When the sel is on, we are either doubling, adding or handling the edge case
@@ -27,24 +27,24 @@ namespace ecc;
     // Point P in affine form
     pol commit p_x;
     pol commit p_y;
-    pol commit p_is_inf;
+    pol commit p_is_inf; // @boolean
     p_is_inf * (1 - p_is_inf) = 0;
 
     // Point Q in affine form
     pol commit q_x;
     pol commit q_y;
-    pol commit q_is_inf;
+    pol commit q_is_inf; // @boolean
     q_is_inf * (1 - q_is_inf) = 0;
 
     // Resulting Point R in affine form
     pol commit r_x;
     pol commit r_y;
-    pol commit r_is_inf;
+    pol commit r_is_inf; // @boolean
     r_is_inf * (1 - r_is_inf) = 0;
 
     // Check the coordinates to see if we need to handle an edge case
     // Check x coordinates, i.e. p_x == q_x
-    pol commit x_match;
+    pol commit x_match; // @boolean
     x_match * (1 - x_match) = 0;
     pol X_DIFF = q_x - p_x;
     pol commit inv_x_diff;
@@ -52,7 +52,7 @@ namespace ecc;
     sel * (X_DIFF * (x_match * (1 - inv_x_diff) + inv_x_diff) - 1 + x_match) = 0;
 
     // Check y coordinates, i.e. p_y == q_y
-    pol commit y_match;
+    pol commit y_match; // @boolean
     y_match * (1 - y_match) = 0;
     pol Y_DIFF = q_y - p_y;
     pol commit inv_y_diff;
diff --git a/barretenberg/cpp/pil/vm2/ecc_mem.pil b/barretenberg/cpp/pil/vm2/ecc_mem.pil
index 1960dd73303e..ea9d826e4b2a 100644
--- a/barretenberg/cpp/pil/vm2/ecc_mem.pil
+++ b/barretenberg/cpp/pil/vm2/ecc_mem.pil
@@ -52,7 +52,7 @@ include "gt.pil";
 
 namespace ecc_add_mem;
 
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
@@ -73,7 +73,7 @@ namespace ecc_add_mem;
     ////////////////////////////////////////////////
     // Error Handling - Out of Range Memory Access
     ////////////////////////////////////////////////
-    pol commit sel_dst_out_of_range_err; // Constrained to be boolean by the lookup into gt. (provided that sel == 1).
+    pol commit sel_dst_out_of_range_err; // @boolean Constrained to be boolean by the lookup into gt. (provided that sel == 1).
 
     // Use the comparison gadget to check that the max addresses are within range
     // The comparison gadget provides the ability to test GreaterThan so we check
@@ -89,10 +89,10 @@ namespace ecc_add_mem;
     ////////////////////////////////////////////////
     // Error Handling - Check Points are on curve
     ////////////////////////////////////////////////
-    pol commit sel_p_not_on_curve_err;
+    pol commit sel_p_not_on_curve_err; // @boolean
     sel_p_not_on_curve_err * (1 - sel_p_not_on_curve_err) = 0;
 
-    pol commit sel_q_not_on_curve_err;
+    pol commit sel_q_not_on_curve_err; // @boolean
     sel_q_not_on_curve_err * (1 - sel_q_not_on_curve_err) = 0;
 
     // Y^2 = X^3 − 17, re-formulate to Y^2 - (X^3 - 17) = 0
@@ -117,14 +117,14 @@ namespace ecc_add_mem;
     #[Q_ON_CURVE_CHECK]
     sel * (q_is_on_curve_eqn * ((1 - sel_q_not_on_curve_err) * (1 - q_is_on_curve_eqn_inv) + q_is_on_curve_eqn_inv) - sel_q_not_on_curve_err) = 0;
 
-    pol commit err; // Consolidate errors
+    pol commit err; // @boolean Consolidate errors (by definition)
     err = 1 - (1 - sel_dst_out_of_range_err) * (1 - sel_p_not_on_curve_err) * (1 - sel_q_not_on_curve_err);
 
     ///////////////////////////////////////////////////////////////////////
     // Dispatch inputs to ecc add and retrieve outputs
     ///////////////////////////////////////////////////////////////////////
     pol commit res_x, res_y, res_is_inf;
-    pol commit sel_should_exec;
+    pol commit sel_should_exec; // @boolean (by definition)
     sel_should_exec = sel * (1 - err);
 
     #[INPUT_OUTPUT_ECC_ADD]
diff --git a/barretenberg/cpp/pil/vm2/execution/addressing.pil b/barretenberg/cpp/pil/vm2/execution/addressing.pil
index 2460a35193ec..cd72e257d11f 100644
--- a/barretenberg/cpp/pil/vm2/execution/addressing.pil
+++ b/barretenberg/cpp/pil/vm2/execution/addressing.pil
@@ -232,7 +232,7 @@ op_after_relative[6] = op[6] + SEL_OP_IS_RELATIVE_EFFECTIVE_6_ * RELATIVE_RESOLU
 // is not active. Therefore, we do not have to gate the above relations by SEL_SHOULD_RESOLVE_ADDRESS.
 // In addition, the above relations can be skipped when SEL_SHOULD_RESOLVE_ADDRESS == 0 (skippable condition).
 
-pol commit sel_op_do_overflow_check[7]; //@boolean (from definition)
+pol commit sel_op_do_overflow_check[7]; // @boolean (by definition)
 sel_op_do_overflow_check[0] = SEL_OP_IS_RELATIVE_EFFECTIVE_0_ * (1 - sel_base_address_failure);
 sel_op_do_overflow_check[1] = SEL_OP_IS_RELATIVE_EFFECTIVE_1_ * (1 - sel_base_address_failure);
 sel_op_do_overflow_check[2] = SEL_OP_IS_RELATIVE_EFFECTIVE_2_ * (1 - sel_base_address_failure);
diff --git a/barretenberg/cpp/pil/vm2/execution/discard.pil b/barretenberg/cpp/pil/vm2/execution/discard.pil
index f86d824bfa8f..65046425aaf9 100644
--- a/barretenberg/cpp/pil/vm2/execution/discard.pil
+++ b/barretenberg/cpp/pil/vm2/execution/discard.pil
@@ -41,7 +41,7 @@ namespace execution; // virtual to execution.pil
     sel_failure * (1 - discard) = 0;
 
     // Helper columns for checking if context_id == dying_context_id
-    pol commit is_dying_context; // @boolean (on active rows) 1 iff context_id == dying_context_id
+    pol commit is_dying_context; // @boolean (on active rows - 1 iff context_id == dying_context_id)
     is_dying_context * (1 - is_dying_context) = 0; // Boolean constraint
     pol DYING_CONTEXT_DIFF = context_id - dying_context_id;
     pol commit dying_context_diff_inv; // Inverse of (context_id - dying_context_id) when they're different
diff --git a/barretenberg/cpp/pil/vm2/execution/gas.pil b/barretenberg/cpp/pil/vm2/execution/gas.pil
index ef1733af1336..efdb4b219a91 100644
--- a/barretenberg/cpp/pil/vm2/execution/gas.pil
+++ b/barretenberg/cpp/pil/vm2/execution/gas.pil
@@ -63,8 +63,8 @@ namespace execution;
     pol L2_GAS_USED = BASE_L2_GAS + DYNAMIC_L2_GAS_USED;
     pol DA_GAS_USED = base_da_gas + DYNAMIC_DA_GAS_USED;
 
-    pol commit out_of_gas_l2; // Boolean constraint enforced through lookup into gt when `sel_should_check_gas = 1`.
-    pol commit out_of_gas_da; // Boolean constraint enforced through lookup into gt when `sel_should_check_gas = 1`.
+    pol commit out_of_gas_l2; // @boolean (by lookup into gt when sel_should_check_gas = 1)
+    pol commit out_of_gas_da; // @boolean (by lookup into gt when sel_should_check_gas = 1)
 
     // Alias Support Lookup: Once we support expression in lookup, we can replace this column by an alias.
     pol commit total_gas_l2;
@@ -91,8 +91,7 @@ namespace execution;
     sel_should_check_gas { total_gas_da, da_gas_limit, out_of_gas_da } in gt.sel_gas { gt.input_a, gt.input_b, gt.res };
 
     // sel_out_of_gas == out_of_gas_l2 || out_of_gas_da when `sel_should_check_gas = 1`.
-    pol commit sel_out_of_gas; // @boolean (follows from definition and constraint below forcing to be 0
-                               //           if `sel_should_check_gas = 0`)
+    pol commit sel_out_of_gas; // @boolean (by definition, forced to 0 if sel_should_check_gas = 0)
     sel_out_of_gas = 1 - (1 - out_of_gas_l2) * (1 - out_of_gas_da);
 
     // If we shouldn't check the gas, you shouldn't be able to claim out of gas.
diff --git a/barretenberg/cpp/pil/vm2/ff_gt.pil b/barretenberg/cpp/pil/vm2/ff_gt.pil
index 3142bdf8af56..b56764723d17 100644
--- a/barretenberg/cpp/pil/vm2/ff_gt.pil
+++ b/barretenberg/cpp/pil/vm2/ff_gt.pil
@@ -37,7 +37,7 @@ include "./range_check.pil";
 // WARNING: Never invoke FF_GT with `sel` selector. This is not a valid usage of the gadget.
 
 namespace ff_gt;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
diff --git a/barretenberg/cpp/pil/vm2/gt.pil b/barretenberg/cpp/pil/vm2/gt.pil
index 9f611730cb58..b91f4634b3ac 100644
--- a/barretenberg/cpp/pil/vm2/gt.pil
+++ b/barretenberg/cpp/pil/vm2/gt.pil
@@ -20,15 +20,15 @@ include "range_check.pil";
 // - sel_others
 namespace gt;
 
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     // This is used to decouple generation of inverses of lookups into this trace.
-    pol commit sel_sha256;
-    pol commit sel_addressing;
-    pol commit sel_alu;
-    pol commit sel_gas;
-    pol commit sel_others;  // Any other lookup into this trace.
+    pol commit sel_sha256; // @boolean
+    pol commit sel_addressing; // @boolean
+    pol commit sel_alu; // @boolean
+    pol commit sel_gas; // @boolean
+    pol commit sel_others; // @boolean Any other lookup into this trace.
     sel_sha256 * (1 - sel_sha256) = 0;
     sel_addressing * (1 - sel_addressing) = 0;
     sel_alu * (1 - sel_alu) = 0;
@@ -43,7 +43,7 @@ namespace gt;
     pol commit input_a;
     pol commit input_b;
 
-    pol commit res; // Boolean
+    pol commit res; // @boolean
     res * (1 - res) = 0;
 
     pol A_LTE_B = input_b - input_a;
diff --git a/barretenberg/cpp/pil/vm2/internal_call_stack.pil b/barretenberg/cpp/pil/vm2/internal_call_stack.pil
index d959385deb0e..32e0ee7f30cc 100644
--- a/barretenberg/cpp/pil/vm2/internal_call_stack.pil
+++ b/barretenberg/cpp/pil/vm2/internal_call_stack.pil
@@ -8,7 +8,7 @@ include "precomputed.pil";
 // we can reset the internal call ptr information ({id, return_id})
 
 namespace internal_call_stack;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
diff --git a/barretenberg/cpp/pil/vm2/keccak_memory.pil b/barretenberg/cpp/pil/vm2/keccak_memory.pil
index eb1518ab281a..850f315abbf7 100644
--- a/barretenberg/cpp/pil/vm2/keccak_memory.pil
+++ b/barretenberg/cpp/pil/vm2/keccak_memory.pil
@@ -83,17 +83,17 @@ namespace keccak_memory;
 // Note that we need a separate column because `single_tag_error` defines `last` which
 // controls when the computation or propagation stops.
 
-pol commit sel;
+pol commit sel; // @boolean
 sel * (1 - sel) = 0;
 
 // No relations will be checked if this identity is satisfied.
 #[skippable_if]
 sel = 0;
 
-pol commit start_read;
+pol commit start_read; // @boolean
 start_read * (1 - start_read) = 0;
 
-pol commit start_write;
+pol commit start_write; // @boolean
 start_write * (1 - start_write) = 0;
 
 pol commit clk;
@@ -101,8 +101,7 @@ pol commit ctr;
 pol commit addr;
 pol commit tag;
 pol commit space_id;
-pol commit tag_error;
-pol commit single_tag_error;
+pol commit tag_error; // @boolean (by definition)
 
 // Values for memory slice
 pol commit val[25];
@@ -122,7 +121,7 @@ pol commit ctr_inv;
 ctr * ((1 - sel) * (1 - ctr_inv) + ctr_inv) - sel = 0;
 
 // ctr_end is toggled when all slice rows have been processed.
-pol commit ctr_end;
+pol commit ctr_end; // @boolean
 ctr_end * (1 - ctr_end) = 0;
 
 // We define ctr_end == 1 <==> ctr == AVM_KECCAKF1600_STATE_SIZE (25)
@@ -131,7 +130,7 @@ pol commit state_size_min_ctr_inv;
 sel * ((constants.AVM_KECCAKF1600_STATE_SIZE - ctr) * (ctr_end * (1 - state_size_min_ctr_inv) + state_size_min_ctr_inv) + ctr_end - 1) = 0;
 
 // Last ctr of a multi-rows processing of a slice
-pol commit last;
+pol commit last; // @boolean (by definition)
 
 // last == ctr_end || single_tag_error
 // `last` is boolean by definition
@@ -143,8 +142,10 @@ last = 1 - (1 - ctr_end) * (1 - single_tag_error);
 sel * (1 - last) * (ctr' - ctr - 1) = 0;
 
 // Copied from memory.pil through lookup and constrained to be boolean in memory.pil.
-pol commit rw;
+pol commit rw; // @boolean (constrained by memory.pil)
 
+pol commit single_tag_error; // @boolean
+#[SINGLE_TAG_ERROR_BOOLEAN]
 single_tag_error * (1 - single_tag_error) = 0;
 
 #[NO_TAG_ERROR_ON_WRITE]
@@ -177,9 +178,6 @@ pol TAG_MIN_U64 = tag - constants.MEM_TAG_U64;
 #[SINGLE_TAG_ERROR]
 sel * (TAG_MIN_U64 * ((1 - single_tag_error) * (1 - tag_min_u64_inv) + tag_min_u64_inv) - single_tag_error) = 0;
 
-#[SINGLE_TAG_ERROR_BOOLEAN]
-single_tag_error * (1 - single_tag_error) = 0;
-
 #[VAL01]
 val[1] = (1 - last) * val[0]';
 #[VAL02]
diff --git a/barretenberg/cpp/pil/vm2/keccakf1600.pil b/barretenberg/cpp/pil/vm2/keccakf1600.pil
index c86059aaf92e..244a53a62d1c 100644
--- a/barretenberg/cpp/pil/vm2/keccakf1600.pil
+++ b/barretenberg/cpp/pil/vm2/keccakf1600.pil
@@ -69,7 +69,7 @@ namespace keccakf1600;
 // Only on last row, we constrain the output columns.
 
 // keccakf1600 selector
-pol commit sel;
+pol commit sel; // @boolean
 sel * (1 - sel) = 0;
 
 // No relations will be checked if this identity is satisfied.
@@ -77,7 +77,7 @@ sel * (1 - sel) = 0;
 sel = 0;
 
 // error is defined below after round function
-pol commit sel_no_error;
+pol commit sel_no_error; // @boolean (by definition)
 #[SEL_NO_ERROR]
 start * (sel_no_error - 1 + error) = 0;
 
@@ -86,7 +86,7 @@ pol commit round;
 
 // First round of a keccak permutation. This is where the multi-rows computation starts and selector start
 // is used by the caller to trigger the keccak permutation computation.
-pol commit start;
+pol commit start; // @boolean
 start * (1 - start) = 0;
 
 // We enforce the initial round to be set to 1.
@@ -107,7 +107,7 @@ sel * (1 - last) * (round' - round - 1) = 0;
 // This is achieved through #[SEL_SLICE_WRITE] and #[WRITE_TO_SLICE]. If there is no error,
 // the former guarantees that the write slice is active whenever `last == 1`. The latter guarantees
 // that `round` is equal to 24 (by fixing a constant 24 in the destination permutation tuple).
-pol commit last;
+pol commit last; // @boolean
 last * (1 - last) = 0;
 
 // TODO: We need this temporarily while we do not allow for constants in the lookup tuple
diff --git a/barretenberg/cpp/pil/vm2/memory.pil b/barretenberg/cpp/pil/vm2/memory.pil
index 5c766d376927..9733045e4788 100644
--- a/barretenberg/cpp/pil/vm2/memory.pil
+++ b/barretenberg/cpp/pil/vm2/memory.pil
@@ -21,14 +21,14 @@ pol commit tag;
 pol commit space_id; // Memory space identifier (16-bit).
 pol commit address; // Memory address (32-bit).
 pol commit clk; // Clock cycle. (32-bit) Row index of corresponding opcode in the execution trace.
-pol commit rw; // Memory operation type: 0 for read, 1 for write.
+pol commit rw; // @boolean Memory operation type: 0 for read, 1 for write.
 
 // Boolean selectors.
-pol commit sel; // Main selector to toggle an active row (used by any interaction lookups.).
-pol commit last_access; // Last memory access for a given global address
-pol commit sel_rng_chk; // Every active row except the last one
-pol commit sel_tag_is_ff; // Toggles if tag == FF
-pol commit sel_rng_write; // Toggles if rw == 1 and tag != FF (Activate range check for write values.)
+pol commit sel; // @boolean Main selector to toggle an active row (used by any interaction lookups.).
+pol commit last_access; // @boolean Last memory access for a given global address
+pol commit sel_rng_chk; // @boolean (by definition) Every active row except the last one
+pol commit sel_tag_is_ff; // @boolean Toggles if tag == FF
+pol commit sel_rng_write; // @boolean (by definition) Toggles if rw == 1 and tag != FF (Activate range check for write values.)
 
 // Derived values.
 pol commit global_addr; // Global unique address derived from space_id and address.
@@ -65,8 +65,8 @@ pol commit max_bits; // Number of bits corresponding to the tag. (Retrieved from
 sel = 0;
 
 // Permutation selectors (execution/addressing.pil).
-pol commit sel_addressing_base;
-pol commit sel_addressing_indirect[7];
+pol commit sel_addressing_base; // @boolean
+pol commit sel_addressing_indirect[7]; // @boolean
 sel_addressing_base * (1 - sel_addressing_base) = 0;
 sel_addressing_indirect[0] * (1 - sel_addressing_indirect[0]) = 0;
 sel_addressing_indirect[1] * (1 - sel_addressing_indirect[1]) = 0;
@@ -77,7 +77,7 @@ sel_addressing_indirect[5] * (1 - sel_addressing_indirect[5]) = 0;
 sel_addressing_indirect[6] * (1 - sel_addressing_indirect[6]) = 0;
 
 // Permutation selectors (execution/registers.pil)
-pol commit sel_register_op[6];
+pol commit sel_register_op[6]; // @boolean
 sel_register_op[0] * (1 - sel_register_op[0]) = 0;
 sel_register_op[1] * (1 - sel_register_op[1]) = 0;
 sel_register_op[2] * (1 - sel_register_op[2]) = 0;
@@ -86,24 +86,24 @@ sel_register_op[4] * (1 - sel_register_op[4]) = 0;
 sel_register_op[5] * (1 - sel_register_op[5]) = 0;
 
 // Permutation selectors (data_copy.pil).
-pol commit sel_data_copy_read;
-pol commit sel_data_copy_write;
+pol commit sel_data_copy_read; // @boolean
+pol commit sel_data_copy_write; // @boolean
 sel_data_copy_read * (1 - sel_data_copy_read) = 0;
 sel_data_copy_write * (1 - sel_data_copy_write) = 0;
 
 // Permutation selectors (opcodes/get_contract_instance.pil).
-pol commit sel_get_contract_instance_exists_write;
-pol commit sel_get_contract_instance_member_write;
+pol commit sel_get_contract_instance_exists_write; // @boolean
+pol commit sel_get_contract_instance_member_write; // @boolean
 sel_get_contract_instance_exists_write * (1 - sel_get_contract_instance_exists_write) = 0;
 sel_get_contract_instance_member_write * (1 - sel_get_contract_instance_member_write) = 0;
 
 // Permutation selectors (opcodes/emit_unencrypted_log.pil).
-pol commit sel_unencrypted_log_read;
+pol commit sel_unencrypted_log_read; // @boolean
 sel_unencrypted_log_read * (1 - sel_unencrypted_log_read) = 0;
 
 // Permutation selectors (poseidon2_mem.pil).
-pol commit sel_poseidon2_read[4];
-pol commit sel_poseidon2_write[4];
+pol commit sel_poseidon2_read[4]; // @boolean
+pol commit sel_poseidon2_write[4]; // @boolean
 sel_poseidon2_read[0] * (1 - sel_poseidon2_read[0]) = 0;
 sel_poseidon2_read[1] * (1 - sel_poseidon2_read[1]) = 0;
 sel_poseidon2_read[2] * (1 - sel_poseidon2_read[2]) = 0;
@@ -114,12 +114,12 @@ sel_poseidon2_write[2] * (1 - sel_poseidon2_write[2]) = 0;
 sel_poseidon2_write[3] * (1 - sel_poseidon2_write[3]) = 0;
 
 // Permutation selectors (keccak_memory.pil).
-pol commit sel_keccak;
+pol commit sel_keccak; // @boolean
 sel_keccak * (1 - sel_keccak) = 0;
 
 // Permutation selectors (sha256_mem.pil).
-pol commit sel_sha256_read;
-pol commit sel_sha256_op[8];
+pol commit sel_sha256_read; // @boolean
+pol commit sel_sha256_op[8]; // @boolean
 sel_sha256_read * (1 - sel_sha256_read) = 0;
 sel_sha256_op[0] * (1 - sel_sha256_op[0]) = 0;
 sel_sha256_op[1] * (1 - sel_sha256_op[1]) = 0;
@@ -131,13 +131,13 @@ sel_sha256_op[6] * (1 - sel_sha256_op[6]) = 0;
 sel_sha256_op[7] * (1 - sel_sha256_op[7]) = 0;
 
 // Permutation selectors (ecc_mem.pil).
-pol commit sel_ecc_write[3];
+pol commit sel_ecc_write[3]; // @boolean
 sel_ecc_write[0] * (1 - sel_ecc_write[0]) = 0;
 sel_ecc_write[1] * (1 - sel_ecc_write[1]) = 0;
 sel_ecc_write[2] * (1 - sel_ecc_write[2]) = 0;
 
 // Permutation selectors (to_radix_mem.pil).
-pol commit sel_to_radix_write;
+pol commit sel_to_radix_write; // @boolean
 sel_to_radix_write * (1 - sel_to_radix_write) = 0;
 
 // Permutation consistency.
diff --git a/barretenberg/cpp/pil/vm2/opcodes/emit_notehash.pil b/barretenberg/cpp/pil/vm2/opcodes/emit_notehash.pil
index c0d746d99e5e..b8716472839b 100644
--- a/barretenberg/cpp/pil/vm2/opcodes/emit_notehash.pil
+++ b/barretenberg/cpp/pil/vm2/opcodes/emit_notehash.pil
@@ -12,7 +12,7 @@ namespace execution; // this is a virtual gadget that shares rows with the execu
     pol REMAINING_NOTE_HASH_WRITES = constants.MAX_NOTE_HASHES_PER_TX -
         prev_num_note_hashes_emitted;
 
-    pol commit sel_reached_max_note_hashes;
+    pol commit sel_reached_max_note_hashes; // @boolean
     sel_reached_max_note_hashes * (1 - sel_reached_max_note_hashes) = 0;
 
     pol commit remaining_note_hashes_inv;
@@ -25,8 +25,8 @@ namespace execution; // this is a virtual gadget that shares rows with the execu
     sel_execute_emit_notehash * ((1 - sel_reached_max_note_hashes) * (1 - is_static) - (1 - sel_opcode_error)) = 0;
 
     // Commited since it's used in the lookup
-    pol commit sel_write_note_hash;
-    sel_execute_emit_notehash * ((1 - sel_opcode_error) - sel_write_note_hash) = 0;
+    pol commit sel_write_note_hash; // @boolean (by definition)
+    sel_write_note_hash = sel_execute_emit_notehash * (1 - sel_opcode_error);
 
     // =========== OPCODE EXECUTION ===========
 
diff --git a/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil b/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil
index 02f7495c9596..2ad83afe0337 100644
--- a/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil
+++ b/barretenberg/cpp/pil/vm2/opcodes/emit_nullifier.pil
@@ -33,7 +33,7 @@ namespace execution; // this is a virtual gadget that shares rows with the execu
     pol REMAINING_NULLIFIER_WRITES = constants.MAX_NULLIFIERS_PER_TX -
         prev_num_nullifiers_emitted;
 
-    pol commit sel_reached_max_nullifiers;
+    pol commit sel_reached_max_nullifiers; // @boolean
     sel_reached_max_nullifiers * (1 - sel_reached_max_nullifiers) = 0;
 
     pol commit remaining_nullifiers_inv;
@@ -41,10 +41,10 @@ namespace execution; // this is a virtual gadget that shares rows with the execu
     #[MAX_NULLIFIER_WRITES_REACHED]
     sel_execute_emit_nullifier * (REMAINING_NULLIFIER_WRITES * (sel_reached_max_nullifiers * (1 - remaining_nullifiers_inv) + remaining_nullifiers_inv) - 1 + sel_reached_max_nullifiers) = 0;
 
-    pol commit sel_write_nullifier;
+    pol commit sel_write_nullifier; // @boolean (by definition)
     // Validation errors if we've reached the max nullifiers or if we're in a static context
     #[VALIDATION_ERROR_DISABLE_WRITE]
-    sel_execute_emit_nullifier * ((1 - sel_reached_max_nullifiers) * (1 - is_static) - sel_write_nullifier) = 0;
+    sel_write_nullifier = sel_execute_emit_nullifier * (1 - sel_reached_max_nullifiers) * (1 - is_static);
 
     // A validation error must cause an "opcode error".
     //     if sel_write_nullifier == 0, sel_opcode_error must be 1
diff --git a/barretenberg/cpp/pil/vm2/opcodes/emit_unencrypted_log.pil b/barretenberg/cpp/pil/vm2/opcodes/emit_unencrypted_log.pil
index 40b3179260f3..8499f2acf179 100644
--- a/barretenberg/cpp/pil/vm2/opcodes/emit_unencrypted_log.pil
+++ b/barretenberg/cpp/pil/vm2/opcodes/emit_unencrypted_log.pil
@@ -65,7 +65,8 @@ include "../constants_gen.pil";
  */
 namespace emit_unencrypted_log;
 
-    pol commit sel;
+    pol commit sel; // @boolean
+    sel * (1 - sel) = 0;
 
     #[skippable_if]
     sel = 0;
@@ -78,16 +79,16 @@ namespace emit_unencrypted_log;
     pol commit contract_address;
     pol commit prev_num_unencrypted_log_fields;
     pol commit next_num_unencrypted_log_fields;
-    pol commit is_static;
-    pol commit error;
-    pol commit discard;
+    pol commit is_static; // @boolean (when start == 1, which is the destination selector of lookup from execution)
+    pol commit error; // @boolean (when start == 1, which is the destination selector of lookup from execution)
+    pol commit discard; // @boolean (when start == 1, which is the destination selector of lookup from execution)
     error * (1 - error) = 0;
 
     // =============== LIFECYCLE ===============
-    pol commit start;
+    pol commit start; // @boolean
     start * (1 - start) = 0;
 
-    pol commit end;
+    pol commit end; // @boolean
     end * (1 - end) = 0;
     pol NOT_END = sel * (1 - end);
 
@@ -120,7 +121,7 @@ namespace emit_unencrypted_log;
     // =============== ERROR HANDLING ===============
     // Memory bounds check
 
-    pol commit error_out_of_bounds; // Constrained to be boolean by the lookup into gt. (provided that start == 1).
+    pol commit error_out_of_bounds; // @boolean (by lookup into gt when start == 1)
 
     // TODO: Column needed until we support constants in lookups
     pol commit max_mem_size;
@@ -140,7 +141,7 @@ namespace emit_unencrypted_log;
 
     // Log fields count check
 
-    pol commit error_too_many_log_fields; // Constrained to be boolean by the lookup into gt. (provided that start == 1).
+    pol commit error_too_many_log_fields; // @boolean (unconditionally via explicit constraint; also by lookup into gt when start == 1)
     error_too_many_log_fields * (1 - error_too_many_log_fields) = 0;
 
     pol TOTAL_LOG_FIELDS_SIZE = constants.PUBLIC_LOG_HEADER_LENGTH + log_size;
@@ -160,7 +161,7 @@ namespace emit_unencrypted_log;
     // Tag check
 
     // Tag mismatch is hinted in the start row and propagated down to be checked on end
-    pol commit error_tag_mismatch;
+    pol commit error_tag_mismatch; // @boolean
     error_tag_mismatch * (1 - error_tag_mismatch) = 0;
 
     #[ERROR_TAG_MISMATCH_CONSISTENCY]
@@ -170,7 +171,7 @@ namespace emit_unencrypted_log;
     // check on end if we've seen 1 or more wrong tags.
     // We'll use the WRONG_NEXT_TAG variable, which is a boolean indicating whether the tag is wrong for the next row.
     // WRONG_NEXT_TAG will be constrained in the memory section.
-    pol commit seen_wrong_tag;
+    pol commit seen_wrong_tag; // @boolean
     seen_wrong_tag * (1 - seen_wrong_tag) = 0;
     // Initial value of seen_wrong_tag is false
     start * seen_wrong_tag = 0;
@@ -188,7 +189,7 @@ namespace emit_unencrypted_log;
 
     // error = error_out_of_bounds | error_too_many_logs | error_tag_mismatch | is_static
     // we split the above computation in 2 to reduce the degree of the full relation
-    pol commit error_too_many_logs_wrong_tag_is_static;
+    pol commit error_too_many_logs_wrong_tag_is_static; // @boolean (by definition, when start == 1)
     start * ((1 - error_too_many_log_fields) * (1 - error_tag_mismatch) * (1 - is_static) - (1 - error_too_many_logs_wrong_tag_is_static)) = 0;
     start * ((1 - error_out_of_bounds) * (1 - error_too_many_logs_wrong_tag_is_static) - (1 - error)) = 0;
 
@@ -199,11 +200,11 @@ namespace emit_unencrypted_log;
     // We write the log length in the start row
     pol IS_WRITE_LOG_LENGTH = start;
     // is_write_contract_address will only be on in the row after start. There will always be a row after start, the contract address one.
-    pol commit is_write_contract_address;
+    pol commit is_write_contract_address; // @boolean
     is_write_contract_address * (1 - is_write_contract_address) = 0;
     is_write_contract_address' = start;
     // is_write_memory_value starts off and is turned on after is_write_contract_address
-    pol commit is_write_memory_value;
+    pol commit is_write_memory_value; // @boolean
     is_write_memory_value * (1 - is_write_memory_value) = 0;
     start * is_write_memory_value = 0;
     // if we are not ending, the next is_write_memory_value is equal to current is_write_memory_value or is_write_contract_address
@@ -250,7 +251,7 @@ namespace emit_unencrypted_log;
     sel * (1 - sel_should_read_memory) * (constants.MEM_TAG_FF - tag) = 0;
 
     // Tag should be zero since that's the FF tag.
-    pol commit correct_tag;
+    pol commit correct_tag; // @boolean
     correct_tag * (1 - correct_tag) = 0;
     pol WRONG_NEXT_TAG = 1 - correct_tag';
 
@@ -262,7 +263,7 @@ namespace emit_unencrypted_log;
     // We write to public inputs if we don't have an error at all and if discard is off.
     // Remember that we will always generate all rows necessary to process a log, it's just that we'll
     // gate the writes to public inputs based on the error and discard flags.
-    pol commit sel_should_write_to_public_inputs;
+    pol commit sel_should_write_to_public_inputs; // @boolean (by definition)
     start * ((1 - error) * (1 - discard) - sel_should_write_to_public_inputs) = 0;
     #[SEL_SHOULD_WRITE_TO_PUBLIC_INPUTS_CONSISTENCY]
     NOT_END * (sel_should_write_to_public_inputs' - sel_should_write_to_public_inputs) = 0;
diff --git a/barretenberg/cpp/pil/vm2/opcodes/external_call.pil b/barretenberg/cpp/pil/vm2/opcodes/external_call.pil
index 0ca6d8c1fc7b..c072ceded2a0 100644
--- a/barretenberg/cpp/pil/vm2/opcodes/external_call.pil
+++ b/barretenberg/cpp/pil/vm2/opcodes/external_call.pil
@@ -52,7 +52,7 @@ da_gas_left = sel_enter_call * (da_gas_limit - da_gas_used);
 
 // Compare the gas allocated to the call by the user, with the gas left.
 // Helper column containing whether the L2 left gas is greater than the allocated gas.
-pol commit is_l2_gas_left_gt_allocated; // @boolean (on row with `sel_enter_call = 1`) Guaranteed by the gt lookup.
+pol commit is_l2_gas_left_gt_allocated; // @boolean (by lookup, on row with `sel_enter_call = 1`) Guaranteed by the gt lookup.
 
 // Both inputs are 32 bits and therefore valid inputs for the gt gadget (register[0] is 32-bit).
 #[IS_L2_GAS_LEFT_GT_ALLOCATED]
@@ -67,7 +67,7 @@ sel_enter_call * ((register[0] - l2_gas_left) * is_l2_gas_left_gt_allocated + l2
 
 // Compare the gas allocated to the call by the user, with the gas left.
 // Helper column containing whether the DA left gas is greater than the allocated gas.
-pol commit is_da_gas_left_gt_allocated; // @boolean (on row with `sel_enter_call = 1`) Guaranteed by the gt lookup.
+pol commit is_da_gas_left_gt_allocated; // @boolean (by lookup, on row with `sel_enter_call = 1`) Guaranteed by the gt lookup.
 
 // Both inputs are 32 bits and therefore valid inputs for the gt gadget (register[1] is 32-bit).
 #[IS_DA_GAS_LEFT_GT_ALLOCATED]
diff --git a/barretenberg/cpp/pil/vm2/opcodes/get_contract_instance.pil b/barretenberg/cpp/pil/vm2/opcodes/get_contract_instance.pil
index 8004b66de24f..bd0a2a1a33bb 100644
--- a/barretenberg/cpp/pil/vm2/opcodes/get_contract_instance.pil
+++ b/barretenberg/cpp/pil/vm2/opcodes/get_contract_instance.pil
@@ -80,7 +80,7 @@ include "../bytecode/contract_instance_retrieval.pil";
 namespace get_contract_instance;
 
     // Selector for when this gadget is active
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     // No relations will be checked if this identity is satisfied.
@@ -103,7 +103,7 @@ namespace get_contract_instance;
     // So, here we check that that memory offset is within the bounds.
     // If dst_offset = 0xFFFFFFFF (max valid mem offset), then dst_offset+1 is out of bounds.
     // Otherwise, we know that dst_offset+1 is in-bounds since dst_offset has already been validated by main execution logic.
-    pol commit is_valid_writes_in_bounds;
+    pol commit is_valid_writes_in_bounds; // @boolean
     is_valid_writes_in_bounds * (1 - is_valid_writes_in_bounds) = 0;
     pol WRITES_OUT_OF_BOUNDS = 1 - is_valid_writes_in_bounds;
     pol DST_OFFSET_DIFF_MAX = constants.AVM_HIGHEST_MEM_ADDRESS - dst_offset;
@@ -113,10 +113,10 @@ namespace get_contract_instance;
 
     // Member selection helper columns
     // (from precomputed.pil's GETCONTRACTINSTANCE opcode precomputed columns)
-    pol commit is_valid_member_enum;
-    pol commit is_deployer;
-    pol commit is_class_id;
-    pol commit is_init_hash;
+    pol commit is_valid_member_enum; // @boolean (by lookup when is_valid_writes_in_bounds == 1)
+    pol commit is_deployer; // @boolean (by lookup when is_valid_writes_in_bounds == 1)
+    pol commit is_class_id; // @boolean (by lookup when is_valid_writes_in_bounds == 1)
+    pol commit is_init_hash; // @boolean (by lookup when is_valid_writes_in_bounds == 1)
     // Note: member_enum is guaranteed to be 8 bits by execution (as a U8 immediate operand),
     // and the precomputed table is populated for the entire 8-bit range (256 rows).
     #[PRECOMPUTED_INFO]
diff --git a/barretenberg/cpp/pil/vm2/sha256_mem.pil b/barretenberg/cpp/pil/vm2/sha256_mem.pil
index 255715e80a03..06e726a371bb 100644
--- a/barretenberg/cpp/pil/vm2/sha256_mem.pil
+++ b/barretenberg/cpp/pil/vm2/sha256_mem.pil
@@ -106,7 +106,10 @@ namespace sha256;
     ////////////////////////////////////////////////
     // Control flow
     ////////////////////////////////////////////////
-    pol commit start;
+    pol commit start; // @boolean (by definition)
+    // start * (1 - sel) = 0; means that start != 0 ==> sel == 1 or equivalently sel == 0 ==> start == 0
+    // And from #[START_AFTER_LAST], we have sel == 1 ==> start is boolean.
+    // Together, we have the guarantee that start is boolean.
     start * (1 - sel) = 0;
 
     // Selector to indicate end of this chunk of sha256
diff --git a/barretenberg/cpp/pil/vm2/trees/l1_to_l2_message_tree_check.pil b/barretenberg/cpp/pil/vm2/trees/l1_to_l2_message_tree_check.pil
index 251852bca6cc..79046f238572 100644
--- a/barretenberg/cpp/pil/vm2/trees/l1_to_l2_message_tree_check.pil
+++ b/barretenberg/cpp/pil/vm2/trees/l1_to_l2_message_tree_check.pil
@@ -17,14 +17,15 @@ include "../constants_gen.pil";
  * };
 **/
 namespace l1_to_l2_message_tree_check;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
     sel = 0;
 
     // Inputs to the gadget
-    pol commit exists;
+    pol commit exists; // @boolean
+    exists * (1 - exists) = 0;
 
     pol commit msg_hash;
     pol commit leaf_index;
diff --git a/barretenberg/cpp/pil/vm2/trees/note_hash_tree_check.pil b/barretenberg/cpp/pil/vm2/trees/note_hash_tree_check.pil
index 1fcd78381079..170baf192e8b 100644
--- a/barretenberg/cpp/pil/vm2/trees/note_hash_tree_check.pil
+++ b/barretenberg/cpp/pil/vm2/trees/note_hash_tree_check.pil
@@ -29,29 +29,30 @@ include "../public_inputs.pil";
  * As write variant usage, we can omit the address column whenever we pass should_silo == 0.
 **/
 namespace note_hash_tree_check;
-    pol commit sel;
+    pol commit sel; // @boolean
     sel * (1 - sel) = 0;
 
     #[skippable_if]
     sel = 0;
 
     // Inputs to the gadget
-    pol commit write;
+    pol commit write; // @boolean
     write * (1 - write) = 0;
     pol READ = 1 - write;
-    pol commit exists;
+    pol commit exists; // @boolean
+    exists * (1 - exists) = 0;
 
     pol commit note_hash;
     pol commit leaf_index;
     pol commit prev_root;
 
     // Write specific inputs
-    pol commit should_silo;
+    pol commit should_silo; // @boolean
     should_silo * (1 - should_silo) = 0;
 
     pol commit address;
 
-    pol commit should_unique;
+    pol commit should_unique; // @boolean
     should_unique * (1 - should_unique) = 0;
 
     pol commit note_hash_index;
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/fuzz.test.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/fuzz.test.cpp
index 0a8058048d1b..3aa248f5cf65 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/fuzz.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/fuzz.test.cpp
@@ -1492,12 +1492,23 @@ TEST(fuzz, SendL2ToL1Msg)
 
 TEST(fuzz, EmitUnencryptedLog)
 {
-    auto emitunencryptedlog_instruction =
-        EMITUNENCRYPTEDLOG_Instruction{ .log_size = 1,
-                                        .log_size_address = AddressRef{ .address = 0, .mode = AddressingMode::Direct },
-                                        .log_values = { 1 },
-                                        .log_values_address_start = 1 };
-    auto instruction_blocks = std::vector<std::vector<FuzzInstruction>>{ { emitunencryptedlog_instruction } };
+    auto log_size_address = AddressRef{ .address = 0, .mode = AddressingMode::Direct };
+    auto log_values_address = AddressRef{ .address = 1, .mode = AddressingMode::Direct };
+    uint32_t log_size = 1;
+    FF log_value = 42;
+
+    std::vector<FuzzInstruction> instructions;
+
+    instructions.push_back(SET_32_Instruction{
+        .value_tag = bb::avm2::MemoryTag::U32, .result_address = log_size_address, .value = log_size });
+
+    instructions.push_back(SET_FF_Instruction{
+        .value_tag = bb::avm2::MemoryTag::FF, .result_address = log_values_address, .value = log_value });
+
+    instructions.push_back(EMITUNENCRYPTEDLOG_Instruction{ .log_size_address = log_size_address,
+                                                           .log_values_address = log_values_address });
+
+    auto instruction_blocks = std::vector<std::vector<FuzzInstruction>>{ instructions };
     auto control_flow = ControlFlow(instruction_blocks);
     control_flow.process_cfg_instruction(InsertSimpleInstructionBlock{ .instruction_block_idx = 0 });
     auto bytecode = control_flow.build_bytecode(
@@ -1513,22 +1524,38 @@ namespace external_calls {
 /// ADD8: 1 + 1
 TEST(fuzz, ExternalCallToAdd8)
 {
-    auto call_instruction = CALL_Instruction{ .function_index = 0,
-                                              .address_offset = 1,
-                                              .l2_gas = 10000,
-                                              .l2_gas_address = 2,
-                                              .da_gas = 10000,
-                                              .da_gas_address = 3,
-                                              .arg_size_offset = 4,
-                                              .args_offset = 5,
-                                              .args = {},
-                                              .is_static_call = false };
-    auto returndatasize_with_returndatacopy_instruction = RETURNDATASIZE_WITH_RETURNDATACOPY_Instruction{
-        .copy_size_offset = 6, .dst_address = 7, .rd_start = 0, .rd_start_offset = 8
-    };
-    auto instruction_blocks =
-        std::vector<std::vector<FuzzInstruction>>{ { call_instruction,
-                                                     returndatasize_with_returndatacopy_instruction } };
+    std::vector<FuzzInstruction> instructions;
+    auto contract_address = bb::avm2::fuzzer::ContractDBProxy::get_instance()->get_function_address(0);
+    AddressRef contract_address_address = AddressRef{ .address = 1, .mode = AddressingMode::Direct };
+    instructions.push_back(SET_FF_Instruction{
+        .value_tag = bb::avm2::MemoryTag::FF, .result_address = contract_address_address, .value = contract_address });
+
+    uint32_t l2_gas = 10000;
+    AddressRef l2_gas_address = AddressRef{ .address = 2, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = l2_gas_address, .value = l2_gas });
+
+    uint32_t da_gas = 10000;
+    AddressRef da_gas_address = AddressRef{ .address = 3, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = da_gas_address, .value = da_gas });
+
+    uint16_t arg_size = 0;
+    AddressRef arg_size_address = AddressRef{ .address = 4, .mode = AddressingMode::Direct };
+    AddressRef args_address = AddressRef{ .address = 5, .mode = AddressingMode::Direct };
+
+    instructions.push_back(CALL_Instruction{ .l2_gas_address = l2_gas_address,
+                                             .da_gas_address = da_gas_address,
+                                             .contract_address_address = contract_address_address,
+                                             .calldata_address = args_address,
+                                             .calldata_size_address = arg_size_address,
+                                             .calldata_size = arg_size,
+                                             .is_static_call = false });
+
+    instructions.push_back(RETURNDATASIZE_WITH_RETURNDATACOPY_Instruction{
+        .copy_size_offset = 6, .dst_address = 7, .rd_start = 0, .rd_start_offset = 8 });
+
+    auto instruction_blocks = std::vector<std::vector<FuzzInstruction>>{ instructions };
     auto control_flow = ControlFlow(instruction_blocks);
     control_flow.process_cfg_instruction(InsertSimpleInstructionBlock{ .instruction_block_idx = 0 });
     auto bytecode = control_flow.build_bytecode(
@@ -1570,20 +1597,37 @@ TEST(fuzz, GetContractInstance)
 // Calls add8, sucesscopy, return
 TEST(fuzz, SuccessCopy)
 {
-    auto call_instruction = CALL_Instruction{ .function_index = 0,
-                                              .address_offset = 1,
-                                              .l2_gas = 10000,
-                                              .l2_gas_address = 2,
-                                              .da_gas = 10000,
-                                              .da_gas_address = 3,
-                                              .arg_size_offset = 4,
-                                              .args_offset = 5,
-                                              .args = {},
-                                              .is_static_call = true };
-    auto successcopy_instruction =
-        SUCCESSCOPY_Instruction{ .dst_address = AddressRef{ .address = 6, .mode = AddressingMode::Direct } };
-    auto instruction_blocks =
-        std::vector<std::vector<FuzzInstruction>>{ { call_instruction, successcopy_instruction } };
+    std::vector<FuzzInstruction> instructions;
+    auto contract_address = bb::avm2::fuzzer::ContractDBProxy::get_instance()->get_function_address(0);
+    AddressRef contract_address_address = AddressRef{ .address = 1, .mode = AddressingMode::Direct };
+    instructions.push_back(SET_FF_Instruction{
+        .value_tag = bb::avm2::MemoryTag::FF, .result_address = contract_address_address, .value = contract_address });
+
+    uint32_t l2_gas = 10000;
+    AddressRef l2_gas_address = AddressRef{ .address = 2, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = l2_gas_address, .value = l2_gas });
+
+    uint32_t da_gas = 10000;
+    AddressRef da_gas_address = AddressRef{ .address = 3, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = da_gas_address, .value = da_gas });
+
+    uint16_t arg_size = 0;
+    AddressRef arg_size_address = AddressRef{ .address = 4, .mode = AddressingMode::Direct };
+    AddressRef args_address = AddressRef{ .address = 5, .mode = AddressingMode::Direct };
+
+    instructions.push_back(CALL_Instruction{ .l2_gas_address = l2_gas_address,
+                                             .da_gas_address = da_gas_address,
+                                             .contract_address_address = contract_address_address,
+                                             .calldata_address = args_address,
+                                             .calldata_size_address = arg_size_address,
+                                             .calldata_size = arg_size,
+                                             .is_static_call = false });
+
+    instructions.push_back(
+        SUCCESSCOPY_Instruction{ .dst_address = AddressRef{ .address = 6, .mode = AddressingMode::Direct } });
+    auto instruction_blocks = std::vector<std::vector<FuzzInstruction>>{ instructions };
     auto control_flow = ControlFlow(instruction_blocks);
     control_flow.process_cfg_instruction(InsertSimpleInstructionBlock{ .instruction_block_idx = 0 });
     auto bytecode = control_flow.build_bytecode(
@@ -1597,20 +1641,36 @@ TEST(fuzz, SuccessCopy)
 // The result should be 0
 TEST(fuzz, CallToZeroDivisionSuccessCopy)
 {
-    auto static_call_instruction = CALL_Instruction{ .function_index = 1,
-                                                     .address_offset = 1,
-                                                     .l2_gas = 10000,
-                                                     .l2_gas_address = 2,
-                                                     .da_gas = 10000,
-                                                     .da_gas_address = 3,
-                                                     .arg_size_offset = 4,
-                                                     .args_offset = 5,
-                                                     .args = {},
-                                                     .is_static_call = true };
-    auto successcopy_instruction =
-        SUCCESSCOPY_Instruction{ .dst_address = AddressRef{ .address = 6, .mode = AddressingMode::Direct } };
-    auto instruction_blocks =
-        std::vector<std::vector<FuzzInstruction>>{ { static_call_instruction, successcopy_instruction } };
+    std::vector<FuzzInstruction> instructions;
+    auto contract_address = bb::avm2::fuzzer::ContractDBProxy::get_instance()->get_function_address(1);
+    AddressRef contract_address_address = AddressRef{ .address = 1, .mode = AddressingMode::Direct };
+    instructions.push_back(SET_FF_Instruction{
+        .value_tag = bb::avm2::MemoryTag::FF, .result_address = contract_address_address, .value = contract_address });
+
+    uint32_t l2_gas = 10000;
+    AddressRef l2_gas_address = AddressRef{ .address = 2, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = l2_gas_address, .value = l2_gas });
+
+    uint32_t da_gas = 10000;
+    AddressRef da_gas_address = AddressRef{ .address = 3, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = da_gas_address, .value = da_gas });
+
+    uint16_t arg_size = 0;
+    AddressRef arg_size_address = AddressRef{ .address = 4, .mode = AddressingMode::Direct };
+    AddressRef args_address = AddressRef{ .address = 5, .mode = AddressingMode::Direct };
+
+    instructions.push_back(CALL_Instruction{ .l2_gas_address = l2_gas_address,
+                                             .da_gas_address = da_gas_address,
+                                             .contract_address_address = contract_address_address,
+                                             .calldata_address = args_address,
+                                             .calldata_size_address = arg_size_address,
+                                             .calldata_size = arg_size,
+                                             .is_static_call = true });
+    instructions.push_back(
+        SUCCESSCOPY_Instruction{ .dst_address = AddressRef{ .address = 6, .mode = AddressingMode::Direct } });
+    auto instruction_blocks = std::vector<std::vector<FuzzInstruction>>{ instructions };
     auto control_flow = ControlFlow(instruction_blocks);
     control_flow.process_cfg_instruction(InsertSimpleInstructionBlock{ .instruction_block_idx = 0 });
     auto bytecode = control_flow.build_bytecode(
@@ -1623,20 +1683,36 @@ TEST(fuzz, CallToZeroDivisionSuccessCopy)
 /// Performs static call to SSTORE_FUNCTION, SUCCESSCOPY, RETURN
 TEST(fuzz, StaticCallToNonStaticFunctionSuccessCopy)
 {
-    auto static_call_instruction = CALL_Instruction{ .function_index = 2,
-                                                     .address_offset = 1,
-                                                     .l2_gas = 10000,
-                                                     .l2_gas_address = 2,
-                                                     .da_gas = 10000,
-                                                     .da_gas_address = 3,
-                                                     .arg_size_offset = 4,
-                                                     .args_offset = 5,
-                                                     .args = {},
-                                                     .is_static_call = true };
-    auto successcopy_instruction =
-        SUCCESSCOPY_Instruction{ .dst_address = AddressRef{ .address = 6, .mode = AddressingMode::Direct } };
-    auto instruction_blocks =
-        std::vector<std::vector<FuzzInstruction>>{ { static_call_instruction, successcopy_instruction } };
+    std::vector<FuzzInstruction> instructions;
+    auto contract_address = bb::avm2::fuzzer::ContractDBProxy::get_instance()->get_function_address(2);
+    AddressRef contract_address_address = AddressRef{ .address = 1, .mode = AddressingMode::Direct };
+    instructions.push_back(SET_FF_Instruction{
+        .value_tag = bb::avm2::MemoryTag::FF, .result_address = contract_address_address, .value = contract_address });
+
+    uint32_t l2_gas = 10000;
+    AddressRef l2_gas_address = AddressRef{ .address = 2, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = l2_gas_address, .value = l2_gas });
+
+    uint32_t da_gas = 10000;
+    AddressRef da_gas_address = AddressRef{ .address = 3, .mode = AddressingMode::Direct };
+    instructions.push_back(
+        SET_32_Instruction{ .value_tag = bb::avm2::MemoryTag::U32, .result_address = da_gas_address, .value = da_gas });
+
+    uint16_t arg_size = 0;
+    AddressRef arg_size_address = AddressRef{ .address = 4, .mode = AddressingMode::Direct };
+    AddressRef args_address = AddressRef{ .address = 5, .mode = AddressingMode::Direct };
+
+    instructions.push_back(CALL_Instruction{ .l2_gas_address = l2_gas_address,
+                                             .da_gas_address = da_gas_address,
+                                             .contract_address_address = contract_address_address,
+                                             .calldata_address = args_address,
+                                             .calldata_size_address = arg_size_address,
+                                             .calldata_size = arg_size,
+                                             .is_static_call = true });
+    instructions.push_back(
+        SUCCESSCOPY_Instruction{ .dst_address = AddressRef{ .address = 6, .mode = AddressingMode::Direct } });
+    auto instruction_blocks = std::vector<std::vector<FuzzInstruction>>{ instructions };
     auto control_flow = ControlFlow(instruction_blocks);
     control_flow.process_cfg_instruction(InsertSimpleInstructionBlock{ .instruction_block_idx = 0 });
     auto bytecode = control_flow.build_bytecode(
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/instruction.hpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/instruction.hpp
index 1f1ad138b6e8..1661dab50ec7 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/instruction.hpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/instruction.hpp
@@ -576,11 +576,10 @@ struct RETURNDATASIZE_WITH_RETURNDATACOPY_Instruction {
 };
 
 struct GETCONTRACTINSTANCE_Instruction {
-    uint16_t contract_index;             // index of the contract in the contract db
-    AddressRef contract_address_address; // where the contract address will be stored
+    ParamRef contract_address_address; // where the contract address will be stored
+    uint8_t member_enum;
     AddressRef dst_address;
-    uint8_t member_enum; // taken modulo 3. 0 -> DEPLOYER, 1 -> CLASS_ID, 2 -> INIT_HASH
-    MSGPACK_FIELDS(contract_index, contract_address_address, dst_address, member_enum);
+    MSGPACK_FIELDS(contract_address_address, member_enum, dst_address);
 };
 
 struct SUCCESSCOPY_Instruction {
@@ -701,9 +700,9 @@ template <class... Ts> struct overloaded : Ts... {
 };
 template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
-inline std::ostream& operator<<(std::ostream& os, const MemoryTag& tag)
+inline std::ostream& operator<<(std::ostream& os, const MemoryTagWrapper& tag)
 {
-    os << std::to_string(tag);
+    os << tag.value;
     return os;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/program_block.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/program_block.cpp
index b032a1ee527a..f0469df60c64 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/program_block.cpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/fuzz_lib/program_block.cpp
@@ -1291,33 +1291,25 @@ void ProgramBlock::process_getcontractinstance_instruction(GETCONTRACTINSTANCE_I
 #ifdef DISABLE_GETCONTRACTINSTANCE_INSTRUCTION
     return;
 #endif
-    auto contract_address =
-        bb::avm2::fuzzer::ContractDBProxy::get_instance()->get_function_address(instruction.contract_index);
-    auto set_function_address_instruction = SET_FF_Instruction{ .value_tag = bb::avm2::MemoryTag::FF,
-                                                                .result_address = instruction.contract_address_address,
-                                                                .value = contract_address };
-    this->process_set_ff_instruction(set_function_address_instruction);
-    auto contract_address_address_operand =
+    auto contract_address_address =
         memory_manager.get_resolved_address_and_operand_16(instruction.contract_address_address);
-    if (!contract_address_address_operand.has_value()) {
-        return;
-    }
-    preprocess_memory_addresses(contract_address_address_operand.value().first);
-    auto dst_address_operand = memory_manager.get_resolved_address_and_operand_16(instruction.dst_address);
-    if (!dst_address_operand.has_value()) {
+
+    auto dst_address = memory_manager.get_resolved_address_and_operand_16(instruction.dst_address);
+    if (!contract_address_address.has_value() || !dst_address.has_value()) {
         return;
     }
-    preprocess_memory_addresses(dst_address_operand.value().first);
+    preprocess_memory_addresses(contract_address_address.value().first);
+    preprocess_memory_addresses(dst_address.value().first);
+
     auto get_contract_instance_instruction =
         bb::avm2::testing::InstructionBuilder(bb::avm2::WireOpCode::GETCONTRACTINSTANCE)
-            .operand(contract_address_address_operand.value().second)
-            .operand(dst_address_operand.value().second)
-            .operand(
-                static_cast<uint8_t>(instruction.member_enum % 3)) // taking modulo 3 to ensure the member enum is valid
+            .operand(contract_address_address.value().second)
+            .operand(dst_address.value().second)
+            .operand(instruction.member_enum)
             .build();
     instructions.push_back(get_contract_instance_instruction);
-    memory_manager.set_memory_address(bb::avm2::MemoryTag::U1, dst_address_operand.value().first.absolute_address);
-    memory_manager.set_memory_address(bb::avm2::MemoryTag::FF, dst_address_operand.value().first.absolute_address + 1);
+    memory_manager.set_memory_address(bb::avm2::MemoryTag::U1, dst_address.value().first.absolute_address);
+    memory_manager.set_memory_address(bb::avm2::MemoryTag::FF, dst_address.value().first.absolute_address + 1);
 }
 
 void ProgramBlock::process_successcopy_instruction(SUCCESSCOPY_Instruction instruction)
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/calldata.fuzzer.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/calldata.fuzzer.cpp
index ae912887852f..ab0b2ad3f3da 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/calldata.fuzzer.cpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/harness/calldata.fuzzer.cpp
@@ -19,6 +19,7 @@
 #include "barretenberg/vm2/simulation/events/event_emitter.hpp"
 #include "barretenberg/vm2/simulation/gadgets/calldata_hashing.hpp"
 #include "barretenberg/vm2/simulation/interfaces/calldata_hashing.hpp"
+#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
 #include "barretenberg/vm2/tooling/debugger.hpp"
 #include "barretenberg/vm2/tracegen/calldata_trace.hpp"
 #include "barretenberg/vm2/tracegen/execution_trace.hpp"
@@ -363,7 +364,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     try {
         for (size_t i = 0; i < num_events; i++) {
             auto calldata_interface = calldata_hashing_provider.make_calldata_hasher(context_id++);
-            calldata_interface->compute_calldata_hash(calldata_fields[i]);
+            FF cd_hash = compute_calldata_hash(calldata_fields[i]);
+            calldata_interface->assert_calldata_hash(cd_hash, calldata_fields[i]);
         }
     } catch (const std::exception& e) {
         // If any exception occurs, we cannot proceed further.
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/configuration.hpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/configuration.hpp
index a7093e3023bc..eb4f55d6907d 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/configuration.hpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/configuration.hpp
@@ -464,12 +464,11 @@ constexpr ReturndatasizeWithReturndatacopyMutationConfig
         { ReturndatasizeWithReturndatacopyMutationOptions::rd_start_offset, 1 },
     });
 
-enum class GetContractInstanceMutationOptions { contract_index, contract_address_address, dst_address, member_enum };
-using GetContractInstanceMutationConfig = WeightedSelectionConfig<GetContractInstanceMutationOptions, 4>;
+enum class GetContractInstanceMutationOptions { contract_address_address, dst_address, member_enum };
+using GetContractInstanceMutationConfig = WeightedSelectionConfig<GetContractInstanceMutationOptions, 3>;
 
 constexpr GetContractInstanceMutationConfig BASIC_GETCONTRACTINSTANCE_MUTATION_CONFIGURATION =
     GetContractInstanceMutationConfig({
-        { GetContractInstanceMutationOptions::contract_index, 1 },
         { GetContractInstanceMutationOptions::contract_address_address, 1 },
         { GetContractInstanceMutationOptions::dst_address, 1 },
         { GetContractInstanceMutationOptions::member_enum, 1 },
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/instructions/instruction.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/instructions/instruction.cpp
index 645fa31f51cc..c0821668af3a 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/instructions/instruction.cpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/instructions/instruction.cpp
@@ -504,6 +504,37 @@ std::vector<FuzzInstruction> generate_call_instruction(std::mt19937_64& rng)
     return instructions;
 }
 
+std::vector<FuzzInstruction> generate_getcontractinstance_instruction(std::mt19937_64& rng)
+{
+    bool use_backfill = std::uniform_int_distribution<int>(0, 4)(rng) != 0;
+    if (!use_backfill) {
+        return { GETCONTRACTINSTANCE_Instruction{
+            .contract_address_address = generate_variable_ref(rng),
+            .member_enum = generate_random_uint8(rng),
+            .dst_address = generate_address_ref(rng, MAX_16BIT_OPERAND),
+        } };
+    }
+
+    std::vector<FuzzInstruction> instructions;
+    instructions.reserve(2);
+
+    auto contract_address_address = generate_address_ref(rng, MAX_16BIT_OPERAND);
+    instructions.push_back(SET_FF_Instruction{
+        .value_tag = bb::avm2::MemoryTag::FF,
+        .result_address = contract_address_address,
+        .value =
+            bb::avm2::fuzzer::ContractDBProxy::get_instance()->get_function_address(generate_random_uint16(rng)) });
+    uint8_t member_enum = std::uniform_int_distribution<uint8_t>(0, 2)(rng);
+
+    instructions.push_back(GETCONTRACTINSTANCE_Instruction{
+        .contract_address_address = contract_address_address,
+        .member_enum = member_enum,
+        .dst_address = generate_address_ref(rng, MAX_16BIT_OPERAND),
+    });
+
+    return instructions;
+}
+
 std::vector<FuzzInstruction> generate_instruction(std::mt19937_64& rng)
 {
     InstructionGenerationOptions option = BASIC_INSTRUCTION_GENERATION_CONFIGURATION.select(rng);
@@ -680,11 +711,7 @@ std::vector<FuzzInstruction> generate_instruction(std::mt19937_64& rng)
                                                                  .dst_address = generate_random_uint16(rng),
                                                                  .rd_start_offset = generate_random_uint16(rng) } };
     case InstructionGenerationOptions::GETCONTRACTINSTANCE:
-        return { GETCONTRACTINSTANCE_Instruction{ .contract_index = generate_random_uint16(rng),
-                                                  .contract_address_address =
-                                                      generate_address_ref(rng, MAX_16BIT_OPERAND),
-                                                  .dst_address = generate_address_ref(rng, MAX_16BIT_OPERAND),
-                                                  .member_enum = generate_random_uint8(rng) } };
+        return generate_getcontractinstance_instruction(rng);
     case InstructionGenerationOptions::SUCCESSCOPY:
         return { SUCCESSCOPY_Instruction{ .dst_address = generate_address_ref(rng, MAX_16BIT_OPERAND) } };
     case InstructionGenerationOptions::ECADD:
@@ -1213,11 +1240,8 @@ void mutate_getcontractinstance_instruction(GETCONTRACTINSTANCE_Instruction& ins
 {
     GetContractInstanceMutationOptions option = BASIC_GETCONTRACTINSTANCE_MUTATION_CONFIGURATION.select(rng);
     switch (option) {
-    case GetContractInstanceMutationOptions::contract_index:
-        mutate_uint16_t(instruction.contract_index, rng, BASIC_UINT16_T_MUTATION_CONFIGURATION);
-        break;
     case GetContractInstanceMutationOptions::contract_address_address:
-        mutate_address_ref(instruction.contract_address_address, rng, MAX_16BIT_OPERAND);
+        mutate_param_ref(instruction.contract_address_address, rng, MemoryTag::FF, MAX_16BIT_OPERAND);
         break;
     case GetContractInstanceMutationOptions::dst_address:
         mutate_address_ref(instruction.dst_address, rng, MAX_16BIT_OPERAND);
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.cpp
index 2ded216ba3e0..71ec8b4dea49 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.cpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.cpp
@@ -1,16 +1,60 @@
 #include "barretenberg/avm_fuzzer/mutations/tx_data.hpp"
+
 #include "barretenberg/avm_fuzzer/fuzz_lib/constants.hpp"
 #include "barretenberg/avm_fuzzer/mutations/basic_types/field.hpp"
 #include "barretenberg/avm_fuzzer/mutations/basic_types/vector.hpp"
 #include "barretenberg/avm_fuzzer/mutations/fuzzer_data.hpp"
 #include "barretenberg/avm_fuzzer/mutations/instructions/instruction_block.hpp"
+#include "barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.hpp"
+#include "barretenberg/vm2/common/avm_io.hpp"
 #include "barretenberg/vm2/common/aztec_constants.hpp"
 #include "barretenberg/vm2/common/aztec_types.hpp"
 #include "barretenberg/vm2/common/tagged_value.hpp"
 #include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
 
+#include <optional>
 #include <random>
 
+namespace {
+
+void mutate_enqueued_calls(std::vector<PublicCallRequestWithCalldata>& enqueued_calls,
+                           std::vector<AztecAddress>& contract_addresses,
+                           std::mt19937_64& rng)
+{
+    auto mutate_fn = [&](PublicCallRequestWithCalldata& call, std::mt19937_64& rng) {
+        bb::avm2::fuzzer::mutate_public_call_request(call, contract_addresses, rng);
+    };
+
+    auto gen_fn = [&](std::mt19937_64& rng) {
+        return bb::avm2::fuzzer::generate_public_call_request(contract_addresses, rng);
+    };
+
+    mutate_vec<PublicCallRequestWithCalldata>(enqueued_calls, rng, mutate_fn, gen_fn, BASIC_VEC_MUTATION_CONFIGURATION);
+};
+
+void mutate_teardown(std::optional<PublicCallRequestWithCalldata>& teardown_call,
+                     std::vector<AztecAddress>& contract_addresses,
+                     std::mt19937_64& rng)
+{
+    if (!teardown_call.has_value()) {
+        // Nothing to mutate, generate a new one
+        teardown_call = bb::avm2::fuzzer::generate_public_call_request(contract_addresses, rng);
+        return;
+    }
+
+    // If we already have a teardown call, there's a 1 in 10 chance we discard it
+    bool discard = std::uniform_int_distribution<int>(0, 9)(rng) == 0;
+    if (discard) {
+        fuzz_info("Discarding teardown enqueued call");
+        teardown_call = std::nullopt;
+    } else {
+        // Mutate existing teardown call
+        bb::avm2::fuzzer::mutate_public_call_request(teardown_call.value(), contract_addresses, rng);
+    }
+}
+
+} // namespace
+
 namespace bb::avm2::fuzzer {
 
 // Gas bounds for mutation
@@ -29,32 +73,25 @@ constexpr uint32_t AVM_MAX_PROCESSABLE_DA_GAS = (MAX_NOTE_HASHES_PER_TX * AVM_EM
 
 void mutate_tx(Tx& tx, std::vector<AztecAddress>& contract_addresses, std::mt19937_64& rng)
 {
-    auto choice = std::uniform_int_distribution<uint8_t>(0, 1)(rng);
+    auto choice = TX_MUTATION_CONFIGURATION.select(rng);
 
     switch (choice) {
-    case 0:
+    case TxMutationOptions::SetupEnqueuedCalls:
         // Mutate setup enqueued calls
         fuzz_info("Mutating setup enqueued calls: ", tx.setup_enqueued_calls.size());
-        mutate_vec<PublicCallRequestWithCalldata>(
-            tx.setup_enqueued_calls,
-            rng,
-            [&](PublicCallRequestWithCalldata& call, std::mt19937_64& rng) {
-                mutate_public_call_request(call, contract_addresses, rng);
-            },
-            [&](std::mt19937_64& rng) { return generate_public_call_request(contract_addresses, rng); },
-            BASIC_VEC_MUTATION_CONFIGURATION);
+        mutate_enqueued_calls(tx.setup_enqueued_calls, contract_addresses, rng);
         break;
-    case 1:
+    case TxMutationOptions::AppLogicEnqueuedCalls:
         // Mutate app logic enqueued calls
         fuzz_info("Mutating app logic enqueued calls: ", tx.app_logic_enqueued_calls.size());
-        mutate_vec<PublicCallRequestWithCalldata>(
-            tx.app_logic_enqueued_calls,
-            rng,
-            [&](PublicCallRequestWithCalldata& call, std::mt19937_64& rng) {
-                mutate_public_call_request(call, contract_addresses, rng);
-            },
-            [&](std::mt19937_64& rng) { return generate_public_call_request(contract_addresses, rng); },
-            BASIC_VEC_MUTATION_CONFIGURATION);
+        mutate_enqueued_calls(tx.app_logic_enqueued_calls, contract_addresses, rng);
+        break;
+    case TxMutationOptions::TearDownEnqueuedCall:
+        // Mutate teardown enqueued call
+        fuzz_info("Mutating teardown enqueued call");
+        mutate_teardown(tx.teardown_enqueued_call, contract_addresses, rng);
+        break;
+
         // case 2:
         //     // Mutate gas_settings
         //     mutate_gas_settings(tx.gas_settings, rng);
@@ -92,10 +129,6 @@ void mutate_tx(Tx& tx, std::vector<AztecAddress>& contract_addresses, std::mt199
         //                                     BASIC_VEC_MUTATION_CONFIGURATION);
         //     break;
         // break;
-        // case 7:
-        //     // Mutate teardown enqueued call
-        //
-        //     break;
         // case 8:
         //     // Mutate gas_used_by_private
         //     break;
@@ -180,20 +213,6 @@ void mutate_gas_fees(GasFees& fees, std::mt19937_64& rng)
     }
 }
 
-void mutate_ff_vec(std::vector<FF>& vec, std::mt19937_64& rng, size_t max_size)
-{
-    mutate_vec<FF>(
-        vec,
-        rng,
-        [](bb::avm2::FF& value, std::mt19937_64& rng) { mutate_field(value, rng, BASIC_FIELD_MUTATION_CONFIGURATION); },
-        generate_random_field,
-        BASIC_VEC_MUTATION_CONFIGURATION);
-
-    if (vec.size() > max_size) {
-        vec.resize(max_size);
-    }
-}
-
 void mutate_l2_to_l1_msg(ScopedL2ToL1Message& msg, std::mt19937_64& rng)
 {
     auto choice = std::uniform_int_distribution<uint8_t>(0, 2)(rng);
@@ -222,26 +241,6 @@ ScopedL2ToL1Message generate_l2_to_l1_msg(std::mt19937_64& rng)
     };
 }
 
-void mutate_bool_vec(std::vector<bool>& vec, size_t target_size, std::mt19937_64& rng)
-{
-    // Resize to match target size
-    while (vec.size() < target_size) {
-        vec.push_back(std::uniform_int_distribution<uint8_t>(0, 1)(rng) == 1);
-    }
-    while (vec.size() > target_size) {
-        vec.pop_back();
-    }
-
-    // Flip a random bool with some probability
-    if (!vec.empty()) {
-        auto flip_prob = std::uniform_int_distribution<uint8_t>(0, 4)(rng);
-        if (flip_prob == 0) {
-            auto idx = std::uniform_int_distribution<size_t>(0, vec.size() - 1)(rng);
-            vec[idx] = !vec[idx];
-        }
-    }
-}
-
 void mutate_fuzzer_data_vec(std::vector<FuzzerData>& enqueued_calls, std::mt19937_64& rng, size_t max_size)
 {
     auto choice = std::uniform_int_distribution<uint8_t>(0, 1)(rng);
@@ -278,73 +277,4 @@ void mutate_fuzzer_data_vec(std::vector<FuzzerData>& enqueued_calls, std::mt1993
     }
 }
 
-void mutate_public_call_request([[maybe_unused]] PublicCallRequestWithCalldata& request,
-                                [[maybe_unused]] std::vector<AztecAddress>& contract_addresses,
-                                [[maybe_unused]] std::mt19937_64& rng)
-{
-    if (contract_addresses.empty()) {
-        return; // Nothing to mutate to
-    }
-    // fixme(ilyas): this should be weighted since stuff like mutate calldata hash is fail-early
-    auto choice = std::uniform_int_distribution<uint8_t>(0, 0)(rng);
-    //
-    switch (choice) {
-    case 0:
-        // Mutate contract_address
-        // This is likely to cause immediate failure, needs to be weighted appropriately
-        auto contract_address_choice = std::uniform_int_distribution<size_t>(0, contract_addresses.size() - 1)(rng);
-        auto contract_address = contract_addresses[contract_address_choice];
-        request.request.contract_address = contract_address;
-        break;
-        //     case 1:
-        //         // Mutate msg_sender
-        //         request.request.msg_sender = generate_random_field(rng);
-        //         break;
-        //     case 2: {
-        //         // Mutate is_static_call
-        //         request.request.is_static_call = !request.request.is_static_call;
-        //         break;
-        //     }
-        //     case 3:
-        //         // Mutate calldata_hash - the intention here is to fail the hash check
-        //         request.request.calldata_hash = generate_random_field(rng);
-        //         break;
-        //     case 4:
-        //         // Mutate calldata
-        //         mutate_ff_vec(request.calldata, rng, 256);
-        //         // fixme: recompute calldata_hash when we start doing tracegen versions
-        //         // request.calldata_hash = compute_calldata_hash(request.calldata);
-        //         break;
-    }
-}
-
-PublicCallRequestWithCalldata generate_public_call_request(std::vector<AztecAddress>& contract_addresses,
-                                                           std::mt19937_64& rng)
-{
-    fuzz_info("Generating new public call request");
-    // Generate random calldata
-    size_t calldata_size = std::uniform_int_distribution<size_t>(0, 256)(rng);
-    std::vector<FF> calldata{};
-    for (size_t i = 0; i < calldata_size; ++i) {
-        calldata.push_back(generate_random_field(rng));
-    }
-
-    auto contract_address =
-        contract_addresses.empty()
-            ? generate_random_field(rng)
-            : contract_addresses[std::uniform_int_distribution<size_t>(0, contract_addresses.size() - 1)(rng)];
-    fuzz_info("Using contract address: ", contract_address);
-    FF calldata_hash = simulation::compute_calldata_hash(calldata);
-    return PublicCallRequestWithCalldata{
-        .request =
-            PublicCallRequest{
-                .msg_sender = generate_random_field(rng),
-                .contract_address = contract_address,
-                .is_static_call = (std::uniform_int_distribution<uint8_t>(0, 1)(rng) == 1),
-                .calldata_hash = calldata_hash,
-            },
-        .calldata = calldata,
-    };
-}
-
 } // namespace bb::avm2::fuzzer
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.hpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.hpp
index 958b336a1bce..ab7f6f37bf30 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.hpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_data.hpp
@@ -1,14 +1,26 @@
 #pragma once
 
-#include <functional>
-#include <optional>
 #include <random>
 #include <vector>
 
+#include "barretenberg/avm_fuzzer/common/weighted_selection.hpp"
 #include "barretenberg/avm_fuzzer/fuzz_lib/fuzzer_data.hpp"
 #include "barretenberg/vm2/common/avm_io.hpp"
 #include "barretenberg/vm2/common/aztec_types.hpp"
-#include "barretenberg/vm2/common/field.hpp"
+
+enum class TxMutationOptions {
+    SetupEnqueuedCalls,
+    AppLogicEnqueuedCalls,
+    TearDownEnqueuedCall,
+};
+
+using TxMutationConfig = WeightedSelectionConfig<TxMutationOptions, 3>;
+
+constexpr TxMutationConfig TX_MUTATION_CONFIGURATION = TxMutationConfig({
+    { TxMutationOptions::SetupEnqueuedCalls, 30 },
+    { TxMutationOptions::AppLogicEnqueuedCalls, 30 },
+    { TxMutationOptions::TearDownEnqueuedCall, 10 },
+});
 
 namespace bb::avm2::fuzzer {
 
@@ -23,22 +35,10 @@ void mutate_gas(Gas& gas, std::mt19937_64& rng);
 // GasFees mutation
 void mutate_gas_fees(GasFees& fees, std::mt19937_64& rng);
 
-// Field vector mutation
-void mutate_ff_vec(std::vector<FF>& vec, std::mt19937_64& rng, size_t max_size = 10);
-
 // L2ToL1Msg vector mutation
 void mutate_l2_to_l1_msg(ScopedL2ToL1Message& vec, std::mt19937_64& rng);
 ScopedL2ToL1Message generate_l2_to_l1_msg(std::mt19937_64& rng);
 
-// Boolean vector mutation
-void mutate_bool_vec(std::vector<bool>& vec, size_t target_size, std::mt19937_64& rng);
-
 void mutate_fuzzer_data_vec(std::vector<FuzzerData>& enqueued_calls, std::mt19937_64& rng, size_t max_size = 10);
 
-void mutate_public_call_request(PublicCallRequestWithCalldata& request,
-                                std::vector<AztecAddress>& contract_addreses,
-                                std::mt19937_64& rng);
-PublicCallRequestWithCalldata generate_public_call_request(std::vector<AztecAddress>& contract_addresses,
-                                                           std::mt19937_64& rng);
-
 } // namespace bb::avm2::fuzzer
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.cpp
new file mode 100644
index 000000000000..f88b7062b126
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.cpp
@@ -0,0 +1,105 @@
+#include "barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.hpp"
+
+#include "barretenberg/avm_fuzzer/fuzz_lib/constants.hpp"
+#include "barretenberg/avm_fuzzer/mutations/basic_types/field.hpp"
+#include "barretenberg/avm_fuzzer/mutations/basic_types/vector.hpp"
+#include "barretenberg/avm_fuzzer/mutations/calldata/calldata_vec.hpp"
+#include "barretenberg/avm_fuzzer/mutations/configuration.hpp"
+#include "barretenberg/vm2/common/avm_io.hpp"
+#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
+
+using bb::avm2::AztecAddress;
+using bb::avm2::FF;
+
+namespace {
+
+void mutate_contract_address(AztecAddress& address, std::vector<AztecAddress>& contract_addresses, std::mt19937_64& rng)
+{
+    if (contract_addresses.empty()) {
+        address = generate_random_field(rng);
+    }
+    // Most of the time we want to pick from the existing contract addresses, since a random address will fail early
+    auto contract_address_choice = std::uniform_int_distribution<size_t>(0, contract_addresses.size() - 1)(rng);
+    address = contract_addresses[contract_address_choice];
+
+    // 1 in 1000 chance for the contract address to be random
+    bool random_address = std::uniform_int_distribution<int>(0, 999)(rng) == 0;
+    if (random_address) {
+        fuzz_info("Mutating contract address to a random address");
+        mutate_field(address, rng, BASIC_FIELD_MUTATION_CONFIGURATION);
+    }
+}
+
+void mutate_calldata(PublicCallRequestWithCalldata& request, std::mt19937_64& rng)
+{
+    mutate_calldata_vec(request.calldata, rng);
+    if (request.calldata.size() > fuzzer::MAX_CALLDATA_SIZE) {
+        request.calldata.resize(fuzzer::MAX_CALLDATA_SIZE);
+    }
+
+    request.request.calldata_hash = simulation::compute_calldata_hash(request.calldata);
+}
+
+} // namespace
+
+namespace bb::avm2::fuzzer {
+
+void mutate_public_call_request(PublicCallRequestWithCalldata& request,
+                                std::vector<AztecAddress>& contract_addresses,
+                                std::mt19937_64& rng)
+{
+    fuzz_info("Mutating public call request");
+    auto choice = PUB_REQUEST_MUTATION_CONFIGURATION.select(rng);
+
+    switch (choice) {
+    case PublicCallRequestMutationOptions::ContractAddress:
+        // Mutate contract_address
+        mutate_contract_address(request.request.contract_address, contract_addresses, rng);
+        break;
+    case PublicCallRequestMutationOptions::MsgSender:
+        // Mutate msg_sender
+        mutate_field(request.request.msg_sender, rng, BASIC_FIELD_MUTATION_CONFIGURATION);
+        break;
+    case PublicCallRequestMutationOptions::IsStaticCall:
+        // Mutate is_static_call
+        request.request.is_static_call = !request.request.is_static_call;
+        break;
+    case PublicCallRequestMutationOptions::Calldata:
+        // Mutate calldata, this also updates the calldata_hash
+        mutate_calldata(request, rng);
+        break;
+    }
+}
+
+PublicCallRequestWithCalldata generate_public_call_request(std::vector<AztecAddress>& contract_addresses,
+                                                           std::mt19937_64& rng)
+{
+    fuzz_info("Generating new public call request");
+    // Generate random calldata
+    size_t calldata_size = std::uniform_int_distribution<size_t>(0, MAX_CALLDATA_SIZE)(rng);
+    std::vector<FF> calldata;
+    calldata.reserve(calldata_size);
+    for (size_t i = 0; i < calldata_size; ++i) {
+        calldata.push_back(generate_random_field(rng));
+    }
+
+    auto contract_address =
+        contract_addresses.empty()
+            ? generate_random_field(rng)
+            : contract_addresses[std::uniform_int_distribution<size_t>(0, contract_addresses.size() - 1)(rng)];
+    fuzz_info("Using contract address: ", contract_address);
+    FF calldata_hash = simulation::compute_calldata_hash(calldata);
+
+    return PublicCallRequestWithCalldata{
+        .request =
+            PublicCallRequest{
+                .msg_sender = generate_random_field(rng),
+                .contract_address = contract_address,
+                .is_static_call = (std::uniform_int_distribution<uint8_t>(0, 1)(rng) == 1),
+                .calldata_hash = calldata_hash,
+            },
+        .calldata = calldata,
+    };
+}
+
+} // namespace bb::avm2::fuzzer
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.hpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.hpp
new file mode 100644
index 000000000000..e97c1659eed6
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/mutations/tx_types/public_call_request.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <random>
+#include <vector>
+
+#include "barretenberg/avm_fuzzer/common/weighted_selection.hpp"
+#include "barretenberg/vm2/common/avm_io.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+
+namespace bb::avm2::fuzzer {
+
+constexpr uint16_t MAX_CALLDATA_SIZE = 256;
+
+enum class PublicCallRequestMutationOptions : uint8_t {
+    ContractAddress,
+    MsgSender,
+    IsStaticCall,
+    Calldata,
+};
+
+using PublicCallRequestMutationConfig = WeightedSelectionConfig<PublicCallRequestMutationOptions, 4>;
+
+constexpr PublicCallRequestMutationConfig PUB_REQUEST_MUTATION_CONFIGURATION = PublicCallRequestMutationConfig({
+    { PublicCallRequestMutationOptions::ContractAddress, 3 },
+    { PublicCallRequestMutationOptions::MsgSender, 1 },
+    { PublicCallRequestMutationOptions::IsStaticCall, 3 },
+    { PublicCallRequestMutationOptions::Calldata, 5 },
+});
+
+PublicCallRequestWithCalldata generate_public_call_request(std::vector<AztecAddress>& contract_addresses,
+                                                           std::mt19937_64& rng);
+
+void mutate_public_call_request(PublicCallRequestWithCalldata& request,
+                                std::vector<AztecAddress>& contract_addresses,
+                                std::mt19937_64& rng);
+} // namespace bb::avm2::fuzzer
diff --git a/barretenberg/cpp/src/barretenberg/avm_fuzzer/prover.fuzzer.cpp b/barretenberg/cpp/src/barretenberg/avm_fuzzer/prover.fuzzer.cpp
index cf41dd525b76..56a01bda9ec0 100644
--- a/barretenberg/cpp/src/barretenberg/avm_fuzzer/prover.fuzzer.cpp
+++ b/barretenberg/cpp/src/barretenberg/avm_fuzzer/prover.fuzzer.cpp
@@ -14,7 +14,6 @@ using namespace bb::avm2::fuzzer;
 extern "C" int LLVMFuzzerInitialize(int*, char***)
 {
     FuzzerWorldStateManager::initialize();
-    std::filesystem::create_directories("proving_inputs");
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/common/assert.hpp b/barretenberg/cpp/src/barretenberg/common/assert.hpp
index a53e4606733f..7041dc2c1aaf 100644
--- a/barretenberg/cpp/src/barretenberg/common/assert.hpp
+++ b/barretenberg/cpp/src/barretenberg/common/assert.hpp
@@ -93,8 +93,8 @@ struct AssertGuard {
 #define BB_ASSERT_EQ(actual, expected, ...)                                                                            \
     do {                                                                                                               \
         BB_BENCH_ASSERT("BB_ASSERT_EQ" #actual " == " #expected);                                                      \
-        auto _actual = (actual);                                                                                       \
-        auto _expected = (expected);                                                                                   \
+        const auto& _actual = (actual);                                                                                \
+        const auto& _expected = (expected);                                                                            \
         if (!(BB_LIKELY(_actual == _expected))) {                                                                      \
             std::ostringstream oss;                                                                                    \
             oss << "Assertion failed: (" #actual " == " #expected ")\n";                                               \
@@ -108,8 +108,8 @@ struct AssertGuard {
 #define BB_ASSERT_NEQ(actual, expected, ...)                                                                           \
     do {                                                                                                               \
         BB_BENCH_ASSERT("BB_ASSERT_NEQ" #actual " != " #expected);                                                     \
-        auto _actual = (actual);                                                                                       \
-        auto _expected = (expected);                                                                                   \
+        const auto& _actual = (actual);                                                                                \
+        const auto& _expected = (expected);                                                                            \
         if (!(BB_LIKELY(_actual != _expected))) {                                                                      \
             std::ostringstream oss;                                                                                    \
             oss << "Assertion failed: (" #actual " != " #expected ")\n";                                               \
@@ -123,8 +123,8 @@ struct AssertGuard {
 #define BB_ASSERT_GT(left, right, ...)                                                                                 \
     do {                                                                                                               \
         BB_BENCH_ASSERT("BB_ASSERT_GT" #left " > " #right);                                                            \
-        auto _left = (left);                                                                                           \
-        auto _right = (right);                                                                                         \
+        const auto& _left = (left);                                                                                    \
+        const auto& _right = (right);                                                                                  \
         if (!(BB_LIKELY(_left > _right))) {                                                                            \
             std::ostringstream oss;                                                                                    \
             oss << "Assertion failed: (" #left " > " #right ")\n";                                                     \
@@ -138,8 +138,8 @@ struct AssertGuard {
 #define BB_ASSERT_GTE(left, right, ...)                                                                                \
     do {                                                                                                               \
         BB_BENCH_ASSERT("BB_ASSERT_GTE" #left " >= " #right);                                                          \
-        auto _left = (left);                                                                                           \
-        auto _right = (right);                                                                                         \
+        const auto& _left = (left);                                                                                    \
+        const auto& _right = (right);                                                                                  \
         if (!(BB_LIKELY(_left >= _right))) {                                                                           \
             std::ostringstream oss;                                                                                    \
             oss << "Assertion failed: (" #left " >= " #right ")\n";                                                    \
@@ -153,8 +153,8 @@ struct AssertGuard {
 #define BB_ASSERT_LT(left, right, ...)                                                                                 \
     do {                                                                                                               \
         BB_BENCH_ASSERT("BB_ASSERT_LT" #left " < " #right);                                                            \
-        auto _left = (left);                                                                                           \
-        auto _right = (right);                                                                                         \
+        const auto& _left = (left);                                                                                    \
+        const auto& _right = (right);                                                                                  \
         if (!(BB_LIKELY(_left < _right))) {                                                                            \
             std::ostringstream oss;                                                                                    \
             oss << "Assertion failed: (" #left " < " #right ")\n";                                                     \
@@ -168,8 +168,8 @@ struct AssertGuard {
 #define BB_ASSERT_LTE(left, right, ...)                                                                                \
     do {                                                                                                               \
         BB_BENCH_ASSERT("BB_ASSERT_LTE" #left " <= " #right);                                                          \
-        auto _left = (left);                                                                                           \
-        auto _right = (right);                                                                                         \
+        const auto& _left = (left);                                                                                    \
+        const auto& _right = (right);                                                                                  \
         if (!(BB_LIKELY(_left <= _right))) {                                                                           \
             std::ostringstream oss;                                                                                    \
             oss << "Assertion failed: (" #left " <= " #right ")\n";                                                    \
diff --git a/barretenberg/cpp/src/barretenberg/common/log.cpp b/barretenberg/cpp/src/barretenberg/common/log.cpp
index 29b80a3b4a04..65b3354e0ec4 100644
--- a/barretenberg/cpp/src/barretenberg/common/log.cpp
+++ b/barretenberg/cpp/src/barretenberg/common/log.cpp
@@ -2,6 +2,8 @@
 #include <cstdlib>
 #include <string>
 
+#include "barretenberg/common/log.hpp"
+
 #ifndef __wasm__
 bool verbose_logging = std::getenv("BB_VERBOSE") == nullptr ? false : std::string(std::getenv("BB_VERBOSE")) == "1";
 #else
@@ -10,3 +12,11 @@ bool verbose_logging = true;
 
 // Used for `debug` in log.hpp.
 bool debug_logging = false;
+
+// Used for `log_function` in log.hpp. Defaults to `logstr`.
+LogFunction log_function = [](LogLevel /*unused*/, const char* msg) { logstr(msg); };
+
+void set_log_function(LogFunction new_log_function)
+{
+    log_function = std::move(new_log_function);
+}
diff --git a/barretenberg/cpp/src/barretenberg/common/log.hpp b/barretenberg/cpp/src/barretenberg/common/log.hpp
index 2302d1e034cc..8d70c2906f34 100644
--- a/barretenberg/cpp/src/barretenberg/common/log.hpp
+++ b/barretenberg/cpp/src/barretenberg/common/log.hpp
@@ -1,12 +1,14 @@
 #pragma once
-#include "barretenberg/env/logstr.hpp"
-#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
+
 #include <algorithm>
 #include <functional>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "barretenberg/env/logstr.hpp"
+#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
+
 #define BENCHMARK_INFO_PREFIX "##BENCHMARK_INFO_PREFIX##"
 #define BENCHMARK_INFO_SEPARATOR "#"
 #define BENCHMARK_INFO_SUFFIX "##BENCHMARK_INFO_SUFFIX##"
@@ -32,7 +34,7 @@ template <typename T> void benchmark_format_chain(std::ostream& os, T const& fir
     std::stringstream current_argument;
     current_argument << first;
     std::string current_argument_string = current_argument.str();
-    std::replace(current_argument_string.begin(), current_argument_string.end(), ',', ';');
+    std::ranges::replace(current_argument_string, ',', ';');
     os << current_argument_string << BENCHMARK_INFO_SUFFIX;
 }
 
@@ -43,7 +45,7 @@ void benchmark_format_chain(std::ostream& os, T const& first, Args const&... arg
     std::stringstream current_argument;
     current_argument << first;
     std::string current_argument_string = current_argument.str();
-    std::replace(current_argument_string.begin(), current_argument_string.end(), ',', ';');
+    std::ranges::replace(current_argument_string, ',', ';');
     os << current_argument_string << BENCHMARK_INFO_SEPARATOR;
     benchmark_format_chain(os, args...);
 }
@@ -56,6 +58,18 @@ template <typename... Args> std::string benchmark_format(Args... args)
     return os.str();
 }
 
+enum class LogLevel : int {
+    DEBUG = 0,
+    INFO = 1,
+    VERBOSE = 2,
+    IMPORTANT = 3,
+};
+
+// This allows the logging sink to be customized. Useful for Typescript use-cases.
+using LogFunction = std::function<void(LogLevel level, const char* msg)>;
+extern LogFunction log_function;
+void set_log_function(LogFunction new_log_function);
+
 extern bool debug_logging;
 // In release mode (e.g., NDEBUG is defined), we don't compile debug logs.
 #ifndef NDEBUG
@@ -68,13 +82,13 @@ extern bool debug_logging;
 inline void debug_(std::function<std::string()> func)
 {
     if (debug_logging) {
-        logstr(func().c_str());
+        log_function(LogLevel::DEBUG, func().c_str());
     }
 }
 
 template <typename... Args> inline void info(Args... args)
 {
-    logstr(format(args...).c_str());
+    log_function(LogLevel::INFO, format(args...).c_str());
 }
 
 #define vinfo(...) vinfo_([&]() { return format(__VA_ARGS__); })
@@ -83,19 +97,19 @@ extern bool verbose_logging;
 inline void vinfo_(std::function<std::string()> func)
 {
     if (verbose_logging) {
-        info(func());
+        log_function(LogLevel::VERBOSE, func().c_str());
     }
 }
 
 template <typename... Args> inline void important(Args... args)
 {
-    logstr(format("important: ", args...).c_str());
+    log_function(LogLevel::IMPORTANT, format("important: ", args...).c_str());
 }
 
 /**
  * @brief Info used to store circuit statistics during CI/CD with concrete structure. Writes straight to log
  *
- * @details Automatically appends the necessary prefix and suffix,  as well as separators.
+ * @details Automatically appends the necessary prefix and suffix, as well as separators.
  *
  * @tparam Args
  * @param args
@@ -129,7 +143,7 @@ class BenchmarkInfoCollator {
  * @brief Info used to store circuit statistics during CI/CD with concrete structure. Stores string in vector for now
  * (used to flush all benchmarks at the end of test).
  *
- * @details Automatically appends the necessary prefix and suffix,  as well as separators.
+ * @details Automatically appends the necessary prefix and suffix, as well as separators.
  *
  * @tparam Args
  * @param args
diff --git a/barretenberg/cpp/src/barretenberg/nodejs_module/avm_simulate/avm_simulate_napi.cpp b/barretenberg/cpp/src/barretenberg/nodejs_module/avm_simulate/avm_simulate_napi.cpp
index e78c0853943f..6195303a7da4 100644
--- a/barretenberg/cpp/src/barretenberg/nodejs_module/avm_simulate/avm_simulate_napi.cpp
+++ b/barretenberg/cpp/src/barretenberg/nodejs_module/avm_simulate/avm_simulate_napi.cpp
@@ -1,5 +1,6 @@
-#include "avm_simulate_napi.hpp"
+#include "barretenberg/nodejs_module/avm_simulate/avm_simulate_napi.hpp"
 
+#include <array>
 #include <memory>
 #include <vector>
 
@@ -13,8 +14,8 @@
 #include "barretenberg/vm2/simulation/lib/cancellation_token.hpp"
 
 namespace bb::nodejs {
-
 namespace {
+
 // Log levels from TS foundation/src/log/log-levels.ts: ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug',
 // 'trace'] Map: 0=silent, 1=fatal, 2=error, 3=warn, 4=info, 5=verbose, 6=debug, 7=trace
 constexpr int LOG_LEVEL_VERBOSE = 5;
@@ -29,6 +30,46 @@ inline void set_logging_from_level(int log_level)
     debug_logging = (log_level >= LOG_LEVEL_TRACE);
 }
 
+// Map C++ LogLevel enum to TypeScript log level string
+// C++ LogLevel: DEBUG=0, INFO=1, VERBOSE=2, IMPORTANT=3
+// TS LogLevels: ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace']
+inline const char* cpp_log_level_to_ts(LogLevel level)
+{
+    switch (level) {
+    case LogLevel::DEBUG:
+        return "debug";
+    case LogLevel::INFO:
+        return "info";
+    case LogLevel::VERBOSE:
+        return "verbose";
+    case LogLevel::IMPORTANT:
+        return "warn";
+    default:
+        return "info";
+    }
+}
+
+// Helper to create a LogFunction wrapper from a ThreadSafeFunction
+// This allows C++ logging to call back to TypeScript logger from worker threads
+LogFunction create_log_function_from_tsfn(const std::shared_ptr<Napi::ThreadSafeFunction>& logger_tsfn)
+{
+    return [logger_tsfn](LogLevel level, const char* msg) {
+        // Convert C++ LogLevel to TS log level string
+        const char* ts_level = cpp_log_level_to_ts(level);
+        std::string msg_str(msg);
+
+        // Call TypeScript logger function on the JS main thread
+        // Using BlockingCall to ensure synchronous execution
+        // Ignore errors - logging failures shouldn't crash the simulation
+        logger_tsfn->BlockingCall([ts_level, msg_str](Napi::Env env, Napi::Function js_logger) {
+            // Create arguments: (level: string, msg: string)
+            auto level_js = Napi::String::New(env, ts_level);
+            auto msg_js = Napi::String::New(env, msg_str);
+            js_logger.Call({ level_js, msg_js });
+        });
+    };
+}
+
 // Callback method names
 constexpr const char* CALLBACK_GET_CONTRACT_INSTANCE = "getContractInstance";
 constexpr const char* CALLBACK_GET_CONTRACT_CLASS = "getContractClass";
@@ -117,63 +158,42 @@ Napi::Value AvmSimulateNapi::simulate(const Napi::CallbackInfo& cb_info)
 {
     Napi::Env env = cb_info.Env();
 
-    // Validate arguments - expects 4-5 arguments
+    // Validate arguments - expects 3-6 arguments
     // arg[0]: inputs Buffer (required)
     // arg[1]: contractProvider object (required)
     // arg[2]: worldStateHandle external (required)
-    // arg[3]: logLevel number (required) - index into TS LogLevels array
-    // arg[4]: cancellationToken external (optional)
-    if (cb_info.Length() < 4) {
-        throw Napi::TypeError::New(env,
-                                   "Wrong number of arguments. Expected 4-5 arguments: inputs Buffer, contractProvider "
-                                   "object, worldStateHandle, logLevel, and optional cancellationToken.");
+    // arg[3]: logLevel number (optional) - index into TS LogLevels array, -1 if omitted
+    // arg[4]: loggerFunction (optional) - can be null/undefined
+    // arg[5]: cancellationToken external (optional)
+    if (cb_info.Length() < 3) {
+        throw Napi::TypeError::New(
+            env,
+            "Wrong number of arguments. Expected 3-6 arguments: inputs Buffer, contractProvider "
+            "object, worldStateHandle, optional logLevel, optional loggerFunction, and optional cancellationToken.");
     }
 
+    /*******************************
+     *** AvmFastSimulationInputs ***
+     *******************************/
     if (!cb_info[0].IsBuffer()) {
         throw Napi::TypeError::New(env,
                                    "First argument must be a Buffer containing serialized AvmFastSimulationInputs");
     }
-
-    if (!cb_info[1].IsObject()) {
-        throw Napi::TypeError::New(env, "Second argument must be a contractProvider object");
-    }
-
-    if (!cb_info[2].IsExternal()) {
-        throw Napi::TypeError::New(env, "Third argument must be a WorldState handle (External)");
-    }
-
-    if (!cb_info[3].IsNumber()) {
-        throw Napi::TypeError::New(env, "Fourth argument must be a log level number (0-7)");
-    }
-
-    // Extract optional cancellation token (5th argument)
-    avm2::simulation::CancellationTokenPtr cancellation_token = nullptr;
-    if (cb_info.Length() > 4 && cb_info[4].IsExternal()) {
-        auto token_external = cb_info[4].As<Napi::External<avm2::simulation::CancellationToken>>();
-        // Wrap the raw pointer in a shared_ptr that does NOT delete (since the External owns it)
-        cancellation_token = std::shared_ptr<avm2::simulation::CancellationToken>(
-            token_external.Data(), [](avm2::simulation::CancellationToken*) {
-                // No-op deleter: the External
-                // (via shared_ptr destructor
-                // callback) owns the token
-            });
-    }
-
-    // Extract log level and set logging flags
-    int log_level = cb_info[3].As<Napi::Number>().Int32Value();
-    set_logging_from_level(log_level);
-
     // Extract the inputs buffer
     auto inputs_buffer = cb_info[0].As<Napi::Buffer<uint8_t>>();
     size_t length = inputs_buffer.Length();
-
     // Copy the buffer data into C++ memory (we can't access Napi objects from worker thread)
     auto data = std::make_shared<std::vector<uint8_t>>(inputs_buffer.Data(), inputs_buffer.Data() + length);
 
+    /***********************************
+     *** ContractProvider (required) ***
+     ***********************************/
+    if (!cb_info[1].IsObject()) {
+        throw Napi::TypeError::New(env, "Second argument must be a contractProvider object");
+    }
     // Extract and validate contract provider callbacks
     auto contract_provider = cb_info[1].As<Napi::Object>();
     ContractCallbacks::validate(env, contract_provider);
-
     // Create thread-safe function wrappers for callbacks
     // These allow us to call TypeScript from the C++ worker thread
     ContractTsfns tsfns{
@@ -196,18 +216,68 @@ Napi::Value AvmSimulateNapi::simulate(const Napi::CallbackInfo& cb_info)
             env, ContractCallbacks::get(contract_provider, CALLBACK_REVERT_CHECKPOINT), CALLBACK_REVERT_CHECKPOINT),
     };
 
+    /*****************************
+     *** WorldState (required) ***
+     *****************************/
+    if (!cb_info[2].IsExternal()) {
+        throw Napi::TypeError::New(env, "Third argument must be a WorldState handle (External)");
+    }
     // Extract WorldState handle (3rd argument)
     auto external = cb_info[2].As<Napi::External<world_state::WorldState>>();
     world_state::WorldState* ws_ptr = external.Data();
 
-    // Create a deferred promise
-    auto deferred = std::make_shared<Napi::Promise::Deferred>(env);
+    /***************************
+     *** LogLevel (optional) ***
+     ***************************/
+    int log_level = -1;
+    if (cb_info.Length() > 3 && cb_info[3].IsNumber()) {
+        log_level = cb_info[3].As<Napi::Number>().Int32Value();
+        set_logging_from_level(log_level);
+    }
+
+    /*********************************
+     *** LoggerFunction (optional) ***
+     *********************************/
+    std::shared_ptr<Napi::ThreadSafeFunction> logger_tsfn = nullptr;
+    if (cb_info.Length() > 4 && !cb_info[4].IsNull() && !cb_info[4].IsUndefined()) {
+        if (cb_info[4].IsFunction()) {
+            // Logger function provided - create thread-safe wrapper
+            auto logger_function = cb_info[4].As<Napi::Function>();
+            logger_tsfn = make_tsfn(env, logger_function, "LoggerCallback");
+            // Create LogFunction wrapper and set it as the global log function
+            // This will be used by C++ logging macros (info, debug, vinfo, important)
+            set_log_function(create_log_function_from_tsfn(logger_tsfn));
+        } else {
+            throw Napi::TypeError::New(env, "Fifth argument must be a logger function, null, or undefined");
+        }
+    }
+
+    /*************************************
+     *** Cancellation Token (optional) ***
+     *************************************/
+    avm2::simulation::CancellationTokenPtr cancellation_token = nullptr;
+    if (cb_info.Length() > 5 && cb_info[5].IsExternal()) {
+        auto token_external = cb_info[5].As<Napi::External<avm2::simulation::CancellationToken>>();
+        // Wrap the raw pointer in a shared_ptr that does NOT delete (since the External owns it)
+        cancellation_token = std::shared_ptr<avm2::simulation::CancellationToken>(
+            token_external.Data(), [](avm2::simulation::CancellationToken*) {
+                // No-op deleter: the External (via shared_ptr destructor callback) owns the token
+            });
+    }
+
+    /**********************************************************
+     *** Create Deferred Promise and launch async operation ***
+     **********************************************************/
 
+    auto deferred = std::make_shared<Napi::Promise::Deferred>(env);
     // Create async operation that will run on a worker thread
-    auto* op =
-        new AsyncOperation(env, deferred, [data, tsfns, ws_ptr, cancellation_token](msgpack::sbuffer& result_buffer) {
+    auto* op = new AsyncOperation(
+        env, deferred, [data, tsfns, logger_tsfn, ws_ptr, cancellation_token](msgpack::sbuffer& result_buffer) {
+            // Collect all thread-safe functions including logger for cleanup
+            auto all_tsfns = tsfns.to_vector();
+            all_tsfns.push_back(logger_tsfn);
             // Ensure all thread-safe functions are released in all code paths
-            TsfnReleaser releaser = TsfnReleaser(tsfns.to_vector());
+            TsfnReleaser releaser = TsfnReleaser(std::move(all_tsfns));
 
             try {
                 // Deserialize inputs from msgpack
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp
index ce4ac501d9ea..467d244111b4 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp
@@ -601,7 +601,7 @@ inline bool is_protocol_contract_address(const AztecAddress& address)
 inline std::optional<AztecAddress> get_derived_address(const ProtocolContracts& protocol_contracts,
                                                        const AztecAddress& canonical_address)
 {
-    assert(is_protocol_contract_address(canonical_address) && "Protocol contract canonical address out of bounds");
+    BB_ASSERT(is_protocol_contract_address(canonical_address), "Protocol contract canonical address out of bounds");
     AztecAddress derived_address =
         protocol_contracts.derived_addresses.at(static_cast<uint32_t>(canonical_address) - 1);
     if (derived_address.is_zero()) {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.cpp b/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.cpp
index 887b99389ffd..2e3b38453222 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.cpp
@@ -178,7 +178,7 @@ uint8_t get_tag_bits(ValueTag tag)
         return 0; // It is more useful for this to be 0 in the circuit
     }
 
-    assert(false && "Invalid tag");
+    __builtin_unreachable();
     return 0;
 }
 
@@ -197,7 +197,7 @@ uint8_t get_tag_bytes(ValueTag tag)
         return 0; // It is more useful for this to be 0 in the circuit
     }
 
-    assert(false && "Invalid tag");
+    __builtin_unreachable();
     return 0;
 }
 
@@ -215,7 +215,7 @@ uint256_t get_tag_max_value(ValueTag tag)
         return FF::modulus - 1;
     }
 
-    assert(false && "Invalid tag");
+    __builtin_unreachable();
     return 0;
 }
 
@@ -226,9 +226,9 @@ TaggedValue::TaggedValue(TaggedValue::value_type value_)
 
 TaggedValue TaggedValue::from_tag(ValueTag tag, FF value)
 {
-    auto assert_bounds = [](const FF& value, uint8_t bits) {
+    auto assert_bounds = [tag](const FF& value, uint8_t bits) {
         if (static_cast<uint256_t>(value).get_msb() >= bits) {
-            throw std::runtime_error("Value out of bounds");
+            throw ValueOutOfBounds(format("Value: ", value, " is out of bounds for tag: ", tag));
         }
     };
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.hpp
index 460d1227903d..ca2061949c4f 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/tagged_value.hpp
@@ -2,6 +2,7 @@
 
 #include <cstdint>
 #include <functional>
+#include <ostream>
 #include <string>
 #include <variant>
 
@@ -12,24 +13,43 @@
 
 namespace bb::avm2 {
 
-class TagMismatchException : public std::runtime_error {
+class TaggedValueException : public std::runtime_error {
+  public:
+    using std::runtime_error::runtime_error; // Inherit the constructor.
+};
+
+class TagMismatchException : public TaggedValueException {
   public:
     TagMismatchException(const std::string& msg)
-        : std::runtime_error("Mismatched tags: " + msg)
+        : TaggedValueException("Mismatched tags: " + msg)
     {}
 };
 
-class InvalidOperationTag : public std::runtime_error {
+class InvalidOperationTag : public TaggedValueException {
   public:
     InvalidOperationTag(const std::string& msg)
-        : std::runtime_error("InvalidOperationTag: " + msg)
+        : TaggedValueException("InvalidOperationTag: " + msg)
     {}
 };
 
-class DivisionByZero : public std::runtime_error {
+class DivisionByZero : public TaggedValueException {
   public:
     DivisionByZero(const std::string& msg)
-        : std::runtime_error("Division by zero: " + msg)
+        : TaggedValueException("Division by zero: " + msg)
+    {}
+};
+
+class ValueOutOfBounds : public TaggedValueException {
+  public:
+    ValueOutOfBounds(const std::string& msg)
+        : TaggedValueException("Value out of bounds: " + msg)
+    {}
+};
+
+class CastException : public TaggedValueException {
+  public:
+    CastException(const std::string& msg)
+        : TaggedValueException("CastException: " + msg)
     {}
 };
 
@@ -44,6 +64,30 @@ enum class ValueTag {
     MAX = U128,
 };
 
+inline std::ostream& operator<<(std::ostream& os, ValueTag tag)
+{
+    switch (tag) {
+    case ValueTag::FF:
+        return os << "FF";
+    case ValueTag::U1:
+        return os << "U1";
+    case ValueTag::U8:
+        return os << "U8";
+    case ValueTag::U16:
+        return os << "U16";
+    case ValueTag::U32:
+        return os << "U32";
+    case ValueTag::U64:
+        return os << "U64";
+    case ValueTag::U128:
+        return os << "U128";
+    default:
+        return os << "Unknown";
+    }
+
+    __builtin_unreachable();
+}
+
 template <typename T> ValueTag tag_for_type()
 {
     if constexpr (std::is_same_v<T, FF>) {
@@ -118,8 +162,8 @@ class TaggedValue {
         if (std::holds_alternative<T>(value)) {
             return std::get<T>(value);
         }
-        throw std::runtime_error("TaggedValue::as(): type mismatch. Wanted type " +
-                                 std::to_string(static_cast<uint32_t>(tag_for_type<T>())) + " but got " + to_string());
+        throw CastException("TaggedValue::as(): type mismatch. Wanted type " +
+                            std::to_string(static_cast<uint32_t>(tag_for_type<T>())) + " but got " + to_string());
     }
 
     // This method try to do the smallest conversion possible.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/to_radix.cpp b/barretenberg/cpp/src/barretenberg/vm2/common/to_radix.cpp
index 38b845b704d3..6cac1879fa0a 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/common/to_radix.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/to_radix.cpp
@@ -53,7 +53,7 @@ const std::array<std::vector<uint8_t>, 257>& get_p_limbs_per_radix()
 
 size_t get_p_limbs_per_radix_size(size_t radix)
 {
-    assert(radix <= 256);
+    BB_ASSERT_LTE(radix, static_cast<decltype(radix)>(256), "Radix out of bounds");
     return p_limbs_per_radix_sizes[radix];
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/polynomials.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/polynomials.cpp
index 9c13f20f8866..64719de95efc 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/constraining/polynomials.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/polynomials.cpp
@@ -17,7 +17,9 @@ AvmProver::ProverPolynomials compute_polynomials(tracegen::TraceContainer& trace
     // Polynomials that will be shifted need special care.
     AVM_TRACK_TIME("proving/init_polys_to_be_shifted", ({
                        auto to_be_shifted = polys.get_to_be_shifted();
-                       assert(to_be_shifted.size() == TO_BE_SHIFTED_COLUMNS_ARRAY.size());
+                       BB_ASSERT_EQ(to_be_shifted.size(),
+                                    TO_BE_SHIFTED_COLUMNS_ARRAY.size(),
+                                    "To be shifted columns array size mismatch");
 
                        // NOTE: we can't parallelize because Polynomial construction uses parallelism.
                        for (size_t i = 0; i < to_be_shifted.size(); i++) {
@@ -98,7 +100,9 @@ void resize_inverses(AvmFlavor::ProverPolynomials& prover_polynomials,
 
     const size_t num_rows = std::max<size_t>(src_selector.end_index(), dst_selector.end_index());
     inverse_polynomial = AvmProver::Polynomial::create_non_parallel_zero_init(num_rows, MAX_AVM_TRACE_SIZE);
-    assert(prover_polynomials.get(static_cast<ColumnAndShifts>(inverses_col)).size() == num_rows);
+    BB_ASSERT_EQ(prover_polynomials.get(static_cast<ColumnAndShifts>(inverses_col)).size(),
+                 num_rows,
+                 "Inverse polynomial size mismatch");
 }
 
 std::shared_ptr<AvmProver::ProvingKey> proving_key_from_polynomials(AvmProver::ProverPolynomials& polynomials)
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/prover.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/prover.cpp
index 36ef1e7a2dfa..5dab10e69b37 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/constraining/prover.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/prover.cpp
@@ -49,7 +49,7 @@ void AvmProver::execute_preamble_round()
 {
     FF vk_hash = vk->hash();
     transcript->add_to_hash_buffer("avm_vk_hash", vk_hash);
-    info("AVM vk hash in prover: ", vk_hash);
+    vinfo("AVM vk hash in prover: ", vk_hash);
 }
 
 /**
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/instr_fetching.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/instr_fetching.test.cpp
index 4665d4a9a17c..05bd8a9201c4 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/instr_fetching.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/instr_fetching.test.cpp
@@ -829,5 +829,105 @@ TEST(InstrFetchingConstrainingTest, NegativeTogglingPcInRange)
                               "PC_OUT_OF_RANGE_TOGGLE");
 }
 
+TEST(InstrFetchingConstrainingTest, ErrorFlagSetButSelParsingErrIsZero)
+{
+    // Create a minimal trace that satisfies all constraints EXCEPT the (commented out) one
+    // that should enforce sel_parsing_err = pc_out_of_range + opcode_out_of_range + instr_out_of_range +
+    // tag_out_of_range
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::instr_fetching_sel, 1 },
+            // Error flags - pc_out_of_range is SET to 1
+            { C::instr_fetching_pc_out_of_range, 1 },
+            { C::instr_fetching_opcode_out_of_range, 0 },
+            { C::instr_fetching_instr_out_of_range, 0 },
+            { C::instr_fetching_tag_out_of_range, 0 },
+            // sel_parsing_err should be 1 (since pc_out_of_range = 1) but we set it to 0
+            { C::instr_fetching_sel_parsing_err, 0 },
+            // Values to satisfy PC_OUT_OF_RANGE_TOGGLE constraint (subrelation 4):
+            // pc_abs_diff = sel * ((2 * pc_out_of_range - 1) * (pc - bytecode_size) - 1 + pc_out_of_range)
+            // With pc_out_of_range = 1: pc_abs_diff = (2*1-1) * (pc - bytecode_size) - 1 + 1 = pc - bytecode_size
+            { C::instr_fetching_bytecode_size, 10 },
+            { C::instr_fetching_pc, 15 },              // pc > bytecode_size
+            { C::instr_fetching_pc_abs_diff, 5 },      // pc - bytecode_size = 15 - 10 = 5
+            { C::instr_fetching_pc_size_in_bits, 32 }, // AVM_PC_SIZE_IN_BITS constant
+            // Values to satisfy INSTR_OUT_OF_RANGE_TOGGLE constraint (subrelation 6):
+            // instr_abs_diff = (2 * instr_out_of_range - 1) * (instr_size - bytes_to_read) - instr_out_of_range
+            // With instr_out_of_range = 0: instr_abs_diff = (-1) * (instr_size - bytes_to_read) = bytes_to_read -
+            // instr_size
+            { C::instr_fetching_bytes_to_read, 10 },
+            { C::instr_fetching_instr_size, 5 },
+            { C::instr_fetching_instr_abs_diff, 5 }, // bytes_to_read - instr_size = 10 - 5 = 5
+        },
+    });
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<instr_fetching>(trace),
+                              "Relation instr_fetching, subrelation 5 failed at row 1");
+}
+
+/**
+ * This test verifies that when sel_parsing_err is correctly set to 1 when errors occur,
+ * the relation passes. This should continue to pass after the fix.
+ */
+TEST(InstrFetchingConstrainingTest, CorrectBehavior_SelParsingErrMatchesErrors)
+{
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::instr_fetching_sel, 1 },
+            { C::instr_fetching_pc_out_of_range, 1 },
+            { C::instr_fetching_opcode_out_of_range, 0 },
+            { C::instr_fetching_instr_out_of_range, 0 },
+            { C::instr_fetching_tag_out_of_range, 0 },
+            { C::instr_fetching_sel_parsing_err, 1 }, // Correctly set to 1
+            // Supporting values
+            { C::instr_fetching_bytecode_size, 10 },
+            { C::instr_fetching_pc, 15 },
+            { C::instr_fetching_pc_abs_diff, 5 },
+            { C::instr_fetching_pc_size_in_bits, 32 },
+            { C::instr_fetching_bytes_to_read, 10 },
+            { C::instr_fetching_instr_size, 5 },
+            { C::instr_fetching_instr_abs_diff, 5 }, // bytes_to_read - instr_size = 10 - 5 = 5
+        },
+    });
+
+    // This should pass both before and after the fix.
+    check_relation<instr_fetching>(trace);
+}
+
+/**
+ * No errors means sel_parsing_err should be 0
+ */
+TEST(InstrFetchingConstrainingTest, CorrectBehavior_NoErrorsMeansSelParsingErrIsZero)
+{
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::instr_fetching_sel, 1 },
+            { C::instr_fetching_pc_out_of_range, 0 },
+            { C::instr_fetching_opcode_out_of_range, 0 },
+            { C::instr_fetching_instr_out_of_range, 0 },
+            { C::instr_fetching_tag_out_of_range, 0 },
+            { C::instr_fetching_sel_parsing_err, 0 }, // Correctly set to 0
+            { C::instr_fetching_sel_pc_in_range, 1 }, // sel * (1 - pc_out_of_range) = 1 * 1 = 1
+            // pc_abs_diff = sel * ((2 * pc_out_of_range - 1) * (pc - bytecode_size) - 1 + pc_out_of_range)
+            // With pc_out_of_range = 0: pc_abs_diff = (2*0-1) * (pc - bytecode_size) - 1 + 0
+            //                         = -(pc - bytecode_size) - 1 = bytecode_size - pc - 1
+            { C::instr_fetching_bytecode_size, 20 },
+            { C::instr_fetching_pc, 5 },
+            { C::instr_fetching_pc_abs_diff, 14 }, // bytecode_size - pc - 1 = 20 - 5 - 1 = 14
+            { C::instr_fetching_pc_size_in_bits, 32 },
+            // instr_abs_diff = bytes_to_read - instr_size (when instr_out_of_range = 0)
+            { C::instr_fetching_bytes_to_read, 15 },
+            { C::instr_fetching_instr_size, 10 },
+            { C::instr_fetching_instr_abs_diff, 5 }, // bytes_to_read - instr_size = 15 - 10 = 5
+        },
+    });
+
+    // This should pass both before and after the fix.
+    check_relation<instr_fetching>(trace);
+}
+
 } // namespace
 } // namespace bb::avm2::constraining
diff --git a/barretenberg/cpp/src/barretenberg/vm2/dsl/avm2_recursion_constraint.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/dsl/avm2_recursion_constraint.test.cpp
index fe9a43dacc36..56f42dd46acb 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/dsl/avm2_recursion_constraint.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/dsl/avm2_recursion_constraint.test.cpp
@@ -133,9 +133,6 @@ TEST_F(AvmRecursionConstraintTest, GateCountAndVKCheck)
     }
     using ProverInstance = ProverInstance_<UltraRollupFlavor>;
 
-    static constexpr FF EXPECTED_OUTER_VK_HASH =
-        FF("0x195059523571dbadeae1b213250567e17b4994568b736b73a1aae2b0c65fd2cd");
-
     AcirConstraint constraint;
     WitnessVector witness;
     Base::generate_constraints(constraint, witness);
@@ -152,9 +149,13 @@ TEST_F(AvmRecursionConstraintTest, GateCountAndVKCheck)
 
     auto prover_instance = std::make_shared<ProverInstance>(builder);
     auto vk = std::make_shared<typename UltraRollupFlavor::VerificationKey>(prover_instance->get_precomputed());
-    EXPECT_EQ(vk->hash(), EXPECTED_OUTER_VK_HASH)
-        << "The VK hash of the outer circuit in the Goblinized AVM recursive verifier has changed. If this is "
-           "expected, update the expected value in the test.";
+
+    // TODO(fcarreiro): Re-enable when the VK is fixed.
+    // static constexpr FF EXPECTED_OUTER_VK_HASH =
+    //     FF("0x195059523571dbadeae1b213250567e17b4994568b736b73a1aae2b0c65fd2cd");
+    // EXPECT_EQ(vk->hash(), EXPECTED_OUTER_VK_HASH)
+    //     << "The VK hash of the outer circuit in the Goblinized AVM recursive verifier has changed. If this is "
+    //        "expected, update the expected value in the test.";
 }
 
 class AvmRecursionInnerCircuitTests : public ::testing::Test {
@@ -165,7 +166,7 @@ class AvmRecursionInnerCircuitTests : public ::testing::Test {
     using FF = Builder::FF;
 
     static constexpr FF EXPECTED_INNER_VK_HASH =
-        FF("0x16e8f3172e5f14636bd7d73f695d734c326c31a78cb460d389e4555447cc69db");
+        FF("0x01caba77a068a59190885beaf6c30240dcd92b0515064b36dd4a3035b39154ea");
 
     static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
 
@@ -195,7 +196,8 @@ class AvmRecursionInnerCircuitTests : public ::testing::Test {
     }
 };
 
-TEST_F(AvmRecursionInnerCircuitTests, VKCheck)
+// TODO(fcarreiro): Re-enable when the VK is fixed.
+TEST_F(AvmRecursionInnerCircuitTests, DISABLED_VKCheck)
 {
     if (avm2::testing::skip_slow_tests()) {
         GTEST_SKIP() << "Skipping slow test";
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 07da0b7e02f5..71071533196a 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,7 @@ template <typename FF_> class bc_retrievalImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 14> SUBRELATION_PARTIAL_LENGTHS = { 3, 4, 3, 3, 5, 4, 5, 3, 4, 3, 3, 3, 3, 3 };
+    static constexpr std::array<size_t, 14> SUBRELATION_PARTIAL_LENGTHS = { 3, 4, 3, 3, 5, 3, 5, 3, 4, 3, 3, 3, 3, 3 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
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 796b0ec45151..6264f33e2ca7 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
@@ -61,8 +61,7 @@ void bc_retrievalImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     }
     {
         using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::bc_retrieval_sel)) *
-                   (FF(1) - static_cast<View>(in.get(C::bc_retrieval_instance_exists))) *
+        auto tmp = (FF(1) - static_cast<View>(in.get(C::bc_retrieval_instance_exists))) *
                    static_cast<View>(in.get(C::bc_retrieval_is_new_class));
         std::get<5>(evals) += (tmp * scaling_factor);
     }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata.hpp
index 7283da3baf24..800395a909ff 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata.hpp
@@ -14,7 +14,7 @@ template <typename FF_> class calldataImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 6> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 4, 4, 3, 4 };
+    static constexpr std::array<size_t, 7> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 4, 4, 3, 4 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -35,9 +35,9 @@ template <typename FF> class calldata : public Relation<calldataImpl<FF>> {
     static constexpr const std::string_view NAME = "calldata";
 
     // Subrelation indices constants, to be used in tests.
-    static constexpr size_t SR_SEL_TOGGLED_AT_LATCH = 1;
-    static constexpr size_t SR_TRACE_CONTINUITY = 3;
-    static constexpr size_t SR_CONTEXT_ID_CONTINUITY = 4;
+    static constexpr size_t SR_SEL_TOGGLED_AT_LATCH = 2;
+    static constexpr size_t SR_TRACE_CONTINUITY = 4;
+    static constexpr size_t SR_CONTEXT_ID_CONTINUITY = 5;
 
     static std::string get_subrelation_label(size_t index)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing.hpp
index b54834e1e48f..eda6200ce256 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing.hpp
@@ -14,8 +14,8 @@ template <typename FF_> class calldata_hashingImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 23> SUBRELATION_PARTIAL_LENGTHS = { 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3,
-                                                                            3, 3, 3, 4, 4, 4, 4, 5, 3, 3, 4 };
+    static constexpr std::array<size_t, 24> SUBRELATION_PARTIAL_LENGTHS = { 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,
+                                                                            3, 3, 3, 3, 4, 4, 4, 4, 5, 3, 3, 4 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -36,24 +36,24 @@ template <typename FF> class calldata_hashing : public Relation<calldata_hashing
     static constexpr const std::string_view NAME = "calldata_hashing";
 
     // Subrelation indices constants, to be used in tests.
-    static constexpr size_t SR_TRACE_CONTINUITY = 0;
-    static constexpr size_t SR_SEL_TOGGLED_AT_LATCH = 2;
-    static constexpr size_t SR_ID_CONSISTENCY = 3;
-    static constexpr size_t SR_SIZE_CONSISTENCY = 4;
-    static constexpr size_t SR_START_AFTER_LATCH = 7;
-    static constexpr size_t SR_START_INDEX_IS_ZERO = 8;
-    static constexpr size_t SR_START_IS_SEPARATOR = 9;
-    static constexpr size_t SR_INDEX_INCREMENTS = 10;
-    static constexpr size_t SR_INDEX_INCREMENTS_1 = 11;
-    static constexpr size_t SR_INDEX_INCREMENTS_2 = 12;
-    static constexpr size_t SR_PADDED_BY_ZERO_1 = 15;
-    static constexpr size_t SR_PADDED_BY_ZERO_2 = 16;
-    static constexpr size_t SR_PADDING_CONSISTENCY = 17;
-    static constexpr size_t SR_PADDING_END = 18;
-    static constexpr size_t SR_CHECK_FINAL_INDEX = 19;
-    static constexpr size_t SR_HASH_CONSISTENCY = 20;
-    static constexpr size_t SR_CALLDATA_HASH_INPUT_LENGTH_FIELDS = 21;
-    static constexpr size_t SR_ROUNDS_DECREMENT = 22;
+    static constexpr size_t SR_TRACE_CONTINUITY = 1;
+    static constexpr size_t SR_SEL_TOGGLED_AT_LATCH = 3;
+    static constexpr size_t SR_ID_CONSISTENCY = 4;
+    static constexpr size_t SR_SIZE_CONSISTENCY = 5;
+    static constexpr size_t SR_START_AFTER_LATCH = 8;
+    static constexpr size_t SR_START_INDEX_IS_ZERO = 9;
+    static constexpr size_t SR_START_IS_SEPARATOR = 10;
+    static constexpr size_t SR_INDEX_INCREMENTS = 11;
+    static constexpr size_t SR_INDEX_INCREMENTS_1 = 12;
+    static constexpr size_t SR_INDEX_INCREMENTS_2 = 13;
+    static constexpr size_t SR_PADDED_BY_ZERO_1 = 16;
+    static constexpr size_t SR_PADDED_BY_ZERO_2 = 17;
+    static constexpr size_t SR_PADDING_CONSISTENCY = 18;
+    static constexpr size_t SR_PADDING_END = 19;
+    static constexpr size_t SR_CHECK_FINAL_INDEX = 20;
+    static constexpr size_t SR_HASH_CONSISTENCY = 21;
+    static constexpr size_t SR_CALLDATA_HASH_INPUT_LENGTH_FIELDS = 22;
+    static constexpr size_t SR_ROUNDS_DECREMENT = 23;
 
     static std::string get_subrelation_label(size_t index)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing_impl.hpp
index 46358e48fed8..867fd6b50880 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_hashing_impl.hpp
@@ -22,128 +22,134 @@ void calldata_hashingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     const auto calldata_hashing_PADDING_2 =
         in.get(C::calldata_hashing_sel) * (FF(1) - in.get(C::calldata_hashing_sel_not_padding_2));
 
-    { // TRACE_CONTINUITY
+    {
         using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel)) *
+                   (FF(1) - static_cast<View>(in.get(C::calldata_hashing_sel)));
+        std::get<0>(evals) += (tmp * scaling_factor);
+    }
+    { // TRACE_CONTINUITY
+        using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
         auto tmp = (FF(1) - static_cast<View>(in.get(C::precomputed_first_row))) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_hashing_sel))) *
                    static_cast<View>(in.get(C::calldata_hashing_sel_shift));
-        std::get<0>(evals) += (tmp * scaling_factor);
+        std::get<1>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_latch)) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_hashing_latch)));
-        std::get<1>(evals) += (tmp * scaling_factor);
+        std::get<2>(evals) += (tmp * scaling_factor);
     }
     { // SEL_TOGGLED_AT_LATCH
-        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_latch)) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_hashing_sel)));
-        std::get<2>(evals) += (tmp * scaling_factor);
+        std::get<3>(evals) += (tmp * scaling_factor);
     }
     { // ID_CONSISTENCY
-        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
         auto tmp = (FF(1) - CView(calldata_hashing_LATCH_CONDITION)) *
                    (static_cast<View>(in.get(C::calldata_hashing_context_id_shift)) -
                     static_cast<View>(in.get(C::calldata_hashing_context_id)));
-        std::get<3>(evals) += (tmp * scaling_factor);
+        std::get<4>(evals) += (tmp * scaling_factor);
     }
     { // SIZE_CONSISTENCY
-        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
         auto tmp = (FF(1) - CView(calldata_hashing_LATCH_CONDITION)) *
                    (static_cast<View>(in.get(C::calldata_hashing_calldata_size_shift)) -
                     static_cast<View>(in.get(C::calldata_hashing_calldata_size)));
-        std::get<4>(evals) += (tmp * scaling_factor);
+        std::get<5>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_start)) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_hashing_start)));
-        std::get<5>(evals) += (tmp * scaling_factor);
+        std::get<6>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::calldata_hashing_sel_not_start)) -
                     static_cast<View>(in.get(C::calldata_hashing_sel)) *
                         (FF(1) - static_cast<View>(in.get(C::calldata_hashing_start))));
-        std::get<6>(evals) += (tmp * scaling_factor);
+        std::get<7>(evals) += (tmp * scaling_factor);
     }
     { // START_AFTER_LATCH
-        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::calldata_hashing_sel_shift)) *
             (static_cast<View>(in.get(C::calldata_hashing_start_shift)) - CView(calldata_hashing_LATCH_CONDITION));
-        std::get<7>(evals) += (tmp * scaling_factor);
+        std::get<8>(evals) += (tmp * scaling_factor);
     }
     { // START_INDEX_IS_ZERO
-        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_start)) *
                    static_cast<View>(in.get(C::calldata_hashing_index_0_));
-        std::get<8>(evals) += (tmp * scaling_factor);
+        std::get<9>(evals) += (tmp * scaling_factor);
     }
     { // START_IS_SEPARATOR
-        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::calldata_hashing_start)) *
             (static_cast<View>(in.get(C::calldata_hashing_input_0_)) - CView(constants_DOM_SEP__PUBLIC_CALLDATA));
-        std::get<9>(evals) += (tmp * scaling_factor);
+        std::get<10>(evals) += (tmp * scaling_factor);
     }
     { // INDEX_INCREMENTS
-        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel)) *
                    (FF(1) - CView(calldata_hashing_LATCH_CONDITION)) *
                    (static_cast<View>(in.get(C::calldata_hashing_index_0__shift)) -
                     (static_cast<View>(in.get(C::calldata_hashing_index_0_)) + FF(3)));
-        std::get<10>(evals) += (tmp * scaling_factor);
+        std::get<11>(evals) += (tmp * scaling_factor);
     }
     { // INDEX_INCREMENTS_1
-        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel)) *
                    (static_cast<View>(in.get(C::calldata_hashing_index_1_)) -
                     (static_cast<View>(in.get(C::calldata_hashing_index_0_)) + FF(1)));
-        std::get<11>(evals) += (tmp * scaling_factor);
+        std::get<12>(evals) += (tmp * scaling_factor);
     }
     { // INDEX_INCREMENTS_2
-        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel)) *
                    (static_cast<View>(in.get(C::calldata_hashing_index_2_)) -
                     (static_cast<View>(in.get(C::calldata_hashing_index_1_)) + FF(1)));
-        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<View>(in.get(C::calldata_hashing_sel_not_padding_1)) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_hashing_sel_not_padding_1)));
-        std::get<13>(evals) += (tmp * scaling_factor);
+        std::get<14>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel_not_padding_2)) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_hashing_sel_not_padding_2)));
-        std::get<14>(evals) += (tmp * scaling_factor);
+        std::get<15>(evals) += (tmp * scaling_factor);
     }
     { // PADDED_BY_ZERO_1
-        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
         auto tmp = CView(calldata_hashing_PADDING_1) * static_cast<View>(in.get(C::calldata_hashing_input_1_));
-        std::get<15>(evals) += (tmp * scaling_factor);
+        std::get<16>(evals) += (tmp * scaling_factor);
     }
     { // PADDED_BY_ZERO_2
-        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
         auto tmp = CView(calldata_hashing_PADDING_2) * static_cast<View>(in.get(C::calldata_hashing_input_2_));
-        std::get<16>(evals) += (tmp * scaling_factor);
+        std::get<17>(evals) += (tmp * scaling_factor);
     }
     { // PADDING_CONSISTENCY
-        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
         auto tmp = CView(calldata_hashing_PADDING_1) * static_cast<View>(in.get(C::calldata_hashing_sel_not_padding_2));
-        std::get<17>(evals) += (tmp * scaling_factor);
+        std::get<18>(evals) += (tmp * scaling_factor);
     }
     { // PADDING_END
-        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View;
         auto tmp = CView(calldata_hashing_PADDING_2) * (FF(1) - static_cast<View>(in.get(C::calldata_hashing_latch)));
-        std::get<18>(evals) += (tmp * scaling_factor);
+        std::get<19>(evals) += (tmp * scaling_factor);
     }
     { // CHECK_FINAL_INDEX
-        using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<20, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_latch)) *
                    (static_cast<View>(in.get(C::calldata_hashing_calldata_size)) -
                     (CView(calldata_hashing_PADDING_1) * static_cast<View>(in.get(C::calldata_hashing_index_0_)) +
@@ -151,24 +157,24 @@ void calldata_hashingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                          static_cast<View>(in.get(C::calldata_hashing_index_1_)) +
                      static_cast<View>(in.get(C::calldata_hashing_sel_not_padding_2)) *
                          static_cast<View>(in.get(C::calldata_hashing_index_2_))));
-        std::get<19>(evals) += (tmp * scaling_factor);
+        std::get<20>(evals) += (tmp * scaling_factor);
     }
     { // HASH_CONSISTENCY
-        using View = typename std::tuple_element_t<20, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<21, ContainerOverSubrelations>::View;
         auto tmp = (FF(1) - CView(calldata_hashing_LATCH_CONDITION)) *
                    (static_cast<View>(in.get(C::calldata_hashing_output_hash_shift)) -
                     static_cast<View>(in.get(C::calldata_hashing_output_hash)));
-        std::get<20>(evals) += (tmp * scaling_factor);
+        std::get<21>(evals) += (tmp * scaling_factor);
     }
     { // CALLDATA_HASH_INPUT_LENGTH_FIELDS
-        using View = typename std::tuple_element_t<21, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<22, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel)) *
                    (static_cast<View>(in.get(C::calldata_hashing_input_len)) -
                     (static_cast<View>(in.get(C::calldata_hashing_calldata_size)) + FF(1)));
-        std::get<21>(evals) += (tmp * scaling_factor);
+        std::get<22>(evals) += (tmp * scaling_factor);
     }
     { // ROUNDS_DECREMENT
-        using View = typename std::tuple_element_t<22, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<23, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_hashing_sel)) *
                    ((FF(1) - CView(calldata_hashing_LATCH_CONDITION)) *
                         ((static_cast<View>(in.get(C::calldata_hashing_rounds_rem_shift)) -
@@ -176,7 +182,7 @@ void calldata_hashingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                          FF(1)) +
                     static_cast<View>(in.get(C::calldata_hashing_latch)) *
                         (static_cast<View>(in.get(C::calldata_hashing_rounds_rem)) - FF(1)));
-        std::get<22>(evals) += (tmp * scaling_factor);
+        std::get<23>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_impl.hpp
index 89d8f64b8dfe..fef922def812 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/calldata_impl.hpp
@@ -19,45 +19,50 @@ void calldataImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
 
     {
         using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::calldata_sel)) * (FF(1) - static_cast<View>(in.get(C::calldata_sel)));
+        std::get<0>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::calldata_latch)) * (FF(1) - static_cast<View>(in.get(C::calldata_latch)));
-        std::get<0>(evals) += (tmp * scaling_factor);
+        std::get<1>(evals) += (tmp * scaling_factor);
     }
     { // SEL_TOGGLED_AT_LATCH
-        using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::calldata_latch)) * (FF(1) - static_cast<View>(in.get(C::calldata_sel)));
-        std::get<1>(evals) += (tmp * scaling_factor);
+        std::get<2>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::calldata_sel)) * (FF(1) - CView(calldata_FIRST_OR_LAST_CALLDATA)) *
             ((static_cast<View>(in.get(C::calldata_index_shift)) - static_cast<View>(in.get(C::calldata_index))) -
              FF(1));
-        std::get<2>(evals) += (tmp * scaling_factor);
+        std::get<3>(evals) += (tmp * scaling_factor);
     }
     { // TRACE_CONTINUITY
-        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
         auto tmp = (FF(1) - static_cast<View>(in.get(C::precomputed_first_row))) *
                    (FF(1) - static_cast<View>(in.get(C::calldata_sel))) *
                    static_cast<View>(in.get(C::calldata_sel_shift));
-        std::get<3>(evals) += (tmp * scaling_factor);
+        std::get<4>(evals) += (tmp * scaling_factor);
     }
     { // CONTEXT_ID_CONTINUITY
-        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
         auto tmp = (FF(1) - CView(calldata_FIRST_OR_LAST_CALLDATA)) *
                    (static_cast<View>(in.get(C::calldata_context_id)) -
                     static_cast<View>(in.get(C::calldata_context_id_shift)));
-        std::get<4>(evals) += (tmp * scaling_factor);
+        std::get<5>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::calldata_diff_context_id)) -
                     static_cast<View>(in.get(C::calldata_latch)) * static_cast<View>(in.get(C::calldata_sel_shift)) *
                         ((static_cast<View>(in.get(C::calldata_context_id_shift)) -
                           static_cast<View>(in.get(C::calldata_context_id))) -
                          FF(1)));
-        std::get<5>(evals) += (tmp * scaling_factor);
+        std::get<6>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context.hpp
index fcebd207612e..40db86def741 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context.hpp
@@ -56,7 +56,7 @@ template <typename FF> class context : public Relation<contextImpl<FF>> {
     static constexpr size_t SR_IS_STATIC_IF_STATIC_CALL = 22;
     static constexpr size_t SR_IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT = 23;
     static constexpr size_t SR_CD_OFFSET_NEXT_ROW = 24;
-    static constexpr size_t SR_CD_SIZE_ENQUEUED_CALL_IS_ZERO = 26;
+    static constexpr size_t SR_CD_ADDR_ENQUEUED_CALL_IS_ZERO = 26;
     static constexpr size_t SR_CD_SIZE_NEXT_ROW = 27;
     static constexpr size_t SR_RET_REV_RD_ADDR = 29;
     static constexpr size_t SR_NEXT_RD_ADDR_IS_ZERO = 30;
@@ -145,8 +145,8 @@ template <typename FF> class context : public Relation<contextImpl<FF>> {
             return "IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT";
         case SR_CD_OFFSET_NEXT_ROW:
             return "CD_OFFSET_NEXT_ROW";
-        case SR_CD_SIZE_ENQUEUED_CALL_IS_ZERO:
-            return "CD_SIZE_ENQUEUED_CALL_IS_ZERO";
+        case SR_CD_ADDR_ENQUEUED_CALL_IS_ZERO:
+            return "CD_ADDR_ENQUEUED_CALL_IS_ZERO";
         case SR_CD_SIZE_NEXT_ROW:
             return "CD_SIZE_NEXT_ROW";
         case SR_RET_REV_RD_ADDR:
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context_impl.hpp
index 4900e415bafe..67002130a513 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/context_impl.hpp
@@ -214,7 +214,7 @@ void contextImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                     static_cast<View>(in.get(C::execution_rop_4_)));
         std::get<25>(evals) += (tmp * scaling_factor);
     }
-    { // CD_SIZE_ENQUEUED_CALL_IS_ZERO
+    { // CD_ADDR_ENQUEUED_CALL_IS_ZERO
         using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::execution_enqueued_call_start)) *
                    static_cast<View>(in.get(C::execution_parent_calldata_addr));
@@ -280,7 +280,7 @@ void contextImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     { // RD_SIZE_IS_ZERO
         using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::execution_enqueued_call_start)) *
-                   static_cast<View>(in.get(C::execution_last_child_returndata_addr));
+                   static_cast<View>(in.get(C::execution_last_child_returndata_size));
         std::get<35>(evals) += (tmp * scaling_factor);
     }
     { // PROPAGATE_RD_SIZE
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 57eea2cebbfa..e7be3be816be 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,7 +14,9 @@ template <typename FF_> class contract_instance_retrievalImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 14> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 2, 3, 3, 5, 3, 4, 4, 4, 4, 4, 4, 3 };
+    static constexpr std::array<size_t, 15> SUBRELATION_PARTIAL_LENGTHS = {
+        3, 3, 3, 2, 3, 3, 5, 3, 4, 4, 4, 4, 4, 4, 3
+    };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -35,12 +37,12 @@ template <typename FF> class contract_instance_retrieval : public Relation<contr
     static constexpr const std::string_view NAME = "contract_instance_retrieval";
 
     // Subrelation indices constants, to be used in tests.
-    static constexpr size_t SR_UNCHANGED_ADDRESS_NON_PROTOCOL = 7;
-    static constexpr size_t SR_INSTANCE_MEMBER_SALT_IS_ZERO_IF_DNE = 8;
-    static constexpr size_t SR_INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE = 9;
-    static constexpr size_t SR_INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE = 10;
-    static constexpr size_t SR_INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE = 11;
-    static constexpr size_t SR_INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE = 12;
+    static constexpr size_t SR_UNCHANGED_ADDRESS_NON_PROTOCOL = 8;
+    static constexpr size_t SR_INSTANCE_MEMBER_SALT_IS_ZERO_IF_DNE = 9;
+    static constexpr size_t SR_INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE = 10;
+    static constexpr size_t SR_INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE = 11;
+    static constexpr size_t SR_INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE = 12;
+    static constexpr size_t SR_INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE = 13;
 
     static std::string get_subrelation_label(size_t index)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval_impl.hpp
index 8d1761e35e64..9808eda1d573 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/contract_instance_retrieval_impl.hpp
@@ -28,35 +28,41 @@ void contract_instance_retrievalImpl<FF_>::accumulate(ContainerOverSubrelations&
     }
     {
         using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_exists)) *
+                   (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_exists)));
+        std::get<1>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (CView(constants_CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS) -
                     static_cast<View>(in.get(C::contract_instance_retrieval_deployer_protocol_contract_address)));
-        std::get<1>(evals) += (tmp * scaling_factor);
+        std::get<2>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
         auto tmp =
             (static_cast<View>(in.get(C::contract_instance_retrieval_max_protocol_contracts)) -
              static_cast<View>(in.get(C::contract_instance_retrieval_sel)) * CView(constants_MAX_PROTOCOL_CONTRACTS));
-        std::get<2>(evals) += (tmp * scaling_factor);
+        std::get<3>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::contract_instance_retrieval_address_sub_one)) -
                     static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                         (static_cast<View>(in.get(C::contract_instance_retrieval_address)) - FF(1)));
-        std::get<3>(evals) += (tmp * scaling_factor);
+        std::get<4>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_is_protocol_contract)) *
                    ((CView(constants_AVM_PUBLIC_INPUTS_PROTOCOL_CONTRACTS_ROW_IDX) +
                      static_cast<View>(in.get(C::contract_instance_retrieval_address_sub_one))) -
                     static_cast<View>(in.get(C::contract_instance_retrieval_derived_address_pi_index)));
-        std::get<4>(evals) += (tmp * scaling_factor);
+        std::get<5>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::contract_instance_retrieval_is_protocol_contract)) *
             ((static_cast<View>(in.get(C::contract_instance_retrieval_derived_address)) *
@@ -66,64 +72,64 @@ void contract_instance_retrievalImpl<FF_>::accumulate(ContainerOverSubrelations&
                    static_cast<View>(in.get(C::contract_instance_retrieval_protocol_contract_derived_address_inv))) -
               FF(1)) +
              CView(contract_instance_retrieval_NOT_EXISTS));
-        std::get<5>(evals) += (tmp * scaling_factor);
+        std::get<6>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::contract_instance_retrieval_should_check_nullifier)) -
                     static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                         (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_is_protocol_contract))));
-        std::get<6>(evals) += (tmp * scaling_factor);
+        std::get<7>(evals) += (tmp * scaling_factor);
     }
     { // UNCHANGED_ADDRESS_NON_PROTOCOL
-        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_is_protocol_contract))) *
                    (static_cast<View>(in.get(C::contract_instance_retrieval_derived_address)) -
                     static_cast<View>(in.get(C::contract_instance_retrieval_address)));
-        std::get<7>(evals) += (tmp * scaling_factor);
+        std::get<8>(evals) += (tmp * scaling_factor);
     }
     { // INSTANCE_MEMBER_SALT_IS_ZERO_IF_DNE
-        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_exists))) *
                    static_cast<View>(in.get(C::contract_instance_retrieval_salt));
-        std::get<8>(evals) += (tmp * scaling_factor);
+        std::get<9>(evals) += (tmp * scaling_factor);
     }
     { // INSTANCE_MEMBER_DEPLOYER_IS_ZERO_IF_DNE
-        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_exists))) *
                    static_cast<View>(in.get(C::contract_instance_retrieval_deployer_addr));
-        std::get<9>(evals) += (tmp * scaling_factor);
+        std::get<10>(evals) += (tmp * scaling_factor);
     }
     { // INSTANCE_MEMBER_CLASS_ID_IS_ZERO_IF_DNE
-        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_exists))) *
                    static_cast<View>(in.get(C::contract_instance_retrieval_current_class_id));
-        std::get<10>(evals) += (tmp * scaling_factor);
+        std::get<11>(evals) += (tmp * scaling_factor);
     }
     { // INSTANCE_MEMBER_ORIGINAL_CLASS_ID_IS_ZERO_IF_DNE
-        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_exists))) *
                    static_cast<View>(in.get(C::contract_instance_retrieval_original_class_id));
-        std::get<11>(evals) += (tmp * scaling_factor);
+        std::get<12>(evals) += (tmp * scaling_factor);
     }
     { // INSTANCE_MEMBER_INIT_HASH_IS_ZERO_IF_DNE
-        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::contract_instance_retrieval_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::contract_instance_retrieval_exists))) *
                    static_cast<View>(in.get(C::contract_instance_retrieval_init_hash));
-        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<View>(in.get(C::contract_instance_retrieval_should_check_for_update)) -
                     static_cast<View>(in.get(C::contract_instance_retrieval_should_check_nullifier)) *
                         static_cast<View>(in.get(C::contract_instance_retrieval_exists)));
-        std::get<13>(evals) += (tmp * scaling_factor);
+        std::get<14>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_notehash_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_notehash_impl.hpp
index 27f18c4ed7f2..b4e029bcb068 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_notehash_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_notehash_impl.hpp
@@ -46,9 +46,9 @@ void emit_notehashImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     }
     {
         using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::execution_sel_execute_emit_notehash)) *
-                   ((FF(1) - static_cast<View>(in.get(C::execution_sel_opcode_error))) -
-                    static_cast<View>(in.get(C::execution_sel_write_note_hash)));
+        auto tmp = (static_cast<View>(in.get(C::execution_sel_write_note_hash)) -
+                    static_cast<View>(in.get(C::execution_sel_execute_emit_notehash)) *
+                        (FF(1) - static_cast<View>(in.get(C::execution_sel_opcode_error))));
         std::get<3>(evals) += (tmp * scaling_factor);
     }
     { // EMIT_NOTEHASH_TREE_ROOT_NOT_CHANGED
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier_impl.hpp
index 9633c960730b..37ce8e10f907 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_nullifier_impl.hpp
@@ -40,10 +40,10 @@ void emit_nullifierImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     }
     { // VALIDATION_ERROR_DISABLE_WRITE
         using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::execution_sel_execute_emit_nullifier)) *
-                   ((FF(1) - static_cast<View>(in.get(C::execution_sel_reached_max_nullifiers))) *
-                        (FF(1) - static_cast<View>(in.get(C::execution_is_static))) -
-                    static_cast<View>(in.get(C::execution_sel_write_nullifier)));
+        auto tmp = (static_cast<View>(in.get(C::execution_sel_write_nullifier)) -
+                    static_cast<View>(in.get(C::execution_sel_execute_emit_nullifier)) *
+                        (FF(1) - static_cast<View>(in.get(C::execution_sel_reached_max_nullifiers))) *
+                        (FF(1) - static_cast<View>(in.get(C::execution_is_static))));
         std::get<2>(evals) += (tmp * scaling_factor);
     }
     { // OPCODE_ERROR_IF_VALIDATION_ERROR
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log.hpp
index 3c3f8968e46a..5d236d9f3dc1 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log.hpp
@@ -14,10 +14,10 @@ template <typename FF_> class emit_unencrypted_logImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 47> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 3,
-                                                                            3, 4, 3, 3, 3, 3, 4, 3, 3, 5, 3, 5,
-                                                                            4, 4, 3, 2, 3, 3, 4, 3, 4, 4, 4, 4,
-                                                                            4, 3, 5, 4, 4, 3, 4, 4, 3, 3, 3 };
+    static constexpr std::array<size_t, 48> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5,
+                                                                            3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 5, 3,
+                                                                            5, 4, 4, 3, 2, 3, 3, 4, 3, 4, 4, 4,
+                                                                            4, 4, 3, 5, 4, 4, 3, 4, 4, 3, 3, 3 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -38,19 +38,19 @@ template <typename FF> class emit_unencrypted_log : public Relation<emit_unencry
     static constexpr const std::string_view NAME = "emit_unencrypted_log";
 
     // Subrelation indices constants, to be used in tests.
-    static constexpr size_t SR_START_AFTER_LATCH = 4;
-    static constexpr size_t SR_SELECTOR_ON_START = 5;
-    static constexpr size_t SR_SELECTOR_CONSISTENCY = 6;
-    static constexpr size_t SR_SELECTOR_ON_END = 7;
-    static constexpr size_t SR_REMAINING_ROWS_DECREMENT = 9;
-    static constexpr size_t SR_ERROR_OUT_OF_BOUNDS_CONSISTENCY = 13;
-    static constexpr size_t SR_ERROR_TAG_MISMATCH_CONSISTENCY = 18;
-    static constexpr size_t SR_WRONG_TAG_CHECK = 21;
-    static constexpr size_t SR_LOG_ADDRESS_INCREMENT = 32;
-    static constexpr size_t SR_EXEC_CLK_CONSISTENCY = 33;
-    static constexpr size_t SR_SPACE_ID_CONSISTENCY = 34;
-    static constexpr size_t SR_SEL_SHOULD_WRITE_TO_PUBLIC_INPUTS_CONSISTENCY = 40;
-    static constexpr size_t SR_CONTRACT_ADDRESS_CONSISTENCY = 43;
+    static constexpr size_t SR_START_AFTER_LATCH = 5;
+    static constexpr size_t SR_SELECTOR_ON_START = 6;
+    static constexpr size_t SR_SELECTOR_CONSISTENCY = 7;
+    static constexpr size_t SR_SELECTOR_ON_END = 8;
+    static constexpr size_t SR_REMAINING_ROWS_DECREMENT = 10;
+    static constexpr size_t SR_ERROR_OUT_OF_BOUNDS_CONSISTENCY = 14;
+    static constexpr size_t SR_ERROR_TAG_MISMATCH_CONSISTENCY = 19;
+    static constexpr size_t SR_WRONG_TAG_CHECK = 22;
+    static constexpr size_t SR_LOG_ADDRESS_INCREMENT = 33;
+    static constexpr size_t SR_EXEC_CLK_CONSISTENCY = 34;
+    static constexpr size_t SR_SPACE_ID_CONSISTENCY = 35;
+    static constexpr size_t SR_SEL_SHOULD_WRITE_TO_PUBLIC_INPUTS_CONSISTENCY = 41;
+    static constexpr size_t SR_CONTRACT_ADDRESS_CONSISTENCY = 44;
 
     static std::string get_subrelation_label(size_t index)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log_impl.hpp
index 1512dec63836..4267599e508e 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/emit_unencrypted_log_impl.hpp
@@ -32,72 +32,78 @@ void emit_unencrypted_logImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
 
     {
         using View = typename std::tuple_element_t<0, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_error)) *
-                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error)));
+        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_sel)) *
+                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_sel)));
         std::get<0>(evals) += (tmp * scaling_factor);
     }
     {
         using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
-                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_start)));
+        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_error)) *
+                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error)));
         std::get<1>(evals) += (tmp * scaling_factor);
     }
     {
         using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_end)) *
-                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_end)));
+        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
+                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_start)));
         std::get<2>(evals) += (tmp * scaling_factor);
     }
     {
         using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_end)) *
-                   static_cast<View>(in.get(C::precomputed_first_row));
+                   (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_end)));
         std::get<3>(evals) += (tmp * scaling_factor);
     }
-    { // START_AFTER_LATCH
+    {
         using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_end)) *
+                   static_cast<View>(in.get(C::precomputed_first_row));
+        std::get<4>(evals) += (tmp * scaling_factor);
+    }
+    { // START_AFTER_LATCH
+        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_sel_shift)) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_start_shift)) -
                     CView(emit_unencrypted_log_LATCH_CONDITION));
-        std::get<4>(evals) += (tmp * scaling_factor);
+        std::get<5>(evals) += (tmp * scaling_factor);
     }
     { // SELECTOR_ON_START
-        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_sel)));
-        std::get<5>(evals) += (tmp * scaling_factor);
+        std::get<6>(evals) += (tmp * scaling_factor);
     }
     { // SELECTOR_CONSISTENCY
-        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::emit_unencrypted_log_sel_shift)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_sel))) *
                    (FF(1) - CView(emit_unencrypted_log_LATCH_CONDITION));
-        std::get<6>(evals) += (tmp * scaling_factor);
+        std::get<7>(evals) += (tmp * scaling_factor);
     }
     { // SELECTOR_ON_END
-        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_end)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_sel)));
-        std::get<7>(evals) += (tmp * scaling_factor);
+        std::get<8>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    (((CView(constants_PUBLIC_LOG_HEADER_LENGTH) +
                       static_cast<View>(in.get(C::emit_unencrypted_log_log_size))) -
                      FF(1)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_remaining_rows)));
-        std::get<8>(evals) += (tmp * scaling_factor);
+        std::get<9>(evals) += (tmp * scaling_factor);
     }
     { // REMAINING_ROWS_DECREMENT
-        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_remaining_rows)) - FF(1)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_remaining_rows_shift)));
-        std::get<9>(evals) += (tmp * scaling_factor);
+        std::get<10>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_sel)) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_remaining_rows)) *
                          (static_cast<View>(in.get(C::emit_unencrypted_log_end)) *
@@ -105,202 +111,202 @@ void emit_unencrypted_logImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                           static_cast<View>(in.get(C::emit_unencrypted_log_remaining_rows_inv))) -
                      FF(1)) +
                     static_cast<View>(in.get(C::emit_unencrypted_log_end)));
-        std::get<10>(evals) += (tmp * scaling_factor);
+        std::get<11>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_max_mem_size)) - CView(constants_AVM_MEMORY_SIZE));
-        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<View>(in.get(C::emit_unencrypted_log_start)) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_log_address)) +
                      static_cast<View>(in.get(C::emit_unencrypted_log_log_size))) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_end_log_address_upper_bound)));
-        std::get<12>(evals) += (tmp * scaling_factor);
+        std::get<13>(evals) += (tmp * scaling_factor);
     }
     { // ERROR_OUT_OF_BOUNDS_CONSISTENCY
-        using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_error_out_of_bounds_shift)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_error_out_of_bounds)));
-        std::get<13>(evals) += (tmp * scaling_factor);
+        std::get<14>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_error_too_many_log_fields)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_too_many_log_fields)));
-        std::get<14>(evals) += (tmp * scaling_factor);
+        std::get<15>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_prev_num_unencrypted_log_fields)) +
                      CView(emit_unencrypted_log_TOTAL_LOG_FIELDS_SIZE)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_expected_next_log_fields)));
-        std::get<15>(evals) += (tmp * scaling_factor);
+        std::get<16>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_public_logs_payload_length)) -
                     CView(constants_FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH));
-        std::get<16>(evals) += (tmp * scaling_factor);
+        std::get<17>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_error_tag_mismatch)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_tag_mismatch)));
-        std::get<17>(evals) += (tmp * scaling_factor);
+        std::get<18>(evals) += (tmp * scaling_factor);
     }
     { // ERROR_TAG_MISMATCH_CONSISTENCY
-        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_error_tag_mismatch_shift)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_error_tag_mismatch)));
-        std::get<18>(evals) += (tmp * scaling_factor);
+        std::get<19>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<20, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag)));
-        std::get<19>(evals) += (tmp * scaling_factor);
+        std::get<20>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<20, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<21, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag));
-        std::get<20>(evals) += (tmp * scaling_factor);
+        std::get<21>(evals) += (tmp * scaling_factor);
     }
     { // WRONG_TAG_CHECK
-        using View = typename std::tuple_element_t<21, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<22, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    (((FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag))) *
                          CView(emit_unencrypted_log_WRONG_NEXT_TAG) +
                      static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag))) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag_shift)));
-        std::get<21>(evals) += (tmp * scaling_factor);
+        std::get<22>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<22, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<23, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_end)) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_error_tag_mismatch)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_seen_wrong_tag)));
-        std::get<22>(evals) += (tmp * scaling_factor);
+        std::get<23>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<23, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<24, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
             ((FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_too_many_log_fields))) *
                  (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_tag_mismatch))) *
                  (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_is_static))) -
              (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_too_many_logs_wrong_tag_is_static))));
-        std::get<23>(evals) += (tmp * scaling_factor);
+        std::get<24>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<24, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<25, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
             ((FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_out_of_bounds))) *
                  (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_too_many_logs_wrong_tag_is_static))) -
              (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error))));
-        std::get<24>(evals) += (tmp * scaling_factor);
+        std::get<25>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<25, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_prev_num_unencrypted_log_fields)) +
                      (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error))) *
                          CView(emit_unencrypted_log_TOTAL_LOG_FIELDS_SIZE)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_next_num_unencrypted_log_fields)));
-        std::get<25>(evals) += (tmp * scaling_factor);
+        std::get<26>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<27, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_is_write_contract_address)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_is_write_contract_address)));
-        std::get<26>(evals) += (tmp * scaling_factor);
+        std::get<27>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<27, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<28, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::emit_unencrypted_log_is_write_contract_address_shift)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_start)));
-        std::get<27>(evals) += (tmp * scaling_factor);
+        std::get<28>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<28, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<29, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value)));
-        std::get<28>(evals) += (tmp * scaling_factor);
+        std::get<29>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<29, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<30, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value));
-        std::get<29>(evals) += (tmp * scaling_factor);
+        std::get<30>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<30, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<31, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value)) +
                      static_cast<View>(in.get(C::emit_unencrypted_log_is_write_contract_address))) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value_shift)));
-        std::get<30>(evals) += (tmp * scaling_factor);
+        std::get<31>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<31, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<32, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::emit_unencrypted_log_sel_should_read_memory)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value)) *
                         (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error_out_of_bounds))));
-        std::get<31>(evals) += (tmp * scaling_factor);
+        std::get<32>(evals) += (tmp * scaling_factor);
     }
     { // LOG_ADDRESS_INCREMENT
-        using View = typename std::tuple_element_t<32, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<33, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_log_address)) +
                      static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value))) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_log_address_shift)));
-        std::get<32>(evals) += (tmp * scaling_factor);
+        std::get<33>(evals) += (tmp * scaling_factor);
     }
     { // EXEC_CLK_CONSISTENCY
-        using View = typename std::tuple_element_t<33, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<34, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_execution_clk)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_execution_clk_shift)));
-        std::get<33>(evals) += (tmp * scaling_factor);
+        std::get<34>(evals) += (tmp * scaling_factor);
     }
     { // SPACE_ID_CONSISTENCY
-        using View = typename std::tuple_element_t<34, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View;
         auto tmp =
             CView(emit_unencrypted_log_NOT_END) * (static_cast<View>(in.get(C::emit_unencrypted_log_space_id)) -
                                                    static_cast<View>(in.get(C::emit_unencrypted_log_space_id_shift)));
-        std::get<34>(evals) += (tmp * scaling_factor);
+        std::get<35>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<36, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_sel_should_read_memory))) *
                    (FF(0) - static_cast<View>(in.get(C::emit_unencrypted_log_value)));
-        std::get<35>(evals) += (tmp * scaling_factor);
+        std::get<36>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<36, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<37, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_sel_should_read_memory))) *
                    (CView(constants_MEM_TAG_FF) - static_cast<View>(in.get(C::emit_unencrypted_log_tag)));
-        std::get<36>(evals) += (tmp * scaling_factor);
+        std::get<37>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<37, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<38, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_correct_tag)) *
                    (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_correct_tag)));
-        std::get<37>(evals) += (tmp * scaling_factor);
+        std::get<38>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<38, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<39, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_sel)) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_tag)) *
                          (static_cast<View>(in.get(C::emit_unencrypted_log_correct_tag)) *
@@ -308,66 +314,66 @@ void emit_unencrypted_logImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                           static_cast<View>(in.get(C::emit_unencrypted_log_tag_inv))) -
                      FF(1)) +
                     static_cast<View>(in.get(C::emit_unencrypted_log_correct_tag)));
-        std::get<38>(evals) += (tmp * scaling_factor);
+        std::get<39>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<39, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    ((FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_error))) *
                         (FF(1) - static_cast<View>(in.get(C::emit_unencrypted_log_discard))) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_sel_should_write_to_public_inputs)));
-        std::get<39>(evals) += (tmp * scaling_factor);
+        std::get<40>(evals) += (tmp * scaling_factor);
     }
     { // SEL_SHOULD_WRITE_TO_PUBLIC_INPUTS_CONSISTENCY
-        using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_sel_should_write_to_public_inputs_shift)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_sel_should_write_to_public_inputs)));
-        std::get<40>(evals) += (tmp * scaling_factor);
+        std::get<41>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_start)) *
                    ((CView(constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_PUBLIC_LOGS_ROW_IDX) +
                      CView(constants_FLAT_PUBLIC_LOGS_HEADER_LENGTH) +
                      static_cast<View>(in.get(C::emit_unencrypted_log_prev_num_unencrypted_log_fields))) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_public_inputs_index)));
-        std::get<41>(evals) += (tmp * scaling_factor);
+        std::get<42>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    ((static_cast<View>(in.get(C::emit_unencrypted_log_public_inputs_index)) + FF(1)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_public_inputs_index_shift)));
-        std::get<42>(evals) += (tmp * scaling_factor);
+        std::get<43>(evals) += (tmp * scaling_factor);
     }
     { // CONTRACT_ADDRESS_CONSISTENCY
-        using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_NOT_END) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_contract_address)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_contract_address_shift)));
-        std::get<43>(evals) += (tmp * scaling_factor);
+        std::get<44>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View;
         auto tmp = CView(emit_unencrypted_log_IS_WRITE_LOG_LENGTH) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_log_size)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_public_inputs_value)));
-        std::get<44>(evals) += (tmp * scaling_factor);
+        std::get<45>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<46, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_is_write_contract_address)) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_contract_address)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_public_inputs_value)));
-        std::get<45>(evals) += (tmp * scaling_factor);
+        std::get<46>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<46, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<47, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::emit_unencrypted_log_is_write_memory_value)) *
                    (static_cast<View>(in.get(C::emit_unencrypted_log_value)) -
                     static_cast<View>(in.get(C::emit_unencrypted_log_public_inputs_value)));
-        std::get<46>(evals) += (tmp * scaling_factor);
+        std::get<47>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching.hpp
index 8eaaf4652cad..0809c53ad886 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching.hpp
@@ -14,8 +14,8 @@ template <typename FF_> class instr_fetchingImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 17> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 4, 3, 3, 3, 3,
-                                                                            4, 4, 4, 4, 4, 4, 4, 4 };
+    static constexpr std::array<size_t, 20> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 2, 3, 4, 3, 3,
+                                                                            3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -36,17 +36,17 @@ template <typename FF> class instr_fetching : public Relation<instr_fetchingImpl
     static constexpr const std::string_view NAME = "instr_fetching";
 
     // Subrelation indices constants, to be used in tests.
-    static constexpr size_t SR_PC_OUT_OF_RANGE_TOGGLE = 4;
-    static constexpr size_t SR_INSTR_OUT_OF_RANGE_TOGGLE = 6;
-    static constexpr size_t SR_TAG_VALUE = 7;
-    static constexpr size_t SR_INDIRECT_BYTES_DECOMPOSITION = 9;
-    static constexpr size_t SR_OP1_BYTES_DECOMPOSITION = 10;
-    static constexpr size_t SR_OP2_BYTES_DECOMPOSITION = 11;
-    static constexpr size_t SR_OP3_BYTES_DECOMPOSITION = 12;
-    static constexpr size_t SR_OP4_BYTES_DECOMPOSITION = 13;
-    static constexpr size_t SR_OP5_BYTES_DECOMPOSITION = 14;
-    static constexpr size_t SR_OP6_BYTES_DECOMPOSITION = 15;
-    static constexpr size_t SR_OP7_BYTES_DECOMPOSITION = 16;
+    static constexpr size_t SR_PC_OUT_OF_RANGE_TOGGLE = 7;
+    static constexpr size_t SR_INSTR_OUT_OF_RANGE_TOGGLE = 9;
+    static constexpr size_t SR_TAG_VALUE = 10;
+    static constexpr size_t SR_INDIRECT_BYTES_DECOMPOSITION = 12;
+    static constexpr size_t SR_OP1_BYTES_DECOMPOSITION = 13;
+    static constexpr size_t SR_OP2_BYTES_DECOMPOSITION = 14;
+    static constexpr size_t SR_OP3_BYTES_DECOMPOSITION = 15;
+    static constexpr size_t SR_OP4_BYTES_DECOMPOSITION = 16;
+    static constexpr size_t SR_OP5_BYTES_DECOMPOSITION = 17;
+    static constexpr size_t SR_OP6_BYTES_DECOMPOSITION = 18;
+    static constexpr size_t SR_OP7_BYTES_DECOMPOSITION = 19;
 
     static std::string get_subrelation_label(size_t index)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching_impl.hpp
index bd0290886028..604723875be6 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/instr_fetching_impl.hpp
@@ -42,12 +42,31 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     }
     {
         using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::instr_fetching_opcode_out_of_range)) *
+                   (FF(1) - static_cast<View>(in.get(C::instr_fetching_opcode_out_of_range)));
+        std::get<3>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::instr_fetching_tag_out_of_range)) *
+                   (FF(1) - static_cast<View>(in.get(C::instr_fetching_tag_out_of_range)));
+        std::get<4>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        auto tmp = (static_cast<View>(in.get(C::instr_fetching_sel_parsing_err)) -
+                    (CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR) +
+                     static_cast<View>(in.get(C::instr_fetching_tag_out_of_range))));
+        std::get<5>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::instr_fetching_sel_parsing_err)) *
                    (FF(1) - static_cast<View>(in.get(C::instr_fetching_sel_parsing_err)));
-        std::get<3>(evals) += (tmp * scaling_factor);
+        std::get<6>(evals) += (tmp * scaling_factor);
     }
     { // PC_OUT_OF_RANGE_TOGGLE
-        using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_pc_abs_diff)) -
                     static_cast<View>(in.get(C::instr_fetching_sel)) *
                         (((FF(2) * static_cast<View>(in.get(C::instr_fetching_pc_out_of_range)) - FF(1)) *
@@ -55,43 +74,43 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                                static_cast<View>(in.get(C::instr_fetching_bytecode_size))) -
                           FF(1)) +
                          static_cast<View>(in.get(C::instr_fetching_pc_out_of_range))));
-        std::get<4>(evals) += (tmp * scaling_factor);
+        std::get<7>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::instr_fetching_sel)) *
             (static_cast<View>(in.get(C::instr_fetching_pc_size_in_bits)) - CView(constants_AVM_PC_SIZE_IN_BITS));
-        std::get<5>(evals) += (tmp * scaling_factor);
+        std::get<8>(evals) += (tmp * scaling_factor);
     }
     { // INSTR_OUT_OF_RANGE_TOGGLE
-        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_instr_abs_diff)) -
                     ((FF(2) * static_cast<View>(in.get(C::instr_fetching_instr_out_of_range)) - FF(1)) *
                          (static_cast<View>(in.get(C::instr_fetching_instr_size)) -
                           static_cast<View>(in.get(C::instr_fetching_bytes_to_read))) -
                      static_cast<View>(in.get(C::instr_fetching_instr_out_of_range))));
-        std::get<6>(evals) += (tmp * scaling_factor);
+        std::get<9>(evals) += (tmp * scaling_factor);
     }
     { // TAG_VALUE
-        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_tag_value)) -
                     ((static_cast<View>(in.get(C::instr_fetching_sel_has_tag)) -
                       static_cast<View>(in.get(C::instr_fetching_sel_tag_is_op2))) *
                          static_cast<View>(in.get(C::instr_fetching_op3)) +
                      static_cast<View>(in.get(C::instr_fetching_sel_tag_is_op2)) *
                          static_cast<View>(in.get(C::instr_fetching_op2))));
-        std::get<7>(evals) += (tmp * scaling_factor);
+        std::get<10>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_sel_pc_in_range)) -
                     static_cast<View>(in.get(C::instr_fetching_sel)) *
                         (FF(1) - static_cast<View>(in.get(C::instr_fetching_pc_out_of_range))));
-        std::get<8>(evals) += (tmp * scaling_factor);
+        std::get<11>(evals) += (tmp * scaling_factor);
     }
     { // INDIRECT_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
         auto tmp =
             (static_cast<View>(in.get(C::instr_fetching_indirect)) -
              (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
@@ -99,10 +118,10 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                       (static_cast<View>(in.get(C::instr_fetching_bd1)) * FF(256) +
                        static_cast<View>(in.get(C::instr_fetching_bd2)) * FF(1)) +
                   CView(instr_fetching_SEL_OP_DC_17) * static_cast<View>(in.get(C::instr_fetching_bd1)) * FF(1)));
-        std::get<9>(evals) += (tmp * scaling_factor);
+        std::get<12>(evals) += (tmp * scaling_factor);
     }
     { // OP1_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_op1)) -
                     (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
                         (static_cast<View>(in.get(C::instr_fetching_sel_op_dc_0)) *
@@ -118,10 +137,10 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                               static_cast<View>(in.get(C::instr_fetching_bd2)) * FF(65536) +
                               static_cast<View>(in.get(C::instr_fetching_bd3)) * FF(256) +
                               static_cast<View>(in.get(C::instr_fetching_bd4)) * FF(1))));
-        std::get<10>(evals) += (tmp * scaling_factor);
+        std::get<13>(evals) += (tmp * scaling_factor);
     }
     { // OP2_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_op2)) -
                     (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
                         (static_cast<View>(in.get(C::instr_fetching_sel_op_dc_0)) *
@@ -139,10 +158,10 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                               static_cast<View>(in.get(C::instr_fetching_bd5)) * FF(65536) +
                               static_cast<View>(in.get(C::instr_fetching_bd6)) * FF(256) +
                               static_cast<View>(in.get(C::instr_fetching_bd7)) * FF(1))));
-        std::get<11>(evals) += (tmp * scaling_factor);
+        std::get<14>(evals) += (tmp * scaling_factor);
     }
     { // OP3_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
         auto tmp =
             (static_cast<View>(in.get(C::instr_fetching_op3)) -
              (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
@@ -237,10 +256,10 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                        static_cast<View>(in.get(C::instr_fetching_bd6)) * FF(1)) +
                   static_cast<View>(in.get(C::instr_fetching_sel_op_dc_14)) *
                       static_cast<View>(in.get(C::instr_fetching_bd4)) * FF(1)));
-        std::get<12>(evals) += (tmp * scaling_factor);
+        std::get<15>(evals) += (tmp * scaling_factor);
     }
     { // OP4_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<13, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_op4)) -
                     (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
                         (static_cast<View>(in.get(C::instr_fetching_sel_op_dc_0)) *
@@ -249,10 +268,10 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                          static_cast<View>(in.get(C::instr_fetching_sel_op_dc_5)) *
                              (static_cast<View>(in.get(C::instr_fetching_bd8)) * FF(256) +
                               static_cast<View>(in.get(C::instr_fetching_bd9)) * FF(1))));
-        std::get<13>(evals) += (tmp * scaling_factor);
+        std::get<16>(evals) += (tmp * scaling_factor);
     }
     { // OP5_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_op5)) -
                     (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
                         (static_cast<View>(in.get(C::instr_fetching_sel_op_dc_0)) *
@@ -261,25 +280,25 @@ void instr_fetchingImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                          static_cast<View>(in.get(C::instr_fetching_sel_op_dc_5)) *
                              (static_cast<View>(in.get(C::instr_fetching_bd10)) * FF(256) +
                               static_cast<View>(in.get(C::instr_fetching_bd11)) * FF(1))));
-        std::get<14>(evals) += (tmp * scaling_factor);
+        std::get<17>(evals) += (tmp * scaling_factor);
     }
     { // OP6_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_op6)) -
                     (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
                         static_cast<View>(in.get(C::instr_fetching_sel_op_dc_1)) *
                         (static_cast<View>(in.get(C::instr_fetching_bd13)) * FF(256) +
                          static_cast<View>(in.get(C::instr_fetching_bd14)) * FF(1)));
-        std::get<15>(evals) += (tmp * scaling_factor);
+        std::get<18>(evals) += (tmp * scaling_factor);
     }
     { // OP7_BYTES_DECOMPOSITION
-        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::instr_fetching_op7)) -
                     (FF(1) - CView(instr_fetching_PARSING_ERROR_EXCEPT_TAG_ERROR)) *
                         static_cast<View>(in.get(C::instr_fetching_sel_op_dc_1)) *
                         (static_cast<View>(in.get(C::instr_fetching_bd15)) * FF(256) +
                          static_cast<View>(in.get(C::instr_fetching_bd16)) * FF(1)));
-        std::get<16>(evals) += (tmp * scaling_factor);
+        std::get<19>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory.hpp
index 8dd3d44c0d63..53f79ff832b6 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory.hpp
@@ -14,10 +14,10 @@ template <typename FF_> class keccak_memoryImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 46> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 4, 3, 5, 3, 4, 3,
-                                                                            3, 3, 3, 4, 3, 3, 3, 5, 3, 3, 3, 3,
-                                                                            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-                                                                            3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
+    static constexpr std::array<size_t, 45> SUBRELATION_PARTIAL_LENGTHS = {
+        3, 3, 3, 3, 3, 3, 4, 3, 5, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 5, 3, 3, 3,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
+    };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -45,6 +45,7 @@ template <typename FF> class keccak_memory : public Relation<keccak_memoryImpl<F
     static constexpr size_t SR_CTR_END = 8;
     static constexpr size_t SR_LAST = 9;
     static constexpr size_t SR_CTR_INCREMENT = 10;
+    static constexpr size_t SR_SINGLE_TAG_ERROR_BOOLEAN = 11;
     static constexpr size_t SR_NO_TAG_ERROR_ON_WRITE = 12;
     static constexpr size_t SR_TAG_ERROR_INIT = 13;
     static constexpr size_t SR_TAG_ERROR_PROPAGATION = 14;
@@ -53,31 +54,30 @@ template <typename FF> class keccak_memory : public Relation<keccak_memoryImpl<F
     static constexpr size_t SR_CLK_PROPAGATION = 17;
     static constexpr size_t SR_RW_PROPAGATION = 18;
     static constexpr size_t SR_SINGLE_TAG_ERROR = 19;
-    static constexpr size_t SR_SINGLE_TAG_ERROR_BOOLEAN = 20;
-    static constexpr size_t SR_VAL01 = 21;
-    static constexpr size_t SR_VAL02 = 22;
-    static constexpr size_t SR_VAL03 = 23;
-    static constexpr size_t SR_VAL04 = 24;
-    static constexpr size_t SR_VAL05 = 25;
-    static constexpr size_t SR_VAL06 = 26;
-    static constexpr size_t SR_VAL07 = 27;
-    static constexpr size_t SR_VAL8 = 28;
-    static constexpr size_t SR_VAL09 = 29;
-    static constexpr size_t SR_VAL10 = 30;
-    static constexpr size_t SR_VAL11 = 31;
-    static constexpr size_t SR_VAL12 = 32;
-    static constexpr size_t SR_VAL13 = 33;
-    static constexpr size_t SR_VAL14 = 34;
-    static constexpr size_t SR_VAL15 = 35;
-    static constexpr size_t SR_VAL41 = 36;
-    static constexpr size_t SR_VAL17 = 37;
-    static constexpr size_t SR_VAL18 = 38;
-    static constexpr size_t SR_VAL19 = 39;
-    static constexpr size_t SR_VAL20 = 40;
-    static constexpr size_t SR_VAL21 = 41;
-    static constexpr size_t SR_VAL22 = 42;
-    static constexpr size_t SR_VAL23 = 43;
-    static constexpr size_t SR_VAL24 = 44;
+    static constexpr size_t SR_VAL01 = 20;
+    static constexpr size_t SR_VAL02 = 21;
+    static constexpr size_t SR_VAL03 = 22;
+    static constexpr size_t SR_VAL04 = 23;
+    static constexpr size_t SR_VAL05 = 24;
+    static constexpr size_t SR_VAL06 = 25;
+    static constexpr size_t SR_VAL07 = 26;
+    static constexpr size_t SR_VAL8 = 27;
+    static constexpr size_t SR_VAL09 = 28;
+    static constexpr size_t SR_VAL10 = 29;
+    static constexpr size_t SR_VAL11 = 30;
+    static constexpr size_t SR_VAL12 = 31;
+    static constexpr size_t SR_VAL13 = 32;
+    static constexpr size_t SR_VAL14 = 33;
+    static constexpr size_t SR_VAL15 = 34;
+    static constexpr size_t SR_VAL41 = 35;
+    static constexpr size_t SR_VAL17 = 36;
+    static constexpr size_t SR_VAL18 = 37;
+    static constexpr size_t SR_VAL19 = 38;
+    static constexpr size_t SR_VAL20 = 39;
+    static constexpr size_t SR_VAL21 = 40;
+    static constexpr size_t SR_VAL22 = 41;
+    static constexpr size_t SR_VAL23 = 42;
+    static constexpr size_t SR_VAL24 = 43;
 
     static std::string get_subrelation_label(size_t index)
     {
@@ -96,6 +96,8 @@ template <typename FF> class keccak_memory : public Relation<keccak_memoryImpl<F
             return "LAST";
         case SR_CTR_INCREMENT:
             return "CTR_INCREMENT";
+        case SR_SINGLE_TAG_ERROR_BOOLEAN:
+            return "SINGLE_TAG_ERROR_BOOLEAN";
         case SR_NO_TAG_ERROR_ON_WRITE:
             return "NO_TAG_ERROR_ON_WRITE";
         case SR_TAG_ERROR_INIT:
@@ -112,8 +114,6 @@ template <typename FF> class keccak_memory : public Relation<keccak_memoryImpl<F
             return "RW_PROPAGATION";
         case SR_SINGLE_TAG_ERROR:
             return "SINGLE_TAG_ERROR";
-        case SR_SINGLE_TAG_ERROR_BOOLEAN:
-            return "SINGLE_TAG_ERROR_BOOLEAN";
         case SR_VAL01:
             return "VAL01";
         case SR_VAL02:
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory_impl.hpp
index cd8e3996cc74..56b0e1a11379 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/keccak_memory_impl.hpp
@@ -99,7 +99,7 @@ void keccak_memoryImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
              FF(1));
         std::get<10>(evals) += (tmp * scaling_factor);
     }
-    {
+    { // SINGLE_TAG_ERROR_BOOLEAN
         using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::keccak_memory_single_tag_error)) *
                    (FF(1) - static_cast<View>(in.get(C::keccak_memory_single_tag_error)));
@@ -164,186 +164,180 @@ void keccak_memoryImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                     static_cast<View>(in.get(C::keccak_memory_single_tag_error)));
         std::get<19>(evals) += (tmp * scaling_factor);
     }
-    { // SINGLE_TAG_ERROR_BOOLEAN
-        using View = typename std::tuple_element_t<20, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::keccak_memory_single_tag_error)) *
-                   (FF(1) - static_cast<View>(in.get(C::keccak_memory_single_tag_error)));
-        std::get<20>(evals) += (tmp * scaling_factor);
-    }
     { // VAL01
-        using View = typename std::tuple_element_t<21, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<20, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_1_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_0__shift)));
-        std::get<21>(evals) += (tmp * scaling_factor);
+        std::get<20>(evals) += (tmp * scaling_factor);
     }
     { // VAL02
-        using View = typename std::tuple_element_t<22, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<21, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_2_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_1__shift)));
-        std::get<22>(evals) += (tmp * scaling_factor);
+        std::get<21>(evals) += (tmp * scaling_factor);
     }
     { // VAL03
-        using View = typename std::tuple_element_t<23, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<22, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_3_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_2__shift)));
-        std::get<23>(evals) += (tmp * scaling_factor);
+        std::get<22>(evals) += (tmp * scaling_factor);
     }
     { // VAL04
-        using View = typename std::tuple_element_t<24, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<23, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_4_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_3__shift)));
-        std::get<24>(evals) += (tmp * scaling_factor);
+        std::get<23>(evals) += (tmp * scaling_factor);
     }
     { // VAL05
-        using View = typename std::tuple_element_t<25, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<24, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_5_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_4__shift)));
-        std::get<25>(evals) += (tmp * scaling_factor);
+        std::get<24>(evals) += (tmp * scaling_factor);
     }
     { // VAL06
-        using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<25, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_6_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_5__shift)));
-        std::get<26>(evals) += (tmp * scaling_factor);
+        std::get<25>(evals) += (tmp * scaling_factor);
     }
     { // VAL07
-        using View = typename std::tuple_element_t<27, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<26, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_7_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_6__shift)));
-        std::get<27>(evals) += (tmp * scaling_factor);
+        std::get<26>(evals) += (tmp * scaling_factor);
     }
     { // VAL8
-        using View = typename std::tuple_element_t<28, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<27, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_8_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_7__shift)));
-        std::get<28>(evals) += (tmp * scaling_factor);
+        std::get<27>(evals) += (tmp * scaling_factor);
     }
     { // VAL09
-        using View = typename std::tuple_element_t<29, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<28, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_9_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_8__shift)));
-        std::get<29>(evals) += (tmp * scaling_factor);
+        std::get<28>(evals) += (tmp * scaling_factor);
     }
     { // VAL10
-        using View = typename std::tuple_element_t<30, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<29, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_10_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_9__shift)));
-        std::get<30>(evals) += (tmp * scaling_factor);
+        std::get<29>(evals) += (tmp * scaling_factor);
     }
     { // VAL11
-        using View = typename std::tuple_element_t<31, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<30, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_11_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_10__shift)));
-        std::get<31>(evals) += (tmp * scaling_factor);
+        std::get<30>(evals) += (tmp * scaling_factor);
     }
     { // VAL12
-        using View = typename std::tuple_element_t<32, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<31, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_12_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_11__shift)));
-        std::get<32>(evals) += (tmp * scaling_factor);
+        std::get<31>(evals) += (tmp * scaling_factor);
     }
     { // VAL13
-        using View = typename std::tuple_element_t<33, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<32, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_13_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_12__shift)));
-        std::get<33>(evals) += (tmp * scaling_factor);
+        std::get<32>(evals) += (tmp * scaling_factor);
     }
     { // VAL14
-        using View = typename std::tuple_element_t<34, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<33, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_14_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_13__shift)));
-        std::get<34>(evals) += (tmp * scaling_factor);
+        std::get<33>(evals) += (tmp * scaling_factor);
     }
     { // VAL15
-        using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<34, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_15_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_14__shift)));
-        std::get<35>(evals) += (tmp * scaling_factor);
+        std::get<34>(evals) += (tmp * scaling_factor);
     }
     { // VAL41
-        using View = typename std::tuple_element_t<36, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<35, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_16_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_15__shift)));
-        std::get<36>(evals) += (tmp * scaling_factor);
+        std::get<35>(evals) += (tmp * scaling_factor);
     }
     { // VAL17
-        using View = typename std::tuple_element_t<37, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<36, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_17_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_16__shift)));
-        std::get<37>(evals) += (tmp * scaling_factor);
+        std::get<36>(evals) += (tmp * scaling_factor);
     }
     { // VAL18
-        using View = typename std::tuple_element_t<38, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<37, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_18_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_17__shift)));
-        std::get<38>(evals) += (tmp * scaling_factor);
+        std::get<37>(evals) += (tmp * scaling_factor);
     }
     { // VAL19
-        using View = typename std::tuple_element_t<39, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<38, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_19_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_18__shift)));
-        std::get<39>(evals) += (tmp * scaling_factor);
+        std::get<38>(evals) += (tmp * scaling_factor);
     }
     { // VAL20
-        using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<39, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_20_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_19__shift)));
-        std::get<40>(evals) += (tmp * scaling_factor);
+        std::get<39>(evals) += (tmp * scaling_factor);
     }
     { // VAL21
-        using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<40, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_21_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_20__shift)));
-        std::get<41>(evals) += (tmp * scaling_factor);
+        std::get<40>(evals) += (tmp * scaling_factor);
     }
     { // VAL22
-        using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<41, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_22_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_21__shift)));
-        std::get<42>(evals) += (tmp * scaling_factor);
+        std::get<41>(evals) += (tmp * scaling_factor);
     }
     { // VAL23
-        using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<42, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_23_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_22__shift)));
-        std::get<43>(evals) += (tmp * scaling_factor);
+        std::get<42>(evals) += (tmp * scaling_factor);
     }
     { // VAL24
-        using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<43, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::keccak_memory_val_24_)) -
                     (FF(1) - static_cast<View>(in.get(C::keccak_memory_last))) *
                         static_cast<View>(in.get(C::keccak_memory_val_23__shift)));
-        std::get<44>(evals) += (tmp * scaling_factor);
+        std::get<43>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<45, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<44, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::keccak_memory_sel)) *
             (static_cast<View>(in.get(C::keccak_memory_num_rounds)) - CView(constants_AVM_KECCAKF1600_NUM_ROUNDS));
-        std::get<45>(evals) += (tmp * scaling_factor);
+        std::get<44>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check.hpp
index c5e4736b4962..9b3b4b9ba43e 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check.hpp
@@ -14,7 +14,7 @@ template <typename FF_> class l1_to_l2_message_tree_checkImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 3> SUBRELATION_PARTIAL_LENGTHS = { 3, 5, 3 };
+    static constexpr std::array<size_t, 4> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 5, 3 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check_impl.hpp
index 170349441ef4..30def71be1c4 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/l1_to_l2_message_tree_check_impl.hpp
@@ -27,6 +27,12 @@ void l1_to_l2_message_tree_checkImpl<FF_>::accumulate(ContainerOverSubrelations&
     }
     {
         using View = typename std::tuple_element_t<1, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::l1_to_l2_message_tree_check_exists)) *
+                   (FF(1) - static_cast<View>(in.get(C::l1_to_l2_message_tree_check_exists)));
+        std::get<1>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::l1_to_l2_message_tree_check_sel)) *
                    ((CView(l1_to_l2_message_tree_check_LEAF_VALUE_MSG_HASH_DIFF) *
                          (static_cast<View>(in.get(C::l1_to_l2_message_tree_check_exists)) *
@@ -35,14 +41,14 @@ void l1_to_l2_message_tree_checkImpl<FF_>::accumulate(ContainerOverSubrelations&
                           static_cast<View>(in.get(C::l1_to_l2_message_tree_check_leaf_value_msg_hash_diff_inv))) -
                      FF(1)) +
                     static_cast<View>(in.get(C::l1_to_l2_message_tree_check_exists)));
-        std::get<1>(evals) += (tmp * scaling_factor);
+        std::get<2>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::l1_to_l2_message_tree_check_sel)) *
                    (CView(constants_L1_TO_L2_MSG_TREE_HEIGHT) -
                     static_cast<View>(in.get(C::l1_to_l2_message_tree_check_l1_to_l2_message_tree_height)));
-        std::get<2>(evals) += (tmp * scaling_factor);
+        std::get<3>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check.hpp
index c619c4c224dd..9fbb5c9455cc 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check.hpp
@@ -14,8 +14,8 @@ template <typename FF_> class note_hash_tree_checkImpl {
   public:
     using FF = FF_;
 
-    static constexpr std::array<size_t, 19> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 4, 3, 3,
-                                                                            4, 3, 3, 3, 5, 3, 3, 3, 3 };
+    static constexpr std::array<size_t, 20> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 3, 3, 3, 3, 3, 3, 4, 3,
+                                                                            3, 4, 3, 3, 3, 5, 3, 3, 3, 3 };
 
     template <typename AllEntities> inline static bool skip(const AllEntities& in)
     {
@@ -36,10 +36,10 @@ template <typename FF> class note_hash_tree_check : public Relation<note_hash_tr
     static constexpr const std::string_view NAME = "note_hash_tree_check";
 
     // Subrelation indices constants, to be used in tests.
-    static constexpr size_t SR_DISABLE_SILOING_ON_READ = 5;
-    static constexpr size_t SR_PASSTHROUGH_SILOING = 7;
-    static constexpr size_t SR_DISABLE_UNIQUENESS_ON_READ = 9;
-    static constexpr size_t SR_PASSTHROUGH_UNIQUENESS = 10;
+    static constexpr size_t SR_DISABLE_SILOING_ON_READ = 6;
+    static constexpr size_t SR_PASSTHROUGH_SILOING = 8;
+    static constexpr size_t SR_DISABLE_UNIQUENESS_ON_READ = 10;
+    static constexpr size_t SR_PASSTHROUGH_UNIQUENESS = 11;
 
     static std::string get_subrelation_label(size_t index)
     {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check_impl.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check_impl.hpp
index 6980ef0b7e76..a418072a2ebf 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/note_hash_tree_check_impl.hpp
@@ -39,84 +39,90 @@ void note_hash_tree_checkImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     }
     {
         using View = typename std::tuple_element_t<2, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_should_silo)) *
-                   (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_silo)));
+        auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_exists)) *
+                   (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_exists)));
         std::get<2>(evals) += (tmp * scaling_factor);
     }
     {
         using View = typename std::tuple_element_t<3, ContainerOverSubrelations>::View;
-        auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_should_unique)) *
-                   (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_unique)));
+        auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_should_silo)) *
+                   (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_silo)));
         std::get<3>(evals) += (tmp * scaling_factor);
     }
     {
         using View = typename std::tuple_element_t<4, ContainerOverSubrelations>::View;
+        auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_should_unique)) *
+                   (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_unique)));
+        std::get<4>(evals) += (tmp * scaling_factor);
+    }
+    {
+        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_write)) *
                    (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_sel)));
-        std::get<4>(evals) += (tmp * scaling_factor);
+        std::get<5>(evals) += (tmp * scaling_factor);
     }
     { // DISABLE_SILOING_ON_READ
-        using View = typename std::tuple_element_t<5, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
         auto tmp = CView(note_hash_tree_check_READ) * static_cast<View>(in.get(C::note_hash_tree_check_should_silo));
-        std::get<5>(evals) += (tmp * scaling_factor);
+        std::get<6>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<6, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_should_silo)) *
                    (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_unique)));
-        std::get<6>(evals) += (tmp * scaling_factor);
+        std::get<7>(evals) += (tmp * scaling_factor);
     }
     { // PASSTHROUGH_SILOING
-        using View = typename std::tuple_element_t<7, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_silo))) *
                    (static_cast<View>(in.get(C::note_hash_tree_check_note_hash)) -
                     static_cast<View>(in.get(C::note_hash_tree_check_siloed_note_hash)));
-        std::get<7>(evals) += (tmp * scaling_factor);
+        std::get<8>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<8, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_sel)) *
                    (CView(constants_DOM_SEP__SILOED_NOTE_HASH) -
                     static_cast<View>(in.get(C::note_hash_tree_check_siloing_separator)));
-        std::get<8>(evals) += (tmp * scaling_factor);
+        std::get<9>(evals) += (tmp * scaling_factor);
     }
     { // DISABLE_UNIQUENESS_ON_READ
-        using View = typename std::tuple_element_t<9, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
         auto tmp = CView(note_hash_tree_check_READ) * static_cast<View>(in.get(C::note_hash_tree_check_should_unique));
-        std::get<9>(evals) += (tmp * scaling_factor);
+        std::get<10>(evals) += (tmp * scaling_factor);
     }
     { // PASSTHROUGH_UNIQUENESS
-        using View = typename std::tuple_element_t<10, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_sel)) *
                    (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_should_unique))) *
                    (static_cast<View>(in.get(C::note_hash_tree_check_siloed_note_hash)) -
                     static_cast<View>(in.get(C::note_hash_tree_check_unique_note_hash)));
-        std::get<10>(evals) += (tmp * scaling_factor);
+        std::get<11>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<11, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<12, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_sel)) *
                    (CView(constants_AVM_PUBLIC_INPUTS_PREVIOUS_NON_REVERTIBLE_ACCUMULATED_DATA_NULLIFIERS_ROW_IDX) -
                     static_cast<View>(in.get(C::note_hash_tree_check_first_nullifier_pi_index)));
-        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<View>(in.get(C::note_hash_tree_check_sel)) *
                    (CView(constants_DOM_SEP__NOTE_HASH_NONCE) -
                     static_cast<View>(in.get(C::note_hash_tree_check_nonce_separator)));
-        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<View>(in.get(C::note_hash_tree_check_sel)) *
                    (CView(constants_DOM_SEP__UNIQUE_NOTE_HASH) -
                     static_cast<View>(in.get(C::note_hash_tree_check_unique_note_hash_separator)));
-        std::get<13>(evals) += (tmp * scaling_factor);
+        std::get<14>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<14, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
         auto tmp =
             static_cast<View>(in.get(C::note_hash_tree_check_sel)) *
             ((CView(note_hash_tree_check_PREV_LEAF_VALUE_UNIQUE_NOTE_HASH_DIFF) *
@@ -126,36 +132,36 @@ void note_hash_tree_checkImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                    static_cast<View>(in.get(C::note_hash_tree_check_prev_leaf_value_unique_note_hash_diff_inv))) -
               FF(1)) +
              static_cast<View>(in.get(C::note_hash_tree_check_exists)));
-        std::get<14>(evals) += (tmp * scaling_factor);
+        std::get<15>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<15, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_write)) *
                    (static_cast<View>(in.get(C::note_hash_tree_check_unique_note_hash)) -
                     static_cast<View>(in.get(C::note_hash_tree_check_next_leaf_value)));
-        std::get<15>(evals) += (tmp * scaling_factor);
+        std::get<16>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<16, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_sel)) *
                    (CView(constants_NOTE_HASH_TREE_HEIGHT) -
                     static_cast<View>(in.get(C::note_hash_tree_check_note_hash_tree_height)));
-        std::get<16>(evals) += (tmp * scaling_factor);
+        std::get<17>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<17, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
         auto tmp = (static_cast<View>(in.get(C::note_hash_tree_check_write)) *
                         (FF(1) - static_cast<View>(in.get(C::note_hash_tree_check_discard))) -
                     static_cast<View>(in.get(C::note_hash_tree_check_should_write_to_public_inputs)));
-        std::get<17>(evals) += (tmp * scaling_factor);
+        std::get<18>(evals) += (tmp * scaling_factor);
     }
     {
-        using View = typename std::tuple_element_t<18, ContainerOverSubrelations>::View;
+        using View = typename std::tuple_element_t<19, ContainerOverSubrelations>::View;
         auto tmp = static_cast<View>(in.get(C::note_hash_tree_check_should_write_to_public_inputs)) *
                    ((CView(constants_AVM_PUBLIC_INPUTS_AVM_ACCUMULATED_DATA_NOTE_HASHES_ROW_IDX) +
                      static_cast<View>(in.get(C::note_hash_tree_check_note_hash_index))) -
                     static_cast<View>(in.get(C::note_hash_tree_check_public_inputs_index)));
-        std::get<18>(evals) += (tmp * scaling_factor);
+        std::get<19>(evals) += (tmp * scaling_factor);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp
index bfa534eead0e..d9a216762e96 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp
@@ -44,7 +44,7 @@ AvmProvingHelper::VkData AvmProvingHelper::get_verification_key()
     auto verification_key =
         std::make_shared<AvmVerifier::VerificationKey>(constraining::AvmFixedVKCommitments::get_all());
 
-    info("AVM vk hash: ", verification_key->hash());
+    vinfo("AVM vk hash: ", verification_key->hash());
 
     auto serialized_vk = to_buffer(verification_key->to_field_elements());
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp
index d04f62891ad4..cc8b2298c546 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp
@@ -3,6 +3,7 @@
 #include <cassert>
 #include <vector>
 
+#include "barretenberg/common/assert.hpp"
 #include "barretenberg/vm2/common/set.hpp"
 
 namespace bb::avm2::simulation {
@@ -76,7 +77,7 @@ template <typename Event> class OneShotEventEmitter : public EventEmitterInterfa
     virtual ~OneShotEventEmitter() = default;
     void emit(Event&& event) override
     {
-        assert(!has_emitted);
+        BB_ASSERT(!has_emitted, "Event already emitted");
         has_emitted = true;
         this->event = event;
     }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/address_derivation.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/address_derivation.cpp
index 1f884d43ef98..07f3b9c778b0 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/address_derivation.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/address_derivation.cpp
@@ -37,7 +37,7 @@ void AddressDerivation::assert_derivation(const AztecAddress& address, const Con
     EmbeddedCurvePoint preaddress_public_key = ecc.scalar_mul(EmbeddedCurvePoint::one(), preaddress);
     EmbeddedCurvePoint address_point = ecc.add(preaddress_public_key, instance.public_keys.incoming_viewing_key);
 
-    assert(address == address_point.x());
+    BB_ASSERT_EQ(address, address_point.x(), "Address derivation mismatch");
 
     // Cache this derivation so we don't repeat it
     cached_derivations.insert(address);
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/addressing.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/addressing.cpp
index 78c8a6b61fae..5914c3072dc9 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/addressing.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/addressing.cpp
@@ -52,7 +52,7 @@ std::vector<Operand> Addressing::resolve(const Instruction& instruction, MemoryI
 
     // This represents either: (1) wrong info in the spec, or (2) a wrong witgen deserialization.
     // Therefore, it is not an error the circuit should be able to prove.
-    assert(spec.num_addresses <= instruction.operands.size());
+    BB_ASSERT_LTE(spec.num_addresses, instruction.operands.size(), "Spec num addresses out of bounds");
 
     // Check if there is any relative address.
     bool has_relative_address = false;
@@ -86,7 +86,9 @@ std::vector<Operand> Addressing::resolve(const Instruction& instruction, MemoryI
             // This should be guaranteed by instruction fetching and the wire format.
             // The operand must fit in a MemoryAddress but does not need to be of the right tag.
             // For instance, a 16-bit operand can be cast to a MemoryAddress and fit.
-            assert(FF(static_cast<MemoryAddress>(instruction.operands[i].as_ff())) == instruction.operands[i].as_ff());
+            // NOTE: Only asserting in debug builds because these convertions are in the hot path.
+            BB_ASSERT_DEBUG(FF(static_cast<MemoryAddress>(instruction.operands[i].as_ff())) ==
+                            instruction.operands[i].as_ff());
 
             // Guarantees at this point:
             // - original operand is a valid address IF interpreted as a MemoryAddress.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bitwise.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bitwise.cpp
index 39ae19b660d1..0c65b7577530 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bitwise.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bitwise.cpp
@@ -14,7 +14,7 @@ MemoryValue Bitwise::and_op(const MemoryValue& a, const MemoryValue& b)
         MemoryValue c = a & b;
         events.emit({ .operation = BitwiseOperation::AND, .a = a, .b = b, .res = static_cast<uint128_t>(c.as_ff()) });
         return c;
-    } catch (const std::exception& e) {
+    } catch (const TaggedValueException& e) {
         // We emit an event if we fail, but default the result to 0.
         events.emit({ .operation = BitwiseOperation::AND, .a = a, .b = b, .res = 0 });
         throw BitwiseException("AND, " + std::string(e.what()));
@@ -27,7 +27,7 @@ MemoryValue Bitwise::or_op(const MemoryValue& a, const MemoryValue& b)
         MemoryValue c = a | b;
         events.emit({ .operation = BitwiseOperation::OR, .a = a, .b = b, .res = static_cast<uint128_t>(c.as_ff()) });
         return c;
-    } catch (const std::exception& e) {
+    } catch (const TaggedValueException& e) {
         // We emit an event if we fail, but default the result to 0.
         events.emit({ .operation = BitwiseOperation::OR, .a = a, .b = b, .res = 0 });
         throw BitwiseException("OR, " + std::string(e.what()));
@@ -45,7 +45,7 @@ MemoryValue Bitwise::xor_op(const MemoryValue& a, const MemoryValue& b)
             .res = static_cast<uint128_t>(c.as_ff()),
         });
         return c;
-    } catch (const std::exception& e) {
+    } catch (const TaggedValueException& e) {
         // We emit an event if we fail, but default the result to 0.
         events.emit({ .operation = BitwiseOperation::XOR, .a = a, .b = b, .res = 0 });
         throw BitwiseException("XOR, " + std::string(e.what()));
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_hashing.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_hashing.cpp
index 57b1c006fba0..85acfd64dcba 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_hashing.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_hashing.cpp
@@ -19,10 +19,8 @@ void BytecodeHasher::assert_public_bytecode_commitment(const BytecodeId& bytecod
     inputs.insert(inputs.end(), bytecode_as_fields.begin(), bytecode_as_fields.end());
 
     FF hash = hasher.hash(inputs);
-    assert(hash == public_bytecode_commitment);
-    // To please the compiler.
-    (void)hash;
-    (void)public_bytecode_commitment;
+    // This will throw an unexpected exception if it fails.
+    BB_ASSERT_EQ(hash, public_bytecode_commitment, "Public bytecode commitment hash mismatch");
 
     events.emit({ .bytecode_id = bytecode_id,
                   .bytecode_length = bytecode_length_in_bytes,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.cpp
index 6aa2b3cea8b3..c23b95550a01 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.cpp
@@ -66,14 +66,14 @@ BytecodeId TxBytecodeManager::get_bytecode(const AztecAddress& address)
     std::optional<ContractClass> maybe_klass = contract_db.get_contract_class(current_class_id);
     // Note: we don't need to silo and check the class id because the deployer contract guarantees
     // that if a contract instance exists, the class has been registered.
-    assert(maybe_klass.has_value());
+    BB_ASSERT(maybe_klass.has_value(), "Contract class not found");
     auto& klass = maybe_klass.value();
     retrieval_event.contract_class = klass; // WARNING: this class has the whole bytecode.
 
     // Bytecode hashing and decomposition, deduplicated by bytecode_id (commitment)
     std::optional<FF> maybe_bytecode_commitment = contract_db.get_bytecode_commitment(current_class_id);
     // If we reach this point, class ID and instance both exist which means bytecode commitment must exist.
-    assert(maybe_bytecode_commitment.has_value());
+    BB_ASSERT(maybe_bytecode_commitment.has_value(), "Bytecode commitment not found");
     BytecodeId bytecode_id = maybe_bytecode_commitment.value();
     retrieval_event.bytecode_id = bytecode_id;
     debug("Bytecode for ", address, " successfully retrieved!");
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.hpp
index 62f9ae062800..539c174227ec 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/bytecode_manager.hpp
@@ -67,6 +67,8 @@ class TxBytecodeManager : public TxBytecodeManagerInterface {
     unordered_flat_map<BytecodeId, std::shared_ptr<std::vector<uint8_t>>> bytecodes;
 };
 
+// This implementation of BytecodeManagerInterface caches the bytecode id and bytecode pointer after the first
+// retrieval. Calls to read_instruction will not ask the TxBytecodeManager to retrieve the bytecode again.
 class BytecodeManager : public BytecodeManagerInterface {
   public:
     BytecodeManager(AztecAddress address, TxBytecodeManagerInterface& tx_bytecode_manager)
@@ -76,6 +78,8 @@ class BytecodeManager : public BytecodeManagerInterface {
 
     Instruction read_instruction(uint32_t pc) override
     {
+        // We only assert in debug mode because this is in the hot path of the execution.
+        BB_ASSERT_DEBUG(bytecode_id.has_value(), "Bytecode not retrieved before call to read_instruction");
         auto id = get_bytecode_id();
         return tx_bytecode_manager.read_instruction(id, bytecode_ptr, pc);
     }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.cpp
index d5d9d0dfe2e5..27df179d99f0 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.cpp
@@ -6,7 +6,7 @@
 
 namespace bb::avm2::simulation {
 
-FF CalldataHasher::compute_calldata_hash(std::span<const FF> calldata)
+void CalldataHasher::assert_calldata_hash(const FF& cd_hash, std::span<const FF> calldata)
 {
     // todo(ilyas): this probably simulates faster at the cost of re-work in tracegen
     std::vector<FF> calldata_with_sep = { DOM_SEP__PUBLIC_CALLDATA };
@@ -14,13 +14,13 @@ FF CalldataHasher::compute_calldata_hash(std::span<const FF> calldata)
         // Note: Using `insert` breaks GCC.
         calldata_with_sep.push_back(value);
     }
-    FF output_hash = hasher.hash(calldata_with_sep);
+    FF computed_hash = hasher.hash(calldata_with_sep);
+    BB_ASSERT_EQ(computed_hash, cd_hash);
 
     events.emit({
         .context_id = context_id,
         .calldata = { calldata.begin(), calldata.end() },
     });
-    return output_hash;
 }
 
 } // namespace bb::avm2::simulation
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.hpp
index c736c65f82ab..b2d6600d218d 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.hpp
@@ -18,7 +18,7 @@ class CalldataHasher : public CalldataHashingInterface {
         , hasher(hasher)
     {}
 
-    FF compute_calldata_hash(std::span<const FF> calldata) override;
+    void assert_calldata_hash(const FF& cd_hash, std::span<const FF> calldata) override;
 
   private:
     uint32_t context_id;
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.test.cpp
index 085735096685..1a8eabbfc7d4 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/calldata_hashing.test.cpp
@@ -59,9 +59,8 @@ TEST_F(CalldataHashingTest, SimpleHash)
 
     EXPECT_CALL(poseidon2, hash(prepended_calldata_fields)).WillOnce(Return(hash));
 
-    auto output_hash = calldata_hasher.compute_calldata_hash(calldata_fields);
+    calldata_hasher.assert_calldata_hash(hash, calldata_fields);
 
-    EXPECT_EQ(output_hash, hash);
     EXPECT_THAT(
         calldata_events.dump_events(),
         AllOf(SizeIs(1),
@@ -77,7 +76,7 @@ TEST_F(CalldataHashingTest, Hash)
     auto hash = RawPoseidon2::hash(prepended_calldata_fields);
     EXPECT_CALL(poseidon2, hash(prepended_calldata_fields)).WillOnce(Return(hash));
 
-    calldata_hasher.compute_calldata_hash(calldata);
+    calldata_hasher.assert_calldata_hash(hash, calldata);
     EXPECT_THAT(
         calldata_events.dump_events(),
         AllOf(SizeIs(1),
@@ -93,7 +92,7 @@ TEST_F(CalldataHashingTest, Empty)
     auto hash = RawPoseidon2::hash(prepended_calldata_fields);
     EXPECT_CALL(poseidon2, hash(prepended_calldata_fields)).WillOnce(Return(hash));
 
-    calldata_hasher.compute_calldata_hash(calldata);
+    calldata_hasher.assert_calldata_hash(hash, calldata);
     EXPECT_THAT(
         calldata_events.dump_events(),
         AllOf(SizeIs(1),
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/class_id_derivation.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/class_id_derivation.cpp
index 0a11015d5724..723e929796be 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/class_id_derivation.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/class_id_derivation.cpp
@@ -21,8 +21,8 @@ void ClassIdDerivation::assert_derivation(const ContractClassWithCommitment& kla
                                             klass.artifact_hash,
                                             klass.private_functions_root,
                                             klass.public_bytecode_commitment });
-    (void)computed_class_id; // Silence unused variable warning when assert is stripped out
-    assert(computed_class_id == klass.id);
+    // This will throw an unexpected exception if it fails.
+    BB_ASSERT_EQ(computed_class_id, klass.id, "Computed class ID mismatch");
 
     // Cache this derivation so we don't repeat it
     cached_derivations.insert(klass.id);
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 122240ff2b74..da800d186eb4 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/concrete_dbs.cpp
@@ -37,7 +37,7 @@ std::optional<ContractClass> ContractDB::get_contract_class(const ContractClassI
     // Get the bytecode commitment for this class.
     std::optional<FF> maybe_bytecode_commitment = raw_contract_db.get_bytecode_commitment(class_id);
     // If the class exists, the bytecode commitment must also exist.
-    assert(maybe_bytecode_commitment.has_value());
+    BB_ASSERT(maybe_bytecode_commitment.has_value(), "Bytecode commitment not found");
 
     // Perform class ID derivation to verify the class ID is correctly derived from the class data.
     class_id_derivation.assert_derivation(maybe_klass->with_commitment(maybe_bytecode_commitment.value()));
@@ -115,9 +115,9 @@ void MerkleDB::storage_write(const AztecAddress& contract_address,
                                                                          insertion_hint.path,
                                                                          is_protocol_write);
 
-    (void)snapshot_after; // Silence unused variable warning when assert is stripped out
-    // Sanity check.
-    assert(snapshot_after == raw_merkle_db.get_tree_roots().public_data_tree);
+    // This will throw an unexpected exception if it fails.
+    BB_ASSERT_EQ(snapshot_after, raw_merkle_db.get_tree_roots().public_data_tree, "Snapshot after mismatch");
+
     if (!is_protocol_write) {
         written_public_data_slots.insert(contract_address, slot);
     }
@@ -209,9 +209,8 @@ void MerkleDB::nullifier_write_internal(std::optional<AztecAddress> contract_add
                                                                        snapshot_before,
                                                                        insertion_path);
 
-    (void)snapshot_after; // Silence unused variable warning when assert is stripped out
-    // Sanity check.
-    assert(snapshot_after == raw_merkle_db.get_tree_roots().nullifier_tree);
+    // 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");
 
     if (!present) {
         tree_counters_stack.top().nullifier_counter++;
@@ -245,9 +244,8 @@ void MerkleDB::note_hash_write(const AztecAddress& contract_address, const FF& n
     AppendOnlyTreeSnapshot snapshot_after =
         note_hash_tree_check.append_note_hash(note_hash, contract_address, note_hash_counter, path, snapshot_before);
 
-    (void)snapshot_after; // Silence unused variable warning when assert is stripped out
-    // Sanity check.
-    assert(snapshot_after == raw_merkle_db.get_tree_roots().note_hash_tree);
+    // This will throw an unexpected exception if it fails.
+    BB_ASSERT_EQ(snapshot_after, raw_merkle_db.get_tree_roots().note_hash_tree, "Snapshot after mismatch");
 
     tree_counters_stack.top().note_hash_counter++;
 }
@@ -267,9 +265,8 @@ void MerkleDB::siloed_note_hash_write(const FF& siloed_note_hash)
     AppendOnlyTreeSnapshot snapshot_after =
         note_hash_tree_check.append_siloed_note_hash(siloed_note_hash, note_hash_counter, path, snapshot_before);
 
-    (void)snapshot_after; // Silence unused variable warning when assert is stripped out
-    // Sanity check.
-    assert(snapshot_after == raw_merkle_db.get_tree_roots().note_hash_tree);
+    // This will throw an unexpected exception if it fails.
+    BB_ASSERT_EQ(snapshot_after, raw_merkle_db.get_tree_roots().note_hash_tree, "Snapshot after mismatch");
 
     tree_counters_stack.top().note_hash_counter++;
 }
@@ -285,9 +282,8 @@ void MerkleDB::unique_note_hash_write(const FF& unique_note_hash)
     AppendOnlyTreeSnapshot snapshot_after =
         note_hash_tree_check.append_unique_note_hash(unique_note_hash, note_hash_counter, path, snapshot_before);
 
-    (void)snapshot_after; // Silence unused variable warning when assert is stripped out
-    // Sanity check.
-    assert(snapshot_after == raw_merkle_db.get_tree_roots().note_hash_tree);
+    // This will throw an unexpected exception if it fails.
+    BB_ASSERT_EQ(snapshot_after, raw_merkle_db.get_tree_roots().note_hash_tree, "Snapshot after mismatch");
 
     tree_counters_stack.top().note_hash_counter++;
 }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.cpp
index b85afae231b7..bc567a5fc6ed 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.cpp
@@ -18,7 +18,7 @@ std::unique_ptr<ContextInterface> ContextProvider::make_nested_context(AztecAddr
     merkle_db.create_checkpoint(); // Fork DB just like in TS.
     uint32_t context_id = next_context_id++;
     // Memory assumes that the space id is <= 16 bits.
-    assert(context_id <= std::numeric_limits<uint16_t>::max());
+    BB_ASSERT_LTE(context_id, std::numeric_limits<uint16_t>::max(), "Context ID out of bounds");
     uint16_t space_id = static_cast<uint16_t>(context_id);
     return std::make_unique<NestedContext>(
         context_id,
@@ -45,6 +45,7 @@ std::unique_ptr<ContextInterface> ContextProvider::make_enqueued_context(AztecAd
                                                                          AztecAddress msg_sender,
                                                                          FF transaction_fee,
                                                                          std::span<const FF> calldata,
+                                                                         const FF& calldata_hash,
                                                                          bool is_static,
                                                                          Gas gas_limit,
                                                                          Gas gas_used,
@@ -53,10 +54,10 @@ std::unique_ptr<ContextInterface> ContextProvider::make_enqueued_context(AztecAd
 
     uint32_t context_id = next_context_id++;
     // Memory assumes that the space id is <= 16 bits.
-    assert(context_id <= std::numeric_limits<uint16_t>::max());
+    BB_ASSERT_LTE(context_id, std::numeric_limits<uint16_t>::max(), "Context ID out of bounds");
     uint16_t space_id = static_cast<uint16_t>(context_id);
 
-    cd_hash_provider.make_calldata_hasher(context_id)->compute_calldata_hash(calldata);
+    cd_hash_provider.make_calldata_hasher(context_id)->assert_calldata_hash(calldata_hash, calldata);
 
     return std::make_unique<EnqueuedCallContext>(
         context_id,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.hpp
index b581d53c508d..d471322c1a38 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/context_provider.hpp
@@ -48,6 +48,7 @@ class ContextProvider : public ContextProviderInterface {
                                                             AztecAddress msg_sender,
                                                             FF transaction_fee,
                                                             std::span<const FF> calldata,
+                                                            const FF& calldata_hash,
                                                             bool is_static,
                                                             Gas gas_limit,
                                                             Gas gas_used,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/contract_instance_manager.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/contract_instance_manager.cpp
index 137f408b55aa..493300e926bf 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/contract_instance_manager.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/contract_instance_manager.cpp
@@ -1,5 +1,6 @@
 #include "barretenberg/vm2/simulation/gadgets/contract_instance_manager.hpp"
 
+#include "barretenberg/common/assert.hpp"
 #include "barretenberg/vm2/common/aztec_constants.hpp"
 #include "barretenberg/vm2/simulation/interfaces/field_gt.hpp"
 
@@ -50,8 +51,9 @@ std::optional<ContractInstance> ContractInstanceManager::get_contract_instance(c
         std::optional<AztecAddress> derived_address = get_derived_address(protocol_contracts, contract_address);
 
         // Sanity check: if we found a derived address, we should also have the instance, and vice versa.
-        assert(derived_address.has_value() == maybe_instance.has_value() &&
-               "Derived address should be found if the instance was retrieved and vice versa");
+        BB_ASSERT_EQ(derived_address.has_value(),
+                     maybe_instance.has_value(),
+                     "Derived address should be found if the instance was retrieved and vice versa");
 
         event_emitter.emit({
             .address = contract_address,
@@ -78,7 +80,7 @@ std::optional<ContractInstance> ContractInstanceManager::get_contract_instance(c
         return std::nullopt;
     }
 
-    assert(maybe_instance.has_value() && "Contract instance should be found if nullifier exists");
+    BB_ASSERT(maybe_instance.has_value(), "Contract instance should be found if nullifier exists");
     const ContractInstance& instance = maybe_instance.value();
 
     // Validate that the contract instance is the latest if there have been any updates.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/ecc.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/ecc.cpp
index 68e6352f0252..c382f84558fe 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/ecc.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/ecc.cpp
@@ -6,14 +6,23 @@
 
 namespace bb::avm2::simulation {
 
+namespace {
+
+class InternalEccException : public std::runtime_error {
+  public:
+    using std::runtime_error::runtime_error; // Inherit the constructor.
+};
+
+} // namespace
+
 // This function assumes that the points p and q are on the curve. You should only
 // use this function internally if you can guarantee this. Otherwise it is called
 // via the opcode ECADD, see the overloaded function Ecc::add (which performs the curve check)
 EmbeddedCurvePoint Ecc::add(const EmbeddedCurvePoint& p, const EmbeddedCurvePoint& q)
 {
-    // Check if points are on the curve.
-    assert(p.on_curve() && "Point p is not on the curve");
-    assert(q.on_curve() && "Point q is not on the curve");
+    // Check if points are on the curve. These will throw an unexpected exception if they fail.
+    BB_ASSERT(p.on_curve(), "Point p is not on the curve");
+    BB_ASSERT(q.on_curve(), "Point q is not on the curve");
 
     EmbeddedCurvePoint result = p + q;
     add_events.emit({ .p = p, .q = q, .result = result });
@@ -25,6 +34,7 @@ EmbeddedCurvePoint Ecc::add(const EmbeddedCurvePoint& p, const EmbeddedCurvePoin
 EmbeddedCurvePoint Ecc::scalar_mul(const EmbeddedCurvePoint& point, const FF& scalar)
 {
     // This is bad - the scalar mul circuit assumes that the point is on the curve.
+    // This will throw an unexpected exception if it fails.
     BB_ASSERT(point.on_curve(), "Point must be on the curve for scalar multiplication");
 
     auto intermediate_states = std::vector<ScalarMulIntermediateState>(254);
@@ -66,14 +76,15 @@ void Ecc::add(MemoryInterface& memory,
         // Therefore, the maximum address that needs to be written to is dst_address + 2.
         uint64_t max_write_address = static_cast<uint64_t>(dst_address) + 2;
         if (gt.gt(max_write_address, AVM_HIGHEST_MEM_ADDRESS)) {
-            throw std::runtime_error("dst address out of range");
+            throw InternalEccException("dst address out of range");
         }
 
         if (!p.on_curve() || !q.on_curve()) {
-            throw std::runtime_error("One of the points is not on the curve");
+            throw InternalEccException("One of the points is not on the curve");
         }
 
-        EmbeddedCurvePoint result = add(p, q);
+        EmbeddedCurvePoint result = add(p, q); // Cannot throw.
+
         memory.set(dst_address, MemoryValue::from<FF>(result.x()));
         memory.set(dst_address + 1, MemoryValue::from<FF>(result.y()));
         memory.set(dst_address + 2, MemoryValue::from<uint1_t>(result.is_infinity() ? 1 : 0));
@@ -84,7 +95,7 @@ void Ecc::add(MemoryInterface& memory,
                                  .q = q,
                                  .result = result,
                                  .dst_address = dst_address });
-    } catch (const std::exception& e) {
+    } catch (const InternalEccException& e) {
         // Note this point is not on the curve, but corresponds
         // to default values the circuit will assign.
         EmbeddedCurvePoint res = EmbeddedCurvePoint(0, 0, false);
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/execution.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/execution.cpp
index 6d918fccb358..480f2ff73438 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/execution.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/execution.cpp
@@ -1328,9 +1328,10 @@ void Execution::get_contract_instance(ContextInterface& context,
 
     // Execution can still handle address memory read and tag checking
     const auto& address_value = memory.get(address_offset);
-    AztecAddress contract_address = address_value.as<AztecAddress>();
     set_and_validate_inputs(opcode, { address_value });
 
+    AztecAddress contract_address = address_value.as<AztecAddress>();
+
     get_gas_tracker().consume_gas();
 
     // Call the dedicated opcode component to get the contract instance, validate the enum,
@@ -1809,8 +1810,8 @@ EnqueuedCallResult Execution::execute(std::unique_ptr<ContextInterface> enqueued
         } catch (const std::exception& e) {
             // This is a coding error, we should not get here.
             // All exceptions should fall in the above catch blocks.
-            info("An unhandled exception occurred: ", e.what());
-            throw e;
+            important("An unhandled exception occurred: ", e.what());
+            throw;
         }
 
         // We always do what follows. "Finally".
@@ -2139,7 +2140,8 @@ inline void Execution::call_with_operands(void (Execution::*f)(ContextInterface&
                                           ContextInterface& context,
                                           const std::vector<Operand>& resolved_operands)
 {
-    assert(resolved_operands.size() == sizeof...(Ts));
+    // NOTE: Only asserting in debug builds because these convertions are in the hot path.
+    BB_ASSERT_DEBUG(resolved_operands.size() == sizeof...(Ts), "Resolved operands size mismatch");
     auto operand_indices = std::make_index_sequence<sizeof...(Ts)>{};
     [f, this, &context, &resolved_operands]<std::size_t... Is>(std::index_sequence<Is...>) {
         (this->*f)(context, resolved_operands.at(Is).to<std::decay_t<Ts>>()...);
@@ -2156,7 +2158,8 @@ inline void Execution::call_with_operands(void (Execution::*f)(ContextInterface&
 void Execution::set_and_validate_inputs(ExecutionOpCode opcode, const std::vector<MemoryValue>& inputs)
 {
     const auto& register_info = instruction_info_db.get(opcode).register_info;
-    assert(inputs.size() == register_info.num_inputs());
+    // NOTE: Only asserting in debug builds because these convertions are in the hot path.
+    BB_ASSERT_DEBUG(inputs.size() == register_info.num_inputs(), "Inputs size mismatch");
     this->inputs = inputs;
     for (size_t i = 0; i < register_info.num_inputs(); i++) {
         if (register_info.expected_tag(i) && register_info.expected_tag(i) != this->inputs.at(i).get_tag()) {
@@ -2179,8 +2182,8 @@ void Execution::set_and_validate_inputs(ExecutionOpCode opcode, const std::vecto
 void Execution::set_output(ExecutionOpCode opcode, const MemoryValue& output)
 {
     const auto& register_info = instruction_info_db.get(opcode).register_info;
-    (void)register_info; // To please GCC.
-    assert(register_info.num_outputs() == 1);
+    // NOTE: Only asserting in debug builds because these convertions are in the hot path.
+    BB_ASSERT_DEBUG(register_info.num_outputs() == 1, "Outputs size mismatch");
     this->output = output;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/gas_tracker.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/gas_tracker.cpp
index 118ded3601fb..93c386cdce2e 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/gas_tracker.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/gas_tracker.cpp
@@ -24,8 +24,8 @@ struct IntermediateGas {
 
     Gas to_gas() const
     {
-        assert(l2_gas <= std::numeric_limits<uint32_t>::max());
-        assert(da_gas <= std::numeric_limits<uint32_t>::max());
+        BB_ASSERT_LTE(l2_gas, std::numeric_limits<uint32_t>::max(), "L2 gas out of bounds");
+        BB_ASSERT_LTE(da_gas, std::numeric_limits<uint32_t>::max(), "DA gas out of bounds");
         return Gas{ .l2_gas = static_cast<uint32_t>(l2_gas), .da_gas = static_cast<uint32_t>(da_gas) };
     }
 };
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/keccakf1600.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/keccakf1600.cpp
index 32b8cce7c535..2284eb12176c 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/keccakf1600.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/keccakf1600.cpp
@@ -24,7 +24,7 @@ MemoryValue unconstrained_rotate_left(MemoryValue x, uint8_t len)
     }
 
     const auto x_uint64_t = x.as<uint64_t>();
-    assert(len < 64);
+    BB_ASSERT_LT(len, 64, "Length out of bounds");
     const auto out_uint64_t = (x_uint64_t << len) | x_uint64_t >> (64 - len);
     return MemoryValue::from(out_uint64_t);
 }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/merkle_check.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/merkle_check.cpp
index 8068239f77ed..37b8ed79c06e 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/merkle_check.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/merkle_check.cpp
@@ -25,7 +25,7 @@ void MerkleCheck::assert_membership(const FF& leaf_value,
                                     const FF& root)
 {
     // Gadget breaks if tree_height > 64 (leaf_index is of type uint64_t)
-    assert(sibling_path.size() <= 64 && "Merkle path length must be less than or equal to 64");
+    BB_ASSERT_LTE(sibling_path.size(), static_cast<size_t>(64), "Merkle path length must be less than or equal to 64");
 
     FF curr_value = leaf_value;
     uint64_t curr_index = leaf_index;
@@ -77,7 +77,7 @@ FF MerkleCheck::write(const FF& current_value,
                       const FF& current_root)
 {
     // Gadget breaks if tree_height > 64 (leaf_index is of type uint64_t)
-    assert(sibling_path.size() <= 64 && "Merkle path length must be less than or equal to 64");
+    BB_ASSERT_LTE(sibling_path.size(), static_cast<size_t>(64), "Merkle path length must be less than or equal to 64");
 
     FF read_value = current_value;
     FF write_value = new_value;
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/poseidon2.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/poseidon2.cpp
index e85469a22296..2c4c0dc773ed 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/poseidon2.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/poseidon2.cpp
@@ -14,6 +14,14 @@ using bb::crypto::Poseidon2Permutation;
 
 namespace bb::avm2::simulation {
 
+namespace {
+
+class InternalPoseidon2Exception : public std::runtime_error {
+    using std::runtime_error::runtime_error; // Inherit the constructor.
+};
+
+} // namespace
+
 FF Poseidon2::hash(const std::vector<FF>& input)
 {
     size_t input_size = input.size();
@@ -77,7 +85,7 @@ void Poseidon2::permutation(MemoryInterface& memory, MemoryAddress src_address,
 
     try {
         if (read_out_of_range || write_out_of_range) {
-            throw std::runtime_error("src or dst address out of range");
+            throw InternalPoseidon2Exception("src or dst address out of range");
         }
 
         // Read 4 elements from memory starting at src_address
@@ -89,7 +97,7 @@ void Poseidon2::permutation(MemoryInterface& memory, MemoryAddress src_address,
         // are loaded as the circuit expects reading and tagging checking to be different temporality groups
         if (std::ranges::any_of(
                 input.begin(), input.end(), [](const MemoryValue& val) { return val.get_tag() != MemoryTag::FF; })) {
-            throw std::runtime_error("An input tag is not FF");
+            throw InternalPoseidon2Exception("An input tag is not FF");
         }
 
         // This calls the Poseidon2 gadget permutation function and so generates events
@@ -111,7 +119,7 @@ void Poseidon2::permutation(MemoryInterface& memory, MemoryAddress src_address,
                                .input = input,
                                .output = output });
 
-    } catch (const std::exception& e) {
+    } catch (const InternalPoseidon2Exception& e) {
         perm_mem_events.emit({ .space_id = space_id,
                                .execution_clk = execution_clk,
                                .src_address = src_address,
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 5217b3121c88..884c90ceecf2 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,5 +1,6 @@
 #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"
 
@@ -88,7 +89,8 @@ void RetrievedBytecodesTreeCheck::insert(const FF& class_id)
             .root = write_root,
             .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1,
         };
-        assert(next_snapshot == tree.get_snapshot());
+        // 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,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/sha256.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/sha256.cpp
index a9bcb1203ae8..a073e43def9f 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/sha256.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/sha256.cpp
@@ -37,8 +37,7 @@ MemoryValue Sha256::ror(const MemoryValue& x, uint8_t shift)
 
     // Do this outside of an assert, in case this gets built without assert
     bool lo_in_range = gt.gt(static_cast<uint32_t>(1) << shift, lo); // Ensure the lower bits are in range
-    (void)lo_in_range;                                               // To please GCC.
-    assert(lo_in_range && "Low Value in ROR out of range");
+    BB_ASSERT(lo_in_range, "Low Value in ROR out of range");
     return MemoryValue::from<uint32_t>(result);
 }
 
@@ -52,8 +51,7 @@ MemoryValue Sha256::shr(const MemoryValue& x, uint8_t shift)
 
     // Do this outside of an assert, in case this gets built without assert
     bool lo_in_range = gt.gt(static_cast<uint32_t>(1) << shift, lo); // Ensure the lower bits are in range
-    (void)lo_in_range;                                               // To please GCC.
-    assert(lo_in_range && "Low Value in SHR out of range");
+    BB_ASSERT(lo_in_range, "Low Value in SHR out of range");
 
     return MemoryValue::from<uint32_t>(hi);
 }
@@ -74,9 +72,7 @@ MemoryValue Sha256::modulo_sum(std::span<const MemoryValue> values)
         gt.gt(static_cast<uint64_t>(1) << 32, static_cast<uint64_t>(lo)); // Ensure the lower bits are in range
     bool hi_in_range =
         gt.gt(static_cast<uint64_t>(1) << 32, static_cast<uint64_t>(hi)); // Ensure the upper bits are in range
-    (void)lo_in_range;                                                    // To please GCC.
-    (void)hi_in_range;                                                    // To please GCC.
-    assert(lo_in_range && hi_in_range && "Sum in MODULO_SUM out of range");
+    BB_ASSERT(lo_in_range && hi_in_range, "Sum in MODULO_SUM out of range");
     return MemoryValue::from<uint32_t>(lo);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/tx_execution.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/tx_execution.cpp
index 230989cb7b96..12a5883dfd37 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/tx_execution.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/gadgets/tx_execution.cpp
@@ -107,6 +107,7 @@ TxExecutionResult TxExecution::simulate(const Tx& tx)
                                                                   call.request.msg_sender,
                                                                   /*transaction_fee=*/FF(0),
                                                                   call.calldata,
+                                                                  call.request.calldata_hash,
                                                                   call.request.is_static_call,
                                                                   gas_limit,
                                                                   start_gas,
@@ -166,6 +167,7 @@ TxExecutionResult TxExecution::simulate(const Tx& tx)
                                                                       call.request.msg_sender,
                                                                       /*transaction_fee=*/FF(0),
                                                                       call.calldata,
+                                                                      call.request.calldata_hash,
                                                                       call.request.is_static_call,
                                                                       gas_limit,
                                                                       start_gas,
@@ -229,6 +231,7 @@ TxExecutionResult TxExecution::simulate(const Tx& tx)
                                                                   teardown_enqueued_call.request.msg_sender,
                                                                   fee,
                                                                   teardown_enqueued_call.calldata,
+                                                                  teardown_enqueued_call.request.calldata_hash,
                                                                   teardown_enqueued_call.request.is_static_call,
                                                                   teardown_gas_limit,
                                                                   start_gas,
@@ -255,7 +258,8 @@ TxExecutionResult TxExecution::simulate(const Tx& tx)
         merkle_db.commit_checkpoint();
         contract_db.commit_checkpoint();
     } catch (const TxExecutionException& e) {
-        info("Teardown failure while simulating tx ", tx.hash, ": ", e.what());
+        // TODO(fcarreiro): move these back to important log once/if we have log levels properly set up.
+        vinfo("Teardown failure while simulating tx ", tx.hash, ": ", e.what());
         tx_context.revert_code = tx_context.revert_code == RevertCode::APP_LOGIC_REVERTED
                                      ? RevertCode::BOTH_REVERTED
                                      : RevertCode::TEARDOWN_REVERTED;
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 54aa43986da4..0c5096aa6949 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,5 +1,6 @@
 #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/simulation/lib/merkle.hpp"
 
@@ -99,7 +100,8 @@ void WrittenPublicDataSlotsTreeCheck::insert(const AztecAddress& contract_addres
             .root = write_root,
             .next_available_leaf_index = prev_snapshot.next_available_leaf_index + 1,
         };
-        assert(next_snapshot == tree.get_snapshot());
+        // 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,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/bytecode_manager.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/bytecode_manager.hpp
index 3ad3ad8749f0..1e6e60f70e40 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/bytecode_manager.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/bytecode_manager.hpp
@@ -21,7 +21,9 @@ class TxBytecodeManagerInterface {
     virtual BytecodeId get_bytecode(const AztecAddress& address) = 0;
     virtual std::shared_ptr<std::vector<uint8_t>> get_bytecode_data(const BytecodeId& bytecode_id) = 0;
     // Retrieves an instruction and decomposes it if needed.
+    // This version of read_instruction might retrieve the bytecode (and generate an event) if not already done.
     virtual Instruction read_instruction(const BytecodeId& bytecode_id, uint32_t pc) = 0;
+    // This version of read_instruction does not retrieve the bytecode.
     virtual Instruction read_instruction(const BytecodeId& bytecode_id,
                                          std::shared_ptr<std::vector<uint8_t>> bytecode_ptr,
                                          uint32_t pc) = 0;
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/calldata_hashing.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/calldata_hashing.hpp
index ca67b85ef4a2..b5487e2cf39f 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/calldata_hashing.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/calldata_hashing.hpp
@@ -11,7 +11,7 @@ namespace bb::avm2::simulation {
 class CalldataHashingInterface {
   public:
     virtual ~CalldataHashingInterface() = default;
-    virtual FF compute_calldata_hash(std::span<const FF> calldata) = 0;
+    virtual void assert_calldata_hash(const FF& cd_hash, std::span<const FF> calldata) = 0;
 };
 
 class CalldataHashingProviderInterface {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context.hpp
index e77c7837e9db..81c3a60e96e7 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context.hpp
@@ -48,6 +48,7 @@ class ContextInterface {
 
     virtual TransactionPhase get_phase() const = 0;
 
+    // Should not throw.
     virtual std::vector<MemoryValue> get_calldata(uint32_t cd_offset, uint32_t cd_size) const = 0;
     virtual std::vector<MemoryValue> get_returndata(uint32_t rd_addr, uint32_t rd_size) const = 0;
     virtual ContextInterface& get_child_context() = 0;
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context_provider.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context_provider.hpp
index 0d0729015c71..0464425f4567 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context_provider.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/interfaces/context_provider.hpp
@@ -30,6 +30,7 @@ class ContextProviderInterface {
                                                                     AztecAddress msg_sender,
                                                                     FF transaction_fee,
                                                                     std::span<const FF> calldata,
+                                                                    const FF& calldata_hash,
                                                                     bool is_static,
                                                                     Gas gas_limit,
                                                                     Gas gas_used,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.cpp
index 89e433ff8fb9..cd9f5fc4d816 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.cpp
@@ -31,7 +31,7 @@ void CallStackMetadataCollector::notify_enter_call(const AztecAddress& contract_
                                                    bool is_static_call,
                                                    const Gas& gas_limit)
 {
-    assert(!call_stack_metadata.empty());
+    BB_ASSERT(!call_stack_metadata.empty(), "Call stack metadata is empty");
 
     // Check if we should stop collecting due to limits.
     if (should_skip_collection()) {
@@ -86,7 +86,7 @@ void CallStackMetadataCollector::notify_exit_call(bool success,
     top_call_stack_metadata.internal_call_stack_at_exit = std::move(internal_call_stack);
 
     // While exiting, we will move the top call of the stack to the nested vector of the parent call.
-    assert(call_stack_metadata.size() > 1);
+    BB_ASSERT_GT(call_stack_metadata.size(), static_cast<size_t>(1), "Call stack metadata size is not greater than 1");
     call_stack_metadata.pop();
     call_stack_metadata.top().nested.push_back(std::move(top_call_stack_metadata));
 }
@@ -96,7 +96,7 @@ void CallStackMetadataCollector::notify_tx_revert(const std::string& revert_mess
     // Create a synthetic CallStackMetadata entry to capture the revert reason.
     // This is used when a tx-level revert happens outside of an enqueued call
     // (e.g., during revertible insertions from private).
-    assert(call_stack_metadata.size() == 1);
+    BB_ASSERT_EQ(call_stack_metadata.size(), static_cast<size_t>(1), "Call stack metadata size is not equal to 1");
     call_stack_metadata.top().nested.push_back({
         .timestamp = timestamp++,
         .phase = current_phase,
@@ -116,7 +116,7 @@ void CallStackMetadataCollector::notify_tx_revert(const std::string& revert_mess
 
 std::vector<CallStackMetadata> CallStackMetadataCollector::dump_call_stack_metadata()
 {
-    assert(call_stack_metadata.size() == 1);
+    BB_ASSERT_EQ(call_stack_metadata.size(), static_cast<size_t>(1), "Call stack metadata size is not equal to 1");
     return std::move(call_stack_metadata.top().nested);
 }
 
@@ -124,51 +124,24 @@ CalldataProvider make_calldata_provider(const ContextInterface& context)
 {
     auto cd_size = context.get_parent_cd_size();
     return [&context, cd_size](uint32_t max_size) -> std::vector<FF> {
-        try {
-            // NOTE: get_calldata will handle offsetting into parent memory for nested contexts
-            // TODO: check if this will pad to size. We don't want that.
-            auto data = context.get_calldata(0, std::min(max_size, cd_size));
-            return std::vector<FF>(data.begin(), data.end());
-        } catch (...) {
-            vinfo("Failed to collect calldata (to:",
-                  context.get_address(),
-                  " pc:",
-                  context.get_pc(),
-                  " cd_size:",
-                  cd_size,
-                  " max_size:",
-                  max_size,
-                  ")");
-            return {};
-        }
+        // NOTE: get_calldata will handle offsetting into parent memory for nested contexts
+        // TODO(AVM-186): check if this will pad to size. We don't want that.
+        auto data = context.get_calldata(0, std::min(max_size, cd_size));
+        return std::vector<FF>(data.begin(), data.end());
     };
 }
 
 ReturnDataProvider make_return_data_provider(const ContextInterface& context, uint32_t rd_offset, uint32_t rd_size)
 {
     return [&context, rd_offset, rd_size](uint32_t max_size) -> std::vector<FF> {
-        try {
-            const auto& memory = context.get_memory();
-            std::vector<FF> data;
-            data.reserve(std::min(max_size, rd_size));
-            for (uint32_t i = 0; i < std::min(max_size, rd_size); i++) {
-                data.push_back(memory.get(rd_offset + i).as_ff());
-            }
-            return data;
-        } catch (...) {
-            vinfo("Failed to collect returndata (to:",
-                  context.get_address(),
-                  " pc:",
-                  context.get_pc(),
-                  " rd_offset:",
-                  rd_offset,
-                  " rd_size:",
-                  rd_size,
-                  " max_size:",
-                  max_size,
-                  ")");
-            return {};
+        // TODO(AVM-187): Consider using get_returndata instead.
+        const auto& memory = context.get_memory();
+        std::vector<FF> data;
+        data.reserve(std::min(max_size, rd_size));
+        for (uint32_t i = 0; i < std::min(max_size, rd_size); i++) {
+            data.push_back(memory.get(rd_offset + i).as_ff());
         }
+        return data;
     };
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.test.cpp
index cc275042ce42..581195ea46d1 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/call_stack_metadata_collector.test.cpp
@@ -384,28 +384,6 @@ TEST_F(MakeProviderTest, MakeCalldataProviderRespectsMaxSize)
     ASSERT_EQ(result.size(), max_size);
 }
 
-TEST_F(MakeProviderTest, MakeCalldataProviderHandlesException)
-{
-    static AztecAddress contract_addr(0x1234);
-    uint32_t cd_size = 5;
-
-    // This is called when creating the provider
-    EXPECT_CALL(mock_context, get_parent_cd_size()).WillOnce(Return(cd_size));
-
-    auto provider = make_calldata_provider(mock_context);
-
-    // This is called when invoking the provider, and throws
-    EXPECT_CALL(mock_context, get_calldata(0, _)).WillOnce(::testing::Throw(std::runtime_error("Test exception")));
-    // The exception handler may call get_address() and get_pc() for logging (optional)
-    EXPECT_CALL(mock_context, get_address()).Times(::testing::AnyNumber()).WillRepeatedly(ReturnRef(contract_addr));
-    EXPECT_CALL(mock_context, get_pc()).Times(::testing::AnyNumber()).WillRepeatedly(Return(200));
-
-    auto result = provider(1024);
-
-    // Should return empty vector on exception
-    EXPECT_TRUE(result.empty());
-}
-
 TEST_F(MakeProviderTest, MakeReturnDataProviderSuccess)
 {
     uint32_t rd_addr = 200;
@@ -463,28 +441,5 @@ TEST_F(MakeProviderTest, MakeReturnDataProviderRespectsMaxSize)
     ASSERT_EQ(result.size(), max_size);
 }
 
-TEST_F(MakeProviderTest, MakeReturnDataProviderHandlesException)
-{
-    uint32_t rd_addr = 200;
-    uint32_t rd_size = 3;
-    static AztecAddress contract_addr(0x5678);
-
-    auto provider = make_return_data_provider(mock_context, rd_addr, rd_size);
-
-    // This is called when invoking the provider, and throws
-    StrictMock<MockMemory> memory;
-    EXPECT_CALL(::testing::Const(mock_context), get_memory())
-        .WillOnce(::testing::Throw(std::runtime_error("Test exception")));
-
-    // The exception handler may call get_address() and get_pc() for logging (optional)
-    EXPECT_CALL(mock_context, get_address()).Times(::testing::AnyNumber()).WillRepeatedly(ReturnRef(contract_addr));
-    EXPECT_CALL(mock_context, get_pc()).Times(::testing::AnyNumber()).WillRepeatedly(Return(300));
-
-    auto result = provider(1024);
-
-    // Should return empty vector on exception
-    EXPECT_TRUE(result.empty());
-}
-
 } // namespace
 } // namespace bb::avm2::simulation
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/indexed_memory_tree.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/indexed_memory_tree.hpp
index 056c2b70af76..b4b42f3956c2 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/indexed_memory_tree.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/indexed_memory_tree.hpp
@@ -40,7 +40,7 @@ IndexedMemoryTree<LeafType, HashingPolicy>::IndexedMemoryTree(size_t depth, size
     // We need to create the tree inserting the prefill values. Indexed trees need some leaves to exist from the start
     // in order to be able to provide insertion proofs. Users can customize how many default leaves they want the tree
     // to start with, but there must be at least one.
-    assert(num_default_values > 0);
+    BB_ASSERT_GT(num_default_values, static_cast<size_t>(0), "Number of default values is not greater than 0");
 
     std::vector<LeafType> default_leaves;
     default_leaves.reserve(num_default_values);
@@ -79,7 +79,7 @@ IndexedMemoryTree<LeafType, HashingPolicy>::IndexedMemoryTree(size_t depth,
 {
     // It is assumed that you have included any prefill values as part of the initial_leaves. Remember indexed trees
     // need at least 1 prefill leaf (with value 0) in order to work
-    assert(initial_leaves.size() > 0);
+    BB_ASSERT_GT(initial_leaves.size(), static_cast<size_t>(0), "Initial leaves size is not greater than 0");
 
     // Compute the pointers for the prefill leaves and insert them in the tree.
     for (size_t i = 0; i < initial_leaves.size(); ++i) {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_dbs.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_dbs.cpp
index ba122e10c001..78c4b0618ffe 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_dbs.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_dbs.cpp
@@ -172,10 +172,11 @@ void HintedRawContractDB::add_contracts([[maybe_unused]] const ContractDeploymen
 void HintedRawContractDB::create_checkpoint()
 {
     auto hint_it = create_checkpoint_hints.find(action_counter);
-    assert(hint_it != create_checkpoint_hints.end());
+    BB_ASSERT(hint_it != create_checkpoint_hints.end(), "Hint not found for create checkpoint");
 
     const auto& hint = hint_it->second;
-    assert(hint.old_checkpoint_id == checkpoint_stack.top());
+    BB_ASSERT_EQ(
+        hint.old_checkpoint_id, checkpoint_stack.top(), "Old checkpoint id does not match the current checkpoint id");
 
     checkpoint_stack.push(hint.new_checkpoint_id);
     action_counter++;
@@ -184,29 +185,31 @@ void HintedRawContractDB::create_checkpoint()
 void HintedRawContractDB::commit_checkpoint()
 {
     auto hint_it = commit_checkpoint_hints.find(action_counter);
-    assert(hint_it != commit_checkpoint_hints.end());
+    BB_ASSERT(hint_it != commit_checkpoint_hints.end(), "Hint not found for commit checkpoint");
 
     const auto& hint = hint_it->second;
-    assert(hint.old_checkpoint_id == checkpoint_stack.top());
+    BB_ASSERT_EQ(
+        hint.old_checkpoint_id, checkpoint_stack.top(), "Old checkpoint id does not match the current checkpoint id");
 
     checkpoint_stack.pop();
-    assert(hint.new_checkpoint_id == checkpoint_stack.top());
+    BB_ASSERT_EQ(
+        hint.new_checkpoint_id, checkpoint_stack.top(), "New checkpoint id does not match the current checkpoint id");
     action_counter++;
-    (void)hint;
 }
 
 void HintedRawContractDB::revert_checkpoint()
 {
     auto hint_it = revert_checkpoint_hints.find(action_counter);
-    assert(hint_it != revert_checkpoint_hints.end());
+    BB_ASSERT(hint_it != revert_checkpoint_hints.end(), "Hint not found for revert checkpoint");
 
     const auto& hint = hint_it->second;
-    assert(hint.old_checkpoint_id == checkpoint_stack.top());
+    BB_ASSERT_EQ(
+        hint.old_checkpoint_id, checkpoint_stack.top(), "Old checkpoint id does not match the current checkpoint id");
 
     checkpoint_stack.pop();
-    assert(hint.new_checkpoint_id == checkpoint_stack.top());
+    BB_ASSERT_EQ(
+        hint.new_checkpoint_id, checkpoint_stack.top(), "New checkpoint id does not match the current checkpoint id");
     action_counter++;
-    (void)hint;
 }
 
 uint32_t HintedRawContractDB::get_checkpoint_id() const
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp
index 9e81fd19acea..8ee82fc47e69 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp
@@ -10,6 +10,7 @@
 #include <variant>
 #include <vector>
 
+#include "barretenberg/common/assert.hpp"
 #include "barretenberg/common/log.hpp"
 #include "barretenberg/common/serialize.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
@@ -255,7 +256,7 @@ Instruction deserialize_instruction(std::span<const uint8_t> bytecode, size_t po
 
     const auto opcode = static_cast<WireOpCode>(opcode_byte);
     const auto iter = get_wire_opcode_wire_format().find(opcode);
-    assert(iter != get_wire_opcode_wire_format().end());
+    BB_ASSERT_DEBUG(iter != get_wire_opcode_wire_format().end(), "Wire opcode not found in wire opcode wire format");
     const auto& inst_format = iter->second;
 
     const uint32_t instruction_size = get_wire_instruction_spec().at(opcode).size_in_bytes;
@@ -280,8 +281,8 @@ Instruction deserialize_instruction(std::span<const uint8_t> bytecode, size_t po
     std::vector<Operand> operands;
     for (const OperandType op_type : inst_format) {
         const auto operand_size = get_operand_type_size_bytes().at(op_type);
-        assert(pos + operand_size <= bytecode_length); // Guaranteed to hold due to
-                                                       //  pos + instruction_size <= bytecode_length
+        // Guaranteed to hold due to pos + instruction_size <= bytecode_length
+        BB_ASSERT_DEBUG(pos + operand_size <= bytecode_length, "Operand size is out of range");
 
         switch (op_type) {
         case OperandType::TAG:
@@ -365,13 +366,13 @@ std::string Instruction::to_string() const
 
 size_t Instruction::size_in_bytes() const
 {
-    assert(get_wire_instruction_spec().contains(opcode));
+    BB_ASSERT_DEBUG(get_wire_instruction_spec().contains(opcode), "Wire instruction spec not found for opcode");
     return get_wire_instruction_spec().at(opcode).size_in_bytes;
 }
 
 ExecutionOpCode Instruction::get_exec_opcode() const
 {
-    assert(get_wire_instruction_spec().contains(opcode));
+    BB_ASSERT_DEBUG(get_wire_instruction_spec().contains(opcode), "Wire instruction spec not found for opcode");
     return get_wire_instruction_spec().at(opcode).exec_opcode;
 }
 
@@ -438,12 +439,12 @@ bool check_tag(const Instruction& instruction)
 
     size_t pos = 0; // Position in instruction operands
 
-    for (size_t i = 0; i < wire_format.size(); i++) {
-        if (wire_format[i] == OperandType::INDIRECT8 || wire_format[i] == OperandType::INDIRECT16) {
+    for (const OperandType& operand_type : wire_format) {
+        if (operand_type == OperandType::INDIRECT8 || operand_type == OperandType::INDIRECT16) {
             continue; // No pos increment
         }
 
-        if (wire_format[i] == OperandType::TAG) {
+        if (operand_type == OperandType::TAG) {
             if (pos >= instruction.operands.size()) {
                 vinfo("Instruction operands size is too small. Tag position: ",
                       pos,
@@ -455,7 +456,7 @@ bool check_tag(const Instruction& instruction)
             }
 
             try {
-                uint8_t tag = instruction.operands.at(pos).as<uint8_t>(); // Cast to uint8_t might throw
+                uint8_t tag = instruction.operands.at(pos).as<uint8_t>(); // Cast to uint8_t might throw CastException
 
                 if (tag > static_cast<uint8_t>(MemoryTag::MAX)) {
                     vinfo("Instruction tag operand at position: ",
@@ -467,8 +468,7 @@ bool check_tag(const Instruction& instruction)
                           instruction.opcode);
                     return false;
                 }
-
-            } catch (const std::runtime_error&) {
+            } catch (const CastException&) {
                 vinfo("Instruction operand at position: ",
                       pos,
                       " is longer than a byte.",
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp
index 433503f5610c..6285e7998eeb 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp
@@ -54,9 +54,6 @@ enum class InstrDeserializationEventError : uint8_t {
     OPCODE_OUT_OF_RANGE,
     INSTRUCTION_OUT_OF_RANGE,
     TAG_OUT_OF_RANGE,
-    // FIXME: remove this once all execution opcodes are supported.
-    // Also uncomment proper constraining of error in instr_fetching.pil.
-    INVALID_EXECUTION_OPCODE,
 };
 
 struct InstrDeserializationError {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/hybrid_execution.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/hybrid_execution.cpp
index 3d0ad93ad61b..82edd369dc88 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/hybrid_execution.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/hybrid_execution.cpp
@@ -87,8 +87,8 @@ EnqueuedCallResult HybridExecution::execute(std::unique_ptr<ContextInterface> en
         } catch (const std::exception& e) {
             // This is a coding error, we should not get here.
             // All exceptions should fall in the above catch blocks.
-            info("An unhandled exception occurred: ", e.what());
-            throw e;
+            important("An unhandled exception occurred: ", e.what());
+            throw;
         }
 
         // We always do what follows. "Finally".
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_addressing.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_addressing.cpp
index 4b66fed517d3..707866a1e3dd 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_addressing.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_addressing.cpp
@@ -22,7 +22,7 @@ std::vector<Operand> PureAddressing::resolve(const Instruction& instruction, Mem
     ExecutionOpCode exec_opcode = instruction_info_db.get(instruction.opcode).exec_opcode;
     const ExecInstructionSpec& spec = instruction_info_db.get(exec_opcode);
 
-    assert(spec.num_addresses <= instruction.operands.size());
+    BB_ASSERT_DEBUG(spec.num_addresses <= instruction.operands.size(), "Number of addresses is out of range");
 
     std::optional<MemoryAddress> base_address;
     std::vector<Operand> resolved_operands = instruction.operands;
@@ -33,7 +33,7 @@ std::vector<Operand> PureAddressing::resolve(const Instruction& instruction, Mem
 
         // We assume from serialization that the operand is <= the bits of a memory address.
         // We assert this here as it is a precondition.
-        assert(get_tag_bits(tag) <= get_tag_bits(MemoryAddressTag));
+        BB_ASSERT_DEBUG(get_tag_bits(tag) <= get_tag_bits(MemoryAddressTag), "Tag bits are out of range");
         // Normalize possibly smaller sizes to MemoryAddress.
         if (tag != MemoryAddressTag) {
             operand = Operand::from(static_cast<MemoryAddress>(operand.to<MemoryAddress>()));
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bitwise.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bitwise.cpp
index 216b070bc134..ae0c3a0097d2 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bitwise.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bitwise.cpp
@@ -10,7 +10,7 @@ MemoryValue PureBitwise::and_op(const MemoryValue& a, const MemoryValue& b)
 {
     try {
         return a & b;
-    } catch (const std::exception& e) {
+    } catch (const TaggedValueException& e) {
         throw BitwiseException("AND, " + std::string(e.what()));
     }
 }
@@ -18,7 +18,7 @@ MemoryValue PureBitwise::or_op(const MemoryValue& a, const MemoryValue& b)
 {
     try {
         return a | b;
-    } catch (const std::exception& e) {
+    } catch (const TaggedValueException& e) {
         throw BitwiseException("OR, " + std::string(e.what()));
     }
 }
@@ -26,7 +26,7 @@ MemoryValue PureBitwise::xor_op(const MemoryValue& a, const MemoryValue& b)
 {
     try {
         return a ^ b;
-    } catch (const std::exception& e) {
+    } catch (const TaggedValueException& e) {
         throw BitwiseException("XOR, " + std::string(e.what()));
     }
 }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bytecode_manager.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bytecode_manager.cpp
index 77e2ed3bf656..c8f8c67f97a1 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bytecode_manager.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/standalone/pure_bytecode_manager.cpp
@@ -77,7 +77,7 @@ BytecodeId PureTxBytecodeManager::get_bytecode(const AztecAddress& address)
     std::optional<ContractClass> maybe_klass = contract_db.get_contract_class(current_class_id);
     // Note: we don't need to silo and check the class id because the deployer contract guarantees
     // that if a contract instance exists, the class has been registered.
-    assert(maybe_klass.has_value());
+    BB_ASSERT(maybe_klass.has_value(), "Contract class not found");
     auto& klass = maybe_klass.value();
     debug("Bytecode for ", address, " successfully retrieved!");
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_cd_hasher.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_cd_hasher.hpp
index 5e4dd1a917df..3e7fb739f2c1 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_cd_hasher.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_cd_hasher.hpp
@@ -11,6 +11,6 @@ class MockCalldataHasher : public CalldataHashingInterface {
     MockCalldataHasher();
     ~MockCalldataHasher() override;
 
-    MOCK_METHOD(FF, compute_calldata_hash, (const std::span<const FF> calldata), (override));
+    MOCK_METHOD(void, assert_calldata_hash, (const FF& cd_hash, std::span<const FF> calldata), (override));
 };
 } // namespace bb::avm2::simulation
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_provider.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_provider.hpp
index e35f949d7afa..31b4204ec1d9 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_provider.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_provider.hpp
@@ -37,6 +37,7 @@ class MockContextProvider : public ContextProviderInterface {
                  AztecAddress msg_sender,
                  FF transaction_fee,
                  std::span<const FF> calldata,
+                 const FF& calldata_hash,
                  bool is_static,
                  Gas gas_limit,
                  Gas gas_used,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp
index 6c75d55cbfd3..0984f19100f4 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp
@@ -478,7 +478,7 @@ TxSimulationResult AvmSimulationHelper::simulate_fast_internal(ContractDBInterfa
             const DebugLogLevel debug_log_level = DebugLogLevel::INFO;
             return std::make_unique<DebugLogger>(debug_log_level,
                                                  config.collection_limits.max_debug_log_memory_reads,
-                                                 [](const std::string& message) { info(message); });
+                                                 [](const std::string& message) { vinfo(message); });
         } else {
             return std::make_unique<NoopDebugLogger>();
         }
@@ -509,7 +509,7 @@ TxSimulationResult AvmSimulationHelper::simulate_fast_internal(ContractDBInterfa
                               *debug_log_component,
                               merkle_db,
                               *call_stack_metadata_collector,
-                              cancellation_token);
+                              std::move(cancellation_token));
     TxExecution tx_execution(execution,
                              context_provider,
                              contract_db,
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp
index ee8c0933e082..a1b9d2872cad 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/bytecode_trace.cpp
@@ -306,8 +306,8 @@ void BytecodeTraceBuilder::process_instruction_fetching(
 
             if (wire_instr_spec.tag_operand_idx.has_value()) {
                 const auto tag_value_idx = wire_instr_spec.tag_operand_idx.value();
-                assert((tag_value_idx == 2 || tag_value_idx == 3) &&
-                       "Current constraints support only tag for operand index equal to 2 or 3");
+                BB_ASSERT((tag_value_idx == 2 || tag_value_idx == 3),
+                          "Current constraints support only tag for operand index equal to 2 or 3");
                 has_tag = 1;
 
                 if (tag_value_idx == 2) {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/data_copy_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/data_copy_trace.cpp
index a848d49a2732..b50adb15b9d6 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/data_copy_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/data_copy_trace.cpp
@@ -121,7 +121,7 @@ void DataCopyTraceBuilder::process(
 
         // If there is an error, the copying data is empty. Therefore, we have to perform this
         // assertion after the error check.
-        assert(event.copying_data.size() == copy_size);
+        BB_ASSERT_EQ(event.copying_data.size(), copy_size, "Copying data size is not equal to copy size");
 
         /////////////////////////////
         // Check for Zero Sized Copy
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/ecc_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/ecc_trace.cpp
index 5c9506c3ab2e..fa5bc95a4190 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/ecc_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/ecc_trace.cpp
@@ -73,7 +73,7 @@ void EccTraceBuilder::process_add(const simulation::EventEmitterInterface<simula
 
         bool use_computed_result = !infinity_predicate && (!p.is_infinity() && !q.is_infinity());
 
-        assert(result_is_infinity == result.is_infinity() && "Inconsistent infinity result assumption");
+        BB_ASSERT_EQ(result_is_infinity, result.is_infinity(), "Inconsistent infinity result assumption");
 
         FF lambda = compute_lambda(double_predicate, add_predicate, result_is_infinity, p, q);
 
@@ -145,7 +145,7 @@ void EccTraceBuilder::process_scalar_mul(
 
             simulation::ScalarMulIntermediateState state = event.intermediate_states[intermediate_state_idx];
             if (is_start) {
-                assert(state.res == event.result);
+                BB_ASSERT_EQ(state.res, event.result, "Inconsistent result assumption");
             }
             EmbeddedCurvePoint res = state.res;
 
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp
index 18652d051eb2..d774e9eb40e7 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp
@@ -7,6 +7,7 @@
 #include <ranges>
 #include <stdexcept>
 
+#include "barretenberg/common/assert.hpp"
 #include "barretenberg/vm2/common/addressing.hpp"
 #include "barretenberg/vm2/common/aztec_constants.hpp"
 #include "barretenberg/vm2/common/field.hpp"
@@ -265,8 +266,8 @@ bool is_phase_discarded(TransactionPhase phase, const FailingContexts& failures)
  */
 uint32_t dying_context_for_phase(TransactionPhase phase, const FailingContexts& failures)
 {
-    assert((phase == TransactionPhase::APP_LOGIC || phase == TransactionPhase::TEARDOWN) &&
-           "Execution events must have app logic or teardown phase");
+    BB_ASSERT((phase == TransactionPhase::APP_LOGIC || phase == TransactionPhase::TEARDOWN),
+              "Execution events must have app logic or teardown phase");
 
     switch (phase) {
     case TransactionPhase::APP_LOGIC: {
@@ -572,8 +573,9 @@ void ExecutionTraceBuilder::process(
                 sel_exit_call = true;
                 should_execute_revert = true;
             } else if (exec_opcode == ExecutionOpCode::GETENVVAR) {
-                assert(ex_event.addressing_event.resolution_info.size() == 2 &&
-                       "GETENVVAR should have exactly two resolved operands (envvar enum and output)");
+                BB_ASSERT_EQ(ex_event.addressing_event.resolution_info.size(),
+                             static_cast<size_t>(2),
+                             "GETENVVAR should have exactly two resolved operands (envvar enum and output)");
                 // rop[1] is the envvar enum
                 Operand envvar_enum = ex_event.addressing_event.resolution_info[1].resolved_operand;
                 process_get_env_var_opcode(envvar_enum, ex_event.output, trace, row);
@@ -751,7 +753,7 @@ void ExecutionTraceBuilder::process_instr_fetching(const simulation::Instruction
 
     // At this point we can assume instruction fetching succeeded.
     auto operands = instruction.operands;
-    assert(operands.size() <= AVM_MAX_OPERANDS);
+    BB_ASSERT_LTE(operands.size(), static_cast<size_t>(AVM_MAX_OPERANDS), "Operands size is out of range");
     operands.resize(AVM_MAX_OPERANDS, Operand::from<FF>(0));
 
     for (size_t i = 0; i < AVM_MAX_OPERANDS; i++) {
@@ -843,7 +845,8 @@ void ExecutionTraceBuilder::process_addressing(const simulation::AddressingEvent
     const ExecInstructionSpec& ex_spec = get_exec_instruction_spec().at(exec_opcode);
 
     auto resolution_info_vec = addr_event.resolution_info;
-    assert(resolution_info_vec.size() <= AVM_MAX_OPERANDS);
+    BB_ASSERT_LTE(
+        resolution_info_vec.size(), static_cast<size_t>(AVM_MAX_OPERANDS), "Resolution info size is out of range");
     // Pad with default values for the missing operands.
     resolution_info_vec.resize(AVM_MAX_OPERANDS,
                                {
@@ -1013,7 +1016,7 @@ void ExecutionTraceBuilder::process_registers(ExecutionOpCode exec_opcode,
                                               TraceContainer& trace,
                                               uint32_t row)
 {
-    assert(registers.size() == AVM_MAX_REGISTERS);
+    BB_ASSERT_EQ(registers.size(), static_cast<size_t>(AVM_MAX_REGISTERS), "Registers size is out of range");
     // At this point we can assume instruction fetching succeeded, so this should never fail.
     const auto& register_info = get_exec_instruction_spec().at(exec_opcode).register_info;
 
@@ -1087,7 +1090,7 @@ void ExecutionTraceBuilder::process_get_env_var_opcode(Operand envvar_enum,
                                                        TraceContainer& trace,
                                                        uint32_t row)
 {
-    assert(envvar_enum.get_tag() == ValueTag::U8);
+    BB_ASSERT_EQ(envvar_enum.get_tag(), ValueTag::U8, "Envvar enum tag is not U8");
     const auto& envvar_spec = GetEnvVarSpec::get_table(envvar_enum.as<uint8_t>());
 
     trace.set(row,
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 af27614a4b34..ec2aee583f44 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/discard_reconstruction.hpp
@@ -8,6 +8,7 @@
 #include <variant>
 #include <vector>
 
+#include "barretenberg/common/assert.hpp"
 #include "barretenberg/vm2/simulation/events/checkpoint_event_type.hpp"
 
 namespace bb::avm2::tracegen {
@@ -33,11 +34,11 @@ std::unordered_map<size_t, size_t> compute_reverted_in_map(const std::vector<Eve
                 checkpoint_stack.push(i);
                 break;
             case simulation::CheckPointEventType::COMMIT_CHECKPOINT:
-                assert(!checkpoint_stack.empty());
+                BB_ASSERT(!checkpoint_stack.empty());
                 checkpoint_stack.pop();
                 break;
             case simulation::CheckPointEventType::REVERT_CHECKPOINT:
-                assert(!checkpoint_stack.empty());
+                BB_ASSERT(!checkpoint_stack.empty());
                 reverted_in[checkpoint_stack.top()] = i;
                 checkpoint_stack.pop();
                 break;
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/instruction_spec.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/instruction_spec.cpp
index 0f1aa2ffab0c..11f31e3d3bcf 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/instruction_spec.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/instruction_spec.cpp
@@ -201,7 +201,7 @@ Column get_dyn_gas_selector(uint32_t dyn_gas_id)
     case AVM_DYN_GAS_ID_SSTORE:
         return C::execution_sel_gas_sstore;
     default:
-        assert(false && "Invalid dynamic gas id");
+        BB_ASSERT(false, "Invalid dynamic gas id");
     }
 
     // This is just to please gcc.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/merkle_check_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/merkle_check_trace.cpp
index 7a853a50065e..a40bc401e7ad 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/merkle_check_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/merkle_check_trace.cpp
@@ -45,7 +45,7 @@ void MerkleCheckTraceBuilder::process(
         // to complete the merkle check.
 
         const bool write = event.new_leaf_value.has_value();
-        assert(write == event.new_root.has_value());
+        BB_ASSERT_EQ(write, event.new_root.has_value(), "Write and new root have different values");
 
         FF read_node = event.leaf_value;
         FF write_node = event.new_leaf_value.value_or(FF(0));
@@ -111,9 +111,11 @@ void MerkleCheckTraceBuilder::process(
             row++;
         }
 
-        assert(current_index_in_layer == 0);
-        assert(read_node == root);
-        assert(write_node == new_root);
+        BB_ASSERT_EQ(current_index_in_layer,
+                     static_cast<decltype(current_index_in_layer)>(0),
+                     "Current index in layer is not 0");
+        BB_ASSERT_EQ(read_node, root, "Read node is not equal to root");
+        BB_ASSERT_EQ(write_node, new_root, "Write node is not equal to new root");
     }
 
     // Batch invert the columns.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp
index 8f1f46e24dd6..b457afb9e987 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp
@@ -62,8 +62,8 @@ void PrecomputedTraceBuilder::process_bitwise(TraceContainer& trace)
             return a ^ b;
         }
 
-        assert(false && "This should not happen");
-        return 0; // Should never happen. To please the compiler.
+        BB_ASSERT(false, "This should not happen");
+        __builtin_unreachable();
     };
 
     for (const auto op_id : { BitwiseOperation::AND, BitwiseOperation::OR, BitwiseOperation::XOR }) {
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/public_data_tree_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/public_data_tree_trace.cpp
index b60a4718bed1..110240fff97d 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen/public_data_tree_trace.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/public_data_tree_trace.cpp
@@ -162,11 +162,14 @@ void process_squashing_trace(const std::vector<PublicDataTreeReadWriteEvent>& no
             const auto& next_event = nondiscarded_writes[i + 1];
 
             if (event.leaf_slot == next_event.leaf_slot) {
-                assert(event.execution_id < next_event.execution_id);
+                BB_ASSERT_LT(
+                    event.execution_id, next_event.execution_id, "Execution id is not less than next execution id");
                 clk_diff = next_event.execution_id - event.execution_id;
                 check_clock = true;
             } else {
-                assert(static_cast<uint256_t>(event.leaf_slot) < static_cast<uint256_t>(next_event.leaf_slot));
+                BB_ASSERT_LT(static_cast<uint256_t>(event.leaf_slot),
+                             static_cast<uint256_t>(next_event.leaf_slot),
+                             "Leaf slot is not less than next leaf slot");
                 leaf_slot_increase = true;
             }
         }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp
index 2d080ba0d14e..ae79a5c8c0bb 100644
--- a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp
@@ -165,7 +165,8 @@ void print_trace_stats(const TraceContainer& trace)
               numeric::get_msb(numeric::round_up_power_2(column_size)),
               ")");
     }
-    info("Sum of all column rows: ", total_rows, " (~2^", numeric::get_msb(numeric::round_up_power_2(total_rows)), ")");
+    vinfo(
+        "Sum of all column rows: ", total_rows, " (~2^", numeric::get_msb(numeric::round_up_power_2(total_rows)), ")");
 }
 
 } // namespace
diff --git a/yarn-project/native/src/native_module.ts b/yarn-project/native/src/native_module.ts
index dd23339dcd5c..b1995ac61aa0 100644
--- a/yarn-project/native/src/native_module.ts
+++ b/yarn-project/native/src/native_module.ts
@@ -1,5 +1,5 @@
 import { findNapiBinary } from '@aztec/bb.js';
-import { type LogLevel, LogLevels } from '@aztec/foundation/log';
+import { type LogLevel, LogLevels, type Logger } from '@aztec/foundation/log';
 import { Semaphore } from '@aztec/foundation/queue';
 
 import { createRequire } from 'module';
@@ -90,6 +90,7 @@ const nativeAvmSimulate = nativeModule.avmSimulate as (
   contractProvider: ContractProvider,
   worldStateHandle: any,
   logLevel: number,
+  logFunction?: any,
   cancellationToken?: any,
 ) => Promise<Buffer>;
 
@@ -147,7 +148,8 @@ const avmSimulationSemaphore = new Semaphore(MAX_CONCURRENT_AVM_SIMULATIONS);
  * @param inputs - Msgpack-serialized AvmFastSimulationInputs buffer
  * @param contractProvider - Object with callbacks for fetching contract instances and classes
  * @param worldStateHandle - Native handle to WorldState instance
- * @param logLevel - Log level to control C++ verbosity
+ * @param logLevel - Optional log level to control C++ verbosity (only used if loggerFunction is provided)
+ * @param logger - Optional logger object for C++ logging callbacks
  * @param cancellationToken - Optional token to enable cancellation support
  * @returns Promise resolving to msgpack-serialized AvmCircuitPublicInputs buffer
  */
@@ -156,15 +158,18 @@ export async function avmSimulate(
   contractProvider: ContractProvider,
   worldStateHandle: any,
   logLevel: LogLevel = 'info',
+  logger?: Logger,
   cancellationToken?: CancellationToken,
 ): Promise<Buffer> {
   await avmSimulationSemaphore.acquire();
+
   try {
     return await nativeAvmSimulate(
       inputs,
       contractProvider,
       worldStateHandle,
       LogLevels.indexOf(logLevel),
+      logger ? (level: LogLevel, msg: string) => logger[level](msg) : null,
       cancellationToken,
     );
   } finally {
diff --git a/yarn-project/simulator/src/public/public_tx_simulator/cpp_public_tx_simulator.ts b/yarn-project/simulator/src/public/public_tx_simulator/cpp_public_tx_simulator.ts
index d20036052861..49ebdb207001 100644
--- a/yarn-project/simulator/src/public/public_tx_simulator/cpp_public_tx_simulator.ts
+++ b/yarn-project/simulator/src/public/public_tx_simulator/cpp_public_tx_simulator.ts
@@ -95,7 +95,14 @@ export class CppPublicTxSimulator extends PublicTxSimulator implements PublicTxS
 
     // Store the promise so cancel() can wait for it
     this.log.debug(`Calling C++ simulator for tx ${txHash}`);
-    this.simulationPromise = avmSimulate(inputBuffer, contractProvider, wsCppHandle, logLevel, this.cancellationToken);
+    this.simulationPromise = avmSimulate(
+      inputBuffer,
+      contractProvider,
+      wsCppHandle,
+      logLevel,
+      this.log,
+      this.cancellationToken,
+    );
 
     let resultBuffer: Buffer;
     try {