Add bitcoind_rest interface methods, dispatch, a stub hander.

Author: evoskuil

include/bitcoin/node/interfaces/bitcoind_rest.hpp

@@ -28,9 +28,32 @@ namespace interface {
 
 struct bitcoind_rest_methods
 {
+    // github.com/bitcoin/bitcoin/blob/master/doc/REST-interface.md
     static constexpr std::tuple methods
     {
-        method<"rest1">{},
+        // blocks (block_part is bin|hex only)
+        method<"block", uint8_t, system::hash_cptr>{ "media", "hash" },
+        method<"block_hash", uint8_t, uint32_t>{ "media", "height" },
+        method<"block_txs", uint8_t, system::hash_cptr>{ "media", "hash" },
+        method<"block_headers", uint8_t, system::hash_cptr, uint32_t>{ "media", "hash", "count" },
+        method<"block_part", uint8_t, system::hash_cptr, uint32_t, uint32_t>{ "media", "hash", "offset", "size" },
+        method<"block_spent_tx_outputs", uint8_t, system::hash_cptr>{ "media", "hash" },
+
+        // client filters
+        method<"block_filter", uint8_t, system::hash_cptr, uint8_t>{ "media", "hash", "type" },
+        method<"block_filter_headers", uint8_t, system::hash_cptr, uint8_t>{ "media", "hash", "type" },
+
+        // unspent outputs
+        method<"get_utxos", uint8_t, system::hash_cptr, uint8_t>{ "media", "hash", "type" },
+        method<"get_utxos_confirmed", uint8_t, system::hash_cptr, uint8_t>{ "media", "hash", "type" },
+
+        // mempool (json only)
+        method<"mempool", optional<true>, optional<false>>{ "verbose", "sequence" },
+
+        // info (json only)
+        method<"chain_information">{},
+        method<"mempool_information">{},
+        method<"fork_information", nullable<system::hash_cptr>>{ "hash" }
     };
 
     template <typename... Args>
@@ -40,7 +63,20 @@ struct bitcoind_rest_methods
     using at = method_at<methods, Index>;
 
     // Derive this from above in c++26 using reflection.
-    using rest1 = at<0>;
+    using block = at<0>;
+    using block_hash = at<1>;
+    using block_txs = at<2>;
+    using block_headers = at<3>;
+    using block_part = at<4>;
+    using block_spent_tx_outputs = at<5>;
+    using block_filter = at<6>;
+    using block_filter_headers = at<7>;
+    using get_utxos = at<8>;
+    using get_utxos_confirmed = at<9>;
+    using mempool = at<10>;
+    using chain_information = at<11>;
+    using mempool_information = at<12>;
+    using fork_information = at<13>;
 };
 
 } // namespace interface

include/bitcoin/node/protocols/protocol_bitcoind_rest.hpp

@@ -47,10 +47,18 @@ class BCN_API protocol_bitcoind_rest
 
     /// Public start is required.
     void start() NOEXCEPT override;
+    void stopping(const code& ec) NOEXCEPT override;
 
 protected:
-    /// TODO: Dispatch.
-    /// TODO: Handlers.
+    using get = network::http::method::get;
+
+    /// Dispatch.
+    void handle_receive_get(const code& ec,
+        const get::cptr& get) NOEXCEPT override;
+
+    /// REST interface handlers.
+    bool handle_get_block(const code& ec, rest_interface::block,
+        uint8_t media, system::hash_cptr hash) NOEXCEPT;
 
 private:
     template <class Derived, typename Method, typename... Args>

src/protocols/protocol_bitcoind_rest.cpp

@@ -24,6 +24,20 @@
 namespace libbitcoin {
 namespace node {
 
+#define CLASS protocol_bitcoind_rest
+#define SUBSCRIBE_BITCOIND(method, ...) \
+    subscribe<CLASS>(&CLASS::method, __VA_ARGS__)
+
+using namespace system;
+using namespace network::rpc;
+using namespace network::http;
+using namespace std::placeholders;
+using namespace boost::json;
+
+BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
+BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED)
+BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR)
+
 // Start.
 // ----------------------------------------------------------------------------
 
