feat: L1 contract etherscan verification

Author: spypsy

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_err) * (EXPECTED_C_TAG - ic_tag) = 0;
+(1 - sel_tag_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,10 +12,6 @@ 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).
@@ -37,9 +33,7 @@ namespace execution;
     pol commit contract_address;
     pol commit bytecode_id;
     pol commit transaction_fee;
-    // 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.
+    // Constrained boolean by tx trace (for enqueued call) and #[NEXT_IS_STATIC] for nested
     pol commit is_static;
 
     pol commit parent_calldata_addr;
@@ -195,12 +189,7 @@ namespace execution;
     // otherwise        = 0 ==> is_static' = is_static
     #[IS_STATIC_NEXT_ROW]
     NOT_LAST_EXEC * DEFAULT_CTX_ROW * (is_static' - is_static) = 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;
+    NOT_LAST_EXEC * sel_enter_call  * (is_static' - sel_execute_static_call) = 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_bytecode_retrieval_success * (1 - sel_instruction_fetching_failure);
+sel_instruction_fetching_success = sel * (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_failure,
+       execution.sel_error,
        execution.discard,
        // Tree State
        execution.note_hash_tree_root,

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

@@ -61,25 +61,21 @@ 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 },
@@ -100,7 +96,6 @@ 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 },
           },
@@ -638,137 +633,6 @@ 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_err)) * (alu_EXPECTED_C_TAG - in.get(C::alu_ic_tag));
+        auto tmp = (FF(1) - in.get(C::alu_sel_tag_err)) * (alu_EXPECTED_C_TAG - in.get(C::alu_ic_tag));
         tmp *= scaling_factor;
         std::get<8>(evals) += typename Accumulator::View(tmp);
     }