Merge branch 'next' into gd/acir-serialization-changes

Author: TomAFrench

.github/workflows/deploy-aztec-infra.yml

@@ -100,6 +100,10 @@ on:
         description: Whether to use an external ingress for the rpc
         required: true
         type: boolean
+      otel_collector_url:
+        description: The OpenTelemetry collector that will receive metrics from this deployment. Optional
+        required: false
+        type: string
     secrets:
       GCP_SA_KEY:
         description: The GCP service account key
@@ -207,6 +211,10 @@ on:
         description: Whether to use an external ingress for the rpc
         required: true
         type: boolean
+      otel_collector_url:
+        description: The OpenTelemetry collector that will receive metrics from this deployment. Optional
+        required: false
+        type: string
 
 jobs:
   deploy_aztec_infra:
@@ -237,6 +245,7 @@ jobs:
       TF_VAR_PROVER_RESOURCE_PROFILE: ${{ inputs.prover_resource_profile }}
       TF_VAR_RPC_RESOURCE_PROFILE: ${{ inputs.rpc_resource_profile }}
       TF_VAR_RPC_EXTERNAL_INGRESS: ${{ inputs.rpc_external_ingress }}
+      TF_VAR_OTEL_COLLECTOR_URL: ${{ inputs.otel_collector_url }}
 
     steps:
       - name: Debug inputs

barretenberg/cpp/pil/vm2/alu.pil

