Merge branch 'main' into aa755/rm_rb_assert

Author: aa755

category/execution/ethereum/state3/state.cpp

@@ -239,6 +239,21 @@ bytes32_t State::get_code_hash(Address const &address)
     return NULL_HASH;
 }
 
+bool State::is_destructed(Address const &address)
+{
+    auto const &account_state = recent_account_state(address);
+    return account_state.is_destructed();
+}
+
+bool State::is_current_incarnation(Address const &address)
+{
+    auto const &account = recent_account(address);
+    if (MONAD_LIKELY(account.has_value())) {
+        return account.value().incarnation == incarnation_;
+    }
+    return false;
+}
+
 bytes32_t State::get_storage(Address const &address, bytes32_t const &key)
 {
     auto const it = current_.find(address);
@@ -439,7 +454,10 @@ State::selfdestruct(Address const &address, Address const &beneficiary)
         }
     }
 
-    return {account_state.destruct(), initial_balance};
+    bool const inserted = account_state.destruct();
+    // Recompute reserve-balance status after setting the destructed flag.
+    rb_.on_debit(address);
+    return {inserted, initial_balance};
 }
 
 EXPLICIT_TRAITS_MEMBER(State::selfdestruct);

category/execution/ethereum/state3/state.hpp

@@ -134,6 +134,10 @@ class State
 
     bytes32_t get_code_hash(Address const &);
 
+    bool is_destructed(Address const &);
+
+    bool is_current_incarnation(Address const &);
+
     bytes32_t get_storage(Address const &, bytes32_t const &key);
 
     bytes32_t get_transient_storage(Address const &, bytes32_t const &key);

category/execution/ethereum/test/test_monad_chain.cpp

@@ -703,6 +703,90 @@ TYPED_TEST(MonadTraitsTest, reserve_checks_empty_code_hash)
     }
 }
 
+TYPED_TEST(MonadTraitsTest, reserve_checks_prefunded_init_selfdestruct)
+{
+    using traits = typename TestFixture::Trait;
+    constexpr Address SENDER{1};
+    constexpr Address NEW_CONTRACT{2};
+    constexpr Address BENEFICIARY{3};
+    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};
+
+    ankerl::unordered_dense::segmented_set<Address> const
+        empty_grandparent_senders_and_authorities;
+    ankerl::unordered_dense::segmented_set<Address> const
+        empty_parent_senders_and_authorities;
+    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);
+    ChainContext<traits> const context{
+        .grandparent_senders_and_authorities =
+            empty_grandparent_senders_and_authorities,
+        .parent_senders_and_authorities = empty_parent_senders_and_authorities,
+        .senders_and_authorities = senders_and_authorities,
+        .senders = senders,
+        .authorities = authorities};
+
+    State state{bs, Incarnation{1, 1}};
+    init_reserve_balance_context<traits>(
+        state, SENDER, tx, BASE_FEE_PER_GAS, 0, context);
+    state.subtract_from_balance(SENDER, gas_cost);
+
+    // Model constructor-time SELFDESTRUCT at a pre-funded address:
+    // create the account in current incarnation, then selfdestruct it before
+    // any runtime code is set.
+    state.create_contract(NEW_CONTRACT);
+    auto const [inserted, initial_balance] =
+        state.selfdestruct<traits>(NEW_CONTRACT, BENEFICIARY);
+    EXPECT_TRUE(inserted);
+    EXPECT_EQ(initial_balance, to_wei(3));
+    EXPECT_EQ(state.get_balance(NEW_CONTRACT), 0);
+    EXPECT_EQ(state.get_balance(BENEFICIARY), to_wei(3));
+
+    bool const should_revert = revert_transaction<traits>(
+        SENDER, tx, BASE_FEE_PER_GAS, 0, state, context);
+    bool const should_revert_cached = revert_transaction_cached<traits>(state);
+
+    if constexpr (traits::monad_rev() < MONAD_FOUR) {
+        EXPECT_FALSE(should_revert);
+        EXPECT_FALSE(should_revert_cached);
+    }
+    else if constexpr (traits::monad_rev() >= MONAD_NEXT) {
+        EXPECT_FALSE(should_revert);
+        EXPECT_FALSE(should_revert_cached);
+    }
+    else {
+        EXPECT_TRUE(should_revert);
+        EXPECT_TRUE(should_revert_cached);
+    }
+}
+
 TYPED_TEST(MonadTraitsTest, system_transaction_sender_is_authority)
 {
     InMemoryMachine machine;

category/execution/monad/reserve_balance.cpp

@@ -61,6 +61,9 @@ bool dipped_into_reserve(
     MONAD_ASSERT(i < ctx.authorities.size());
     MONAD_ASSERT(ctx.senders.size() == ctx.authorities.size());
 
+    static constexpr bool allow_init_selfdestruct_exemption =
+        traits::monad_rev() >= MONAD_NEXT;
+
     uint256_t const gas_fees =
         uint256_t{tx.gas_limit} * gas_price<traits>(tx, base_fee_per_gas);
     auto const &orig = state.original();
@@ -90,6 +93,11 @@ bool dipped_into_reserve(
                 continue;
             }
         }
+        else if (
+            allow_init_selfdestruct_exemption && state.is_destructed(addr) &&
+            state.is_current_incarnation(addr)) {
+            continue;
+        }
 
         // Check if dipped into reserve
         std::optional<uint256_t> const violation_threshold =
@@ -208,6 +216,14 @@ void ReserveBalance::update_violation_status(Address const &address)
     }
 
     auto &violation_threshold = violation_thresholds_[address];
