feat(avm): vm2 initial context (#12972)

This adds the initial work for `context` and `context_stack` to vm2. The
interfaces will still need to be updated in the future, but it sets up
the points where the context events will happen (i.e. at the end of the
main execution loop and within `call`).

This also outlines the contents of the two events albeit commented out
for now (until we have the supported inputs in the context itself)

Author: IlyasRidhuan

barretenberg/cpp/pil/vm2/context.pil

@@ -0,0 +1,10 @@
+// This is a virtual gadget, which is part of the execution trace.
+namespace execution;
+
+    pol commit context_id;
+    pol commit pc;
+    pol commit msg_sender;
+    pol commit contract_address;
+    
+    pol commit is_static;
+    is_static * (1 - is_static) = 0;

barretenberg/cpp/pil/vm2/context_stack.pil

@@ -0,0 +1,9 @@
+namespace context_stack;
+
+    pol commit context_id;
+    pol commit pc;
+    pol commit msg_sender;
+    pol commit contract_address;
+    
+    pol commit is_static;
+    is_static * (1 - is_static) = 0;

barretenberg/cpp/pil/vm2/execution.pil

@@ -17,6 +17,8 @@ include "poseidon2_perm.pil";
 include "scalar_mul.pil";
 include "to_radix.pil";
 include "ff_gt.pil";
+include "context.pil;"
+include "context_stack.pil";
 
 namespace execution;
 
@@ -29,7 +31,6 @@ pol commit op1, op2, op3, op4;
 // resolved operands
 pol commit rop1, rop2, rop3, rop4;
 
-pol commit pc;
 pol commit bytecode_id;
 pol commit clk;
 pol commit last;

barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp

@@ -25,6 +25,8 @@
 #include "relations/bc_retrieval.hpp"
 #include "relations/bitwise.hpp"
 #include "relations/class_id_derivation.hpp"
+#include "relations/context.hpp"
+#include "relations/context_stack.hpp"
 #include "relations/ecc.hpp"
 #include "relations/execution.hpp"
 #include "relations/ff_gt.hpp"
@@ -94,12 +96,12 @@ class AvmFlavor {
     static constexpr bool HasZK = false;
 
     static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 44;
-    static constexpr size_t NUM_WITNESS_ENTITIES = 914;
+    static constexpr size_t NUM_WITNESS_ENTITIES = 923;
     static constexpr size_t NUM_SHIFTED_ENTITIES = 134;
     static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES;
     // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for
     // the unshifted and one for the shifted
-    static constexpr size_t NUM_ALL_ENTITIES = 1092;
+    static constexpr size_t NUM_ALL_ENTITIES = 1101;
 
     // In the sumcheck univariate computation, we divide the trace in chunks and each chunk is
     // evenly processed by all the threads. This constant defines the maximum number of rows
@@ -122,6 +124,8 @@ class AvmFlavor {
         avm2::bc_retrieval<FF_>,
         avm2::bitwise<FF_>,
         avm2::class_id_derivation<FF_>,
+        avm2::context<FF_>,
+        avm2::context_stack<FF_>,
         avm2::ecc<FF_>,
         avm2::execution<FF_>,
         avm2::ff_gt<FF_>,

barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp

@@ -0,0 +1,44 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include <string_view>
+
+#include "barretenberg/relations/relation_parameters.hpp"
+#include "barretenberg/relations/relation_types.hpp"
+
+namespace bb::avm2 {
+
+template <typename FF_> class contextImpl {
+  public:
+    using FF = FF_;
+
+    static constexpr std::array<size_t, 1> SUBRELATION_PARTIAL_LENGTHS = { 3 };
+
+    template <typename ContainerOverSubrelations, typename AllEntities>
+    void static accumulate(ContainerOverSubrelations& evals,
+                           const AllEntities& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>&,
+                           [[maybe_unused]] const FF& scaling_factor)
+    {
+
+        {
+            using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>;
+            auto tmp = new_term.execution_is_static * (FF(1) - new_term.execution_is_static);
+            tmp *= scaling_factor;
+            std::get<0>(evals) += typename Accumulator::View(tmp);
+        }
+    }
+};
+
+template <typename FF> class context : public Relation<contextImpl<FF>> {
+  public:
+    static constexpr const std::string_view NAME = "context";
+
+    static std::string get_subrelation_label(size_t index)
+    {
+        switch (index) {}
+        return std::to_string(index);
+    }
+};
+
+} // namespace bb::avm2

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

@@ -0,0 +1,44 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include <string_view>
+
+#include "barretenberg/relations/relation_parameters.hpp"
+#include "barretenberg/relations/relation_types.hpp"
+
+namespace bb::avm2 {
+
+template <typename FF_> class context_stackImpl {
+  public:
+    using FF = FF_;
+
+    static constexpr std::array<size_t, 1> SUBRELATION_PARTIAL_LENGTHS = { 3 };
+
+    template <typename ContainerOverSubrelations, typename AllEntities>
+    void static accumulate(ContainerOverSubrelations& evals,
+                           const AllEntities& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>&,
+                           [[maybe_unused]] const FF& scaling_factor)
+    {
+
+        {
+            using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>;
+            auto tmp = new_term.context_stack_is_static * (FF(1) - new_term.context_stack_is_static);
+            tmp *= scaling_factor;
+            std::get<0>(evals) += typename Accumulator::View(tmp);
+        }
+    }
+};
+
+template <typename FF> class context_stack : public Relation<context_stackImpl<FF>> {
+  public:
+    static constexpr const std::string_view NAME = "context_stack";
+
+    static std::string get_subrelation_label(size_t index)
+    {
+        switch (index) {}
+        return std::to_string(index);
+    }
+};
+
+} // namespace bb::avm2

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

@@ -30,28 +30,38 @@ class ContextInterface {
     virtual bool halted() const = 0;
     virtual void halt() = 0;
 
+    virtual uint32_t get_context_id() const = 0;
+
     // Environment.
     virtual const AztecAddress& get_address() const = 0;
     virtual const AztecAddress& get_msg_sender() const = 0;
     virtual std::span<const FF> get_calldata() const = 0;
     virtual bool get_is_static() const = 0;
+
+    // Events
+    virtual void emit_context_snapshot() = 0;
+    virtual ContextEvent get_current_context() = 0;
 };
 
 // The context for a single nested call.
-class Context : public ContextInterface {
+class BaseContext : public ContextInterface {
   public:
-    Context(AztecAddress address,
-            AztecAddress msg_sender,
-            std::span<const FF> calldata,
-            bool is_static,
-            std::unique_ptr<BytecodeManagerInterface> bytecode,
-            std::unique_ptr<MemoryInterface> memory)
+    BaseContext(uint32_t context_id,
+                AztecAddress address,
+                AztecAddress msg_sender,
+                std::span<const FF> calldata,
+                bool is_static,
+                std::unique_ptr<BytecodeManagerInterface> bytecode,
+                std::unique_ptr<MemoryInterface> memory,
+                EventEmitterInterface<ContextStackEvent>& ctx_stack_events)
         : address(address)
         , msg_sender(msg_sender)
         , calldata(calldata.begin(), calldata.end())
         , is_static(is_static)
+        , context_id(context_id)
         , bytecode(std::move(bytecode))
         , memory(std::move(memory))
+        , ctx_stack_events(ctx_stack_events)
     {}
 
     // Having getters and setters make it easier to mock the context.
@@ -66,26 +76,94 @@ class Context : public ContextInterface {
     bool halted() const override { return has_halted; }
     void halt() override { has_halted = true; }
 
+    uint32_t get_context_id() const override { return context_id; }
+
     // Environment.
     const AztecAddress& get_address() const override { return address; }
     const AztecAddress& get_msg_sender() const override { return msg_sender; }
     std::span<const FF> get_calldata() const override { return calldata; }
     bool get_is_static() const override { return is_static; }
 
+    // Event Emitting
+    void emit_context_snapshot() override
+    {
+        ctx_stack_events.emit({ .id = context_id,
+                                .next_pc = next_pc,
+                                .msg_sender = msg_sender,
+                                .contract_addr = address,
+                                .is_static = is_static });
+    };
+
+    ContextEvent get_current_context() override
+    {
+        return {
+            .id = context_id, .pc = pc, .msg_sender = msg_sender, .contract_addr = address, .is_static = is_static
+        };
+    };
+
   private:
     // Environment.
     AztecAddress address;
     AztecAddress msg_sender;
     std::vector<FF> calldata;
     bool is_static;
 
+    uint32_t context_id;
+
     // Machine state.
     uint32_t pc = 0;
     uint32_t next_pc = 0;
     bool has_halted = false;
     std::vector<FF> nested_returndata;
     std::unique_ptr<BytecodeManagerInterface> bytecode;
     std::unique_ptr<MemoryInterface> memory;
+
+    // Emiiters
+    EventEmitterInterface<ContextStackEvent>& ctx_stack_events;
+};
+
+// TODO(ilyas): flesh these out in the cpp file, these are just temporary
+class EnqueuedCallContext : public BaseContext {
+  public:
+    EnqueuedCallContext(uint32_t context_id,
+                        AztecAddress address,
+                        AztecAddress msg_sender,
+                        std::span<const FF> calldata,
+                        bool is_static,
+                        std::unique_ptr<BytecodeManagerInterface> bytecode,
+                        std::unique_ptr<MemoryInterface> memory,
+                        EventEmitterInterface<ContextStackEvent>& ctx_stack_events)
+        : BaseContext(context_id,
+                      address,
+                      msg_sender,
+                      calldata,
+                      is_static,
+                      std::move(bytecode),
+                      std::move(memory),
+                      ctx_stack_events)
+    {}
+};
+
+// Parameters for a nested call need to be changed
+class NestedContext : public BaseContext {
+  public:
+    NestedContext(uint32_t context_id,
+                  AztecAddress address,
+                  AztecAddress msg_sender,
+                  std::span<const FF> calldata,
+                  bool is_static,
+                  std::unique_ptr<BytecodeManagerInterface> bytecode,
+                  std::unique_ptr<MemoryInterface> memory,
+                  EventEmitterInterface<ContextStackEvent>& ctx_stack_events)
+        : BaseContext(context_id,
+                      address,
+                      msg_sender,
+                      calldata,
+                      is_static,
+                      std::move(bytecode),
+                      std::move(memory),
+                      ctx_stack_events)
+    {}
 };
 
 } // namespace bb::avm2::simulation

barretenberg/cpp/src/barretenberg/vm2/simulation/context.hpp

@@ -2,14 +2,63 @@
 
 #include <cstdint>
 
+#include "barretenberg/vm2/common/aztec_types.hpp"
+
 namespace bb::avm2::simulation {
 
 struct ContextEvent {
-    uint32_t whatever_is_needed = 0;
+    uint32_t id;
+    // uint32_t parent_id;
+
+    // State
+    uint32_t pc;
+    AztecAddress msg_sender;
+    AztecAddress contract_addr;
+    bool is_static;
+
+    // Calldata info
+    // uint32_t cd_addr;
+    // uint32_t cd_size_addr;
+
+    // Returndata info
+    // uint32_t rd_addr;
+    // uint32_t rd_size_addr;
+
+    // Success
+    // bool nested_ctx_success;
+
+    // Gas
+    // uint32_t l2_gas_used;
+    // uint32_t l2_gas_limit;
+    // uint32_t da_gas_used;
+    // uint32_t da_gas_limit;
+
+    // Tree State
+    // TreeSnapshots tree_state;
 };
 
 struct ContextStackEvent {
-    uint32_t whatever_is_snapshot = 0;
+    uint32_t id;
+    // uint32_t parent_id;
+
+    // State
+    uint32_t next_pc;
+    AztecAddress msg_sender;
+    AztecAddress contract_addr;
+    bool is_static;
+
+    // Calldata info
+    // uint32_t cd_addr;
+    // uint32_t cd_size_addr;
+
+    // Gas
+    // uint32_t l2_gas_used;
+    // uint32_t l2_gas_limit;
+    // uint32_t da_gas_used;
+    // uint32_t da_gas_limit;
+
+    // Tree State
+    // TreeSnapshots tree_state;
 };
 
 } // namespace bb::avm2::simulation

barretenberg/cpp/src/barretenberg/vm2/simulation/events/context_events.hpp

@@ -41,6 +41,7 @@ struct EventsContainer {
     EventEmitterInterface<FieldGreaterThanEvent>::Container field_gt;
     EventEmitterInterface<MerkleCheckEvent>::Container merkle_check;
     EventEmitterInterface<RangeCheckEvent>::Container range_check;
+    EventEmitterInterface<ContextStackEvent>::Container context_stack;
 };
 
 } // namespace bb::avm2::simulation