Exposing Engine_GetPayloadV1

CMakeLists.txt

@@ -63,7 +63,8 @@ add_subdirectory(silkworm)
 option(SILKRPC_CLANG_COVERAGE "Clang instrumentation for code coverage reports" OFF)
 
 if(SILKRPC_CLANG_COVERAGE)
-  add_compile_options(-fprofile-instr-generate -fcoverage-mapping)
+
+  add_compile_options(-fprofile-instr-generate -fcoverage-mapping -DBUILD_COVERAGE)
   add_link_options(-fprofile-instr-generate -fcoverage-mapping)
 endif()
 

codecov.yml

@@ -16,6 +16,7 @@ coverage:
 
 ignore:
   - "**/*_test.cpp"
+  - "silkrpc/ethbackend/backend_mock.hpp"
   - "cmd"
   - "silkrpc/croaring"
   - "silkrpc/interfaces"

silkrpc/commands/engine_api.cpp

@@ -0,0 +1,49 @@
+/*
+    Copyright 2022 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 "engine_api.hpp"
+
+#include <string>
+
+namespace silkrpc::commands {
+
+asio::awaitable<void> EngineRpcApi::handle_engine_get_payload_v1(const nlohmann::json& request, nlohmann::json& reply) {
+    auto params = request.at("params");
+
+    if (params.size() != 1) {
+        auto error_msg = "invalid engine_getPayloadV1 params: " + params.dump();
+        SILKRPC_ERROR << error_msg << "\n";
+        reply = make_json_error(request.at("id"), 100, error_msg);
+        co_return;
+    }
+    #ifndef BUILD_COVERAGE
+    try {
+    #endif
+        const auto payload_id = params[0].get<std::string>();
+        reply = co_await backend_->engine_get_payload_v1(std::stoul(payload_id, 0, 16));
+    #ifndef BUILD_COVERAGE
+    } catch (const std::exception& e) {
+        SILKRPC_ERROR << "exception: " << e.what() << " processing request: " << request.dump() << "\n";
+        reply = make_json_error(request.at("id"), 100, e.what());
+    } catch (...) {
+        SILKRPC_ERROR << "unexpected exception processing request: " << request.dump() << "\n";
+        reply = make_json_error(request.at("id"), 100, "unexpected exception");
+    }
+    #endif
+}
+
+
+} // namespace silkrpc::commands

silkrpc/commands/engine_api.hpp

@@ -0,0 +1,55 @@
+/*
+   Copyright 2022 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.
+*/
+
+#ifndef SILKRPC_COMMANDS_ENGINE_API_HPP_
+#define SILKRPC_COMMANDS_ENGINE_API_HPP_
+
+#include <memory>
+#include <vector>
+
+#include <asio/awaitable.hpp>
+#include <asio/thread_pool.hpp>
+#include <nlohmann/json.hpp>
+
+#include <silkrpc/context_pool.hpp>
+#include <silkrpc/json/types.hpp>
+#include <silkrpc/ethbackend/backend_interface.hpp>
+
+
+namespace silkrpc::http { class RequestHandler; }
+
+namespace silkrpc::commands {
+
+class EngineRpcApi {
+public:
+    explicit EngineRpcApi(std::unique_ptr<ethbackend::BackEndInterface>& backend): backend_(backend) {}
+    virtual ~EngineRpcApi() {}
+
+    EngineRpcApi(const EngineRpcApi&) = delete;
+    EngineRpcApi& operator=(const EngineRpcApi&) = delete;
+
+protected:
+    asio::awaitable<void> handle_engine_get_payload_v1(const nlohmann::json& request, nlohmann::json& reply);
+
+private:
+    std::unique_ptr<ethbackend::BackEndInterface>& backend_;
+
+    friend class silkrpc::http::RequestHandler;
+};
+
+} // namespace silkrpc::commands
+
+#endif  // SILKRPC_COMMANDS_ENGINE_API_HPP_

silkrpc/commands/engine_api_test.cpp

