reserve balance checks now use the final state code hash

Author: aa755

category/execution/ethereum/test/test_monad_chain.cpp

@@ -360,7 +360,7 @@ TEST(MonadChain, can_sender_dip_into_reserve)
             .authorities = authorities,
         };
         EXPECT_FALSE(
-            can_sender_dip_into_reserve(Address{1}, 1, NULL_HASH, context));
+            can_sender_dip_into_reserve(Address{1}, 1, false, context));
     }
 
     // False because of authority
@@ -378,7 +378,82 @@ TEST(MonadChain, can_sender_dip_into_reserve)
             .authorities = authorities,
         };
         EXPECT_FALSE(
-            can_sender_dip_into_reserve(Address{1}, 1, NULL_HASH, context));
+            can_sender_dip_into_reserve(Address{1}, 1, false, context));
+    }
+}
+
+TYPED_TEST(MonadTraitsTest, reserve_checks_code_hash)
+{
+    using traits = typename TestFixture::Trait;
+    constexpr Address SENDER{1};
+    constexpr Address NEW_CONTRACT{2};
+    constexpr uint64_t BASE_FEE_PER_GAS = 10;
+    auto const to_wei = [](uint64_t mon) {
+        return uint256_t{mon} * 1000000000000000000ULL;
+    };
+
+    InMemoryMachine machine;
+    mpt::Db db{machine};
+    TrieDb tdb{db};
+    vm::VM vm;
+    BlockState bs{tdb, vm};
+
+    {
+        State init_state{bs, Incarnation{0, 0}};
+        init_state.add_to_balance(SENDER, to_wei(20));
+        init_state.add_to_balance(NEW_CONTRACT, to_wei(3));
+        MONAD_ASSERT(bs.can_merge(init_state));
+        bs.merge(init_state);
+    }
+
+    Transaction const tx{
+        .max_fee_per_gas = BASE_FEE_PER_GAS,
+        .gas_limit = 1,
+        .type = TransactionType::legacy,
+        .max_priority_fee_per_gas = 0,
+    };
+    uint256_t const gas_cost =
+        uint256_t{BASE_FEE_PER_GAS} * uint256_t{tx.gas_limit};
+
+    std::vector<Address> const senders = {SENDER};
+    std::vector<std::vector<std::optional<Address>>> const authorities = {{}};
+    ankerl::unordered_dense::segmented_set<Address> senders_and_authorities;
+    senders_and_authorities.insert(SENDER);
+    MonadChainContext const context{
+        .grandparent_senders_and_authorities = nullptr,
+        .parent_senders_and_authorities = nullptr,
+        .senders_and_authorities = senders_and_authorities,
+        .senders = senders,
+        .authorities = authorities};
+
+    auto const prepare_state = [&](State &state) {
+        state.subtract_from_balance(SENDER, gas_cost);
+        state.subtract_from_balance(NEW_CONTRACT, to_wei(3));
+        byte_string const contract_code{0x60, 0x00};
+        state.set_code(NEW_CONTRACT, contract_code);
+    };
+
+    State state{bs, Incarnation{1, 1}};
+    prepare_state(state);
+
+    bool const should_revert = revert_monad_transaction(
+        traits::monad_rev(),
+        traits::evm_rev(),
+        SENDER,
+        tx,
+        BASE_FEE_PER_GAS,
+        0,
+        state,
+        context);
+
+    if constexpr (traits::monad_rev() < MONAD_FOUR) {
+        EXPECT_FALSE(should_revert);
+    }
+    else if constexpr (traits::monad_rev() >= MONAD_NEXT) {
+        EXPECT_FALSE(should_revert);
+    }
+    else {
+        EXPECT_TRUE(should_revert);
     }
 }
 

category/execution/monad/reserve_balance.cpp

@@ -22,6 +22,7 @@
 #include <category/execution/monad/reserve_balance.h>
 #include <category/execution/monad/reserve_balance.hpp>
 #include <category/vm/evm/delegation.hpp>
+#include <category/vm/evm/monad/revision.h>
 #include <category/vm/interpreter/intercode.hpp>
 
 #include <ankerl/unordered_dense.h>
@@ -51,16 +52,21 @@ bool dipped_into_reserve(
     uint256_t const gas_fees =
         uint256_t{tx.gas_limit} * gas_price(rev, tx, base_fee_per_gas);
     auto const &orig = state.original();
-    for (auto const &[addr, _] : state.current()) {
+    for (auto const &[addr, cur_account] : state.current()) {
         MONAD_ASSERT(orig.contains(addr));
         bytes32_t const orig_code_hash = orig.at(addr).get_code_hash();
+        bytes32_t const effective_code_hash =
+            (monad_rev >= MONAD_NEXT) ? cur_account.recent().get_code_hash()
+                                      : orig_code_hash;
+        bool effective_is_delegated = false;
 
         // Skip if not EOA
-        if (orig_code_hash != NULL_HASH) {
+        if (effective_code_hash != NULL_HASH) {
             vm::SharedIntercode const intercode =
-                state.read_code(orig_code_hash)->intercode();
-            if (!monad::vm::evm::is_delegated(
-                    {intercode->code(), intercode->size()})) {
+                state.read_code(effective_code_hash)->intercode();
+            effective_is_delegated = monad::vm::evm::is_delegated(
+                {intercode->code(), intercode->size()});
+            if (!effective_is_delegated) {
                 continue;
             }
         }
@@ -86,7 +92,7 @@ bool dipped_into_reserve(
             curr_balance < violation_threshold.value()) {
             if (addr == sender) {
                 if (!can_sender_dip_into_reserve(
-                        sender, i, orig_code_hash, ctx)) {
+                        sender, i, effective_is_delegated, ctx)) {
                     MONAD_ASSERT(
                         violation_threshold.has_value(),
                         "gas fee greater than reserve for non-dipping "
@@ -127,10 +133,10 @@ bool revert_monad_transaction(
 }
 
 bool can_sender_dip_into_reserve(
-    Address const &sender, uint64_t const i, bytes32_t const &orig_code_hash,
+    Address const &sender, uint64_t const i, bool const sender_is_delegated,
     MonadChainContext const &ctx)
 {
-    if (orig_code_hash != NULL_HASH) { // check delegated
+    if (sender_is_delegated) { // delegated accounts cannot dip
         return false;
     }
 

category/execution/monad/reserve_balance.hpp

@@ -37,7 +37,7 @@ bool revert_monad_transaction(
     MonadChainContext const &);
 
 bool can_sender_dip_into_reserve(
-    Address const &sender, uint64_t i, bytes32_t const &orig_code_hash,
+    Address const &sender, uint64_t i, bool sender_is_delegated,
     MonadChainContext const &);
 
 uint256_t get_max_reserve(monad_revision, Address const &);