[event] record state access events

There are a few changes here:

- The ExecuteTransaction and ExecuteSystemTransaction functors are
  given a State object rather than creating one, so it can be owned
  by the outer transaction fiber. After the functor is done executing
  the transaction, this outer fiber gives the State to the recording
  code

- `class State` gains the `State::clear` method, so that it can be
  reset when re-execution is needed

- record_txn_events.cpp gains functions for recording State objects
  as `ACCOUNT_ACCESS_LIST_HEADER`, `ACCOUNT_ACCESS`, and
  `STORAGE_ACCESS` events

- All state-affecting changes to the block that occur before
  transaction and after the transaction are also recorded

Author: kjcamann

category/execution/ethereum/dispatch_transaction.cpp

@@ -25,7 +25,7 @@ Result<Receipt> dispatch_transaction(
     Address const &sender,
     std::vector<std::optional<Address>> const &authorities,
     BlockHeader const &header, BlockHashBuffer const &block_hash_buffer,
-    BlockState &block_state, BlockMetrics &block_metrics,
+    BlockMetrics &block_metrics, State &state,
     boost::fibers::promise<void> &prev, CallTracerBase &call_tracer,
     trace::StateTracer &state_tracer,
     RevertTransactionFn const &revert_transaction)
@@ -38,8 +38,8 @@ Result<Receipt> dispatch_transaction(
         authorities,
         header,
         block_hash_buffer,
-        block_state,
         block_metrics,
+        state,
         prev,
         call_tracer,
         state_tracer,

category/execution/ethereum/dispatch_transaction.hpp

@@ -34,7 +34,6 @@ MONAD_NAMESPACE_BEGIN
 
 class BlockHashBuffer;
 class BlockMetrics;
-class BlockState;
 class State;
 struct BlockHeader;
 struct CallTracerBase;
@@ -51,7 +50,7 @@ Result<Receipt> dispatch_transaction(
     Address const &sender,
     std::vector<std::optional<Address>> const &authorities,
     BlockHeader const &header, BlockHashBuffer const &block_hash_buffer,
-    BlockState &block_state, BlockMetrics &block_metrics,
+    BlockMetrics &block_metrics, State &state,
     boost::fibers::promise<void> &prev, CallTracerBase &call_tracer,
     trace::StateTracer &state_tracer,
     RevertTransactionFn const &revert_transaction);

category/execution/ethereum/event/record_txn_events.cpp

@@ -13,10 +13,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+#include <category/core/assert.h>
 #include <category/core/bytes.hpp>
 #include <category/core/config.hpp>
+#include <category/core/int.hpp>
 #include <category/core/keccak.hpp>
 #include <category/core/result.hpp>
+#include <category/execution/ethereum/core/account.hpp>
 #include <category/execution/ethereum/core/address.hpp>
 #include <category/execution/ethereum/core/eth_ctypes.h>
 #include <category/execution/ethereum/core/rlp/transaction_rlp.hpp>
@@ -25,11 +28,16 @@
 #include <category/execution/ethereum/event/exec_event_recorder.hpp>
 #include <category/execution/ethereum/event/record_txn_events.hpp>
 #include <category/execution/ethereum/execute_transaction.hpp>
+#include <category/execution/ethereum/state3/account_state.hpp>
+#include <category/execution/ethereum/state3/state.hpp>
+#include <category/execution/ethereum/state3/version_stack.hpp>
 #include <category/execution/ethereum/trace/call_frame.hpp>
 #include <category/execution/ethereum/validate_transaction.hpp>
 
 #include <bit>
+#include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <optional>
 #include <span>
 #include <utility>
@@ -66,6 +74,209 @@ void init_txn_header_start(
         static_cast<uint32_t>(txn.authorization_list.size());
 }
 
+// Tracks information about an accessed account, including (1) the prestate and
+// the (2) the modified state if a write access modified anything, with helper
+// functions to determine what was modified
+struct AccountAccessInfo
+{
+    Address const *address;
+    OriginalAccountState const *prestate; // State as it existed in original
+    AccountState const *modified_state; // Last state as it existed in current
+
+    bool is_read_only_access() const
+    {
+        return modified_state == nullptr;
+    }
+
+    std::pair<uint64_t, bool> get_nonce_modification() const
+    {
+        if (is_read_only_access()) {
+            return {0, false};
+        }
+        uint64_t const prestate_nonce =
+            is_dead(prestate->account_) ? 0 : prestate->account_->nonce;
+        uint64_t const modified_nonce = is_dead(modified_state->account_)
+                                            ? 0
+                                            : modified_state->account_->nonce;
+        return {modified_nonce, prestate_nonce != modified_nonce};
+    }
+
+    std::pair<uint256_t, bool> get_balance_modification() const
+    {
+        if (is_read_only_access()) {
+            return {0, false};
+        }
+
+        uint256_t const prestate_balance =
+            is_dead(prestate->account_) ? 0 : prestate->account_->balance;
+        uint256_t const modified_balance =
+            is_dead(modified_state->account_)
+                ? 0
+                : modified_state->account_->balance;
+        return {modified_balance, prestate_balance != modified_balance};
+    }
+};
+
+/// Reserves either a block-level or transaction-level event, depending on
+/// whether opt_txn_num is set or not; the account access events are allocated
+/// this way, as some of them occur at system scope
+template <typename T>
+ReservedExecEvent<T> reserve_event(
+    ExecutionEventRecorder *exec_recorder, monad_exec_event_type event_type,
+    std::optional<uint32_t> opt_txn_num)
+{
+    return opt_txn_num
+               ? exec_recorder->reserve_txn_event<T>(event_type, *opt_txn_num)
+               : exec_recorder->reserve_block_event<T>(event_type);
+}
+
+// Records a MONAD_EXEC_STORAGE_ACCESS event for all reads and writes in the
+// AccountState prestate and modified maps
+void record_storage_events(
+    ExecutionEventRecorder *exec_recorder,
+    monad_exec_account_access_context ctx, std::optional<uint32_t> opt_txn_num,
+    uint32_t account_index, Address const *address,
+    AccountState::Map<bytes32_t, bytes32_t> const *prestate_storage,
+    AccountState::Map<bytes32_t, bytes32_t> const *modified_storage,
+    bool is_transient)
+{
+    for (size_t index = 0; auto const &[key, value] : *prestate_storage) {
+        bool is_modified = false;
+        bytes32_t end_value = {};
+
+        if (modified_storage) {
+            if (auto const i = modified_storage->find(key);
+                i != end(*modified_storage)) {
+                end_value = i->second;
+                is_modified = end_value != value;
+            }
+        }
+
+        ReservedExecEvent const storage_access =
+            reserve_event<monad_exec_storage_access>(
+                exec_recorder, MONAD_EXEC_STORAGE_ACCESS, opt_txn_num);
+        *storage_access.payload = monad_exec_storage_access{
+            .address = *address,
+            .index = static_cast<uint32_t>(index),
+            .access_context = ctx,
+            .modified = is_modified,
+            .transient = is_transient,
+            .key = key,
+            .start_value = value,
+            .end_value = end_value,
+        };
+        storage_access.event->content_ext[MONAD_FLOW_ACCOUNT_INDEX] =
+            account_index;
+        exec_recorder->commit(storage_access);
+        ++index;
+    }
+}
+
+// Records an MONAD_EXEC_ACCOUNT_ACCESS event, and delegates to
+// record_storage_events to record both the ordinary and transient storage
+// accesses
+void record_account_events(
+    ExecutionEventRecorder *exec_recorder,
+    monad_exec_account_access_context ctx, std::optional<uint32_t> opt_txn_num,
+    uint32_t index, AccountAccessInfo const &account_info)
+{
+    MONAD_ASSERT(account_info.prestate);
+    monad_c_eth_account_state initial_state;
+    Account const &account = is_dead(account_info.prestate->account_)
+                                 ? Account{}
+                                 : *account_info.prestate->account_;
+
+    initial_state.nonce = account.nonce;
+    initial_state.balance = account.balance;
+    initial_state.code_hash = account.code_hash;
+
+    auto const [modified_balance, is_balance_modified] =
+        account_info.get_balance_modification();
+    auto const [modified_nonce, is_nonce_modified] =
+        account_info.get_nonce_modification();
+
+    ReservedExecEvent const account_access =
+        reserve_event<monad_exec_account_access>(
+            exec_recorder, MONAD_EXEC_ACCOUNT_ACCESS, opt_txn_num);
+    *account_access.payload = monad_exec_account_access{
+        .index = index,
+        .address = *account_info.address,
+        .access_context = ctx,
+        .is_balance_modified = is_balance_modified,
+        .is_nonce_modified = is_nonce_modified,
+        .prestate = initial_state,
+        .modified_balance = modified_balance,
+        .modified_nonce = modified_nonce,
+        .storage_key_count =
+            static_cast<uint32_t>(size(account_info.prestate->storage_)),
+        .transient_count = static_cast<uint32_t>(
+            size(account_info.prestate->transient_storage_))};
+    exec_recorder->commit(account_access);
+
+    auto const *const post_state_storage_map =
+        account_info.is_read_only_access()
+            ? nullptr
+            : &account_info.modified_state->storage_;
+    record_storage_events(
+        exec_recorder,
+        ctx,
+        opt_txn_num,
+        index,
+        account_info.address,
+        &account_info.prestate->storage_,
+        post_state_storage_map,
+        false);
+
+    auto const *const post_state_transient_map =
+        account_info.is_read_only_access()
+            ? nullptr
+            : &account_info.modified_state->transient_storage_;
+    record_storage_events(
+        exec_recorder,
+        ctx,
+        opt_txn_num,
+        index,
+        account_info.address,
+        &account_info.prestate->transient_storage_,
+        post_state_transient_map,
+        true);
+}
+
+// Function that records all state accesses and changes that occurred in some
+// scope, either the block prologue, block epilogue, or in the scope of some
+// transaction
+void record_account_access_events_internal(
+    ExecutionEventRecorder *exec_recorder,
+    monad_exec_account_access_context ctx, std::optional<uint32_t> opt_txn_num,
+    State const &state)
+{
+    auto const &prestate_map = state.original();
+
+    ReservedExecEvent const list_header =
+        reserve_event<monad_exec_account_access_list_header>(
+            exec_recorder, MONAD_EXEC_ACCOUNT_ACCESS_LIST_HEADER, opt_txn_num);
+    *list_header.payload = monad_exec_account_access_list_header{
+        .entry_count = static_cast<uint32_t>(prestate_map.size()),
+        .access_context = ctx};
+    exec_recorder->commit(list_header);
+
+    auto const &current_state_map = state.current();
+    for (uint32_t index = 0; auto const &[address, prestate] : prestate_map) {
+        AccountState const *current_state = nullptr;
+        if (auto const i = current_state_map.find(address);
+            i != end(current_state_map)) {
+            current_state = std::addressof(i->second.recent());
+        }
+        record_account_events(
+            exec_recorder,
+            ctx,
+            opt_txn_num,
+            index,
+            AccountAccessInfo{&address, &prestate, current_state});
+        index++;
+    }
+}
+
 MONAD_ANONYMOUS_NAMESPACE_END
 
 MONAD_NAMESPACE_BEGIN
@@ -74,7 +285,7 @@ void record_txn_events(
     uint32_t txn_num, Transaction const &transaction, Address const &sender,
     std::span<std::optional<Address> const> authorities,
     Result<Receipt> const &receipt_result,
-    std::span<CallFrame const> const call_frames)
+    std::span<CallFrame const> const call_frames, State const &txn_state)
 {
     ExecutionEventRecorder *const exec_recorder = g_exec_event_recorder.get();
     if (exec_recorder == nullptr) {
@@ -223,7 +434,23 @@ void record_txn_events(
         ++index;
     }
 
+    // Account access records for the transaction
+    record_account_access_events_internal(
+        exec_recorder, MONAD_ACCT_ACCESS_TRANSACTION, txn_num, txn_state);
+
     exec_recorder->record_txn_marker_event(MONAD_EXEC_TXN_END, txn_num);
 }
 
+// The externally-visible wrapper of the account-access-recording function that
+// is called from execute_block.cpp, to record prologue and epilogue accesses;
+// transaction-scope state accesses use record_txn_exec_result_events instead
+void record_account_access_events(
+    monad_exec_account_access_context ctx, State const &state)
+{
+    if (ExecutionEventRecorder *const e = g_exec_event_recorder.get()) {
+        return record_account_access_events_internal(
+            e, ctx, std::nullopt, state);
+    }
+}
+
 MONAD_NAMESPACE_END

category/execution/ethereum/event/record_txn_events.hpp

@@ -23,12 +23,16 @@
 #include <optional>
 #include <span>
 
+enum monad_exec_account_access_context : uint8_t;
+
 MONAD_NAMESPACE_BEGIN
 
 struct CallFrame;
 struct Receipt;
 struct Transaction;
 
+class State;
+
 /// Record the transaction header events (TXN_HEADER_START, the EIP-2930
 /// and EIP-7702 events, and TXN_HEADER_END), followed by the TXN_EVM_OUTPUT,
 /// TXN_REJECT, or EVM_ERROR events, depending on what happened during
@@ -37,6 +41,11 @@ struct Transaction;
 void record_txn_events(
     uint32_t txn_num, Transaction const &, Address const &sender,
     std::span<std::optional<Address> const> authorities,
-    Result<Receipt> const &, std::span<CallFrame const>);
+    Result<Receipt> const &, std::span<CallFrame const>, State const &);
+
+/// Record all account state accesses (both reads and writes) described by a
+/// State object
+void record_account_access_events(
+    monad_exec_account_access_context, State const &);
 
 MONAD_NAMESPACE_END

