5#include <bitcoin-build-config.h>
47const std::string
EXAMPLE_ADDRESS[2] = {
"bc1q09vm5lfy0j5reeulh4x5752q25uqqvz34hufdl",
"bc1q02ad21edsxd23d32dfgqqsz4vv4nmtfzuklhy3"};
51 std::vector<std::string>
ret;
52 using U = std::underlying_type_t<TxoutType>;
60 const std::map<std::string, UniValueType>& typesExpected,
64 for (
const auto&
t : typesExpected) {
66 if (!fAllowNull && v.
isNull())
69 if (!(
t.second.typeAny || v.
type() ==
t.second.type || (fAllowNull && v.
isNull())))
75 for (
const std::string&
k : o.
getKeys())
77 if (typesExpected.count(
k) == 0)
79 std::string err =
strprintf(
"Unexpected key %s",
k);
98 return default_verbosity;
122 const std::string& strHex(v.
get_str());
124 if (
auto expected_len{
uint256::size() * 2}; strHex.length() != expected_len) {
154std::string ShellQuote(
const std::string&
s)
157 result.reserve(
s.size() * 2);
158 for (
const char ch:
s) {
165 return "'" + result +
"'";
173std::string ShellQuoteIfNeeded(
const std::string&
s)
175 for (
const char ch:
s) {
176 if (ch ==
' ' || ch ==
'\'' || ch ==
'"') {
177 return ShellQuote(
s);
188 return "> bitcoin-cli " + methodname +
" " +
args +
"\n";
193 std::string result =
"> bitcoin-cli -named " + methodname;
194 for (
const auto& argpair:
args) {
195 const auto& value = argpair.second.isStr()
196 ? argpair.second.get_str()
197 : argpair.second.write();
198 result +=
" " + argpair.first +
"=" + ShellQuoteIfNeeded(value);
206 return "> curl --user myusername --data-binary '{\"jsonrpc\": \"2.0\", \"id\": \"curltest\", "
207 "\"method\": \"" + methodname +
"\", \"params\": [" +
args +
"]}' -H 'content-type: application/json' http://127.0.0.1:8332/\n";
213 for (
const auto& param:
args) {
214 params.
pushKV(param.first, param.second);
217 return "> curl --user myusername --data-binary '{\"jsonrpc\": \"2.0\", \"id\": \"curltest\", "
218 "\"method\": \"" + methodname +
"\", \"params\": " + params.
write() +
"}' -H 'content-type: application/json' http://127.0.0.1:8332/\n";
224 if (!
IsHex(hex_in)) {
227 if (hex_in.length() != 66 && hex_in.length() != 130) {
244 if ((
int)pubkeys.size() < required) {
255 if (!
pk.IsCompressed()) {
289 obj.
pushKV(
"isscript",
false);
290 obj.
pushKV(
"iswitness",
false);
297 obj.
pushKV(
"isscript",
true);
298 obj.
pushKV(
"iswitness",
false);
305 obj.
pushKV(
"isscript",
false);
306 obj.
pushKV(
"iswitness",
true);
307 obj.
pushKV(
"witness_version", 0);
315 obj.
pushKV(
"isscript",
true);
316 obj.
pushKV(
"iswitness",
true);
317 obj.
pushKV(
"witness_version", 0);
325 obj.
pushKV(
"isscript",
true);
326 obj.
pushKV(
"iswitness",
true);
327 obj.
pushKV(
"witness_version", 1);
335 obj.
pushKV(
"isscript",
true);
336 obj.
pushKV(
"iswitness",
true);
343 obj.
pushKV(
"iswitness",
true);
344 obj.
pushKV(
"witness_version",
id.GetWitnessVersion());
345 obj.
pushKV(
"witness_program",
HexStr(
id.GetWitnessProgram()));
369 return result.value();
374 const int target{value.
getInt<
int>()};
375 const unsigned int unsigned_target{
static_cast<unsigned int>(target)};
376 if (target < 1 || unsigned_target > max_target) {
379 return unsigned_target;
385 case PSBTError::UNSUPPORTED:
387 case PSBTError::SIGHASH_MISMATCH:
397 case TransactionError::MEMPOOL_REJECTED:
399 case TransactionError::ALREADY_IN_UTXO_SET:
413 if (err_string.length() > 0) {
425 Section(
const std::string& left,
const std::string& right)
451 const auto indent = std::string(current_indent,
' ');
452 const auto indent_next = std::string(current_indent + 2,
' ');
464 if (is_top_level_arg)
return;
478 PushSection({indent + (push_name ?
"\"" + arg.
GetName() +
"\": " :
"") +
"{", right});
479 for (
const auto& arg_inner : arg.
m_inner) {
485 PushSection({indent +
"}" + (is_top_level_arg ?
"" :
","),
""});
490 left += push_name ?
"\"" + arg.
GetName() +
"\": " :
"";
494 for (
const auto& arg_inner : arg.
m_inner) {
498 PushSection({indent +
"]" + (is_top_level_arg ?
"" :
","),
""});
515 if (
s.m_right.empty()) {
521 std::string left =
s.m_left;
522 left.resize(pad,
' ');
528 size_t new_line_pos =
s.m_right.find_first_of(
'\n');
530 right +=
s.m_right.substr(begin, new_line_pos - begin);
531 if (new_line_pos == std::string::npos) {
534 right +=
"\n" + std::string(pad,
' ');
535 begin =
s.m_right.find_first_not_of(
' ', new_line_pos + 1);
536 if (begin == std::string::npos) {
539 new_line_pos =
s.m_right.find_first_of(
'\n', begin + 1);
553 m_fun{
std::move(fun)},
554 m_description{
std::move(description)},
556 m_results{
std::move(results)},
557 m_examples{
std::move(examples)}
562 enum ParamType { POSITIONAL = 1, NAMED = 2, NAMED_ONLY = 4 };
563 std::map<std::string, int> param_names;
565 for (
const auto& arg :
m_args) {
566 std::vector<std::string> names =
SplitString(arg.m_names,
'|');
568 for (
const std::string&
name : names) {
569 auto& param_type = param_names[
name];
572 param_type |= POSITIONAL;
575 for (
const auto& inner : arg.m_inner) {
576 std::vector<std::string> inner_names =
SplitString(inner.m_names,
'|');
577 for (
const std::string& inner_name : inner_names) {
578 auto& param_type = param_names[inner_name];
579 CHECK_NONFATAL(!(param_type & POSITIONAL) || inner.m_opts.also_positional);
582 param_type |= inner.m_opts.also_positional ? NAMED : NAMED_ONLY;
587 if (arg.m_fallback.index() == 2) {
589 switch (std::get<RPCArg::Default>(arg.m_fallback).getType()) {
621 if (r.m_cond.empty()) {
622 result +=
"\nResult:\n";
624 result +=
"\nResult (" + r.m_cond +
"):\n";
627 r.ToSections(sections);
648 throw std::runtime_error(
ToString());
651 for (
size_t i{0}; i <
m_args.size(); ++i) {
652 const auto& arg{
m_args.at(i)};
654 if (!match.isTrue()) {
655 arg_mismatch.
pushKV(
strprintf(
"Position %s (%s)", i + 1, arg.m_names), std::move(match));
658 if (!arg_mismatch.empty()) {
669 if (match.isTrue()) {
673 mismatch.push_back(std::move(match));
675 if (!mismatch.isNull()) {
677 mismatch.empty() ?
"no possible results defined" :
678 mismatch.size() == 1 ? mismatch[0].write(4) :
680 throw std::runtime_error{
681 strprintf(
"Internal bug detected: RPC call \"%s\" returned incorrect type:\n%s\n%s %s\nPlease report this issue here: %s\n",
695 const RPCArg& param{params.at(i)};
696 if (check) check(param);
698 if (!arg.isNull())
return &arg;
699 if (!std::holds_alternative<RPCArg::Default>(param.m_fallback))
return nullptr;
700 return &std::get<RPCArg::Default>(param.m_fallback);
712#define TMPL_INST(check_param, ret_type, return_code) \
714 ret_type RPCHelpMan::ArgValue<ret_type>(size_t i) const \
716 const UniValue* maybe_arg{ \
717 DetailMaybeArg(check_param, m_args, m_req, i), \
721 void force_semicolon(ret_type)
725TMPL_INST(
nullptr, std::optional<double>, maybe_arg ? std::optional{maybe_arg->get_real()} : std::nullopt;);
726TMPL_INST(
nullptr, std::optional<bool>, maybe_arg ? std::optional{maybe_arg->get_bool()} : std::nullopt;);
727TMPL_INST(
nullptr,
const std::string*, maybe_arg ? &maybe_arg->get_str() :
nullptr;);
738 size_t num_required_args = 0;
739 for (
size_t n =
m_args.size(); n > 0; --n) {
740 if (!
m_args.at(n - 1).IsOptional()) {
741 num_required_args = n;
745 return num_required_args <= num_args && num_args <=
m_args.size();
750 std::vector<std::pair<std::string, bool>>
ret;
752 for (
const auto& arg :
m_args) {
754 for (
const auto& inner : arg.m_inner) {
755 ret.emplace_back(inner.m_names,
true);
758 ret.emplace_back(arg.m_names,
false);
765 auto it{std::find_if(
766 m_args.begin(),
m_args.end(), [&key](
const auto& arg) { return arg.GetName() == key;}
770 return std::distance(
m_args.begin(), it);
779 bool was_optional{
false};
780 for (
const auto& arg :
m_args) {
781 if (arg.m_opts.hidden)
break;
782 const bool optional = arg.IsOptional();
785 if (!was_optional)
ret +=
"( ";
788 if (was_optional)
ret +=
") ";
789 was_optional =
false;
791 ret += arg.ToString(
true);
793 if (was_optional)
ret +=
" )";
802 for (
size_t i{0}; i <
m_args.size(); ++i) {
803 const auto& arg =
m_args.at(i);
804 if (arg.m_opts.hidden)
break;
815 for (
const auto& arg_inner : arg.m_inner) {
816 named_only_sections.
PushSection({arg_inner.GetFirstName(), arg_inner.ToDescriptionString(
true)});
817 named_only_sections.
Push(arg_inner);
824 if (!named_only_sections.
m_sections.empty())
ret +=
"\nNamed Arguments:\n";
840 auto push_back_arg_info = [&arr](
const std::string& rpc_name,
int pos,
const std::string& arg_name,
const RPCArg::Type& type) {
842 map.push_back(rpc_name);
844 map.push_back(arg_name);
847 arr.push_back(std::move(map));
850 for (
int i{0}; i < int(
m_args.size()); ++i) {
851 const auto& arg =
m_args.at(i);
852 std::vector<std::string> arg_names =
SplitString(arg.m_names,
'|');
853 for (
const auto& arg_name : arg_names) {
854 push_back_arg_info(
m_name, i, arg_name, arg.m_type);
856 for (
const auto& inner : arg.m_inner) {
857 std::vector<std::string> inner_names =
SplitString(inner.m_names,
'|');
858 for (
const std::string& inner_name : inner_names) {
859 push_back_arg_info(
m_name, i, inner_name, inner.m_type);
891 case Type::OBJ_NAMED_PARAMS:
892 case Type::OBJ_USER_KEYS: {
907 if (!exp_type)
return true;
909 if (*exp_type != request.
getType()) {
953 ret +=
"numeric or string";
957 ret +=
"numeric or array";
967 ret +=
"json object";
977 ret +=
", optional, default=" + std::get<RPCArg::DefaultHint>(
m_fallback);
979 ret +=
", optional, default=" + std::get<RPCArg::Default>(
m_fallback).write();
981 switch (std::get<RPCArg::Optional>(
m_fallback)) {
983 if (is_named_arg)
ret +=
", optional";
1003 const std::string indent(current_indent,
' ');
1004 const std::string indent_next(current_indent + 2,
' ');
1007 const std::string maybe_separator{outer_type !=
OuterType::NONE ?
"," :
""};
1010 const std::string maybe_key{
1016 const auto Description = [&](
const std::string& type) {
1017 return "(" + type + (this->
m_optional ?
", optional" :
"") +
")" +
1031 sections.
PushSection({indent +
"null" + maybe_separator, Description(
"json null")});
1035 sections.
PushSection({indent + maybe_key +
"\"str\"" + maybe_separator, Description(
"string")});
1039 sections.
PushSection({indent + maybe_key +
"n" + maybe_separator, Description(
"numeric")});
1043 sections.
PushSection({indent + maybe_key +
"\"hex\"" + maybe_separator, Description(
"string")});
1047 sections.
PushSection({indent + maybe_key +
"n" + maybe_separator, Description(
"numeric")});
1051 sections.
PushSection({indent + maybe_key +
"xxx" + maybe_separator, Description(
"numeric")});
1055 sections.
PushSection({indent + maybe_key +
"true|false" + maybe_separator, Description(
"boolean")});
1060 sections.
PushSection({indent + maybe_key +
"[", Description(
"json array")});
1061 for (
const auto& i :
m_inner) {
1069 sections.
m_sections.back().m_left.pop_back();
1071 sections.
PushSection({indent +
"]" + maybe_separator,
""});
1077 sections.
PushSection({indent + maybe_key +
"{}", Description(
"empty JSON object")});
1080 sections.
PushSection({indent + maybe_key +
"{", Description(
"json object")});
1081 for (
const auto& i :
m_inner) {
1089 sections.
m_sections.back().m_left.pop_back();
1091 sections.
PushSection({indent +
"}" + maybe_separator,
""});
1104 return std::nullopt;
1110 case Type::STR_HEX: {
1114 case Type::STR_AMOUNT:
1115 case Type::NUM_TIME: {
1121 case Type::ARR_FIXED:
1141 if (!exp_type)
return true;
1143 if (*exp_type != result.
getType()) {
1149 for (
size_t i{0}; i < result.
get_array().size(); ++i) {
1153 if (!match.isTrue()) errors.
pushKV(
strprintf(
"%d", i), std::move(match));
1155 if (errors.
empty())
return true;
1164 for (
size_t i{0}; i < result.
get_obj().size(); ++i) {
1166 if (!match.isTrue()) errors.
pushKV(result.
getKeys()[i], std::move(match));
1168 if (errors.
empty())
return true;
1171 std::set<std::string> doc_keys;
1172 for (
const auto& doc_entry :
m_inner) {
1173 doc_keys.insert(doc_entry.m_key_name);
1175 std::map<std::string, UniValue> result_obj;
1177 for (
const auto& result_entry : result_obj) {
1178 if (doc_keys.find(result_entry.first) == doc_keys.end()) {
1179 errors.
pushKV(result_entry.first,
"key returned that was not in doc");
1183 for (
const auto& doc_entry :
m_inner) {
1184 const auto result_it{result_obj.find(doc_entry.m_key_name)};
1185 if (result_it == result_obj.end()) {
1186 if (!doc_entry.m_optional) {
1187 errors.
pushKV(doc_entry.m_key_name,
"key missing, despite not being optional in doc");
1191 UniValue match{doc_entry.MatchesType(result_it->second)};
1192 if (!match.isTrue()) errors.
pushKV(doc_entry.m_key_name, std::move(match));
1194 if (errors.
empty())
return true;
1225 return res +
"\"str\"";
1227 return res +
"\"hex\"";
1231 return res +
"n or [n,n]";
1233 return res +
"amount";
1235 return res +
"bool";
1238 for (
const auto& i :
m_inner) {
1239 res += i.ToString(oneline) +
",";
1241 return res +
"...]";
1256 throw std::runtime_error{
1281 return "{" + res +
"}";
1283 return "{" + res +
",...}";
1288 for (
const auto& i :
m_inner) {
1289 res += i.ToString(oneline) +
",";
1291 return "[" + res +
"...]";
1299 if (value.
isNum()) {
1300 return {0, value.
getInt<int64_t>()};
1303 int64_t low = value[0].
getInt<int64_t>();
1304 int64_t high = value[1].
getInt<int64_t>();
1318 if ((high >> 31) != 0) {
1321 if (high >= low + 1000000) {
1329 std::string desc_str;
1330 std::pair<int64_t, int64_t> range = {0, 1000};
1331 if (scanobject.
isStr()) {
1332 desc_str = scanobject.
get_str();
1333 }
else if (scanobject.
isObject()) {
1336 desc_str = desc_uni.get_str();
1338 if (!range_uni.isNull()) {
1346 auto descs =
Parse(desc_str, provider, error);
1347 if (descs.empty()) {
1350 if (!descs.at(0)->IsRange()) {
1354 std::vector<CScript>
ret;
1355 for (
int i = range.first; i <= range.second; ++i) {
1356 for (
const auto& desc : descs) {
1357 std::vector<CScript> scripts;
1358 if (!desc->Expand(i, provider, scripts, provider)) {
1362 desc->ExpandPrivate(i, provider, provider);
1364 std::move(scripts.begin(), scripts.end(), std::back_inserter(
ret));
1375 for (
const auto&
s : bilingual_strings) {
1376 result.push_back(
s.original);
1383 if (warnings.
empty())
return;
1384 obj.
pushKV(
"warnings", warnings);
1389 if (warnings.empty())
return;
1399 {
RPCResult::Type::STR,
"address",
true,
"The Bitcoin address (only if a well-defined address exists)"},
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
static constexpr CAmount COIN
The amount of satoshis in one BTC.
uint256 ArithToUint256(const arith_uint256 &a)
#define CHECK_NONFATAL(condition)
Identity function.
#define NONFATAL_UNREACHABLE()
NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code.
#define STR_INTERNAL_BUG(msg)
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
The block chain is a tree shaped structure starting with the genesis block at the root,...
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
An encapsulated public key.
bool IsFullyValid() const
fully validate whether this is a valid public key (more expensive than IsValid())
Serialized script, used inside transaction inputs and outputs.
UniValue operator()(const WitnessUnknown &id) const
UniValue operator()(const WitnessV0KeyHash &id) const
UniValue operator()(const WitnessV0ScriptHash &id) const
DescribeAddressVisitor()=default
UniValue operator()(const CNoDestination &dest) const
UniValue operator()(const PubKeyDestination &dest) const
UniValue operator()(const WitnessV1Taproot &tap) const
UniValue operator()(const ScriptHash &scriptID) const
UniValue operator()(const PKHash &keyID) const
UniValue operator()(const PayToAnchor &anchor) const
enum JSONRPCRequest::Mode mode
std::function< UniValue(const RPCHelpMan &, const JSONRPCRequest &)> RPCMethodImpl
const RPCExamples m_examples
size_t GetParamIndex(std::string_view key) const
Return positional index of a parameter using its name as key.
RPCHelpMan(std::string name, std::string description, std::vector< RPCArg > args, RPCResults results, RPCExamples examples)
const std::string m_description
bool IsValidNumArgs(size_t num_args) const
If the supplied number of args is neither too small nor too high.
const RPCMethodImpl m_fun
const RPCResults m_results
const std::vector< RPCArg > m_args
std::string ToString() const
UniValue GetArgMap() const
Return the named args that need to be converted from string to another JSON type.
std::vector< std::pair< std::string, bool > > GetArgNames() const
Return list of arguments and whether they are named-only.
const JSONRPCRequest * m_req
UniValue HandleRequest(const JSONRPCRequest &request) const
const std::string & get_str() const
const UniValue & find_value(std::string_view key) const
enum VType getType() const
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
const std::string & getValStr() const
const UniValue & get_obj() const
const std::vector< std::string > & getKeys() const
const UniValue & get_array() const
void pushKV(std::string key, UniValue val)
void getObjMap(std::map< std::string, UniValue > &kv) const
256-bit unsigned big integer.
static constexpr unsigned int size()
static std::optional< uint256 > FromHex(std::string_view str)
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
std::string FormatFullVersion()
is a home for simple enum and struct type definitions that can be used internally by functions in the...
util::Result< int > SighashFromStr(const std::string &sighash)
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
is a home for simple string functions returning descriptive messages that are used in RPC and GUI int...
char const * json() noexcept
Template to generate JSON data.
bilingual_str PSBTErrorString(PSBTError err)
bilingual_str TransactionErrorString(const TransactionError err)
std::vector< std::string > SplitString(std::string_view str, char sep)
bilingual_str ErrorString(const Result< T > &result)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
std::string TrimString(std::string_view str, std::string_view pattern=" \f\n\r\t\v")
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
is a home for public enum and struct type definitions that are used internally by node code,...
CTxDestination AddAndGetDestinationForScript(FlatSigningProvider &keystore, const CScript &script, OutputType type)
Get a destination of the requested type (if possible) to the specified script.
std::optional< arith_uint256 > DeriveTarget(unsigned int nBits, const uint256 pow_limit)
Convert nBits value to target.
UniValue JSONRPCError(int code, const std::string &message)
RPCErrorCode
Bitcoin RPC error codes.
@ RPC_VERIFY_ALREADY_IN_UTXO_SET
Transaction already in utxo set.
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
@ RPC_TRANSACTION_REJECTED
@ RPC_TRANSACTION_ERROR
Aliases for backward compatibility.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
static const UniValue * DetailMaybeArg(CheckFn *check, const std::vector< RPCArg > ¶ms, const JSONRPCRequest *req, size_t i)
std::vector< CScript > EvalDescriptorStringOrObject(const UniValue &scanobject, FlatSigningProvider &provider, const bool expand_priv)
Evaluate a descriptor given as a string, or as a {"desc":...,"range":...} object, with default range ...
void(const RPCArg &) CheckFn
std::pair< int64_t, int64_t > ParseDescriptorRange(const UniValue &value)
Parse a JSON range specified as int64, or [int64, int64].
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpcNamed(const std::string &methodname, const RPCArgList &args)
CAmount AmountFromValue(const UniValue &value, int decimals)
Validate and return a CAmount from a UniValue number or string.
RPCErrorCode RPCErrorFromPSBTError(PSBTError err)
std::vector< unsigned char > ParseHexV(const UniValue &v, std::string_view name)
static UniValue BilingualStringsToUniValue(const std::vector< bilingual_str > &bilingual_strings)
Convert a vector of bilingual strings to a UniValue::VARR containing their original untranslated valu...
void PushWarnings(const UniValue &warnings, UniValue &obj)
Push warning messages to an RPC "warnings" field as a JSON array of strings.
UniValue JSONRPCTransactionError(TransactionError terr, const std::string &err_string)
#define TMPL_INST(check_param, ret_type, return_code)
std::vector< unsigned char > ParseHexO(const UniValue &o, std::string_view strKey)
uint256 GetTarget(const CBlockIndex &blockindex, const uint256 pow_limit)
UniValue JSONRPCPSBTError(PSBTError err)
RPCErrorCode RPCErrorFromTransactionError(TransactionError terr)
CFeeRate ParseFeeRate(const UniValue &json)
Parse a json number or string, denoting BTC/kvB, into a CFeeRate (sat/kvB).
static std::optional< UniValue::VType > ExpectedType(RPCArg::Type type)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
std::string GetAllOutputTypes()
Gets all existing output types formatted for RPC help sections.
int ParseVerbosity(const UniValue &arg, int default_verbosity, bool allow_bool)
Parses verbosity from provided UniValue.
CPubKey HexToPubKey(const std::string &hex_in)
std::optional< int > ParseSighashString(const UniValue &sighash)
Returns a sighash value corresponding to the passed in argument.
const std::string EXAMPLE_ADDRESS[2]
Example bech32 addresses for the RPCExamples help documentation.
CTxDestination AddAndGetMultisigDestination(const int required, const std::vector< CPubKey > &pubkeys, OutputType type, FlatSigningProvider &keystore, CScript &script_out)
static std::pair< int64_t, int64_t > ParseRange(const UniValue &value)
uint256 ParseHashO(const UniValue &o, std::string_view strKey)
unsigned int ParseConfirmTarget(const UniValue &value, unsigned int max_target)
Parse a confirm target option and raise an RPC error if it is invalid.
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
std::string HelpExampleCliNamed(const std::string &methodname, const RPCArgList &args)
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
static void CheckRequiredOrDefault(const RPCArg ¶m)
UniValue DescribeAddress(const CTxDestination &dest)
std::vector< RPCResult > ScriptPubKeyDoc()
std::vector< std::pair< std::string, UniValue > > RPCArgList
static constexpr bool DEFAULT_RPC_DOC_CHECK
OuterType
Serializing JSON objects depends on the outer type.
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
static const int MAX_PUBKEYS_PER_MULTISIG
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
std::string GetTxnOutputType(TxoutType t)
Get the name of a TxoutType as a string.
@ WITNESS_UNKNOWN
Only for Witness versions not already defined above.
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
@ RANGE
Special type that is a NUM or [NUM,NUM].
@ OBJ_USER_KEYS
Special type where the user must set the keys e.g. to define multiple addresses; as opposed to e....
@ STR_HEX
Special type that is a STR with only hex chars.
@ AMOUNT
Special type representing a floating point amount (can be either NUM or STR)
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
const std::vector< RPCArg > m_inner
Only used for arrays or dicts.
const RPCArgOptions m_opts
const std::string m_names
The name of the arg (can be empty for inner args, can contain multiple aliases separated by | for nam...
const Fallback m_fallback
std::string ToString(bool oneline) const
Return the type string of the argument.
UniValue MatchesType(const UniValue &request) const
Check whether the request JSON type matches.
const std::string m_description
std::string ToDescriptionString(bool is_named_arg) const
Return the description string, including the argument type and whether the argument is required.
std::string GetName() const
Return the name, throws when there are aliases.
std::string GetFirstName() const
Return the first of all aliases.
std::string ToStringObj(bool oneline) const
Return the type string of the argument when it is in an object (dict).
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
std::vector< std::string > type_str
Should be empty unless it is supposed to override the auto-generated type strings....
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
std::string ToDescriptionString() const
const std::string m_examples
const std::string m_description
void ToSections(Sections §ions, OuterType outer_type=OuterType::NONE, const int current_indent=0) const
Append the sections of the result.
@ ELISION
Special type to denote elision (...)
@ NUM_TIME
Special numeric to denote unix epoch time.
@ ANY
Special type to disable type checks (for testing only)
@ ARR_FIXED
Special array that has a fixed number of entries.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
const std::vector< RPCResult > m_inner
Only used for arrays or dicts.
UniValue MatchesType(const UniValue &result) const
Check whether the result JSON type matches.
void CheckInnerDoc() const
const std::string m_key_name
Only used for dicts.
const bool m_skip_type_check
std::string ToDescriptionString() const
Return the description string.
const std::vector< RPCResult > m_results
A pair of strings that can be aligned (through padding) with other Sections later on.
Section(const std::string &left, const std::string &right)
const std::string m_right
Keeps track of RPCArgs by transforming them into sections for the purpose of serializing everything t...
void PushSection(const Section &s)
std::vector< Section > m_sections
void Push(const RPCArg &arg, const size_t current_indent=5, const OuterType outer_type=OuterType::NONE)
Recursive helper to translate an RPCArg into sections.
std::string ToString() const
Concatenate all sections with proper padding.
CTxDestination subtype to encode any future Witness version.
const char * uvTypeName(UniValue::VType t)
bool ParseFixedPoint(std::string_view val, int decimals, int64_t *amount_out)
Parse number as fixed point according to JSON number syntax.
bool IsHex(std::string_view str)