rpcdaemon: SuicideAction implementation in trace API (#2111)

Author: Sixtysixter

.github/workflows/rpc-integration-tests.yml

@@ -27,7 +27,7 @@ jobs:
       - name: Checkout RPC Tests Repository & Install Requirements
         run: |
           rm -rf ${{runner.workspace}}/rpc-tests
-          git -c advice.detachedHead=false clone --depth 1 --branch v0.24.0 https://github.com/erigontech/rpc-tests ${{runner.workspace}}/rpc-tests
+          git -c advice.detachedHead=false clone --depth 1 --branch v0.25.3 https://github.com/erigontech/rpc-tests ${{runner.workspace}}/rpc-tests
           cd ${{runner.workspace}}/rpc-tests
           pip3 install -r requirements.txt
 

silkworm/rpc/core/evm_trace.cpp

@@ -186,6 +186,12 @@ void to_json(nlohmann::json& json, const RewardAction& action) {
     json["value"] = to_quantity(action.value);
 }
 
+void to_json(nlohmann::json& json, const SuicideAction& action) {
+    json["address"] = action.address;
+    json["balance"] = to_quantity(action.balance);
+    json["refundAddress"] = action.refund_address;
+}
+
 void to_json(nlohmann::json& json, const TraceResult& trace_result) {
     if (trace_result.address) {
         json["address"] = trace_result.address.value();
@@ -206,6 +212,8 @@ void to_json(nlohmann::json& json, const Trace& trace) {
         json["action"] = std::get<TraceAction>(trace.action);
     } else if (std::holds_alternative<RewardAction>(trace.action)) {
         json["action"] = std::get<RewardAction>(trace.action);
+    } else if (std::holds_alternative<SuicideAction>(trace.action)) {
+        json["action"] = std::get<SuicideAction>(trace.action);
     }
     if (trace.trace_result) {
         json["result"] = trace.trace_result.value();
@@ -462,6 +470,19 @@ int get_stack_count(std::uint8_t op_code) {
     return count;
 }
 
+void copy_address(const evmone::uint256* stack, std::string& address) {
+    std::string addr{"0000000000000000000000000000000000000000"};
+    auto hex = intx::hex(stack[0]);
+    auto pos = static_cast<int>(addr.size()) - static_cast<int>(hex.size());
+
+    if (pos > 0) {
+        std::copy(hex.begin(), hex.end(), addr.begin() + pos);
+    } else {
+        addr = hex;
+    }
+    address = "0x" + addr;
+}
+
 void copy_stack(std::uint8_t op_code, const evmone::uint256* stack, std::vector<std::string>& trace_stack) {
     const int top = get_stack_count(op_code);
     trace_stack.reserve(top > 0 ? static_cast<std::size_t>(top) : 0);
@@ -797,12 +818,41 @@ void TraceTracer::on_execution_start(evmc_revision rev, const evmc_message& msg,
                << ", code: " << silkworm::to_hex(code);
 }
 
-void TraceTracer::on_instruction_start(uint32_t pc, const intx::uint256* /*stack_top*/, const int /*stack_height*/, const int64_t gas,
+void TraceTracer::on_instruction_start(uint32_t pc, const intx::uint256* stack_top, const int /*stack_height*/, const int64_t gas,
                                        const evmone::ExecutionState& execution_state, const silkworm::IntraBlockState& /*intra_block_state*/) noexcept {
     const auto opcode = execution_state.original_code[pc];
-    auto opcode_name = get_opcode_name(opcode_names_, opcode);
-
     current_opcode_ = opcode;
+
+    if (opcode == OP_SELFDESTRUCT) {
+        std::size_t idx = traces_.size();
+        traces_.resize(traces_.size() + 1);
+        Trace& trace = traces_[idx];
+        trace.type = "suicide";
+        trace.action = SuicideAction{};
+
+        auto index = index_stack_.top();
+        Trace& calling_trace = traces_[index];
+        auto& calling_action = std::get<TraceAction>(calling_trace.action);
+
+        auto& suicide_action = std::get<SuicideAction>(trace.action);
+        if (calling_trace.trace_result && calling_trace.trace_result->address) {
+            suicide_action.address = calling_trace.trace_result->address.value();
+        } else if (calling_action.to) {
+            suicide_action.address = calling_action.to.value();
+        }
+        suicide_action.balance = 0;
+        copy_address(stack_top, suicide_action.refund_address);
+
+        trace.trace_address = calling_trace.trace_address;
+        trace.trace_address.push_back(calling_trace.sub_traces);
+
+        calling_trace.sub_traces++;
+
+        nlohmann::json trace_json = trace;
+        nlohmann::json calling_trace_json = calling_trace;
+    }
+
+    auto opcode_name = get_opcode_name(opcode_names_, opcode);
     SILK_DEBUG << "TraceTracer::on_instruction_start:"
                << " pc: " << std::dec << pc
                << ", opcode: 0x" << std::hex << evmc::hex(opcode)
@@ -822,6 +872,7 @@ void TraceTracer::on_execution_end(const evmc_result& result, const silkworm::In
         is_precompile_ = false;
         return;
     }
+
     auto index = index_stack_.top();
     auto start_gas = start_gas_.top();
 
@@ -1172,8 +1223,8 @@ Task<std::vector<Trace>> TraceCallExecutor::trace_block(const BlockWithHash& blo
 
         for (const auto& call_trace : call_traces) {
             Trace trace{call_trace};
-            nlohmann::json json = trace;
             bool skip = !(filter.from_addresses.empty() && filter.to_addresses.empty());
+
             if (std::holds_alternative<TraceAction>(trace.action)) {
                 const auto& action = std::get<TraceAction>(trace.action);
                 if (skip && !filter.from_addresses.empty()) {
@@ -1602,6 +1653,7 @@ Task<void> TraceCallExecutor::trace_filter(const TraceFilter& trace_filter, cons
     if (from_block_with_hash->block.header.number > to_block_with_hash->block.header.number) {
         const Error error{-32000, "invalid parameters: fromBlock cannot be greater than toBlock"};
         stream.write_json_field("error", error);
+        stream.write_json_field("result", nlohmann::json::value_t::null);
         co_return;
     }
 

silkworm/rpc/core/evm_trace.hpp

@@ -120,6 +120,7 @@ void to_json(nlohmann::json& json, const TraceEx& trace_ex);
 void to_json(nlohmann::json& json, const TraceMemory& trace_memory);
 void to_json(nlohmann::json& json, const TraceStorage& trace_storage);
 
+void copy_address(const evmone::uint256* stack, std::string& address);
 void copy_stack(std::uint8_t op_code, const evmone::uint256* stack, std::vector<std::string>& trace_stack);
 void copy_memory(const evmone::Memory& memory, std::optional<TraceMemory>& trace_memory);
 void copy_store(std::uint8_t op_code, const evmone::uint256* stack, std::optional<TraceStorage>& trace_storage);
@@ -168,7 +169,13 @@ struct RewardAction {
     intx::uint256 value{0};
 };
 
-using Action = std::variant<TraceAction, RewardAction>;
+struct SuicideAction {
+    evmc::address address;
+    std::string refund_address;
+    intx::uint256 balance{0};
+};
+
+using Action = std::variant<TraceAction, RewardAction, SuicideAction>;
 
 struct TraceResult {
     std::optional<evmc::address> address;
@@ -192,6 +199,7 @@ struct Trace {
 
 void to_json(nlohmann::json& json, const TraceAction& action);
 void to_json(nlohmann::json& json, const RewardAction& action);
+void to_json(nlohmann::json& json, const SuicideAction& action);
 void to_json(nlohmann::json& json, const TraceResult& trace_result);
 void to_json(nlohmann::json& json, const Trace& trace);