Implementation of eth_getTransactionReceipt API (partial) (#95)

Co-authored-by: canepat <16927169+canepat@users.noreply.github.com>

Author: Sixtysixter

docs/API.md

@@ -30,7 +30,7 @@ The following table shows the current [JSON RPC API](https://eth.wiki/json-rpc/A
 | eth_getTransactionByHash                | Yes          | partially implemented                      |
 | eth_getTransactionByBlockHashAndIndex   | Yes          |                                            |
 | eth_getTransactionByBlockNumberAndIndex | Yes          |                                            |
-| eth_getTransactionReceipt               | -            | not yet implemented                        |
+| eth_getTransactionReceipt               | Yes          | partially implemented                      |
 |                                         |              |                                            |
 | eth_estimateGas                         | -            | not yet implemented                        |
 | eth_getBalance                          | Yes          |                                            |

silkrpc/commands/eth_api.cpp

@@ -17,6 +17,7 @@
 #include "eth_api.hpp"
 
 #include <algorithm>
+#include <cstring>
 #include <exception>
 #include <iostream>
 #include <string>
@@ -581,12 +582,45 @@ asio::awaitable<void> EthereumRpcApi::handle_eth_get_transaction_by_block_number
 
 // https://eth.wiki/json-rpc/API#eth_gettransactionreceipt
 asio::awaitable<void> EthereumRpcApi::handle_eth_get_transaction_receipt(const nlohmann::json& request, nlohmann::json& reply) {
+    auto params = request["params"];
+    if (params.size() != 1) {
+        auto error_msg = "invalid eth_getTransactionReceipt params: " + params.dump();
+        SILKRPC_ERROR << error_msg << "\n";
+        reply = make_json_error(request["id"], 100, error_msg);
+        co_return;
+    }
+    auto transaction_hash = params[0].get<evmc::bytes32>();
+    SILKRPC_DEBUG << "transaction_hash: " << transaction_hash << "\n";
     auto tx = co_await database_->begin();
 
     try {
         ethdb::TransactionDatabase tx_database{*tx};
+        reply = make_json_content(request["id"], nullptr);
+        const auto block_with_hash = co_await core::rawdb::read_block_by_transaction_hash(tx_database, transaction_hash);
+        auto receipts = co_await core::get_receipts(tx_database, block_with_hash.hash, block_with_hash.block.header.number);
+        auto transactions = block_with_hash.block.transactions;
+        if (receipts.size() != transactions.size()) {
+            throw std::invalid_argument{"Unexpected size for receipts in handle_eth_get_transaction_receipt"};
+        }
 
-        reply = make_json_content(request["id"], to_quantity(0));
+        size_t tx_index = -1;
+        for (size_t idx{0}; idx < transactions.size(); idx++) {
+            auto ethash_hash{hash_of_transaction(transactions[idx])};
+
+            SILKRPC_TRACE << "tx " << idx << ") hash: " << silkworm::to_bytes32(ethash_hash.bytes) << "\n";
+            if (std::memcmp(transaction_hash.bytes, ethash_hash.bytes, silkworm::kHashLength) == 0) {
+                tx_index = idx;
+                break;
+            }
+        }
+
+        if (tx_index == -1) {
+            throw std::invalid_argument{"Unexpected transaction index in handle_eth_get_transaction_receipt"};
+        }
+        reply = make_json_content(request["id"], receipts[tx_index]);
+    } catch (const std::invalid_argument& iv) {
+        SILKRPC_DEBUG << "invalid_argument: " << iv.what() << " processing request: " << request.dump() << "\n";
+        reply = make_json_content(request["id"], {});
     } catch (const std::exception& e) {
         SILKRPC_ERROR << "exception: " << e.what() << " processing request: " << request.dump() << "\n";
         reply = make_json_error(request["id"], 100, e.what());

silkrpc/commands/parity_api.cpp

@@ -19,7 +19,6 @@
 #include <string>
 
 #include <silkworm/common/util.hpp>
-#include <silkworm/types/bloom.cpp> // NOLINT(build/include) m3_2048 not exported
 
 #include <silkrpc/common/constants.hpp>
 #include <silkrpc/common/log.hpp>
@@ -34,19 +33,6 @@
 
 namespace silkrpc::commands {
 
-silkworm::Bloom bloom_from_logs(const Logs& logs) {
-    SILKRPC_TRACE << "bloom_from_logs #logs: " << logs.size() << "\n";
-    silkworm::Bloom bloom{};
-    for (auto const& log : logs) {
-        silkworm::m3_2048(bloom, silkworm::full_view(log.address));
-        for (const auto& topic : log.topics) {
-            silkworm::m3_2048(bloom, silkworm::full_view(topic));
-        }
-    }
-    SILKRPC_TRACE << "bloom_from_logs bloom: " << silkworm::to_hex(silkworm::full_view(bloom)) << "\n";
-    return bloom;
-}
-
 // https://eth.wiki/json-rpc/API#parity_getblockreceipts
 asio::awaitable<void> ParityRpcApi::handle_parity_get_block_receipts(const nlohmann::json& request, nlohmann::json& reply) {
     auto params = request["params"];
@@ -70,15 +56,6 @@ asio::awaitable<void> ParityRpcApi::handle_parity_get_block_receipts(const nlohm
         auto receipts{co_await core::get_receipts(tx_database, block_hash, block_number)};
         SILKRPC_INFO << "#receipts: " << receipts.size() << "\n";
 
-        for (auto& receipt : receipts) {
-            auto tx = block_with_hash.block.transactions[receipt.tx_index];
-            tx.recover_sender();
-            receipt.from = tx.from;
-            receipt.to = tx.to;
-            receipt.type = tx.type;
-            receipt.bloom = bloom_from_logs(receipt.logs);
-        }
-
         reply = make_json_content(request["id"], receipts);
     } catch (const std::invalid_argument& iv) {
         SILKRPC_DEBUG << "invalid_argument: " << iv.what() << " processing request: " << request.dump() << "\n";

silkrpc/core/rawdb/chain.cpp

@@ -133,6 +133,18 @@ asio::awaitable<silkworm::BlockWithHash> read_block_by_number(const DatabaseRead
     co_return co_await read_block(reader, block_hash, block_number);
 }
 
+asio::awaitable<silkworm::BlockWithHash> read_block_by_transaction_hash(const DatabaseReader& reader, const evmc::bytes32& transaction_hash) {
+    const silkworm::ByteView tx_hash{transaction_hash.bytes, silkworm::kHashLength};
+
+    auto bytes = co_await reader.get_one(silkworm::db::table::kTxLookup.name, tx_hash);
+    if (bytes.empty()) {
+        throw std::invalid_argument{"empty block number value in read_block_by_transaction_hash"};
+    }
+    auto block_number = std::stoul(silkworm::to_hex(bytes), 0, 16);
+    SILKRPC_TRACE << "Block number " << block_number << " for transaction hash " << transaction_hash << "\n";
+    co_return co_await core::rawdb::read_block_by_number(reader, block_number);
+}
+
 asio::awaitable<silkworm::BlockWithHash> read_block(const DatabaseReader& reader, const evmc::bytes32& block_hash, uint64_t block_number) {
     auto header = co_await read_header(reader, block_hash, block_number);
     SILKRPC_INFO << "header: number=" << header.number << "\n";
@@ -255,6 +267,7 @@ asio::awaitable<Receipts> read_raw_receipts(const DatabaseReader& reader, const
     Walker walker = [&](const silkworm::Bytes& k, const silkworm::Bytes& v) {
         auto tx_id = boost::endian::load_big_u32(&k[sizeof(uint64_t)]);
         cbor_decode(v, receipts[tx_id].logs);
+        receipts[tx_id].bloom = bloom_from_logs(receipts[tx_id].logs);
         SILKRPC_DEBUG << "#receipts[" << tx_id << "].logs: " << receipts[tx_id].logs.size() << "\n";
         return true;
     };
@@ -295,9 +308,12 @@ asio::awaitable<Receipts> read_receipts(const DatabaseReader& reader, const evmc
         if (i == 0) {
             receipts[i].gas_used = receipts[i].cumulative_gas_used;
         } else {
-            receipts[i].gas_used = receipts[i].cumulative_gas_used - receipts[i-1].cumulative_gas_used;;
+            receipts[i].gas_used = receipts[i].cumulative_gas_used - receipts[i-1].cumulative_gas_used;
         }
 
+        receipts[i].from = senders[i];
+        receipts[i].to = transactions[i].to;
+
         // The derived fields of receipt are taken from block and transaction
         for (size_t j{0}; j < receipts[i].logs.size(); j++) {
             receipts[i].logs[j].block_number = block_number;

silkrpc/core/rawdb/chain.hpp

@@ -51,6 +51,8 @@ asio::awaitable<silkworm::BlockWithHash> read_block_by_hash(const DatabaseReader
 
 asio::awaitable<silkworm::BlockWithHash> read_block_by_number(const DatabaseReader& reader, uint64_t block_number);
 
+asio::awaitable<silkworm::BlockWithHash> read_block_by_transaction_hash(const DatabaseReader& reader, const evmc::bytes32& transaction_hash);
+
 asio::awaitable<silkworm::BlockWithHash> read_block(const DatabaseReader& reader, const evmc::bytes32& block_hash, uint64_t block_number);
 
 asio::awaitable<silkworm::BlockHeader> read_header_by_hash(const DatabaseReader& reader, const evmc::bytes32& block_hash);

silkrpc/core/rawdb/chain_test.cpp

@@ -34,13 +34,15 @@ TEST_CASE("decode empty receipt list", "[silkrpc::core][cbor_decode]") {
 
 TEST_CASE("decode receipt list", "[silkrpc::core][cbor_decode]") {
     std::vector<Receipt> receipts{};
-    auto bytes = silkworm::from_hex("8283f6001a0032f05d83f6011a00beadd0").value();
+    auto bytes = silkworm::from_hex("838400f601196d398400f6011a00371b0b8400f6011a003947f4").value();
     cbor_decode(bytes, receipts);
-    CHECK(receipts.size() == 2);
-    CHECK(receipts[0].success == false);
-    CHECK(receipts[0].cumulative_gas_used == 0x32f05d);
+    CHECK(receipts.size() == 3);
+    CHECK(receipts[0].success == true);
+    CHECK(receipts[0].cumulative_gas_used == 0x6d39);
     CHECK(receipts[1].success == true);
-    CHECK(receipts[1].cumulative_gas_used == 0xbeadd0);
+    CHECK(receipts[1].cumulative_gas_used == 0x371b0b);
+    CHECK(receipts[2].success == true);
+    CHECK(receipts[2].cumulative_gas_used == 0x3947f4);
 }
 
 TEST_CASE("decode empty log list", "[silkrpc::core][cbor_decode]") {

silkrpc/json/types.cpp

@@ -305,20 +305,27 @@ void to_json(nlohmann::json& json, const Receipt& receipt) {
 void from_json(const nlohmann::json& json, Receipt& receipt) {
     SILKRPC_TRACE << "from_json<Receipt> json: " << json.dump() << "\n";
     if (json.is_array()) {
-        if (json.size() < 3) {
+        if (json.size() < 4) {
             throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: missing entries"};
         }
-        if (!json[0].is_null()) {
-            throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: null expected in [0]"};
+        if (!json[0].is_number()) {
+            throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [0]"};
         }
-        if (!json[1].is_number()) {
-            throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [1]"};
+        receipt.type = json[0];
+
+        if (!json[1].is_null()) {
+            throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: null expected in [1]"};
         }
-        receipt.success = json[1] == 1u;
+
         if (!json[2].is_number()) {
             throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [2]"};
         }
-        receipt.cumulative_gas_used = json[2];
+        receipt.success = json[2] == 1u;
+
+        if (!json[3].is_number()) {
+            throw std::system_error{std::make_error_code(std::errc::invalid_argument), "Receipt CBOR: number expected in [3]"};
+        }
+        receipt.cumulative_gas_used = json[3];
     } else {
         receipt.success = json.at("success").get<bool>();
         receipt.cumulative_gas_used = json.at("cumulative_gas_used").get<uint64_t>();

silkrpc/types/receipt.cpp

@@ -0,0 +1,71 @@
+/*
+    Copyright 2020 The Silkrpc Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#include "receipt.hpp"
+
+#include <iomanip>
+
+#include <silkrpc/common/log.hpp>
+#include <silkrpc/common/util.hpp>
+#include <silkworm/types/bloom.cpp> // NOLINT(build/include) m3_2048 not exported
+
+namespace silkrpc {
+
+std::ostream& operator<<(std::ostream& out, const Receipt& r) {
+    out << " block_hash: " << r.block_hash;
+    out << " block_number: " << r.block_number;
+    out << " contract_address: " << r.contract_address;
+    out << " cumulative_gas_used: " << r.cumulative_gas_used;
+    if (r.from) {
+        out << " from: " << silkworm::to_hex(*r.from);
+    } else {
+        out << " from: null";
+    }
+    out << " gas_used: " << r.gas_used;
+    out << " #logs: " << r.logs.size();
+    auto bloom_view = silkworm::full_view(r.bloom);
+    out << " bloom: " << silkworm::to_hex(bloom_view);
+    out << " success: " << r.success;
+    if (r.to) {
+        out << " to: " << silkworm::to_hex(*r.to);
+    } else {
+        out << " to: null";
+    }
+    out << " tx_hash: " << r.tx_hash;
+    out << " tx_index: " << r.tx_index;
+    if (r.type) {
+        out << " type: 0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(*r.type);
+    } else {
+        out << " type: null";
+    }
+
+    return out;
+}
+
+silkworm::Bloom bloom_from_logs(const Logs& logs) {
+    SILKRPC_TRACE << "bloom_from_logs #logs: " << logs.size() << "\n";
+    silkworm::Bloom bloom{};
+    for (auto const& log : logs) {
+        silkworm::m3_2048(bloom, silkworm::full_view(log.address));
+        for (const auto& topic : log.topics) {
+            silkworm::m3_2048(bloom, silkworm::full_view(topic));
+        }
+    }
+    SILKRPC_TRACE << "bloom_from_logs bloom: " << silkworm::to_hex(silkworm::full_view(bloom)) << "\n";
+    return bloom;
+}
+
+} // namespace silkrpc

silkrpc/types/receipt.hpp

@@ -34,7 +34,7 @@ struct Receipt {
     /* raw fields */
     bool success{false};
     uint64_t cumulative_gas_used{0};
-    silkworm::Bloom bloom;
+    silkworm::Bloom bloom{};
     Logs logs;
 
     /* derived fields */
@@ -49,6 +49,10 @@ struct Receipt {
     std::optional<uint8_t> type{std::nullopt};  // EIP-2718
 };
 
+std::ostream& operator<<(std::ostream& out, const Receipt& r);
+
+silkworm::Bloom bloom_from_logs(const Logs& logs);
+
 typedef std::vector<Receipt> Receipts;
 
 } // namespace silkrpc

silkrpc/types/transaction.cpp

@@ -23,9 +23,41 @@
 namespace silkrpc {
 
 std::ostream& operator<<(std::ostream& out, const Transaction& t) {
+    out << " #access_list: " << t.access_list.size();
     out << " block_hash: " << t.block_hash;
     out << " block_number: " << t.block_number;
+    if (t.chain_id) {
+        out << " chain_id: " << silkworm::to_hex(silkworm::rlp::big_endian(*t.chain_id));
+    } else {
+        out << " chain_id: null";
+    }
+    out << " data: " << silkworm::to_hex(t.data);
+    if (t.from) {
+        out << " from: " << silkworm::to_hex(*t.from);
+    } else {
+        out << " from: null";
+    }
+    out << " nonce: " << t.nonce;
+    out << " gas_price: " << silkworm::to_hex(silkworm::rlp::big_endian(t.gas_price));
+    out << " gas_limit: " << t.gas_limit;
+    out << " odd_y_parity: " << t.odd_y_parity;
+
+    out << " r: " << silkworm::to_hex(silkworm::rlp::big_endian(t.r));
+    out << " s: " << silkworm::to_hex(silkworm::rlp::big_endian(t.s));
+
+    if (t.to) {
+        out << " to: " << silkworm::to_hex(*t.to);
+    } else {
+        out << " to: null";
+    }
     out << " transaction_index: " << t.transaction_index;
+    if (t.type) {
+        out << " type: 0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(*t.type);
+    } else {
+        out << " type: null";
+    }
+    out << " value: " << silkworm::to_hex(silkworm::rlp::big_endian(t.value));
+
     return out;
 }