Line data    Source code

       1             : // Copyright (c) 2021-2022 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #include <rpc/server_util.h>
       6             : 
       7             : #include <common/args.h>
       8             : #include <net_processing.h>
       9             : #include <node/context.h>
      10             : #include <policy/fees.h>
      11             : #include <rpc/protocol.h>
      12             : #include <rpc/request.h>
      13             : #include <txmempool.h>
      14             : #include <util/any.h>
      15             : #include <validation.h>
      16             : 
      17           2 : #include <any>
      18           2 : 
      19             : using node::NodeContext;
      20             : 
      21           0 : NodeContext& EnsureAnyNodeContext(const std::any& context)
      22             : {
      23           0 :     auto node_context = util::AnyPtr<NodeContext>(context);
      24           0 :     if (!node_context) {
      25           0 :         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node context not found");
      26             :     }
      27           0 :     return *node_context;
      28           0 : }
      29             : 
      30           0 : CTxMemPool& EnsureMemPool(const NodeContext& node)
      31             : {
      32           0 :     if (!node.mempool) {
      33           0 :         throw JSONRPCError(RPC_CLIENT_MEMPOOL_DISABLED, "Mempool disabled or instance not found");
      34             :     }
      35           0 :     return *node.mempool;
      36           0 : }
      37             : 
      38           0 : CTxMemPool& EnsureAnyMemPool(const std::any& context)
      39             : {
      40           0 :     return EnsureMemPool(EnsureAnyNodeContext(context));
      41             : }
      42             : 
      43             : 
      44           0 : BanMan& EnsureBanman(const NodeContext& node)
      45             : {
      46           0 :     if (!node.banman) {
      47           0 :         throw JSONRPCError(RPC_DATABASE_ERROR, "Error: Ban database not loaded");
      48             :     }
      49           0 :     return *node.banman;
      50           0 : }
      51             : 
      52           0 : BanMan& EnsureAnyBanman(const std::any& context)
      53             : {
      54           0 :     return EnsureBanman(EnsureAnyNodeContext(context));
      55             : }
      56             : 
      57           0 : ArgsManager& EnsureArgsman(const NodeContext& node)
      58             : {
      59           0 :     if (!node.args) {
      60           0 :         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node args not found");
      61             :     }
      62           0 :     return *node.args;
      63           0 : }
      64             : 
      65           0 : ArgsManager& EnsureAnyArgsman(const std::any& context)
      66             : {
      67           0 :     return EnsureArgsman(EnsureAnyNodeContext(context));
      68             : }
      69             : 
      70           0 : ChainstateManager& EnsureChainman(const NodeContext& node)
      71             : {
      72           0 :     if (!node.chainman) {
      73           0 :         throw JSONRPCError(RPC_INTERNAL_ERROR, "Node chainman not found");
      74           2 :     }
      75           0 :     return *node.chainman;
      76           0 : }
      77             : 
      78           0 : ChainstateManager& EnsureAnyChainman(const std::any& context)
      79             : {
      80           0 :     return EnsureChainman(EnsureAnyNodeContext(context));
      81             : }
      82             : 
      83           2 : CBlockPolicyEstimator& EnsureFeeEstimator(const NodeContext& node)
      84             : {
      85           0 :     if (!node.fee_estimator) {
      86           0 :         throw JSONRPCError(RPC_INTERNAL_ERROR, "Fee estimation disabled");
      87             :     }
      88           0 :     return *node.fee_estimator;
      89           0 : }
      90             : 
      91           0 : CBlockPolicyEstimator& EnsureAnyFeeEstimator(const std::any& context)
      92             : {
      93           0 :     return EnsureFeeEstimator(EnsureAnyNodeContext(context));
      94             : }
      95             : 
      96           0 : CConnman& EnsureConnman(const NodeContext& node)
      97             : {
      98           0 :     if (!node.connman) {
      99           0 :         throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
     100             :     }
     101           0 :     return *node.connman;
     102           0 : }
     103             : 
     104           0 : PeerManager& EnsurePeerman(const NodeContext& node)
     105             : {
     106           0 :     if (!node.peerman) {
     107           0 :         throw JSONRPCError(RPC_CLIENT_P2P_DISABLED, "Error: Peer-to-peer functionality missing or disabled");
     108             :     }
     109           0 :     return *node.peerman;
     110           0 : }