+    if (allow_init_selfdestruct_exemption_ && state_->is_destructed(address) &&
+        state_->is_current_incarnation(address)) {
+        // Contracts that selfdestruct during init never get a code hash.
+        violation_threshold = uint256_t{0};
+        failed_.erase(address);
+        return;
+    }
+
     if (!violation_threshold.has_value()) {
         if (!subject_account(address)) {
             violation_threshold = uint256_t{0};
@@ -318,6 +334,7 @@ void ReserveBalance::init_from_tx(
     if constexpr (tracking_disabled) {
         tracking_enabled_ = false;
         use_recent_code_hash_ = false;
+        allow_init_selfdestruct_exemption_ = false;
         sender_ = {};
         sender_gas_fees_ = 0;
         sender_can_dip_ = false;
@@ -330,6 +347,7 @@ void ReserveBalance::init_from_tx(
     MONAD_ASSERT(i < ctx.authorities.size());
     MONAD_ASSERT(ctx.senders.size() == ctx.authorities.size());
     use_recent_code_hash_ = traits::monad_rev() >= MONAD_EIGHT;
+    allow_init_selfdestruct_exemption_ = traits::monad_rev() >= MONAD_NEXT;
     bytes32_t const sender_code_hash =
         use_recent_code_hash_
             ? state_->get_code_hash(sender)

category/execution/monad/reserve_balance.hpp

@@ -47,6 +47,7 @@ class ReserveBalance
     State *state_;
     bool tracking_enabled_{false};
     bool use_recent_code_hash_{false};
+    bool allow_init_selfdestruct_exemption_{false};
     Address sender_{};
     uint256_t sender_gas_fees_{0};
     bool sender_can_dip_{false};

category/execution/monad/reserve_balance/reserve_balance_contract.cpp

@@ -18,6 +18,7 @@
 #include <category/execution/ethereum/core/contract/abi_signatures.hpp>
 #include <category/execution/ethereum/core/contract/events.hpp>
 #include <category/execution/ethereum/core/contract/storage_variable.hpp>
+#include <category/execution/ethereum/reserve_balance.hpp>
 #include <category/execution/monad/reserve_balance/reserve_balance_contract.hpp>
 #include <category/execution/monad/reserve_balance/reserve_balance_error.hpp>
 #include <category/vm/evm/explicit_traits.hpp>
@@ -27,10 +28,24 @@
 
 MONAD_ANONYMOUS_NAMESPACE_BEGIN
 
+////////////////////////
+// Function Selectors //
+////////////////////////
+
+struct PrecompileSelector
+{
+    static constexpr uint32_t DIPPED_INTO_RESERVE =
+        abi_encode_selector("dippedIntoReserve()");
+};
+
+static_assert(PrecompileSelector::DIPPED_INTO_RESERVE == 0x3a61584e);
+
 //
 // Gas Costs
 //
 
+constexpr uint64_t DIPPED_INTO_RESERVE_OP_COST = 100; // warm sload coast
+
 constexpr uint64_t FALLBACK_COST = 40'000;
 
 MONAD_ANONYMOUS_NAMESPACE_END
@@ -49,6 +64,19 @@ ReserveBalanceContract::ReserveBalanceContract(
     state_.add_to_balance(RESERVE_BALANCE_CA, 0);
 }
 
+Result<void> function_not_payable(evmc_uint256be const &value)
+{
+    bool const all_zero = std::all_of(
+        value.bytes,
+        value.bytes + sizeof(evmc_uint256be),
+        [](uint8_t const byte) { return byte == 0; });
+
+    if (MONAD_UNLIKELY(!all_zero)) {
+        return ReserveBalanceError::ValueNonZero;
+    }
+    return outcome::success();
+}
+
 template <Traits traits>
 std::pair<ReserveBalanceContract::PrecompileFunc, uint64_t>
 ReserveBalanceContract::precompile_dispatch(byte_string_view &input)
@@ -62,13 +90,30 @@ ReserveBalanceContract::precompile_dispatch(byte_string_view &input)
     input.remove_prefix(4);
 
     switch (signature) {
+    case PrecompileSelector::DIPPED_INTO_RESERVE:
+        return {
+            &ReserveBalanceContract::precompile_dipped_into_reserve<traits>,
+            DIPPED_INTO_RESERVE_OP_COST};
     default:
         return {&ReserveBalanceContract::precompile_fallback, FALLBACK_COST};
     }
 }
 
 EXPLICIT_MONAD_TRAITS(ReserveBalanceContract::precompile_dispatch);
 
+template <Traits traits>
+Result<byte_string> ReserveBalanceContract::precompile_dipped_into_reserve(
+    byte_string_view, evmc_address const &, evmc_uint256be const &msg_value)
+{
+    BOOST_OUTCOME_TRY(function_not_payable(msg_value));
+
+    return byte_string{
+        abi_encode_bool(revert_transaction_cached<traits>(state_))};
+}
+
+EXPLICIT_MONAD_TRAITS_MEMBER(
+    ReserveBalanceContract::precompile_dipped_into_reserve);
+
 Result<byte_string> ReserveBalanceContract::precompile_fallback(
     byte_string_view, evmc_address const &, evmc_uint256be const &)
 {

category/execution/monad/reserve_balance/reserve_balance_contract.hpp

@@ -48,6 +48,10 @@ class ReserveBalanceContract
     static std::pair<PrecompileFunc, uint64_t>
     precompile_dispatch(byte_string_view &);
 
+    template <Traits traits>
+    Result<byte_string> precompile_dipped_into_reserve(
+        byte_string_view, evmc_address const &, evmc_uint256be const &);
+
     Result<byte_string> precompile_fallback(
         byte_string_view, evmc_address const &, evmc_uint256be const &);
 };