feat: merge-train/avm (#16986)

BEGIN_COMMIT_OVERRIDE
feat(avm!): Bytecode Hashing (#16756)
chore(avm)!: gas gt migrations optimized (#16989)
END_COMMIT_OVERRIDE

Author: fcarreiro

barretenberg/cpp/pil/vm2/bytecode/bc_hashing.pil

@@ -153,10 +153,9 @@ should_retrieve {
     retrieved_bytecodes_tree_check.tree_size_after_write
 };
 
-// TODO(dbanks12): re-enable once C++ and PIL use standard poseidon2 hashing for bytecode commitments.
 // Note: only need to hash the bytecode if there is no error. Otherwise there is nothing to hash!
-//#[BYTECODE_HASH_IS_CORRECT]
-//should_retrieve { bytecode_id, /*public_bytecode_commitment=*/ bytecode_id } in bc_hashing.latch { bc_hashing.bytecode_id, bc_hashing.output_hash };
+#[BYTECODE_HASH_IS_CORRECT]
+should_retrieve { bytecode_id, /*public_bytecode_commitment=*/ bytecode_id } in bc_hashing.latch { bc_hashing.bytecode_id, bc_hashing.output_hash };
 
 // If instance does not exist, force current_class_id to 0.
 #[CURRENT_CLASS_ID_IS_ZERO_IF_INSTANCE_DOES_NOT_EXIST]

barretenberg/cpp/pil/vm2/bytecode/bc_retrieval.pil

@@ -485,8 +485,8 @@ namespace execution;
 
     // If any error happened during execution (i.e., sel_error=1), all gas should be consumed.
     pol SEL_CONSUMED_ALL_GAS = sel_error;
-    (l2_gas_limit - PREV_GAS_PLUS_USAGE_L2) * SEL_CONSUMED_ALL_GAS + PREV_GAS_PLUS_USAGE_L2 - l2_gas_used = 0;
-    (da_gas_limit - PREV_GAS_PLUS_USAGE_DA) * SEL_CONSUMED_ALL_GAS + PREV_GAS_PLUS_USAGE_DA - da_gas_used = 0;
+    (l2_gas_limit - total_gas_l2) * SEL_CONSUMED_ALL_GAS + total_gas_l2 - l2_gas_used = 0;
+    (da_gas_limit - total_gas_da) * SEL_CONSUMED_ALL_GAS + total_gas_da - da_gas_used = 0;
 
     // nested_exit_call = 1 <==> prev_gas_used' = parent_gas_used + gas_used
     // sel_enter_call   = 1 <==> prev_gas_used' = 0

barretenberg/cpp/pil/vm2/context.pil

@@ -1,5 +1,5 @@
 include "../precomputed.pil";
-include "../range_check.pil";
+include "../gt.pil";
 
 // This is a virtual gadget, which is part of the execution trace.
 // https://excalidraw.com/#json=-fkwtFjYVOq2Z69Q351AE,O3SbjwK5eHX7-Oz2OH8RqQ
@@ -49,8 +49,8 @@ namespace execution;
     // ==== COMPARISON AGAINST THE LIMITS ====
 
     // We will sum up all the gas used (base and dynamic) and compare just once.
-    pol TOTAL_L2_GAS_USED = BASE_L2_GAS + DYNAMIC_L2_GAS_USED;
-    pol TOTAL_DA_GAS_USED = base_da_gas + DYNAMIC_DA_GAS_USED;
+    pol L2_GAS_USED = BASE_L2_GAS + DYNAMIC_L2_GAS_USED;
+    pol DA_GAS_USED = base_da_gas + DYNAMIC_DA_GAS_USED;
 
     // We are going to do 64 bit comparisons. If we assume:
     // prev_l2_gas_used to be u32::MAX_VALUE
@@ -59,43 +59,24 @@ namespace execution;
     // dynamic_da_gas to be u32::MAX_VALUE
     // Then prev_l2_gas_used + BASE_L2_GAS + dynamic_l2_gas_factor*dynamic_da_gas is exactly u64::MAX_VALUE.
 
-    pol commit constant_64;
-    sel_should_check_gas * (64 - constant_64) = 0;
-
-    pol commit out_of_gas_l2;
-    out_of_gas_l2 * (1 - out_of_gas_l2) = 0;
-    pol commit out_of_gas_da;
-    out_of_gas_da * (1 - out_of_gas_da) = 0;
-
-    pol PREV_GAS_PLUS_USAGE_L2 = prev_l2_gas_used + TOTAL_L2_GAS_USED;
-    // Assumes l2_gas_limit is 32 bit and PREV_GAS_PLUS_USAGE_L2 is 64 bit
-    // So we perform a 64 bit comparison
-    pol LIMIT_GTE_USED_L2 = l2_gas_limit - PREV_GAS_PLUS_USAGE_L2;
-    pol LIMIT_LT_USED_L2 =  PREV_GAS_PLUS_USAGE_L2 - l2_gas_limit - 1;
-    pol commit limit_used_l2_cmp_diff;
-    // We multiply by sel_should_check_gas to force a 0 if we shouldn't check the gas.
-    #[L2_CMP_DIFF]
-    limit_used_l2_cmp_diff = sel_should_check_gas * ((LIMIT_LT_USED_L2 - LIMIT_GTE_USED_L2) * out_of_gas_l2 + LIMIT_GTE_USED_L2);
-
-    #[LIMIT_USED_L2_RANGE]
-    sel_should_check_gas { limit_used_l2_cmp_diff, constant_64 }
-    in
-    range_check.sel { range_check.value, range_check.rng_chk_bits };
-
-    pol PREV_GAS_PLUS_USAGE_DA = prev_da_gas_used + TOTAL_DA_GAS_USED;
-    // Assumes da_gas_limit is 32 bit and PREV_GAS_PLUS_USAGE_DA is 64 bit
-    // So we perform a 64 bit comparison
-    pol LIMIT_GTE_USED_DA = da_gas_limit - PREV_GAS_PLUS_USAGE_DA;
-    pol LIMIT_LT_USED_DA =  PREV_GAS_PLUS_USAGE_DA - da_gas_limit - 1;
-    pol commit limit_used_da_cmp_diff;
-    // We multiply by sel_should_check_gas to force a 0 if we shouldn't check the gas.
-    #[DA_CMP_DIFF]
-    limit_used_da_cmp_diff = sel_should_check_gas * ((LIMIT_LT_USED_DA - LIMIT_GTE_USED_DA) * out_of_gas_da + LIMIT_GTE_USED_DA);
-
-    #[LIMIT_USED_DA_RANGE]
-    sel_should_check_gas { limit_used_da_cmp_diff, constant_64 }
-    in
-    range_check.sel { range_check.value, range_check.rng_chk_bits };
+    pol commit out_of_gas_l2; // Boolean constraint enforced through lookup into gt.
+    pol commit out_of_gas_da; // Boolean constraint enforced through lookup into gt.
+
+    // TODO: Once we support expression in lookup, we can replace this column by an alias.
+    pol commit total_gas_l2;
+    total_gas_l2 = prev_l2_gas_used + L2_GAS_USED;
+    // Assumes l2_gas_limit is 32 bit and total_gas_l2 is 64 bit.
+
+    #[IS_OUT_OF_GAS_L2]
+    sel_should_check_gas { total_gas_l2, l2_gas_limit, out_of_gas_l2 } in gt.sel_gas { gt.input_a, gt.input_b, gt.res };
+
+    // TODO: Once we support expression in lookup, we can replace this column by an alias.
+    pol commit total_gas_da;
+    total_gas_da = prev_da_gas_used + DA_GAS_USED;
+    // Assumes da_gas_limit is 32 bit and total_gas_da is 64 bit.
+
+    #[IS_OUT_OF_GAS_DA]
+    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 };
 
     pol commit sel_out_of_gas;
     sel_out_of_gas = 1 - (1 - out_of_gas_l2) * (1 - out_of_gas_da);

barretenberg/cpp/pil/vm2/execution/gas.pil

@@ -46,7 +46,7 @@ namespace ff_gt;
     pol commit a;
     pol commit b;
     pol commit result;
-    (result * (1 - result)) = 0;
+    result * (1 - result) = 0;
 
     // Should be looked up based on this selector
     // This will be off when doing the shifts for the remaning range constraints.

barretenberg/cpp/pil/vm2/ff_gt.pil

@@ -21,13 +21,15 @@ namespace gt;
     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.
     sel_sha256 * (1 - sel_sha256) = 0;
     sel_addressing * (1 - sel_addressing) = 0;
     sel_alu * (1 - sel_alu) = 0;
+    sel_gas * (1 - sel_gas) = 0;
     sel_others * (1 - sel_others) = 0;
     // If any of the above selectors is 1, then sel must be 1.
-    (sel_sha256 + sel_addressing + sel_alu + sel_others) * (1 - sel) = 0;
+    (sel_sha256 + sel_addressing + sel_alu + sel_gas + sel_others) * (1 - sel) = 0;
 
     #[skippable_if]
     sel = 0;

barretenberg/cpp/pil/vm2/gt.pil

@@ -8,55 +8,39 @@ namespace execution;
 #[skippable_if]
 sel_enter_call = 0;
 
-// TODO: Remove this as a column when we can lookup with constants
-pol commit constant_32;
-sel_enter_call * (32 - constant_32) = 0;
-
 // ==== GAS CLAMPING ====
 // Guaranteed not to wrap since we never put a gas used > gas limit
-pol L2_GAS_LEFT = l2_gas_limit - l2_gas_used;
-pol DA_GAS_LEFT = da_gas_limit - da_gas_used;
+
+// TODO: Once we support expression in lookup, we can replace this column by an alias.
+pol commit l2_gas_left;
+l2_gas_left = sel_enter_call * (l2_gas_limit - l2_gas_used);
+
+// TODO: Once we support expression in lookup, we can replace this column by an alias.
+pol commit da_gas_left;
+da_gas_left = sel_enter_call * (da_gas_limit - da_gas_used);
+
 
 // L2 gas clamping
 
 // Compare the gas allocated to the call by the user, with the gas left.
 // Helper column containing whether the allocated gas is less than the left gas
-pol commit call_is_l2_gas_allocated_lt_left;
-call_is_l2_gas_allocated_lt_left * (1 - call_is_l2_gas_allocated_lt_left) = 0;
+pol commit call_is_l2_gas_allocated_lt_left; // Guaranteed to be boolean through the gt lookup. (provided that sel_enter_call == 1)
 
+#[CALL_IS_L2_GAS_ALLOCATED_LT_LEFT]
+sel_enter_call { l2_gas_left, register[0], call_is_l2_gas_allocated_lt_left } in gt.sel_others { gt.input_a, gt.input_b, gt.res };
 
-pol ALLOCATED_GTE_LEFT_L2 = register[0] - L2_GAS_LEFT;
-pol ALLOCATED_LT_LEFT_L2 = L2_GAS_LEFT - register[0] - 1;
-pol commit call_allocated_left_l2_cmp_diff;
-sel_enter_call * ((ALLOCATED_LT_LEFT_L2 - ALLOCATED_GTE_LEFT_L2) * call_is_l2_gas_allocated_lt_left + ALLOCATED_GTE_LEFT_L2 - call_allocated_left_l2_cmp_diff) = 0;
+// next row's l2_gas_limit = if call_is_l2_gas_allocated_lt_left { register[0] } else { l2_gas_left }
+sel_enter_call * ((register[0] - l2_gas_left) * call_is_l2_gas_allocated_lt_left + l2_gas_left - l2_gas_limit') = 0;
 
-#[CALL_ALLOCATED_LEFT_L2_RANGE]
-sel_enter_call { call_allocated_left_l2_cmp_diff, constant_32 }
-in
-range_check.sel
-    { range_check.value, range_check.rng_chk_bits };
-
-// next row's l2_gas_limit = if call_is_l2_gas_allocated_lt_left { register[0] } else { L2_GAS_LEFT }
-sel_enter_call * ((register[0] - L2_GAS_LEFT) * call_is_l2_gas_allocated_lt_left + L2_GAS_LEFT - l2_gas_limit') = 0;
 
 // DA gas clamping
 
 // Compare the gas allocated to the call by the user, with the gas left.
 // Helper column containing whether the allocated gas is less than the left gas
-pol commit call_is_da_gas_allocated_lt_left;
-call_is_da_gas_allocated_lt_left * (1 - call_is_da_gas_allocated_lt_left) = 0;
-
-pol ALLOCATED_GTE_LEFT_DA = register[1] - DA_GAS_LEFT;
-pol ALLOCATED_LT_LEFT_DA = DA_GAS_LEFT - register[1] - 1;
-pol commit call_allocated_left_da_cmp_diff;
-sel_enter_call * ((ALLOCATED_LT_LEFT_DA - ALLOCATED_GTE_LEFT_DA) * call_is_da_gas_allocated_lt_left + ALLOCATED_GTE_LEFT_DA - call_allocated_left_da_cmp_diff) = 0;
-
-#[CALL_ALLOCATED_LEFT_DA_RANGE]
-sel_enter_call { call_allocated_left_da_cmp_diff, constant_32 }
-in
-range_check.sel
-    { range_check.value, range_check.rng_chk_bits };
+pol commit call_is_da_gas_allocated_lt_left; // Guaranteed to be boolean through the gt lookup. (provided that sel_enter_call == 1)
 
-// next row's da_gas_limit = if call_is_da_gas_allocated_lt_left { reg2 } else { DA_GAS_LEFT }
-sel_enter_call * ((register[1] - DA_GAS_LEFT) * call_is_da_gas_allocated_lt_left + DA_GAS_LEFT - da_gas_limit') = 0;
+#[CALL_IS_DA_GAS_ALLOCATED_LT_LEFT]
+sel_enter_call { da_gas_left, register[1], call_is_da_gas_allocated_lt_left } in gt.sel_others { gt.input_a, gt.input_b, gt.res };
 
+// next row's da_gas_limit = if call_is_da_gas_allocated_lt_left { register[1] } else { da_gas_left }
+sel_enter_call * ((register[1] - da_gas_left) * call_is_da_gas_allocated_lt_left + da_gas_left - da_gas_limit') = 0;

barretenberg/cpp/pil/vm2/opcodes/external_call.pil

@@ -12,6 +12,12 @@
 namespace bb::avm2 {
 
 constexpr size_t NUM_OP_DC_SELECTORS = 18;
+constexpr uint32_t DECOMPOSE_WINDOW_SIZE = 37; // Max size of instruction in bytes.
+// We do not use a static constant to compute this value from WIRE_INSTRUCTION_SPEC
+// because we do not want it to be changed transparently. Namely, if this constant
+// is changed, we need to make significant changes in pil/vm2/bytecode/bc_decomposition.pil
+// and pil/vm2/bytecode/instr_fetching.pil.
+// We rely on the unit test InstructionSpecTest.CheckDecomposeWindowSize to detect if this constant is changed.
 
 struct ExecInstructionSpec {
     struct GasInfo {

barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.hpp

@@ -60,5 +60,19 @@ TEST(InstructionSpecTest, CheckAllInstructionsTagInformation)
     }
 }
 
+// Compute the maximum size of instruction in bytes and enforces it to be equal to DECOMPOSE_WINDOW_SIZE.
+TEST(InstructionSpecTest, CheckDecomposeWindowSize)
+{
+    // We cannot use a static assert in the code as MAX_INSTRUCTION_SIZE is not a constexpr.
+    static const uint32_t MAX_INSTRUCTION_SIZE =
+        std::ranges::max_element(
+            WIRE_INSTRUCTION_SPEC.begin(),
+            WIRE_INSTRUCTION_SPEC.end(),
+            [](const auto& a, const auto& b) { return a.second.size_in_bytes < b.second.size_in_bytes; })
+            ->second.size_in_bytes;
+
+    EXPECT_EQ(DECOMPOSE_WINDOW_SIZE, MAX_INSTRUCTION_SIZE);
+}
+
 } // namespace
 } // namespace bb::avm2

barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.test.cpp

@@ -3,7 +3,6 @@
 
 #include <cstdint>
 
-#include "barretenberg/common/serialize.hpp"
 #include "barretenberg/vm2/common/memory_types.hpp"
 #include "barretenberg/vm2/constraining/flavor_settings.hpp"
 #include "barretenberg/vm2/constraining/testing/check_relation.hpp"