@@ -36,8 +50,93 @@ void protocol_bitcoind_rest::start() NOEXCEPT
     if (started())
         return;
 
+    SUBSCRIBE_BITCOIND(handle_get_block, _1, _2, _3, _4);
     protocol_bitcoind_rpc::start();
 }
 
+void protocol_bitcoind_rest::stopping(const code& ec) NOEXCEPT
+{
+    BC_ASSERT(stranded());
+    rest_dispatcher_.stop(ec);
+    protocol_bitcoind_rpc::stopping(ec);
+}
+
+// Dispatch.
+// ----------------------------------------------------------------------------
+
+// Base rpc protocol handles options and post, this derived handles get.
+void protocol_bitcoind_rest::handle_receive_get(const code& ec,
+    const get::cptr& get) NOEXCEPT
+{
+    BC_ASSERT(stranded());
+
+    if (stopped(ec))
+        return;
+
+    // Enforce http host header (if any hosts are configured).
+    if (!is_allowed_host(*get, get->version()))
+    {
+        send_bad_host(*get);
+        return;
+    }
+
+    // Enforce http origin policy (if any origins are configured).
+    if (!is_allowed_origin(*get, get->version()))
+    {
+        send_forbidden(*get);
+        return;
+    }
+
+    // The post is saved off during asynchonous handling and used in send_json
+    // to formulate response headers, isolating handlers from http semantics.
+    set_request(get);
+
+    ////if (const auto code = rest_dispatcher_.notify({}))
+    ////    stop(code);
+    protocol_bitcoind_rpc::handle_receive_get(ec, get);
+}
+
+// Handlers.
+// ----------------------------------------------------------------------------
+
+constexpr auto data = to_value(media_type::application_octet_stream);
+constexpr auto json = to_value(media_type::application_json);
+constexpr auto text = to_value(media_type::text_plain);
+
+bool protocol_bitcoind_rest::handle_get_block(const code& ec,
+    rest_interface::block, uint8_t , system::hash_cptr ) NOEXCEPT
+{
+    if (stopped(ec))
+        return false;
+
+    ////const auto& query = archive();
+    ////if (const auto block = query.get_block(query.to_header(*hash), true))
+    ////{
+    ////    const auto size = block->serialized_size(true);
+    ////    switch (media)
+    ////    {
+    ////        case data:
+    ////            send_chunk(to_bin(*block, size, true));
+    ////            return true;
+    ////        case text:
+    ////            send_text(to_hex(*block, size, true));
+    ////            return true;
+    ////        case json:
+    ////            send_json(value_from(block), two * size);
+    ////            return true;
+    ////    }
+    ////}
+
+    send_not_found();
+    return true;
+}
+
+// private
+// ----------------------------------------------------------------------------
+
+BC_POP_WARNING()
+BC_POP_WARNING()
+BC_POP_WARNING()
+
 } // namespace node
 } // namespace libbitcoin

src/protocols/protocol_bitcoind_rpc.cpp

@@ -154,7 +154,7 @@ void protocol_bitcoind_rpc::handle_receive_post(const code& ec,
 
     // The post is saved off during asynchonous handling and used in send_json
     // to formulate response headers, isolating handlers from http semantics.
-    set_post(post);
+    set_request(post);
 
     if (const auto code = rpc_dispatcher_.notify(request))
         stop(code);
@@ -310,13 +310,14 @@ void protocol_bitcoind_rpc::send_json(boost::json::value&& model,
     SEND(std::move(response), handle_complete, _1, error::success);
 }
 
-void protocol_bitcoind_rpc::set_post(const post::cptr& post) NOEXCEPT
+void protocol_bitcoind_rpc::set_request(const post::cptr& post) NOEXCEPT
 {
     BC_ASSERT(post);
     post_ = post;
 }
 
-const protocol_bitcoind_rpc::post& protocol_bitcoind_rpc::get_post() const NOEXCEPT
+const protocol_bitcoind_rpc::post& protocol_bitcoind_rpc::
+set_request() const NOEXCEPT
 {
     BC_ASSERT(post_);
     return *post_;