@@ -119,7 +119,7 @@ pol EXPECTED_C_TAG = (sel_op_add + sel_op_sub + sel_op_mul + sel_op_div + sel_op
 // Gating with (1 - sel_tag_err) is necessary because when an error occurs, we have to set the tag to 0,
 // which might not be equal to EXPECTED_C_TAG.
 #[C_TAG_CHECK]
-(1 - sel_tag_err) * (EXPECTED_C_TAG - ic_tag) = 0;
+(1 - sel_err) * (EXPECTED_C_TAG - ic_tag) = 0;
 
 pol commit sel_tag_err;
 sel_tag_err * (1 - sel_tag_err) = 0;

barretenberg/cpp/pil/vm2/context.pil

@@ -12,6 +12,10 @@ namespace execution;
     #[skippable_if]
     sel = 0;
 
+    // TODO: make sure that all uses of `sel_error` here really should be "error" only
+    // since `sel_error` will not be ` for the REVERT opcode. If we need "error or REVERT",
+    // use `sel_failure`.
+
     // Guaranteed to be boolean because sel_execute_call & sel_execute_static_call are mutually exclusive
     pol commit sel_enter_call;
     // The following selectors will be 0 if there is an error during execution (before the opcode execution step).
@@ -33,7 +37,9 @@ namespace execution;
     pol commit contract_address;
     pol commit bytecode_id;
     pol commit transaction_fee;
-    // Constrained boolean by tx trace (for enqueued call) and #[NEXT_IS_STATIC] for nested
+    // Constrained boolean by tx trace for enqueued call, #[IS_STATIC_NEXT_ROW] during normal execution,
+    // IS_STATIC_IF_STATIC_CALL+IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT for nested calls,
+    // and CTX_STACK_CALL for returns or failures.
     pol commit is_static;
 
     pol commit parent_calldata_addr;
@@ -189,7 +195,12 @@ namespace execution;
     // otherwise        = 0 ==> is_static' = is_static
     #[IS_STATIC_NEXT_ROW]
     NOT_LAST_EXEC * DEFAULT_CTX_ROW * (is_static' - is_static) = 0;
-    NOT_LAST_EXEC * sel_enter_call  * (is_static' - sel_execute_static_call) = 0;
+    // An external call from a non-static context only creates a nested static context if the opcode is STATICCALL.
+    #[IS_STATIC_IF_STATIC_CALL]
+    NOT_LAST_EXEC * sel_enter_call * (1 - is_static) * (is_static' - sel_execute_static_call) = 0;
+    // An external call from a static context always creates a nested static context.
+    #[IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT]
+    NOT_LAST_EXEC * sel_enter_call * is_static * (is_static' - 1) = 0;
 
     // nested_exit_call = 1 ==> constraints come from lookup
     // sel_enter_call   = 1 ==> parent_calldata_addr' = rop[4] (resolved operand 5 from execution trace)

barretenberg/cpp/pil/vm2/execution.pil

@@ -147,7 +147,7 @@ sel_bytecode_retrieval_success {
 
 pol commit sel_instruction_fetching_success;
 // If sel = 0, we want sel_instruction_fetching_success = 0. We shouldn't be using it.
-sel_instruction_fetching_success = sel * (1 - sel_instruction_fetching_failure);
+sel_instruction_fetching_success = sel_bytecode_retrieval_success * (1 - sel_instruction_fetching_failure);
 
 #[INSTRUCTION_FETCHING_BODY]
 sel_instruction_fetching_success {

barretenberg/cpp/pil/vm2/tx.pil

@@ -306,7 +306,7 @@ namespace tx;
     execution.enqueued_call_end {
        execution.context_id,
        execution.next_context_id,
-       execution.sel_error,
+       execution.sel_failure,
        execution.discard,
        // Tree State
        execution.note_hash_tree_root,

barretenberg/cpp/src/barretenberg/vm2/constraining/relations/context.test.cpp

@@ -61,21 +61,25 @@ TEST(ContextConstrainingTest, ContextSwitchingCallReturn)
               { C::execution_context_id, 1 },
               { C::execution_next_context_id, 2 },
               { C::execution_bytecode_id, top_bytecode_id },
+              { C::execution_is_static, 0 }, // Non-static context
               { C::execution_parent_l2_gas_limit, 2000 },
               { C::execution_parent_da_gas_limit, 4000 },
               { C::execution_parent_l2_gas_used, 500 },
               { C::execution_parent_da_gas_used, 1500 },
+              { C::execution_enqueued_call_start, 1 },
           },
           // CALL
           {
               { C::execution_sel, 1 },
               { C::execution_pc, 1 },
               { C::execution_next_pc, 2 },
               { C::execution_sel_execute_call, 1 },
+              { C::execution_sel_execute_static_call, 0 }, // Regular CALL, not STATICCALL
               { C::execution_sel_enter_call, 1 },
               { C::execution_context_id, 1 },
               { C::execution_next_context_id, 2 },
               { C::execution_bytecode_id, top_bytecode_id }, // Same as previous row (propagated)
+              { C::execution_is_static, 0 },                 // Still non-static
               { C::execution_rop_4_, /*cd offset=*/10 },
               { C::execution_register_2_, /*contract address=*/0xdeadbeef },
               { C::execution_register_3_, /*cd size=*/1 },
@@ -96,6 +100,7 @@ TEST(ContextConstrainingTest, ContextSwitchingCallReturn)
               { C::execution_has_parent_ctx, 1 },
               { C::execution_contract_address, 0xdeadbeef },
               { C::execution_bytecode_id, nested_bytecode_id }, // New bytecode_id on entering new context
+              { C::execution_is_static, 0 },                    // Remains non-static after regular CALL
               { C::execution_parent_calldata_addr, 10 },
               { C::execution_parent_calldata_size, 1 },
           },
@@ -633,6 +638,137 @@ TEST(ContextConstrainingTest, BytecodeIdPropagation)
                               "BYTECODE_ID_NEXT_ROW"); // Should fail constraint
 }
 
+TEST(ContextConstrainingTest, IsStaticRegularCallFromNonStaticContext)
+{
+    // Non-static context making a regular CALL - should remain non-static
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 1 },
+            { C::execution_next_context_id, 2 },
+            { C::execution_is_static, 0 }, // Non-static context
+            { C::execution_sel_enter_call, 1 },
+            { C::execution_sel_execute_call, 1 }, // Regular CALL
+            { C::execution_sel_execute_static_call, 0 },
+        },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 2 },
+            { C::execution_next_context_id, 3 },
+            { C::execution_is_static, 0 }, // Should remain non-static
+        },
+    });
+    check_relation<context>(
+        trace, context::SR_IS_STATIC_IF_STATIC_CALL, context::SR_IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT);
+
+    // Negative test: change is_static
+    // regular call from non-static context cannot become static
+    trace.set(C::execution_is_static, 2, 1);
+    EXPECT_THROW_WITH_MESSAGE(check_relation<context>(trace, context::SR_IS_STATIC_IF_STATIC_CALL),
+                              "IS_STATIC_IF_STATIC_CALL");
+
+    // reset is_static
+    trace.set(C::execution_is_static, 2, 0);
+}
+
+TEST(ContextConstrainingTest, IsStaticStaticCallFromNonStaticContext)
+{
+    // Non-static context making a STATICCALL - should become static
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 1 },
+            { C::execution_next_context_id, 2 },
+            { C::execution_is_static, 0 }, // Non-static context
+            { C::execution_sel_enter_call, 1 },
+            { C::execution_sel_execute_call, 0 },
+            { C::execution_sel_execute_static_call, 1 }, // STATICCALL
+        },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 2 },
+            { C::execution_next_context_id, 3 },
+            { C::execution_is_static, 1 }, // Should become static
+        },
+    });
+    check_relation<context>(
+        trace, context::SR_IS_STATIC_IF_STATIC_CALL, context::SR_IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT);
+
+    // Negative test: change is_static
+    // static call from non-static context MUST become static
+    trace.set(C::execution_is_static, 2, 0);
+    EXPECT_THROW_WITH_MESSAGE(check_relation<context>(trace, context::SR_IS_STATIC_IF_STATIC_CALL),
+                              "IS_STATIC_IF_STATIC_CALL");
+
+    // reset is_static
+    trace.set(C::execution_is_static, 2, 1);
+}
+
+TEST(ContextConstrainingTest, IsStaticCallFromStaticContext)
+{
+    // Static context making any call - must remain static
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 1 },
+            { C::execution_next_context_id, 2 },
+            { C::execution_is_static, 1 }, // Static context
+            { C::execution_sel_enter_call, 1 },
+            { C::execution_sel_execute_call, 1 }, // Regular CALL
+            { C::execution_sel_execute_static_call, 0 },
+        },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 2 },
+            { C::execution_next_context_id, 3 },
+            { C::execution_is_static, 1 }, // Must remain static
+        },
+    });
+    check_relation<context>(
+        trace, context::SR_IS_STATIC_IF_STATIC_CALL, context::SR_IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT);
+
+    // Negative test: change is_static
+    // static call from static context MUST remain static
+    trace.set(C::execution_is_static, 2, 0);
+    EXPECT_THROW_WITH_MESSAGE(check_relation<context>(trace, context::SR_IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT),
+                              "IS_STATIC_IF_CALL_FROM_STATIC_CONTEXT");
+
+    // reset is_static
+    trace.set(C::execution_is_static, 2, 1);
+}
+
+TEST(ContextConstrainingTest, IsStaticPropagationWithoutCalls)
+{
+    // is_static propagation without calls
+    TestTraceContainer trace({
+        { { C::precomputed_first_row, 1 } },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 1 },
+            { C::execution_next_context_id, 1 },
+            { C::execution_is_static, 1 }, // Static context
+        },
+        {
+            { C::execution_sel, 1 },
+            { C::execution_context_id, 1 },
+            { C::execution_next_context_id, 1 },
+            { C::execution_is_static, 1 }, // Should propagate
+        },
+    });
+    check_relation<context>(trace, context::SR_IS_STATIC_NEXT_ROW);
+
+    // Negative test: change is_static
+    // staticness must propagate without calls
+    trace.set(C::execution_is_static, 2, 0);
+    EXPECT_THROW_WITH_MESSAGE(check_relation<context>(trace, context::SR_IS_STATIC_NEXT_ROW), "IS_STATIC_NEXT_ROW");
+
+    // reset is_static
+    trace.set(C::execution_is_static, 2, 1);
+}
+
 TEST(ContextConstrainingTest, ContextIdPropagation)
 {
     TestTraceContainer trace({

barretenberg/cpp/src/barretenberg/vm2/generated/relations/alu_impl.hpp

@@ -138,7 +138,7 @@ void aluImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
     }
     { // C_TAG_CHECK
         using Accumulator = typename std::tuple_element_t<8, ContainerOverSubrelations>;
-        auto tmp = (FF(1) - in.get(C::alu_sel_tag_err)) * (alu_EXPECTED_C_TAG - in.get(C::alu_ic_tag));
+        auto tmp = (FF(1) - in.get(C::alu_sel_err)) * (alu_EXPECTED_C_TAG - in.get(C::alu_ic_tag));
         tmp *= scaling_factor;
         std::get<8>(evals) += typename Accumulator::View(tmp);
     }