inline the revert transaction logic

Author: zander-xyz

cmd/CMakeLists.txt

@@ -24,8 +24,6 @@ add_executable(
   monad/event.hpp
   monad/file_io.hpp
   monad/file_io.cpp
-  monad/revert_transaction_generator.cpp
-  monad/revert_transaction_generator.hpp
   monad/runloop_ethereum.cpp
   monad/runloop_ethereum.hpp
   monad/runloop_monad.cpp

cmd/monad/revert_transaction_generator.cpp

@@ -36,6 +36,8 @@
 #include <category/execution/ethereum/trace/call_tracer.hpp>
 #include <category/execution/ethereum/validate_block.hpp>
 #include <category/execution/ethereum/validate_transaction.hpp>
+#include <category/execution/monad/chain/monad_chain.hpp>
+#include <category/execution/monad/validate_monad_block.hpp>
 #include <category/vm/evm/explicit_traits.hpp>
 #include <category/vm/evm/switch_traits.hpp>
 #include <category/vm/evm/traits.hpp>
@@ -91,8 +93,7 @@ Result<BlockHeader> process_ethereum_block(
     BlockHashBuffer const &block_hash_buffer,
     fiber::PriorityPool &priority_pool, Block const &block,
     bytes32_t const &block_id, bytes32_t const &parent_block_id,
-    bool const enable_tracing,
-    RevertTransactionGeneratorFn const &make_revert_transaction)
+    bool const enable_tracing, BlockCache *const block_cache)
 {
     [[maybe_unused]] auto const block_start = std::chrono::system_clock::now();
     auto const block_begin = std::chrono::steady_clock::now();
@@ -142,9 +143,88 @@ Result<BlockHeader> process_ethereum_block(
     db.set_block_and_prefix(block.header.number - 1, parent_block_id);
     BlockMetrics block_metrics;
     BlockState block_state(db, vm);
-    BOOST_OUTCOME_TRY(
-        RevertTransactionFn const revert_transaction,
-        make_revert_transaction(senders, recovered_authorities));
+
+    // Build the revert transaction function
+    RevertTransactionFn revert_transaction =
+        [](Address const &, Transaction const &, uint64_t, State &) {
+            return false;
+        };
+    if constexpr (is_monad_trait_v<traits>) {
+        // Monad-specific revert transaction logic
+        BOOST_OUTCOME_TRY(static_validate_monad_senders<traits>(senders));
+
+        // Update the BlockCache with this block's senders and authorities
+        MONAD_ASSERT(block_cache, "block_cache required for Monad traits");
+        auto [entry, success] = block_cache->emplace(
+            block_id,
+            BlockCacheEntry{
+                .block_number = block.header.number,
+                .parent_id = parent_block_id,
+                .senders_and_authorities = {}});
+        MONAD_ASSERT(success, "should never be processing duplicate block");
+        for (Address const &sender : senders) {
+            entry->second.senders_and_authorities.insert(sender);
+        }
+        for (std::vector<std::optional<Address>> const &authorities :
+             recovered_authorities) {
+            for (std::optional<Address> const &authority : authorities) {
+                if (authority.has_value()) {
+                    entry->second.senders_and_authorities.insert(
+                        authority.value());
+                }
+            }
+        }
+
+        // Make the chain context, providing the parent and grandparent
+        MonadChainContext chain_context{
+            .grandparent_senders_and_authorities = nullptr,
+            .parent_senders_and_authorities = nullptr,
+            .senders_and_authorities =
+                block_cache->at(block_id).senders_and_authorities,
+            .senders = senders,
+            .authorities = recovered_authorities};
+
+        if (block.header.number > 1) {
+            MONAD_ASSERT(
+                block_cache->contains(parent_block_id),
+                "block cache must contain parent");
+            BlockCacheEntry const &parent_entry =
+                block_cache->at(parent_block_id);
+            chain_context.parent_senders_and_authorities =
+                &parent_entry.senders_and_authorities;
+            if (block.header.number > 2) {
+                bytes32_t const &grandparent_id = parent_entry.parent_id;
+                MONAD_ASSERT(
+                    block_cache->contains(grandparent_id),
+                    "block cache must contain grandparent");
+                BlockCacheEntry const &grandparent_entry =
+                    block_cache->at(grandparent_id);
+                chain_context.grandparent_senders_and_authorities =
+                    &grandparent_entry.senders_and_authorities;
+            }
+        }
+
+        // Capture chain reference for the revert transaction function
+        MonadChain const *const monad_chain =
+            dynamic_cast<MonadChain const *>(&chain);
+        MONAD_ASSERT(monad_chain, "chain must be a MonadChain");
+        revert_transaction = [monad_chain, &block, chain_context](
+                                 Address const &sender,
+                                 Transaction const &tx,
+                                 uint64_t const i,
+                                 State &state) {
+            return monad_chain->revert_transaction(
+                block.header.number,
+                block.header.timestamp,
+                sender,
+                tx,
+                block.header.base_fee_per_gas.value_or(0),
+                i,
+                state,
+                chain_context);
+        };
+    }
+
     record_block_marker_event(MONAD_EXEC_BLOCK_PERF_EVM_ENTER);
     BOOST_OUTCOME_TRY(
         auto const receipts,

cmd/monad/revert_transaction_generator.hpp

@@ -15,14 +15,15 @@
 
 #pragma once
 
-#include "revert_transaction_generator.hpp"
-
 #include <category/core/bytes.hpp>
 #include <category/core/config.hpp>
 #include <category/core/result.hpp>
+#include <category/execution/ethereum/core/address.hpp>
 #include <category/vm/evm/traits.hpp>
 #include <category/vm/vm.hpp>
 
+#include <ankerl/unordered_dense.h>
+
 #include <cstdint>
 #include <filesystem>
 #include <utility>
@@ -43,21 +44,23 @@ namespace fiber
     class PriorityPool;
 }
 
+struct BlockCacheEntry
+{
+    uint64_t block_number;
+    bytes32_t parent_id;
+    ankerl::unordered_dense::segmented_set<Address> senders_and_authorities;
+};
+
+using BlockCache =
+    ankerl::unordered_dense::segmented_map<bytes32_t, BlockCacheEntry>;
+
 template <Traits traits>
 Result<BlockHeader> process_ethereum_block(
     Chain const &chain, Db &db, vm::VM &vm,
     BlockHashBuffer const &block_hash_buffer,
     fiber::PriorityPool &priority_pool, Block const &block,
     bytes32_t const &block_id, bytes32_t const &parent_block_id,
-    bool const enable_tracing,
-    RevertTransactionGeneratorFn const & =
-        [](std::vector<Address> const &,
-           std::vector<std::vector<std::optional<Address>>> const &)
-            -> Result<RevertTransactionFn> {
-        return [](Address const &, Transaction const &, uint64_t, State &) {
-            return false;
-        };
-    });
+    bool const enable_tracing, BlockCache * = nullptr);
 
 Result<std::pair<uint64_t, uint64_t>> runloop_ethereum(
     Chain const &, std::filesystem::path const &, Db &, vm::VM &,

cmd/monad/runloop_ethereum.cpp

@@ -15,7 +15,6 @@
 
 #include "runloop_monad.hpp"
 #include "file_io.hpp"
-#include "revert_transaction_generator.hpp"
 #include "runloop_ethereum.hpp"
 
 #include <category/core/assert.h>
@@ -150,12 +149,6 @@ Result<BlockExecOutput> propose_block(
     BlockHashBuffer const &block_hash_buffer =
         block_hash_chain.find_chain(consensus_header.parent_id());
 
-    // make a generator which is able to return the revert function based on
-    // purely ethereum concepts
-    RevertTransactionGeneratorFn const make_revert_transaction =
-        revert_transaction_generator<traits>(
-            block_id, consensus_header.parent_id(), block, chain, block_cache);
-
     // Block input validation
     BOOST_OUTCOME_TRY(static_validate_consensus_header(consensus_header));
 
@@ -173,7 +166,7 @@ Result<BlockExecOutput> propose_block(
             block_id,
             is_first_block ? bytes32_t{} : consensus_header.parent_id(),
             enable_tracing,
-            make_revert_transaction));
+            &block_cache));
 
     // Commit prologue: computation of the Ethereum block hash to append to
     // the circular hash buffer