Enable native transfer logs

Author: Baltoli

category/execution/ethereum/evm.cpp

@@ -50,13 +50,6 @@ bool sender_has_balance(State &state, evmc_message const &msg) noexcept
     return state.record_balance_constraint_for_debit(msg.sender, value);
 }
 
-void transfer_balances(State &state, evmc_message const &msg, Address const &to)
-{
-    uint256_t const value = intx::be::load<uint256_t>(msg.value);
-    state.subtract_from_balance(msg.sender, value);
-    state.add_to_balance(to, value);
-}
-
 MONAD_ANONYMOUS_NAMESPACE_END
 
 MONAD_NAMESPACE_BEGIN
@@ -110,7 +103,8 @@ evmc::Result deploy_contract_code(
 EXPLICIT_TRAITS(deploy_contract_code);
 
 template <Traits traits>
-std::optional<evmc::Result> pre_call(evmc_message const &msg, State &state)
+std::optional<evmc::Result>
+pre_call(EvmcHost<traits> &host, evmc_message const &msg, State &state)
 {
     state.push();
 
@@ -122,7 +116,7 @@ std::optional<evmc::Result> pre_call(evmc_message const &msg, State &state)
             return evmc::Result{EVMC_INSUFFICIENT_BALANCE, msg.gas};
         }
         else if (!static_call) {
-            transfer_balances(state, msg, msg.recipient);
+            host.transfer_balances(msg, msg.recipient);
         }
     }
 
@@ -232,7 +226,7 @@ evmc::Result create(
     constexpr auto starting_nonce =
         traits::evm_rev() >= EVMC_SPURIOUS_DRAGON ? 1 : 0;
     state.set_nonce(contract_address, starting_nonce);
-    transfer_balances(state, msg, contract_address);
+    host->transfer_balances(msg, contract_address);
 
     evmc_message const m_call{
         .kind = EVMC_CALL,
@@ -297,7 +291,7 @@ evmc::Result call(
     auto &call_tracer = host->get_call_tracer();
     call_tracer.on_enter(msg);
 
-    if (auto result = pre_call<traits>(msg, state); result.has_value()) {
+    if (auto result = pre_call<traits>(*host, msg, state); result.has_value()) {
         call_tracer.on_exit(result.value());
         return std::move(result.value());
     }

category/execution/ethereum/evmc_host.cpp

@@ -36,12 +36,14 @@ MONAD_NAMESPACE_BEGIN
 EvmcHostBase::EvmcHostBase(
     CallTracerBase &call_tracer, evmc_tx_context const &tx_context,
     BlockHashBuffer const &block_hash_buffer, State &state,
-    std::function<bool()> const &revert_transaction) noexcept
+    std::function<bool()> const &revert_transaction,
+    bool const simulate_v1_enabled) noexcept
     : block_hash_buffer_{block_hash_buffer}
     , tx_context_{tx_context}
     , state_{state}
     , call_tracer_{call_tracer}
     , revert_transaction_{revert_transaction}
+    , simulate_v1_enabled_{simulate_v1_enabled}
 {
 }
 

category/execution/ethereum/evmc_host.hpp

@@ -19,6 +19,9 @@
 #include <category/core/config.hpp>
 #include <category/execution/ethereum/chain/chain.hpp>
 #include <category/execution/ethereum/core/address.hpp>
+#include <category/execution/ethereum/core/contract/abi_encode.hpp>
+#include <category/execution/ethereum/core/contract/abi_signatures.hpp>
+#include <category/execution/ethereum/core/contract/events.hpp>
 #include <category/execution/ethereum/evm.hpp>
 #include <category/execution/ethereum/precompiles.hpp>
 #include <category/execution/ethereum/state3/state.hpp>
@@ -53,13 +56,14 @@ class EvmcHostBase : public vm::Host
     State &state_;
     CallTracerBase &call_tracer_;
     std::function<bool()> revert_transaction_;
+    bool simulate_v1_enabled_;
 
 public:
     EvmcHostBase(
         CallTracerBase &, evmc_tx_context const &, BlockHashBuffer const &,
-        State &, std::function<bool()> const &revert_transaction = [] {
-            return false;
-        }) noexcept;
+        State &,
+        std::function<bool()> const &revert_transaction = [] { return false; },
+        bool simulate_v1_enabled = false) noexcept;
 
     virtual ~EvmcHostBase() noexcept = default;
 
@@ -100,7 +104,7 @@ class EvmcHostBase : public vm::Host
         bytes32_t const &value) noexcept override;
 };
 
-static_assert(sizeof(EvmcHostBase) == 88);
+static_assert(sizeof(EvmcHostBase) == 96);
 static_assert(alignof(EvmcHostBase) == 8);
 
 template <Traits traits>
