LCOV - code coverage report
Current view: top level - src/rpc - util.h (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 54 65 83.1 %
Date: 2024-01-03 14:57:27 Functions: 14 32 43.8 %
Branches: 21 52 40.4 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2017-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                 :            : #ifndef BITCOIN_RPC_UTIL_H
       6                 :            : #define BITCOIN_RPC_UTIL_H
       7                 :            : 
       8                 :            : #include <addresstype.h>
       9                 :            : #include <consensus/amount.h>
      10                 :            : #include <node/transaction.h>
      11                 :            : #include <outputtype.h>
      12                 :            : #include <pubkey.h>
      13                 :            : #include <rpc/protocol.h>
      14                 :            : #include <rpc/request.h>
      15                 :            : #include <script/script.h>
      16                 :            : #include <script/sign.h>
      17                 :            : #include <uint256.h>
      18                 :            : #include <univalue.h>
      19                 :            : #include <util/check.h>
      20                 :            : 
      21                 :            : #include <cstddef>
      22                 :            : #include <cstdint>
      23                 :            : #include <functional>
      24                 :            : #include <initializer_list>
      25                 :            : #include <map>
      26                 :            : #include <optional>
      27                 :            : #include <string>
      28                 :            : #include <string_view>
      29                 :            : #include <type_traits>
      30                 :            : #include <utility>
      31                 :            : #include <variant>
      32                 :            : #include <vector>
      33                 :            : 
      34                 :            : class JSONRPCRequest;
      35                 :            : enum ServiceFlags : uint64_t;
      36                 :            : enum class OutputType;
      37                 :            : enum class TransactionError;
      38                 :            : struct FlatSigningProvider;
      39                 :            : struct bilingual_str;
      40                 :            : 
      41                 :            : static constexpr bool DEFAULT_RPC_DOC_CHECK{
      42                 :            : #ifdef RPC_DOC_CHECK
      43                 :            :     true
      44                 :            : #else
      45                 :            :     false
      46                 :            : #endif
      47                 :            : };
      48                 :            : 
      49                 :            : /**
      50                 :            :  * String used to describe UNIX epoch time in documentation, factored out to a
      51                 :            :  * constant for consistency.
      52                 :            :  */
      53                 :            : extern const std::string UNIX_EPOCH_TIME;
      54                 :            : 
      55                 :            : /**
      56                 :            :  * Example bech32 addresses for the RPCExamples help documentation. They are intentionally
      57                 :            :  * invalid to prevent accidental transactions by users.
      58                 :            :  */
      59                 :            : extern const std::string EXAMPLE_ADDRESS[2];
      60                 :            : 
      61                 :            : class FillableSigningProvider;
      62                 :            : class CScript;
      63                 :            : struct Sections;
      64                 :            : 
      65                 :            : /**
      66                 :            :  * Gets all existing output types formatted for RPC help sections.
      67                 :            :  *
      68                 :            :  * @return Comma separated string representing output type names.
      69                 :            :  */
      70                 :            : std::string GetAllOutputTypes();
      71                 :            : 
      72                 :            : /** Wrapper for UniValue::VType, which includes typeAny:
      73                 :            :  * Used to denote don't care type. */
      74                 :            : struct UniValueType {
      75                 :          0 :     UniValueType(UniValue::VType _type) : typeAny(false), type(_type) {}
      76                 :          0 :     UniValueType() : typeAny(true) {}
      77                 :            :     bool typeAny;
      78                 :            :     UniValue::VType type;
      79                 :            : };
      80                 :            : 
      81                 :            : /*
      82                 :            :   Check for expected keys/value types in an Object.
      83                 :            : */
      84                 :            : void RPCTypeCheckObj(const UniValue& o,
      85                 :            :     const std::map<std::string, UniValueType>& typesExpected,
      86                 :            :     bool fAllowNull = false,
      87                 :            :     bool fStrict = false);
      88                 :            : 
      89                 :            : /**
      90                 :            :  * Utilities: convert hex-encoded Values
      91                 :            :  * (throws error if not hex).
      92                 :            :  */
      93                 :            : uint256 ParseHashV(const UniValue& v, std::string_view name);
      94                 :            : uint256 ParseHashO(const UniValue& o, std::string_view strKey);
      95                 :            : std::vector<unsigned char> ParseHexV(const UniValue& v, std::string_view name);
      96                 :            : std::vector<unsigned char> ParseHexO(const UniValue& o, std::string_view strKey);
      97                 :            : 
      98                 :            : /**
      99                 :            :  * Validate and return a CAmount from a UniValue number or string.
     100                 :            :  *
     101                 :            :  * @param[in] value     UniValue number or string to parse.
     102                 :            :  * @param[in] decimals  Number of significant digits (default: 8).
     103                 :            :  * @returns a CAmount if the various checks pass.
     104                 :            :  */
     105                 :            : CAmount AmountFromValue(const UniValue& value, int decimals = 8);
     106                 :            : 
     107                 :            : using RPCArgList = std::vector<std::pair<std::string, UniValue>>;
     108                 :            : std::string HelpExampleCli(const std::string& methodname, const std::string& args);
     109                 :            : std::string HelpExampleCliNamed(const std::string& methodname, const RPCArgList& args);
     110                 :            : std::string HelpExampleRpc(const std::string& methodname, const std::string& args);
     111                 :            : std::string HelpExampleRpcNamed(const std::string& methodname, const RPCArgList& args);
     112                 :            : 
     113                 :            : CPubKey HexToPubKey(const std::string& hex_in);
     114                 :            : CPubKey AddrToPubKey(const FillableSigningProvider& keystore, const std::string& addr_in);
     115                 :            : CTxDestination AddAndGetMultisigDestination(const int required, const std::vector<CPubKey>& pubkeys, OutputType type, FillableSigningProvider& keystore, CScript& script_out);
     116                 :            : 
     117                 :            : UniValue DescribeAddress(const CTxDestination& dest);
     118                 :            : 
     119                 :            : /** Parse a sighash string representation and raise an RPC error if it is invalid. */
     120                 :            : int ParseSighashString(const UniValue& sighash);
     121                 :            : 
     122                 :            : //! Parse a confirm target option and raise an RPC error if it is invalid.
     123                 :            : unsigned int ParseConfirmTarget(const UniValue& value, unsigned int max_target);
     124                 :            : 
     125                 :            : RPCErrorCode RPCErrorFromTransactionError(TransactionError terr);
     126                 :            : UniValue JSONRPCTransactionError(TransactionError terr, const std::string& err_string = "");
     127                 :            : 
     128                 :            : //! Parse a JSON range specified as int64, or [int64, int64]
     129                 :            : std::pair<int64_t, int64_t> ParseDescriptorRange(const UniValue& value);
     130                 :            : 
     131                 :            : /** Evaluate a descriptor given as a string, or as a {"desc":...,"range":...} object, with default range of 1000. */
     132                 :            : std::vector<CScript> EvalDescriptorStringOrObject(const UniValue& scanobject, FlatSigningProvider& provider, const bool expand_priv = false);
     133                 :            : 
     134                 :            : /**
     135                 :            :  * Serializing JSON objects depends on the outer type. Only arrays and
     136                 :            :  * dictionaries can be nested in json. The top-level outer type is "NONE".
     137                 :            :  */
     138                 :            : enum class OuterType {
     139                 :            :     ARR,
     140                 :            :     OBJ,
     141                 :            :     NONE, // Only set on first recursion
     142                 :            : };
     143                 :            : 
     144                 :         20 : struct RPCArgOptions {
     145                 :            :     bool skip_type_check{false};
     146                 :            :     std::string oneline_description{};   //!< Should be empty unless it is supposed to override the auto-generated summary line
     147                 :            :     std::vector<std::string> type_str{}; //!< Should be empty unless it is supposed to override the auto-generated type strings. Vector length is either 0 or 2, m_opts.type_str.at(0) will override the type of the value in a key-value pair, m_opts.type_str.at(1) will override the type in the argument description.
     148                 :            :     bool hidden{false};                  //!< For testing only
     149                 :            :     bool also_positional{false};         //!< If set allows a named-parameter field in an OBJ_NAMED_PARAM options object
     150                 :            :                                          //!< to have the same name as a top-level parameter. By default the RPC
     151                 :            :                                          //!< framework disallows this, because if an RPC request passes the value by
     152                 :            :                                          //!< name, it is assigned to top-level parameter position, not to the options
     153                 :            :                                          //!< position, defeating the purpose of using OBJ_NAMED_PARAMS instead OBJ for
     154                 :            :                                          //!< that option. But sometimes it makes sense to allow less-commonly used
     155                 :            :                                          //!< options to be passed by name only, and more commonly used options to be
     156                 :            :                                          //!< passed by name or position, so the RPC framework allows this as long as
     157                 :            :                                          //!< methods set the also_positional flag and read values from both positions.
     158                 :            : };
     159                 :            : 
     160 [ +  - ][ +  - ]:         20 : struct RPCArg {
         [ -  + ][ #  # ]
         [ #  # ][ #  # ]
     161                 :            :     enum class Type {
     162                 :            :         OBJ,
     163                 :            :         ARR,
     164                 :            :         STR,
     165                 :            :         NUM,
     166                 :            :         BOOL,
     167                 :            :         OBJ_NAMED_PARAMS, //!< Special type that behaves almost exactly like
     168                 :            :                           //!< OBJ, defining an options object with a list of
     169                 :            :                           //!< pre-defined keys. The only difference between OBJ
     170                 :            :                           //!< and OBJ_NAMED_PARAMS is that OBJ_NAMED_PARMS
     171                 :            :                           //!< also allows the keys to be passed as top-level
     172                 :            :                           //!< named parameters, as a more convenient way to pass
     173                 :            :                           //!< options to the RPC method without nesting them.
     174                 :            :         OBJ_USER_KEYS, //!< Special type where the user must set the keys e.g. to define multiple addresses; as opposed to e.g. an options object where the keys are predefined
     175                 :            :         AMOUNT,        //!< Special type representing a floating point amount (can be either NUM or STR)
     176                 :            :         STR_HEX,       //!< Special type that is a STR with only hex chars
     177                 :            :         RANGE,         //!< Special type that is a NUM or [NUM,NUM]
     178                 :            :     };
     179                 :            : 
     180                 :            :     enum class Optional {
     181                 :            :         /** Required arg */
     182                 :            :         NO,
     183                 :            :         /**
     184                 :            :          * Optional argument for which the default value is omitted from
     185                 :            :          * help text for one of two reasons:
     186                 :            :          * - It's a named argument and has a default value of `null`.
     187                 :            :          * - Its default value is implicitly clear. That is, elements in an
     188                 :            :          *    array may not exist by default.
     189                 :            :          * When possible, the default value should be specified.
     190                 :            :          */
     191                 :            :         OMITTED,
     192                 :            :     };
     193                 :            :     /** Hint for default value */
     194                 :            :     using DefaultHint = std::string;
     195                 :            :     /** Default constant value */
     196                 :            :     using Default = UniValue;
     197                 :            :     using Fallback = std::variant<Optional, DefaultHint, Default>;
     198                 :            : 
     199                 :            :     const std::string m_names; //!< The name of the arg (can be empty for inner args, can contain multiple aliases separated by | for named request arguments)
     200                 :            :     const Type m_type;
     201                 :            :     const std::vector<RPCArg> m_inner; //!< Only used for arrays or dicts
     202                 :            :     const Fallback m_fallback;
     203                 :            :     const std::string m_description;
     204                 :            :     const RPCArgOptions m_opts;
     205                 :            : 
     206                 :         32 :     RPCArg(
     207                 :            :         std::string name,
     208                 :            :         Type type,
     209                 :            :         Fallback fallback,
     210                 :            :         std::string description,
     211                 :            :         RPCArgOptions opts = {})
     212                 :         16 :         : m_names{std::move(name)},
     213                 :         16 :           m_type{std::move(type)},
     214                 :         16 :           m_fallback{std::move(fallback)},
     215                 :         16 :           m_description{std::move(description)},
     216                 :         16 :           m_opts{std::move(opts)}
     217                 :            :     {
     218 [ +  - ][ +  - ]:         16 :         CHECK_NONFATAL(type != Type::ARR && type != Type::OBJ && type != Type::OBJ_NAMED_PARAMS && type != Type::OBJ_USER_KEYS);
         [ -  + ][ +  - ]
     219                 :         16 :     }
     220                 :            : 
     221                 :          4 :     RPCArg(
     222                 :            :         std::string name,
     223                 :            :         Type type,
     224                 :            :         Fallback fallback,
     225                 :            :         std::string description,
     226                 :            :         std::vector<RPCArg> inner,
     227                 :            :         RPCArgOptions opts = {})
     228                 :          4 :         : m_names{std::move(name)},
     229                 :          4 :           m_type{std::move(type)},
     230                 :          4 :           m_inner{std::move(inner)},
     231                 :          4 :           m_fallback{std::move(fallback)},
     232                 :          4 :           m_description{std::move(description)},
     233                 :          4 :           m_opts{std::move(opts)}
     234                 :            :     {
     235 [ +  + ][ -  + ]:          4 :         CHECK_NONFATAL(type == Type::ARR || type == Type::OBJ || type == Type::OBJ_NAMED_PARAMS || type == Type::OBJ_USER_KEYS);
         [ #  # ][ +  - ]
     236                 :          4 :     }
     237                 :            : 
     238                 :            :     bool IsOptional() const;
     239                 :            : 
     240                 :            :     /**
     241                 :            :      * Check whether the request JSON type matches.
     242                 :            :      * Returns true if type matches, or object describing error(s) if not.
     243                 :            :      */
     244                 :            :     UniValue MatchesType(const UniValue& request) const;
     245                 :            : 
     246                 :            :     /** Return the first of all aliases */
     247                 :            :     std::string GetFirstName() const;
     248                 :            : 
     249                 :            :     /** Return the name, throws when there are aliases */
     250                 :            :     std::string GetName() const;
     251                 :            : 
     252                 :            :     /**
     253                 :            :      * Return the type string of the argument.
     254                 :            :      * Set oneline to allow it to be overridden by a custom oneline type string (m_opts.oneline_description).
     255                 :            :      */
     256                 :            :     std::string ToString(bool oneline) const;
     257                 :            :     /**
     258                 :            :      * Return the type string of the argument when it is in an object (dict).
     259                 :            :      * Set oneline to get the oneline representation (less whitespace)
     260                 :            :      */
     261                 :            :     std::string ToStringObj(bool oneline) const;
     262                 :            :     /**
     263                 :            :      * Return the description string, including the argument type and whether
     264                 :            :      * the argument is required.
     265                 :            :      */
     266                 :            :     std::string ToDescriptionString(bool is_named_arg) const;
     267                 :            : };
     268                 :            : 
     269 [ +  - ][ -  + ]:       1000 : struct RPCResult {
         [ #  # ][ #  # ]
     270                 :            :     enum class Type {
     271                 :            :         OBJ,
     272                 :            :         ARR,
     273                 :            :         STR,
     274                 :            :         NUM,
     275                 :            :         BOOL,
     276                 :            :         NONE,
     277                 :            :         ANY,        //!< Special type to disable type checks (for testing only)
     278                 :            :         STR_AMOUNT, //!< Special string to represent a floating point amount
     279                 :            :         STR_HEX,    //!< Special string with only hex chars
     280                 :            :         OBJ_DYN,    //!< Special dictionary with keys that are not literals
     281                 :            :         ARR_FIXED,  //!< Special array that has a fixed number of entries
     282                 :            :         NUM_TIME,   //!< Special numeric to denote unix epoch time
     283                 :            :         ELISION,    //!< Special type to denote elision (...)
     284                 :            :     };
     285                 :            : 
     286                 :            :     const Type m_type;
     287                 :            :     const std::string m_key_name;         //!< Only used for dicts
     288                 :            :     const std::vector<RPCResult> m_inner; //!< Only used for arrays or dicts
     289                 :            :     const bool m_optional;
     290                 :            :     const bool m_skip_type_check;
     291                 :            :     const std::string m_description;
     292                 :            :     const std::string m_cond;
     293                 :            : 
     294                 :          6 :     RPCResult(
     295                 :            :         std::string cond,
     296                 :            :         Type type,
     297                 :            :         std::string m_key_name,
     298                 :            :         bool optional,
     299                 :            :         std::string description,
     300                 :            :         std::vector<RPCResult> inner = {})
     301                 :          6 :         : m_type{std::move(type)},
     302                 :          6 :           m_key_name{std::move(m_key_name)},
     303                 :          6 :           m_inner{std::move(inner)},
     304                 :          6 :           m_optional{optional},
     305                 :          6 :           m_skip_type_check{false},
     306                 :          6 :           m_description{std::move(description)},
     307                 :          6 :           m_cond{std::move(cond)}
     308                 :            :     {
     309         [ +  - ]:          6 :         CHECK_NONFATAL(!m_cond.empty());
     310         [ +  - ]:          6 :         CheckInnerDoc();
     311                 :          6 :     }
     312                 :            : 
     313                 :          6 :     RPCResult(
     314                 :            :         std::string cond,
     315                 :            :         Type type,
     316                 :            :         std::string m_key_name,
     317                 :            :         std::string description,
     318                 :            :         std::vector<RPCResult> inner = {})
     319         [ +  - ]:          6 :         : RPCResult{std::move(cond), type, std::move(m_key_name), /*optional=*/false, std::move(description), std::move(inner)} {}
     320                 :            : 
     321                 :        392 :     RPCResult(
     322                 :            :         Type type,
     323                 :            :         std::string m_key_name,
     324                 :            :         bool optional,
     325                 :            :         std::string description,
     326                 :            :         std::vector<RPCResult> inner = {},
     327                 :            :         bool skip_type_check = false)
     328                 :        392 :         : m_type{std::move(type)},
     329                 :        392 :           m_key_name{std::move(m_key_name)},
     330                 :        392 :           m_inner{std::move(inner)},
     331                 :        392 :           m_optional{optional},
     332                 :        392 :           m_skip_type_check{skip_type_check},
     333                 :        392 :           m_description{std::move(description)},
     334                 :        392 :           m_cond{}
     335                 :            :     {
     336         [ +  - ]:        392 :         CheckInnerDoc();
     337                 :        392 :     }
     338                 :            : 
     339                 :        310 :     RPCResult(
     340                 :            :         Type type,
     341                 :            :         std::string m_key_name,
     342                 :            :         std::string description,
     343                 :            :         std::vector<RPCResult> inner = {},
     344                 :            :         bool skip_type_check = false)
     345         [ +  - ]:        310 :         : RPCResult{type, std::move(m_key_name), /*optional=*/false, std::move(description), std::move(inner), skip_type_check} {}
     346                 :            : 
     347                 :            :     /** Append the sections of the result. */
     348                 :            :     void ToSections(Sections& sections, OuterType outer_type = OuterType::NONE, const int current_indent = 0) const;
     349                 :            :     /** Return the type string of the result when it is in an object (dict). */
     350                 :            :     std::string ToStringObj() const;
     351                 :            :     /** Return the description string, including the result type. */
     352                 :            :     std::string ToDescriptionString() const;
     353                 :            :     /** Check whether the result JSON type matches.
     354                 :            :      * Returns true if type matches, or object describing error(s) if not.
     355                 :            :      */
     356                 :            :     UniValue MatchesType(const UniValue& result) const;
     357                 :            : 
     358                 :            : private:
     359                 :            :     void CheckInnerDoc() const;
     360                 :            : };
     361                 :            : 
     362                 :          0 : struct RPCResults {
     363                 :            :     const std::vector<RPCResult> m_results;
     364                 :            : 
     365                 :         12 :     RPCResults(RPCResult result)
     366 [ +  - ][ +  - ]:         12 :         : m_results{{result}}
     367                 :            :     {
     368                 :         12 :     }
     369                 :            : 
     370                 :          4 :     RPCResults(std::initializer_list<RPCResult> results)
     371         [ +  - ]:          4 :         : m_results{results}
     372                 :            :     {
     373                 :          4 :     }
     374                 :            : 
     375                 :            :     /**
     376                 :            :      * Return the description string.
     377                 :            :      */
     378                 :            :     std::string ToDescriptionString() const;
     379                 :            : };
     380                 :            : 
     381                 :          0 : struct RPCExamples {
     382                 :            :     const std::string m_examples;
     383                 :         16 :     explicit RPCExamples(
     384                 :            :         std::string examples)
     385                 :         16 :         : m_examples(std::move(examples))
     386                 :            :     {
     387                 :         16 :     }
     388                 :            :     std::string ToDescriptionString() const;
     389                 :            : };
     390                 :            : 
     391                 :          0 : class RPCHelpMan
     392                 :            : {
     393                 :            : public:
     394                 :            :     RPCHelpMan(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples);
     395                 :            :     using RPCMethodImpl = std::function<UniValue(const RPCHelpMan&, const JSONRPCRequest&)>;
     396                 :            :     RPCHelpMan(std::string name, std::string description, std::vector<RPCArg> args, RPCResults results, RPCExamples examples, RPCMethodImpl fun);
     397                 :            : 
     398                 :            :     UniValue HandleRequest(const JSONRPCRequest& request) const;
     399                 :            :     /**
     400                 :            :      * Helper to get a request argument.
     401                 :            :      * This function only works during m_fun(), i.e. it should only be used in
     402                 :            :      * RPC method implementations. The helper internally checks whether the
     403                 :            :      * user-passed argument isNull() and parses (from JSON) and returns the
     404                 :            :      * user-passed argument, or the default value derived from the RPCArg
     405                 :            :      * documentation, or a falsy value if no default was given.
     406                 :            :      *
     407                 :            :      * Use Arg<Type>(i) to get the argument or its default value. Otherwise,
     408                 :            :      * use MaybeArg<Type>(i) to get the optional argument or a falsy value.
     409                 :            :      *
     410                 :            :      * The Type passed to this helper must match the corresponding
     411                 :            :      * RPCArg::Type.
     412                 :            :      */
     413                 :            :     template <typename R>
     414                 :          0 :     auto Arg(size_t i) const
     415                 :            :     {
     416                 :            :         // Return argument (required or with default value).
     417                 :            :         if constexpr (std::is_integral_v<R> || std::is_floating_point_v<R>) {
     418                 :            :             // Return numbers by value.
     419                 :          0 :             return ArgValue<R>(i);
     420                 :            :         } else {
     421                 :            :             // Return everything else by reference.
     422                 :          0 :             return ArgValue<const R&>(i);
     423                 :            :         }
     424                 :            :     }
     425                 :            :     template <typename R>
     426                 :          0 :     auto MaybeArg(size_t i) const
     427                 :            :     {
     428                 :            :         // Return optional argument (without default).
     429                 :            :         if constexpr (std::is_integral_v<R> || std::is_floating_point_v<R>) {
     430                 :            :             // Return numbers by value, wrapped in optional.
     431                 :          0 :             return ArgValue<std::optional<R>>(i);
     432                 :            :         } else {
     433                 :            :             // Return other types by pointer.
     434                 :          0 :             return ArgValue<const R*>(i);
     435                 :            :         }
     436                 :            :     }
     437                 :            :     std::string ToString() const;
     438                 :            :     /** Return the named args that need to be converted from string to another JSON type */
     439                 :            :     UniValue GetArgMap() const;
     440                 :            :     /** If the supplied number of args is neither too small nor too high */
     441                 :            :     bool IsValidNumArgs(size_t num_args) const;
     442                 :            :     //! Return list of arguments and whether they are named-only.
     443                 :            :     std::vector<std::pair<std::string, bool>> GetArgNames() const;
     444                 :            : 
     445                 :            :     const std::string m_name;
     446                 :            : 
     447                 :            : private:
     448                 :            :     const RPCMethodImpl m_fun;
     449                 :            :     const std::string m_description;
     450                 :            :     const std::vector<RPCArg> m_args;
     451                 :            :     const RPCResults m_results;
     452                 :            :     const RPCExamples m_examples;
     453                 :            :     mutable const JSONRPCRequest* m_req{nullptr}; // A pointer to the request for the duration of m_fun()
     454                 :            :     template <typename R>
     455                 :            :     R ArgValue(size_t i) const;
     456                 :            : };
     457                 :            : 
     458                 :            : /**
     459                 :            :  * Push warning messages to an RPC "warnings" field as a JSON array of strings.
     460                 :            :  *
     461                 :            :  * @param[in] warnings  Warning messages to push.
     462                 :            :  * @param[out] obj      UniValue object to push the warnings array object to.
     463                 :            :  */
     464                 :            : void PushWarnings(const UniValue& warnings, UniValue& obj);
     465                 :            : void PushWarnings(const std::vector<bilingual_str>& warnings, UniValue& obj);
     466                 :            : 
     467                 :            : #endif // BITCOIN_RPC_UTIL_H

Generated by: LCOV version 1.14