@@ -0,0 +1,77 @@
+/*
+   Copyright 2021 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 "engine_api.hpp"
+
+#include <silkrpc/ethbackend/backend_mock.hpp>
+#include <silkrpc/json/types.hpp>
+#include <silkrpc/http/methods.hpp>
+#include <catch2/catch.hpp>
+#include <asio/use_future.hpp>
+#include <asio/co_spawn.hpp>
+#include <utility>
+
+namespace silkrpc::commands {
+
+using Catch::Matchers::Message;
+
+class EngineRpcApiTest : public EngineRpcApi{
+public:
+    explicit EngineRpcApiTest(std::unique_ptr<ethbackend::BackEndInterface>& backend): EngineRpcApi(backend) {}
+
+    using EngineRpcApi::handle_engine_get_payload_v1;
+};
+
+TEST_CASE("handle_engine_get_payload_v1 succeeds if request is expected payload", "[silkrpc][engine_api]") {
+    SILKRPC_LOG_VERBOSITY(LogLevel::None);
+
+    std::unique_ptr<ethbackend::BackEndInterface> backend(new ethbackend::BackEndMock());
+    ethbackend::test_rpc_call<EngineRpcApiTest, &EngineRpcApiTest::handle_engine_get_payload_v1, std::unique_ptr<ethbackend::BackEndInterface>>(
+        R"({
+            "jsonrpc":"2.0",
+            "id":1,
+            "method":"engine_getPayloadV1",
+            "params":["0x0000000000000001"]
+        })"_json,
+        ethbackend::kGetPayloadTest,
+        std::move(backend)
+    );
+}
+
+TEST_CASE("handle_engine_get_payload_v1 fails with invalid amount of params", "[silkrpc][engine_api]") {
+    SILKRPC_LOG_VERBOSITY(LogLevel::None);
+
+    std::unique_ptr<ethbackend::BackEndInterface> backend(new ethbackend::BackEndMock());
+    ethbackend::test_rpc_call<EngineRpcApiTest, &EngineRpcApiTest::handle_engine_get_payload_v1, std::unique_ptr<ethbackend::BackEndInterface>>(
+        R"({
+            "jsonrpc":"2.0",
+            "id":1,
+            "method":"engine_getPayloadV1",
+            "params":[]
+        })"_json,
+        R"({
+            "error":{
+                "code":100,
+                "message":"invalid engine_getPayloadV1 params: []"
+            },
+            "id":1,
+            "jsonrpc":"2.0" 
+        })"_json,
+        std::move(backend)
+    );
+}
+
+} // namespace silkrpc::commands

silkrpc/commands/eth_api.hpp

@@ -100,7 +100,7 @@ class EthereumRpcApi {
 
     Context& context_;
     std::unique_ptr<ethdb::Database>& database_;
-    std::unique_ptr<ethbackend::BackEnd>& backend_;
+    std::unique_ptr<ethbackend::BackEndInterface>& backend_;
     std::unique_ptr<txpool::Miner>& miner_;
     std::unique_ptr<txpool::TransactionPool>& tx_pool_;
     asio::thread_pool& workers_;

silkrpc/commands/net_api.cpp

@@ -31,30 +31,38 @@ asio::awaitable<void> NetRpcApi::handle_net_listening(const nlohmann::json& requ
 
 // https://eth.wiki/json-rpc/API#net_peercount
 asio::awaitable<void> NetRpcApi::handle_net_peer_count(const nlohmann::json& request, nlohmann::json& reply) {
+    #ifndef BUILD_COVERAGE
     try {
+    #endif
         const auto peer_count = co_await backend_->net_peer_count();
         reply = make_json_content(request["id"], to_quantity(peer_count));
+    #ifndef BUILD_COVERAGE
     } catch (const std::exception& e) {
         SILKRPC_ERROR << "exception: " << e.what() << " processing request: " << request.dump() << "\n";
         reply = make_json_error(request["id"], -32000, e.what());
     } catch (...) {
         SILKRPC_ERROR << "unexpected exception processing request: " << request.dump() << "\n";
         reply = make_json_error(request["id"], 100, "unexpected exception");
     }
+    #endif
 }
 
 // https://eth.wiki/json-rpc/API#net_version
 asio::awaitable<void> NetRpcApi::handle_net_version(const nlohmann::json& request, nlohmann::json& reply) {
+    #ifndef BUILD_COVERAGE
     try {
+    #endif
         const auto net_version = co_await backend_->net_version();
         reply = make_json_content(request["id"], std::to_string(net_version));
+    #ifndef BUILD_COVERAGE
     } catch (const std::exception& e) {
         SILKRPC_ERROR << "exception: " << e.what() << " processing request: " << request.dump() << "\n";
         reply = make_json_error(request["id"], -32000, e.what());
     } catch (...) {
         SILKRPC_ERROR << "unexpected exception processing request: " << request.dump() << "\n";
         reply = make_json_error(request["id"], 100, "unexpected exception");
     }
+    #endif
 }
 
 } // namespace silkrpc::commands

silkrpc/commands/net_api.hpp

@@ -22,6 +22,7 @@
 
 #include <silkrpc/config.hpp> // NOLINT(build/include_order)
 
+#include <silkrpc/context_pool.hpp>
 #include <asio/awaitable.hpp>
 #include <nlohmann/json.hpp>
 
@@ -35,7 +36,7 @@ namespace silkrpc::commands {
 
 class NetRpcApi {
 public:
-    explicit NetRpcApi(std::unique_ptr<ethbackend::BackEnd>& backend) : backend_(backend) {}
+    explicit NetRpcApi(std::unique_ptr<ethbackend::BackEndInterface>& backend) : backend_(backend) {}
     virtual ~NetRpcApi() = default;
 
     NetRpcApi(const NetRpcApi&) = delete;
@@ -49,7 +50,7 @@ class NetRpcApi {
 private:
     friend class silkrpc::http::RequestHandler;
 
-    std::unique_ptr<ethbackend::BackEnd>& backend_;
+    std::unique_ptr<ethbackend::BackEndInterface>& backend_;
 };
 } // namespace silkrpc::commands
 

silkrpc/commands/net_api_test.cpp

@@ -16,11 +16,67 @@
 
 #include "net_api.hpp"
 
+#include <silkrpc/http/methods.hpp>
+#include <silkrpc/ethbackend/backend_mock.hpp>
+#include <silkrpc/json/types.hpp>
 #include <catch2/catch.hpp>
+#include <asio/use_future.hpp>
+#include <asio/co_spawn.hpp>
+#include <utility>
 
-namespace silkrpc {
+namespace silkrpc::commands {
 
 using Catch::Matchers::Message;
 
-} // namespace silkrpc
+class NetRpcApiTest : public NetRpcApi {
+public:
+    explicit NetRpcApiTest(std::unique_ptr<ethbackend::BackEndInterface>& backend): NetRpcApi(backend) {}
+
+    using NetRpcApi::handle_net_peer_count;
+    using NetRpcApi::handle_net_version;
+};
+
+TEST_CASE("handle_net_peer_count succeeds if request is expected peer count", "[silkrpc][net_api]") {
+    SILKRPC_LOG_VERBOSITY(LogLevel::None);
+
+    std::unique_ptr<ethbackend::BackEndInterface> backend(new ethbackend::BackEndMock());
+    ethbackend::test_rpc_call<NetRpcApiTest, &NetRpcApiTest::handle_net_peer_count, std::unique_ptr<ethbackend::BackEndInterface>>(
+        R"({
+            "jsonrpc":"2.0",
+            "id":1,
+            "method":"net_peerCount",
+            "params":[]
+        })"_json,
+        R"({
+            "id":1,
+            "jsonrpc":"2.0",
+            "result":"0x5"
+        })"_json,
+        std::move(backend)
+    );
+}
+
+TEST_CASE("handle_net_version succeeds if request is expected version", "[silkrpc][net_api]") {
+    SILKRPC_LOG_VERBOSITY(LogLevel::None);
+
+    std::unique_ptr<ethbackend::BackEndInterface> backend(new ethbackend::BackEndMock());
+    ethbackend::test_rpc_call<NetRpcApiTest, &NetRpcApiTest::handle_net_version, std::unique_ptr<ethbackend::BackEndInterface>>(
+        R"({
+            "jsonrpc":"2.0",
+            "id":1,
+            "method":"net_version",
+            "params":[]
+        })"_json,
+        R"({
+            "id":1,
+            "jsonrpc":"2.0",
+            "result":"2"
+        })"_json,
+        std::move(backend)
+    );
+}
+
+using Catch::Matchers::Message;
+
+} // namespace silkrpc::commands
 

silkrpc/commands/rpc_api.hpp

@@ -28,18 +28,20 @@
 #include <silkrpc/commands/tg_api.hpp>
 #include <silkrpc/commands/trace_api.hpp>
 #include <silkrpc/commands/web3_api.hpp>
+#include <silkrpc/commands/engine_api.hpp>
 
 namespace silkrpc::http { class RequestHandler; }
 
 namespace silkrpc::commands {
 
 class RpcApiTable;
 
-class RpcApi : protected EthereumRpcApi, NetRpcApi, Web3RpcApi, DebugRpcApi, ParityRpcApi, TurboGethRpcApi, TraceRpcApi {
+class RpcApi : protected EthereumRpcApi, NetRpcApi, Web3RpcApi, DebugRpcApi, ParityRpcApi, TurboGethRpcApi, TraceRpcApi, EngineRpcApi {
 public:
     explicit RpcApi(Context& context, asio::thread_pool& workers) :
         EthereumRpcApi{context, workers}, NetRpcApi{context.backend}, Web3RpcApi{context}, DebugRpcApi{context.database},
-        ParityRpcApi{context.database}, TurboGethRpcApi{context.database}, TraceRpcApi{context.database} {}
+        ParityRpcApi{context.database}, TurboGethRpcApi{context.database}, TraceRpcApi{context.database},
+        EngineRpcApi(context.backend) {}
     virtual ~RpcApi() {}
 
     RpcApi(const RpcApi&) = delete;

silkrpc/commands/rpc_api_table.cpp

@@ -62,6 +62,8 @@ void RpcApiTable::add_handlers(const std::string& api_namespace) {
         add_trace_handlers();
     } else if (api_namespace == kWeb3ApiNamespace) {
         add_web3_handlers();
+    } else if (api_namespace == kEngineApiNamespace) {
+        add_engine_handlers();
     } else {
         SILKRPC_WARN << "Server::add_handlers invalid namespace [" << api_namespace << "] ignored\n";
     }
@@ -156,4 +158,8 @@ void RpcApiTable::add_web3_handlers() {
     handlers_[http::method::k_web3_sha3] = &commands::RpcApi::handle_web3_sha3;
 }
 
+void RpcApiTable::add_engine_handlers() {
+    handlers_[http::method::k_engine_getPayloadV1] = &commands::RpcApi::handle_engine_get_payload_v1;
+}
+
 } // namespace silkrpc::commands

silkrpc/commands/rpc_api_table.hpp

@@ -51,6 +51,7 @@ class RpcApiTable {
     void add_tg_handlers();
     void add_trace_handlers();
     void add_web3_handlers();
+    void add_engine_handlers();
 
     std::map<std::string, HandleMethod> handlers_;
 };