@@ -126,6 +130,12 @@ struct EvmcHost final : public EvmcHostBase
         Address const &address, Address const &beneficiary) noexcept override
     {
         try {
+            emit_native_transfer_event(
+                address,
+                beneficiary,
+                intx::be::load<uint256_t>(
+                    state_.get_current_balance_pessimistic(address)));
+
             call_tracer_.on_self_destruct(address, beneficiary);
             return state_.selfdestruct<traits>(address, beneficiary);
         }
@@ -176,13 +186,45 @@ struct EvmcHost final : public EvmcHostBase
         stack_unwind();
     }
 
+    void transfer_balances(evmc_message const &msg, Address const &to)
+    {
+        uint256_t const value = intx::be::load<uint256_t>(msg.value);
+        state_.subtract_from_balance(msg.sender, value);
+        state_.add_to_balance(to, value);
+        emit_native_transfer_event(msg.sender, to, value);
+    }
+
     CallTracerBase &get_call_tracer() noexcept
     {
         return call_tracer_;
     }
+
+private:
+    void emit_native_transfer_event(
+        Address const &from, Address const &to, uint256_t const &value)
+    {
+        if (simulate_v1_enabled_) {
+            constexpr auto sender =
+                0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee_address;
+            constexpr auto signature =
+                abi_encode_event_signature("Transfer(address,address,uint256)");
+            static_assert(
+                signature ==
+                0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef_bytes32);
+
+            auto const event = EventBuilder(sender, signature)
+                                   .add_topic(abi_encode_address(from))
+                                   .add_topic(abi_encode_address(to))
+                                   .add_data(abi_encode_uint(u256_be{value}))
+                                   .build();
+
+            state_.store_log(event);
+            call_tracer_.on_log(event);
+        }
+    }
 };
 
-static_assert(sizeof(EvmcHost<EvmTraits<EVMC_LATEST_STABLE_REVISION>>) == 88);
+static_assert(sizeof(EvmcHost<EvmTraits<EVMC_LATEST_STABLE_REVISION>>) == 96);
 static_assert(alignof(EvmcHost<EvmTraits<EVMC_LATEST_STABLE_REVISION>>) == 8);
 
 MONAD_NAMESPACE_END

category/execution/ethereum/test/test_call_trace.cpp

@@ -443,3 +443,92 @@ TYPED_TEST(TraitsTest, selfdestruct_logs)
         EXPECT_TRUE(frame.logs.has_value());
     }
 }
+
+TYPED_TEST(TraitsTest, simulate_v1_trace)
+{
+    InMemoryMachine machine;
+    mpt::Db db{machine};
+    TrieDb tdb{db};
+    vm::VM vm;
+
+    commit_sequential(
+        tdb,
+        StateDeltas{
+            {ADDR_A,
+             StateDelta{
+                 .account =
+                     {std::nullopt,
+                      Account{
+                          .balance = std::numeric_limits<uint256_t>::max()}}}},
+            {ADDR_B,
+             StateDelta{.account = {std::nullopt, Account{.balance = 0}}}}},
+        Code{},
+        BlockHeader{});
+
+    BlockState bs{tdb, vm};
+    Incarnation const incarnation{0, 0};
+    State s{bs, incarnation};
+
+    Transaction const tx{
+        .max_fee_per_gas = 1,
+        .gas_limit = 1'000'000,
+        .value = 1'000'000,
+        .to = ADDR_B,
+    };
+
+    auto const &sender = ADDR_A;
+    auto const &beneficiary = ADDR_A;
+
+    evmc_tx_context const tx_context{};
+    BlockHashBufferFinalized buffer{};
+    std::vector<CallFrame> call_frames;
+    CallTracer call_tracer{tx, call_frames};
+    EvmcHost<typename TestFixture::Trait> host{
+        call_tracer,
+        tx_context,
+        buffer,
+        s,
+        [](auto &&...) { return false; },
+        true, // enable simulate_v1 tracing
+    };
+
+    auto const result =
+        ExecuteTransactionNoValidation<typename TestFixture::Trait>(
+            EthereumMainnet{},
+            tx,
+            sender,
+            authorities_empty,
+            BlockHeader{.beneficiary = beneficiary},
+            0)(s, host);
+
+    EXPECT_TRUE(result.status_code == EVMC_SUCCESS);
+    EXPECT_EQ(call_frames.size(), 1);
+
+    CallFrame const expected{
+        .type = CallType::CALL,
+        .flags = 0,
+        .from = sender,
+        .to = ADDR_B,
+        .value = 1'000'000,
+        .gas = 1'000'000,
+        .gas_used = 21'000,
+        .status = EVMC_SUCCESS,
+        .depth = 0,
+        .logs = std::vector<CallFrame::Log>{{
+            {
+                .data = byte_string{intx::be::store<bytes32_t, uint256_t>(
+                    1'000'000)},
+                .topics =
+                    std::vector{
+                        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef_bytes32,
+                        0x0000000000000000000000000000000000000000000000000000000000000100_bytes32,
+                        0x0000000000000000000000000000000000000000000000000000000000000101_bytes32,
+                    },
+                .address = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee_address,
+            },
+            0,
+        }},
+    };
+
+    EXPECT_EQ(call_frames[0], expected);
+}