Derive protocol_bitcoind_rest from _rpc.

evoskuil · evoskuil · commit 23e709fe17e1 · 2025-12-14T21:36:42.000-05:00
diff --git a/include/bitcoin/node/protocols/protocol_bitcoind_rest.hpp b/include/bitcoin/node/protocols/protocol_bitcoind_rest.hpp
@@ -23,24 +23,24 @@
 #include <bitcoin/node/channels/channels.hpp>
 #include <bitcoin/node/define.hpp>
 #include <bitcoin/node/interfaces/interfaces.hpp>
-#include <bitcoin/node/protocols/protocol_http.hpp>
+#include <bitcoin/node/protocols/protocol_bitcoind_rpc.hpp>
 
 namespace libbitcoin {
 namespace node {
 
 class BCN_API protocol_bitcoind_rest
-  : public node::protocol_http,
+  : public node::protocol_bitcoind_rpc,
     protected network::tracker<protocol_bitcoind_rest>
 {
 public:
     typedef std::shared_ptr<protocol_bitcoind_rest> ptr;
-    using interface = interface::bitcoind_rest;
-    using dispatcher = network::rpc::dispatcher<interface>;
+    using rest_interface = interface::bitcoind_rest;
+    using rest_dispatcher = network::rpc::dispatcher<rest_interface>;
 
     inline protocol_bitcoind_rest(const auto& session,
         const network::channel::ptr& channel,
         const options_t& options) NOEXCEPT
-      : node::protocol_http(session, channel, options),
+      : node::protocol_bitcoind_rpc(session, channel, options),
         network::tracker<protocol_bitcoind_rest>(session->log)
     {
     }
@@ -49,17 +49,18 @@ class BCN_API protocol_bitcoind_rest
     void start() NOEXCEPT override;
 
 protected:
+    /// TODO: Dispatch.
+    /// TODO: Handlers.
+
+private:
     template <class Derived, typename Method, typename... Args>
     inline void subscribe(Method&& method, Args&&... args) NOEXCEPT
     {
-        dispatcher_.subscribe(BIND_SHARED(method, args));
+        rest_dispatcher_.subscribe(BIND_SHARED(method, args));
     }
 
-    /// TODO: Handlers.
-
-private:
     // This is protected by strand.
-    dispatcher dispatcher_{};
+    rest_dispatcher rest_dispatcher_{};
 };
 
 } // namespace node
diff --git a/include/bitcoin/node/protocols/protocol_bitcoind_rpc.hpp b/include/bitcoin/node/protocols/protocol_bitcoind_rpc.hpp
@@ -34,8 +34,8 @@ class BCN_API protocol_bitcoind_rpc
 {
 public:
     typedef std::shared_ptr<protocol_bitcoind_rpc> ptr;
-    using interface = interface::bitcoind_rpc;
-    using dispatcher = network::rpc::dispatcher<interface>;
+    using rpc_interface = interface::bitcoind_rpc;
+    using rpc_dispatcher = network::rpc::dispatcher<rpc_interface>;
 
     inline protocol_bitcoind_rpc(const auto& session,
         const network::channel::ptr& channel,
@@ -52,12 +52,6 @@ class BCN_API protocol_bitcoind_rpc
     using post = network::http::method::post;
     using options = network::http::method::options;
 
-    template <class Derived, typename Method, typename... Args>
-    inline void subscribe(Method&& method, Args&&... args) NOEXCEPT
-    {
-        dispatcher_.subscribe(BIND_SHARED(method, args));
-    }
-
     /// Dispatch.
     void handle_receive_options(const code& ec,
         const network::http::method::options::cptr& options) NOEXCEPT override;
@@ -66,44 +60,50 @@ class BCN_API protocol_bitcoind_rpc
 
     /// Handlers.
     bool handle_get_best_block_hash(const code& ec,
-        interface::get_best_block_hash) NOEXCEPT;
+        rpc_interface::get_best_block_hash) NOEXCEPT;
     bool handle_get_block(const code& ec,
-        interface::get_block, const std::string&, double) NOEXCEPT;
+        rpc_interface::get_block, const std::string&, double) NOEXCEPT;
     bool handle_get_block_chain_info(const code& ec,
-        interface::get_block_chain_info) NOEXCEPT;
+        rpc_interface::get_block_chain_info) NOEXCEPT;
     bool handle_get_block_count(const code& ec,
-        interface::get_block_count) NOEXCEPT;
+        rpc_interface::get_block_count) NOEXCEPT;
     bool handle_get_block_filter(const code& ec,
-        interface::get_block_filter, const std::string&,
+        rpc_interface::get_block_filter, const std::string&,
         const std::string&) NOEXCEPT;
     bool handle_get_block_hash(const code& ec,
-        interface::get_block_hash, double) NOEXCEPT;
+        rpc_interface::get_block_hash, double) NOEXCEPT;
     bool handle_get_block_header(const code& ec,
-        interface::get_block_header, const std::string&, bool) NOEXCEPT;
+        rpc_interface::get_block_header, const std::string&, bool) NOEXCEPT;
     bool handle_get_block_stats(const code& ec,
-        interface::get_block_stats, const std::string&,
+        rpc_interface::get_block_stats, const std::string&,
         const network::rpc::array_t&) NOEXCEPT;
     bool handle_get_chain_tx_stats(const code& ec,
-        interface::get_chain_tx_stats, double, const std::string&) NOEXCEPT;
+        rpc_interface::get_chain_tx_stats, double, const std::string&) NOEXCEPT;
     bool handle_get_chain_work(const code& ec,
-        interface::get_chain_work) NOEXCEPT;
+        rpc_interface::get_chain_work) NOEXCEPT;
     bool handle_get_tx_out(const code& ec,
-        interface::get_tx_out, const std::string&, double, bool) NOEXCEPT;
+        rpc_interface::get_tx_out, const std::string&, double, bool) NOEXCEPT;
     bool handle_get_tx_out_set_info(const code& ec,
-        interface::get_tx_out_set_info) NOEXCEPT;
+        rpc_interface::get_tx_out_set_info) NOEXCEPT;
     bool handle_prune_block_chain(const code& ec,
-        interface::prune_block_chain, double) NOEXCEPT;
+        rpc_interface::prune_block_chain, double) NOEXCEPT;
     bool handle_save_mem_pool(const code& ec,
-        interface::save_mem_pool) NOEXCEPT;
+        rpc_interface::save_mem_pool) NOEXCEPT;
     bool handle_scan_tx_out_set(const code& ec,
-        interface::scan_tx_out_set, const std::string&,
+        rpc_interface::scan_tx_out_set, const std::string&,
         const network::rpc::array_t&) NOEXCEPT;
     bool handle_verify_chain(const code& ec,
-        interface::verify_chain, double, double) NOEXCEPT;
+        rpc_interface::verify_chain, double, double) NOEXCEPT;
     bool handle_verify_tx_out_set(const code& ec,
-        interface::verify_tx_out_set, const std::string&) NOEXCEPT;
+        rpc_interface::verify_tx_out_set, const std::string&) NOEXCEPT;
 
 private:
+    template <class Derived, typename Method, typename... Args>
+    inline void subscribe(Method&& method, Args&&... args) NOEXCEPT
+    {
+        rpc_dispatcher_.subscribe(BIND_SHARED(method, args));
+    }
+
     // Send the response.
     void send_json(boost::json::value&& model, size_t size_hint) NOEXCEPT;
 
@@ -115,7 +115,7 @@ class BCN_API protocol_bitcoind_rpc
     ////const options_t& options_;
 
     // These are protected by strand.
-    dispatcher dispatcher_{};
+    rpc_dispatcher rpc_dispatcher_{};
     post::cptr post_{};
 };
 
diff --git a/include/bitcoin/node/protocols/protocol_explore.hpp b/include/bitcoin/node/protocols/protocol_explore.hpp
@@ -36,7 +36,7 @@ class BCN_API protocol_explore
 {
 public:
     typedef std::shared_ptr<protocol_explore> ptr;
-    using interface = interface::explore;
+    using interface = node::interface::explore;
     using dispatcher = network::rpc::dispatcher<interface>;
 
     inline protocol_explore(const auto& session,
diff --git a/include/bitcoin/node/sessions/sessions.hpp b/include/bitcoin/node/sessions/sessions.hpp
@@ -34,7 +34,7 @@ namespace node {
 /// Alias server sessions, all derived from node::session.
 using session_web = session_server<protocol_web>;
 using session_explore = session_server<protocol_explore>;
-using session_bitcoind = session_server<protocol_bitcoind_rpc, protocol_bitcoind_rest>;
+using session_bitcoind = session_server<protocol_bitcoind_rest>;
 using session_electrum = session_server<protocol_electrum>;
 using session_stratum_v1 = session_server<protocol_stratum_v1>;
 using session_stratum_v2 = session_server<protocol_stratum_v2>;
diff --git a/src/protocols/protocol_bitcoind_rest.cpp b/src/protocols/protocol_bitcoind_rest.cpp
@@ -36,7 +36,7 @@ void protocol_bitcoind_rest::start() NOEXCEPT
     if (started())
         return;
 
-    protocol_http::start();
+    protocol_bitcoind_rpc::start();
 }
 
 } // namespace node
diff --git a/src/protocols/protocol_bitcoind_rpc.cpp b/src/protocols/protocol_bitcoind_rpc.cpp
@@ -148,7 +148,7 @@ void protocol_bitcoind_rpc::handle_receive_post(const code& ec,
     // to formulate response headers, isolating handlers from http semantics.
     set_post(post);
 
-    if (const auto code = dispatcher_.notify(request))
+    if (const auto code = rpc_dispatcher_.notify(request))
         stop(code);
 }
 
@@ -159,7 +159,7 @@ void protocol_bitcoind_rpc::handle_receive_post(const code& ec,
 
 // {"jsonrpc": "1.0", "id": "curltest", "method": "getbestblockhash", "params": []}
 bool protocol_bitcoind_rpc::handle_get_best_block_hash(const code& ec,
-    interface::get_best_block_hash) NOEXCEPT
+    rpc_interface::get_best_block_hash) NOEXCEPT
 {
     if (stopped(ec))
         return false;
@@ -175,109 +175,110 @@ bool protocol_bitcoind_rpc::handle_get_best_block_hash(const code& ec,
 
 // method<"getblock", string_t, optional<0_u32>>{ "blockhash", "verbosity" },
 bool protocol_bitcoind_rpc::handle_get_block(const code& ec,
-    interface::get_block, const std::string&, double) NOEXCEPT
+    rpc_interface::get_block, const std::string&, double) NOEXCEPT
 {
     return !ec;
 }
 
 bool protocol_bitcoind_rpc::handle_get_block_chain_info(const code& ec,
-    interface::get_block_chain_info) NOEXCEPT
+    rpc_interface::get_block_chain_info) NOEXCEPT
 {
     return !ec;
 }
 
 bool protocol_bitcoind_rpc::handle_get_block_count(const code& ec,
-    interface::get_block_count) NOEXCEPT
+    rpc_interface::get_block_count) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"getblockfilter", string_t, optional<"basic"_t>>{ "blockhash", "filtertype" },
 bool protocol_bitcoind_rpc::handle_get_block_filter(const code& ec,
-    interface::get_block_filter, const std::string&, const std::string&) NOEXCEPT
+    rpc_interface::get_block_filter, const std::string&,
+    const std::string&) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"getblockhash", number_t>{ "height" },
 bool protocol_bitcoind_rpc::handle_get_block_hash(const code& ec,
-    interface::get_block_hash, network::rpc::number_t) NOEXCEPT
+    rpc_interface::get_block_hash, network::rpc::number_t) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"getblockheader", string_t, optional<true>>{ "blockhash", "verbose" },
 bool protocol_bitcoind_rpc::handle_get_block_header(const code& ec,
-    interface::get_block_header, const std::string&, bool) NOEXCEPT
+    rpc_interface::get_block_header, const std::string&, bool) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"getblockstats", string_t, optional<empty::array>>{ "hash_or_height", "stats" },
 bool protocol_bitcoind_rpc::handle_get_block_stats(const code& ec,
-    interface::get_block_stats, const std::string&,
+    rpc_interface::get_block_stats, const std::string&,
     const network::rpc::array_t&) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"getchaintxstats", optional<-1_i32>, optional<""_t>>{ "nblocks", "blockhash" },
 bool protocol_bitcoind_rpc::handle_get_chain_tx_stats(const code& ec,
-    interface::get_chain_tx_stats, double, const std::string&) NOEXCEPT
+    rpc_interface::get_chain_tx_stats, double, const std::string&) NOEXCEPT
 {
     return !ec;
 }
 
 bool protocol_bitcoind_rpc::handle_get_chain_work(const code& ec,
-    interface::get_chain_work) NOEXCEPT
+    rpc_interface::get_chain_work) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"gettxout", string_t, number_t, optional<true>>{ "txid", "n", "include_mempool" },
 bool protocol_bitcoind_rpc::handle_get_tx_out(const code& ec,
-    interface::get_tx_out, const std::string&, double, bool) NOEXCEPT
+    rpc_interface::get_tx_out, const std::string&, double, bool) NOEXCEPT
 {
     return !ec;
 }
 
 bool protocol_bitcoind_rpc::handle_get_tx_out_set_info(const code& ec,
-    interface::get_tx_out_set_info) NOEXCEPT
+    rpc_interface::get_tx_out_set_info) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"pruneblockchain", number_t>{ "height" },
 bool protocol_bitcoind_rpc::handle_prune_block_chain(const code& ec,
-    interface::prune_block_chain, double) NOEXCEPT
+    rpc_interface::prune_block_chain, double) NOEXCEPT
 {
     return !ec;
 }
 
 bool protocol_bitcoind_rpc::handle_save_mem_pool(const code& ec,
-    interface::save_mem_pool) NOEXCEPT
+    rpc_interface::save_mem_pool) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"scantxoutset", string_t, optional<empty::array>>{ "action", "scanobjects" },
 bool protocol_bitcoind_rpc::handle_scan_tx_out_set(const code& ec,
-    interface::scan_tx_out_set, const std::string&,
+    rpc_interface::scan_tx_out_set, const std::string&,
     const network::rpc::array_t&) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"verifychain", optional<4_u32>, optional<288_u32>>{ "checklevel", "nblocks" },
 bool protocol_bitcoind_rpc::handle_verify_chain(const code& ec,
-    interface::verify_chain, double, double) NOEXCEPT
+    rpc_interface::verify_chain, double, double) NOEXCEPT
 {
     return !ec;
 }
 
 // method<"verifytxoutset", string_t>{ "input_verify_flag" },
 bool protocol_bitcoind_rpc::handle_verify_tx_out_set(const code& ec,
-    interface::verify_tx_out_set, const std::string&) NOEXCEPT
+    rpc_interface::verify_tx_out_set, const std::string&) NOEXCEPT
 {
     return !ec;
 }

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ class BCN_API protocol_explore`
`36`	`36`	`{`
`37`	`37`	`public:`
`38`	`38`	`typedef std::shared_ptr<protocol_explore> ptr;`
`39`		`- using interface = interface::explore;`
	`39`	`+ using interface = node::interface::explore;`
`40`	`40`	`using dispatcher = network::rpc::dispatcher<interface>;`
`41`	`41`
`42`	`42`	`inline protocol_explore(const auto& session,`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ void protocol_bitcoind_rest::start() NOEXCEPT`
`36`	`36`	`if (started())`
`37`	`37`	`return;`
`38`	`38`
`39`		`- protocol_http::start();`
	`39`	`+ protocol_bitcoind_rpc::start();`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`} // namespace node`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ void protocol_bitcoind_rpc::handle_receive_post(const code& ec,`
`148`	`148`	`// to formulate response headers, isolating handlers from http semantics.`
`149`	`149`	`set_post(post);`
`150`	`150`
`151`		`- if (const auto code = dispatcher_.notify(request))`
	`151`	`+ if (const auto code = rpc_dispatcher_.notify(request))`
`152`	`152`	`stop(code);`
`153`	`153`	`}`
`154`	`154`
`@@ -159,7 +159,7 @@ void protocol_bitcoind_rpc::handle_receive_post(const code& ec,`
`159`	`159`
`160`	`160`	`// {"jsonrpc": "1.0", "id": "curltest", "method": "getbestblockhash", "params": []}`
`161`	`161`	`bool protocol_bitcoind_rpc::handle_get_best_block_hash(const code& ec,`
`162`		`- interface::get_best_block_hash) NOEXCEPT`
	`162`	`+ rpc_interface::get_best_block_hash) NOEXCEPT`
`163`	`163`	`{`
`164`	`164`	`if (stopped(ec))`
`165`	`165`	`return false;`
`@@ -175,109 +175,110 @@ bool protocol_bitcoind_rpc::handle_get_best_block_hash(const code& ec,`
`175`	`175`
`176`	`176`	`// method<"getblock", string_t, optional<0_u32>>{ "blockhash", "verbosity" },`
`177`	`177`	`bool protocol_bitcoind_rpc::handle_get_block(const code& ec,`
`178`		`- interface::get_block, const std::string&, double) NOEXCEPT`
	`178`	`+ rpc_interface::get_block, const std::string&, double) NOEXCEPT`
`179`	`179`	`{`
`180`	`180`	`return !ec;`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`bool protocol_bitcoind_rpc::handle_get_block_chain_info(const code& ec,`
`184`		`- interface::get_block_chain_info) NOEXCEPT`
	`184`	`+ rpc_interface::get_block_chain_info) NOEXCEPT`
`185`	`185`	`{`
`186`	`186`	`return !ec;`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`bool protocol_bitcoind_rpc::handle_get_block_count(const code& ec,`
`190`		`- interface::get_block_count) NOEXCEPT`
	`190`	`+ rpc_interface::get_block_count) NOEXCEPT`
`191`	`191`	`{`
`192`	`192`	`return !ec;`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`// method<"getblockfilter", string_t, optional<"basic"_t>>{ "blockhash", "filtertype" },`
`196`	`196`	`bool protocol_bitcoind_rpc::handle_get_block_filter(const code& ec,`
`197`		`- interface::get_block_filter, const std::string&, const std::string&) NOEXCEPT`
	`197`	`+ rpc_interface::get_block_filter, const std::string&,`
	`198`	`+ const std::string&) NOEXCEPT`
`198`	`199`	`{`
`199`	`200`	`return !ec;`
`200`	`201`	`}`
`201`	`202`
`202`	`203`	`// method<"getblockhash", number_t>{ "height" },`
`203`	`204`	`bool protocol_bitcoind_rpc::handle_get_block_hash(const code& ec,`
`204`		`- interface::get_block_hash, network::rpc::number_t) NOEXCEPT`
	`205`	`+ rpc_interface::get_block_hash, network::rpc::number_t) NOEXCEPT`
`205`	`206`	`{`
`206`	`207`	`return !ec;`
`207`	`208`	`}`
`208`	`209`
`209`	`210`	`// method<"getblockheader", string_t, optional<true>>{ "blockhash", "verbose" },`
`210`	`211`	`bool protocol_bitcoind_rpc::handle_get_block_header(const code& ec,`
`211`		`- interface::get_block_header, const std::string&, bool) NOEXCEPT`
	`212`	`+ rpc_interface::get_block_header, const std::string&, bool) NOEXCEPT`
`212`	`213`	`{`
`213`	`214`	`return !ec;`
`214`	`215`	`}`
`215`	`216`
`216`	`217`	`// method<"getblockstats", string_t, optional<empty::array>>{ "hash_or_height", "stats" },`
`217`	`218`	`bool protocol_bitcoind_rpc::handle_get_block_stats(const code& ec,`
`218`		`- interface::get_block_stats, const std::string&,`
	`219`	`+ rpc_interface::get_block_stats, const std::string&,`
`219`	`220`	`const network::rpc::array_t&) NOEXCEPT`
`220`	`221`	`{`
`221`	`222`	`return !ec;`
`222`	`223`	`}`
`223`	`224`
`224`	`225`	`// method<"getchaintxstats", optional<-1_i32>, optional<""_t>>{ "nblocks", "blockhash" },`
`225`	`226`	`bool protocol_bitcoind_rpc::handle_get_chain_tx_stats(const code& ec,`
`226`		`- interface::get_chain_tx_stats, double, const std::string&) NOEXCEPT`
	`227`	`+ rpc_interface::get_chain_tx_stats, double, const std::string&) NOEXCEPT`
`227`	`228`	`{`
`228`	`229`	`return !ec;`
`229`	`230`	`}`
`230`	`231`
`231`	`232`	`bool protocol_bitcoind_rpc::handle_get_chain_work(const code& ec,`
`232`		`- interface::get_chain_work) NOEXCEPT`
	`233`	`+ rpc_interface::get_chain_work) NOEXCEPT`
`233`	`234`	`{`
`234`	`235`	`return !ec;`
`235`	`236`	`}`
`236`	`237`
`237`	`238`	`// method<"gettxout", string_t, number_t, optional<true>>{ "txid", "n", "include_mempool" },`
`238`	`239`	`bool protocol_bitcoind_rpc::handle_get_tx_out(const code& ec,`
`239`		`- interface::get_tx_out, const std::string&, double, bool) NOEXCEPT`
	`240`	`+ rpc_interface::get_tx_out, const std::string&, double, bool) NOEXCEPT`
`240`	`241`	`{`
`241`	`242`	`return !ec;`
`242`	`243`	`}`
`243`	`244`
`244`	`245`	`bool protocol_bitcoind_rpc::handle_get_tx_out_set_info(const code& ec,`
`245`		`- interface::get_tx_out_set_info) NOEXCEPT`
	`246`	`+ rpc_interface::get_tx_out_set_info) NOEXCEPT`
`246`	`247`	`{`
`247`	`248`	`return !ec;`
`248`	`249`	`}`
`249`	`250`
`250`	`251`	`// method<"pruneblockchain", number_t>{ "height" },`
`251`	`252`	`bool protocol_bitcoind_rpc::handle_prune_block_chain(const code& ec,`
`252`		`- interface::prune_block_chain, double) NOEXCEPT`
	`253`	`+ rpc_interface::prune_block_chain, double) NOEXCEPT`
`253`	`254`	`{`
`254`	`255`	`return !ec;`
`255`	`256`	`}`
`256`	`257`
`257`	`258`	`bool protocol_bitcoind_rpc::handle_save_mem_pool(const code& ec,`
`258`		`- interface::save_mem_pool) NOEXCEPT`
	`259`	`+ rpc_interface::save_mem_pool) NOEXCEPT`
`259`	`260`	`{`
`260`	`261`	`return !ec;`
`261`	`262`	`}`
`262`	`263`
`263`	`264`	`// method<"scantxoutset", string_t, optional<empty::array>>{ "action", "scanobjects" },`
`264`	`265`	`bool protocol_bitcoind_rpc::handle_scan_tx_out_set(const code& ec,`
`265`		`- interface::scan_tx_out_set, const std::string&,`
	`266`	`+ rpc_interface::scan_tx_out_set, const std::string&,`
`266`	`267`	`const network::rpc::array_t&) NOEXCEPT`
`267`	`268`	`{`
`268`	`269`	`return !ec;`
`269`	`270`	`}`
`270`	`271`
`271`	`272`	`// method<"verifychain", optional<4_u32>, optional<288_u32>>{ "checklevel", "nblocks" },`
`272`	`273`	`bool protocol_bitcoind_rpc::handle_verify_chain(const code& ec,`
`273`		`- interface::verify_chain, double, double) NOEXCEPT`
	`274`	`+ rpc_interface::verify_chain, double, double) NOEXCEPT`
`274`	`275`	`{`
`275`	`276`	`return !ec;`
`276`	`277`	`}`
`277`	`278`
`278`	`279`	`// method<"verifytxoutset", string_t>{ "input_verify_flag" },`
`279`	`280`	`bool protocol_bitcoind_rpc::handle_verify_tx_out_set(const code& ec,`
`280`		`- interface::verify_tx_out_set, const std::string&) NOEXCEPT`
	`281`	`+ rpc_interface::verify_tx_out_set, const std::string&) NOEXCEPT`
`281`	`282`	`{`
`282`	`283`	`return !ec;`
`283`	`284`	`}`