category/execution/ethereum/execute_block.cpp

@@ -206,6 +206,7 @@ void execute_block_header(
 
     MONAD_ASSERT(block_state.can_merge(state));
     block_state.merge(state);
+    record_account_access_events(MONAD_ACCT_ACCESS_BLOCK_PROLOGUE, state);
 }
 
 EXPLICIT_TRAITS(execute_block_header);
@@ -255,6 +256,7 @@ Result<std::vector<Receipt>> execute_block_transactions(
              &txn_exec_finished,
              &revert_transaction = revert_transaction] {
                 record_txn_marker_event(MONAD_EXEC_TXN_PERF_EVM_ENTER, i);
+                State state{block_state, Incarnation{header.number, i + 1}};
                 try {
                     results[i] = dispatch_transaction<traits>(
                         chain,
@@ -264,8 +266,8 @@ Result<std::vector<Receipt>> execute_block_transactions(
                         authorities,
                         header,
                         block_hash_buffer,
-                        block_state,
                         block_metrics,
+                        state,
                         promises[i],
                         call_tracer,
                         state_tracer,
@@ -278,7 +280,8 @@ Result<std::vector<Receipt>> execute_block_transactions(
                         sender,
                         authorities,
                         *results[i],
-                        call_tracer.get_call_frames());
+                        call_tracer.get_call_frames(),
+                        state);
                 }
                 catch (...) {
                     promises[i + 1].set_exception(std::current_exception());
@@ -296,8 +299,8 @@ Result<std::vector<Receipt>> execute_block_transactions(
     // All transactions have released their merge-order synchronization
     // primitive (promises[i + 1]) but some stragglers could still be running
     // post-execution code that occurs immediately after that, e.g.
-    // `record_txn_exec_result_events`. This waits for everything to finish
-    // so that it's safe to assume we're the only ones using `results`.
+    // `record_txn_events`. This waits for everything to finish so that it's
+    // safe to assume we're the only ones using `results`.
     while (txn_exec_finished.load() < txn_count) {
         cpu_relax();
     }
@@ -377,6 +380,7 @@ Result<std::vector<Receipt>> execute_block(
 
     MONAD_ASSERT(block_state.can_merge(state));
     block_state.merge(state);
+    record_account_access_events(MONAD_ACCT_ACCESS_BLOCK_EPILOGUE, state);
 
     return retvals;
 }