bitcoinrpc-util 0.1.16-alpha.0

crate::ix!();

//-------------------------------------------[.cpp/bitcoin/src/rpc/util.h]

/**
  | String used to describe UNIX epoch time
  | in documentation, factored out to a
  | constant for consistency.
  |
  */
lazy_static!{
    /*
    extern const std::string UNIX_EPOCH_TIME;
    */
}

/**
  | Example bech32 addresses for the RPCExamples
  | help documentation. They are intentionally
  | invalid to prevent accidental transactions
  | by users.
  |
  */
lazy_static!{
    /*
    extern const std::string EXAMPLE_ADDRESS[2];
    */
}

/**
  | Wrapper for UniValue::VType, which
  | includes typeAny:
  | 
  | Used to denote don't care type.
  |
  */
pub struct UniValueType {
    type_any: bool,
    ty:       uni_value::VType,
}

impl Default for UniValueType {
    
    fn default() -> Self {
        todo!();
        /*
        : type_any(true),

        
        */
    }
}

impl From<uni_value::VType> for UniValueType {

    fn from(ty: uni_value::VType) -> Self {
    
        todo!();
        /*
        : type_any(false),
        : ty(_type),

        
        */
    }
}

pub type RPCArgList = Vec<(String,UniValue)>;

/**
  | Serializing JSON objects depends on
  | the outer type. Only arrays and dictionaries
  | can be nested in json. The top-level
  | outer type is "NONE".
  |
  */
pub enum OuterType {
    ARR,
    OBJ,

    /**
      | Only set on first recursion
      |
      */
    NONE, 
}

///---------------------
pub struct RPCArg {

    /**
      | The name of the arg (can be empty for inner
      | args, can contain multiple aliases
      | separated by | for named request arguments)
      |
      */
    names:               String,

    ty:                  rpc_arg::Type,
    hidden:              bool,

    /**
      | Only used for arrays or dicts
      |
      */
    inner:               Vec<RPCArg>,

    fallback:            rpc_arg::Fallback,
    description:         String,

    /**
      | Should be empty unless it is supposed
      | to override the auto-generated summary
      | line
      |
      */
    oneline_description: String,

    /**
      | Should be empty unless it is supposed
      | to override the auto-generated type
      | strings.
      | 
      | Vector length is either 0 or 2, m_type_str.at(0)
      | will override the type of the value in
      | a key-value pair, m_type_str.at(1)
      | will override the type in the argument
      | description.
      |
      */
    type_str:            Vec<String>,
}

pub mod rpc_arg {

    use super::*;

    pub enum Fallback {

        Optional(Optional),

        /*
          | hint for default value
          |
          */
        DefaultHint(String),

        /*
           | default constant value
           |
           */
        Default(UniValue)
    }

    pub enum Type {
        OBJ,
        ARR,
        STR,
        NUM,
        BOOL,

        /**
          | 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
          |
          */
        OBJ_USER_KEYS, 

        /**
          | Special type representing a floating
          | point amount (can be either NUM or STR)
          |
          */
        AMOUNT,        

        /**
          | Special type that is a STR with only hex
          | chars
          |
          */
        STR_HEX,       

        /**
          | Special type that is a NUM or [NUM,NUM]
          |
          */
        RANGE,         
    }

    pub enum Optional {

        /**
          | Required arg
          |
          */
        NO,

        /**
          | Optional arg that is a named argument
          | and has a default value of `null`. When
          | possible, the default value should
          | be specified.
          |
          */
        OMITTED_NAMED_ARG,

        /**
          | Optional argument with default value
          | omitted because they are implicitly
          | clear. That is, elements in an array
          | or object may not exist by default.
          | 
          | When possible, the default value should
          | be specified.
          |
          */
        OMITTED,
    }
}

impl RPCArg {

    pub fn new(
        name:                String,
        ty:                  rpc_arg::Type,
        fallback:            rpc_arg::Fallback,
        description:         String,
        oneline_description: Option<&str>,
        type_str:            Vec<String>,
        hidden:              Option<bool>) -> Self {

        let oneline_description: &str =
                 oneline_description.unwrap_or("");

        let hidden: bool = hidden.unwrap_or(false);

        todo!();
        /*


            : m_names{std::move(name)},
              m_type{std::move(type)},
              m_hidden{hidden},
              m_fallback{std::move(fallback)},
              m_description{std::move(description)},
              m_oneline_description{std::move(oneline_description)},
              m_type_str{std::move(type_str)}

            CHECK_NONFATAL(type != Type::ARR && type != Type::OBJ && type != Type::OBJ_USER_KEYS);
        */
    }
    
    pub fn new_with_inner(
        name:                String,
        ty:                  rpc_arg::Type,
        fallback:            rpc_arg::Fallback,
        description:         String,
        inner:               Vec<RPCArg>,
        oneline_description: Option<&str>,
        type_str:            Vec<String>) -> Self {
        let oneline_description: &str =
                 oneline_description.unwrap_or("");
        todo!();
        /*


            : m_names{std::move(name)},
              m_type{std::move(type)},
              m_hidden{false},
              m_inner{std::move(inner)},
              m_fallback{std::move(fallback)},
              m_description{std::move(description)},
              m_oneline_description{std::move(oneline_description)},
              m_type_str{std::move(type_str)}
            CHECK_NONFATAL(type == Type::ARR || type == Type::OBJ || type == Type::OBJ_USER_KEYS);
        */
    }
}

///------------------------
pub struct RPCResult {

    ty:          rpc_arg::Type,

    /**
      | Only used for dicts
      |
      */
    key_name:    String,

    /**
      | Only used for arrays or dicts
      |
      */
    inner:       Vec<RPCResult>,

    optional:    bool,
    description: String,
    cond:        String,
}

pub mod rpc_result {

    pub enum Type {
        OBJ,
        ARR,
        STR,
        NUM,
        BOOL,
        NONE,

        /**
          | Special type to disable type checks
          | (for testing only)
          |
          */
        ANY,        

        /**
          | Special string to represent a floating
          | point amount
          |
          */
        STR_AMOUNT, 

        /**
          | Special string with only hex chars
          |
          */
        STR_HEX,    

        /**
          | Special dictionary with keys that are
          | not literals
          |
          */
        OBJ_DYN,    

        /**
          | Special array that has a fixed number
          | of entries
          |
          */
        ARR_FIXED,  

        /**
          | Special numeric to denote unix epoch
          | time
          |
          */
        NUM_TIME,   

        /**
          | Special type to denote elision (...)
          |
          */
        ELISION,    
    }
}

impl RPCResult {

    pub fn new_with_cond_and_optional(
        cond:        String,
        ty:          rpc_arg::Type,
        key_name:    String,
        optional:    bool,
        description: String,
        inner:       Vec<RPCResult>) -> Self {
    
        todo!();
        /*
            : m_type{std::move(type)},
              m_key_name{std::move(m_key_name)},
              m_inner{std::move(inner)},
              m_optional{optional},
              m_description{std::move(description)},
              m_cond{std::move(cond)}

            CHECK_NONFATAL(!m_cond.empty());
            const bool inner_needed{type == Type::ARR || type == Type::ARR_FIXED || type == Type::OBJ || type == Type::OBJ_DYN};
            CHECK_NONFATAL(inner_needed != inner.empty());
        */
    }
    
    pub fn new_with_cond(
        cond:        String,
        ty:          rpc_arg::Type,
        key_name:    String,
        description: String,
        inner:       Vec<RPCResult>) -> Self {
    
        todo!();
        /*
            : RPCResult{cond, type, m_key_name, false, description, inner}
        */
    }
    
    fn new_impl(
        ty:          rpc_arg::Type,
        key_name:    String,
        optional:    bool,
        description: String,
        inner:       Vec<RPCResult>) -> Self {
    
        todo!();
        /*
            : m_type{std::move(type)},
              m_key_name{std::move(m_key_name)},
              m_inner{std::move(inner)},
              m_optional{optional},
              m_description{std::move(description)},
              m_cond{}

            const bool inner_needed{type == Type::ARR || type == Type::ARR_FIXED || type == Type::OBJ || type == Type::OBJ_DYN};
            CHECK_NONFATAL(inner_needed != inner.empty());
        */
    }
    
    pub fn new_with_keyname_description_and_rpc_result_vector(
        ty:          rpc_arg::Type,
        key_name:    String,
        description: String,
        inner:       Vec<RPCResult>) -> Self {
    
        todo!();
        /*
            : RPCResult{type, m_key_name, false, description, inner}
        */
    }
}

///-------------------------
pub struct RPCResults {
    results: Vec<RPCResult>,
}

impl From<RPCResult> for RPCResults {
    fn from(result: RPCResult) -> Self {
    
        todo!();
        /*
            : m_results{{result}}
        */
    }
}
    
impl From<&[RPCResult]> for RPCResults {
    fn from(results: &[RPCResult]) -> Self {
    
        todo!();
        /*


            : m_results{results}
        */
    }
}

pub struct RPCExamples {
    examples: String,
}

impl From<String> for RPCExamples {

    fn from(examples: String) -> Self {
    
        todo!();
        /*


            : m_examples(std::move(examples))
        */
    }
}
    
pub struct RPCHelpMan {
    name:        String,
    fun:         rpc_help_man::RPCMethodImpl,
    description: String,
    args:        Vec<RPCArg>,
    results:     RPCResults,
    examples:    RPCExamples,
}

pub mod rpc_help_man {

    use super::*;

    pub type RPCMethodImpl = fn(_0: &RPCHelpMan, _1: &JSONRPCRequest) -> UniValue;
}

//-------------------------------------------[.cpp/bitcoin/src/rpc/util.cpp]

pub const UNIX_EPOCH_TIME: &'static str = "UNIX epoch time";

pub const EXAMPLE_ADDRESS: [&'static str; 2] = [
    "bc1q09vm5lfy0j5reeulh4x5752q25uqqvz34hufdl", 
    "bc1q02ad21edsxd23d32dfgqqsz4vv4nmtfzuklhy3"
];

/**
  | Type-check arguments; throws JSONRPCError
  | if wrong type given. Does not check that
  | the right number of arguments are passed,
  | just that any passed are the correct
  | type.
  |
  */
pub fn rpc_type_check(
        params:         &UniValue,
        types_expected: &LinkedList<UniValueType>,
        allow_null:     Option<bool>)  {

    let allow_null: bool = allow_null.unwrap_or(false);
    
    todo!();
        /*
            unsigned int i = 0;
        for (const UniValueType& t : typesExpected) {
            if (params.size() <= i)
                break;

            const UniValue& v = params[i];
            if (!(fAllowNull && v.isNull())) {
                RPCTypeCheckArgument(v, t);
            }
            i++;
        }
        */
}

/**
  | Type-check one argument; throws JSONRPCError
  | if wrong type given.
  |
  */
pub fn rpc_type_check_argument(
        value:         &UniValue,
        type_expected: &UniValueType)  {
    
    todo!();
        /*
            if (!typeExpected.typeAny && value.type() != typeExpected.type) {
            throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Expected type %s, got %s", uvTypeName(typeExpected.type), uvTypeName(value.type())));
        }
        */
}

/**
  | Check for expected keys/value types
  | in an Object.
  |
  */
pub fn rpc_type_check_obj(
        o:              &UniValue,
        types_expected: &HashMap<String,UniValueType>,
        allow_null:     Option<bool>,
        strict:         Option<bool>)  {

    let allow_null: bool = allow_null.unwrap_or(false);
    let strict:     bool = strict.unwrap_or(false);
    
    todo!();
        /*
            for (const auto& t : typesExpected) {
            const UniValue& v = find_value(o, t.first);
            if (!fAllowNull && v.isNull())
                throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing %s", t.first));

            if (!(t.second.typeAny || v.type() == t.second.type || (fAllowNull && v.isNull()))) {
                std::string err = strprintf("Expected type %s for %s, got %s",
                    uvTypeName(t.second.type), t.first, uvTypeName(v.type()));
                throw JSONRPCError(RPC_TYPE_ERROR, err);
            }
        }

        if (fStrict)
        {
            for (const std::string& k : o.getKeys())
            {
                if (typesExpected.count(k) == 0)
                {
                    std::string err = strprintf("Unexpected key %s", k);
                    throw JSONRPCError(RPC_TYPE_ERROR, err);
                }
            }
        }
        */
}

/**
  | Validate and return a CAmount from a
  | UniValue number or string.
  | 
  | -----------
  | @param[in] value
  | 
  | UniValue number or string to parse.
  | ----------
  | @param[in] decimals
  | 
  | Number of significant digits (default:
  | 8).
  | 
  | -----------
  | @return
  | 
  | a CAmount if the various checks pass.
  |
  */
pub fn amount_from_value(
        value:    &UniValue,
        decimals: Option<i32>) -> Amount {

    let decimals: i32 = decimals.unwrap_or(8);
    
    todo!();
        /*
            if (!value.isNum() && !value.isStr())
            throw JSONRPCError(RPC_TYPE_ERROR, "Amount is not a number or string");
        CAmount amount;
        if (!ParseFixedPoint(value.getValStr(), decimals, &amount))
            throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
        if (!MoneyRange(amount))
            throw JSONRPCError(RPC_TYPE_ERROR, "Amount out of range");
        return amount;
        */
}

/**
  | Utilities: convert hex-encoded Values
  | (throws error if not hex).
  |
  */
pub fn parse_hashv(
        v:        &UniValue,
        str_name: String) -> u256 {
    
    todo!();
        /*
            std::string strHex(v.get_str());
        if (64 != strHex.length())
            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be of length %d (not %d, for '%s')", strName, 64, strHex.length(), strHex));
        if (!IsHex(strHex)) // Note: IsHex("") is false
            throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
        return uint256S(strHex);
        */
}

pub fn parse_hasho(
        o:       &UniValue,
        str_key: String) -> u256 {
    
    todo!();
        /*
            return ParseHashV(find_value(o, strKey), strKey);
        */
}

pub fn parse_hexv(
        v:        &UniValue,
        str_name: String) -> Vec<u8> {
    
    todo!();
        /*
            std::string strHex;
        if (v.isStr())
            strHex = v.get_str();
        if (!IsHex(strHex))
            throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
        return ParseHex(strHex);
        */
}

pub fn parse_hexo(
        o:       &UniValue,
        str_key: String) -> Vec<u8> {
    
    todo!();
        /*
            return ParseHexV(find_value(o, strKey), strKey);
        */
}

/**
  | Quote an argument for shell.
  | 
  | -----------
  | @note
  | 
  | This is intended for help, not for security-sensitive
  | purposes.
  |
  */
pub fn shell_quote(s: &String) -> String {
    
    todo!();
        /*
            std::string result;
        result.reserve(s.size() * 2);
        for (const char ch: s) {
            if (ch == '\'') {
                result += "'\''";
            } else {
                result += ch;
            }
        }
        return "'" + result + "'";
        */
}

/**
  | Shell-quotes the argument if it needs
  | quoting, else returns it literally,
  | to save typing.
  | 
  | -----------
  | @note
  | 
  | This is intended for help, not for security-sensitive
  | purposes.
  |
  */
pub fn shell_quote_if_needed(s: &String) -> String {
    
    todo!();
        /*
            for (const char ch: s) {
            if (ch == ' ' || ch == '\'' || ch == '"') {
                return ShellQuote(s);
            }
        }

        return s;
        */
}

pub fn help_example_cli(
        methodname: &String,
        args:       &String) -> String {
    
    todo!();
        /*
            return "> bitcoin-cli " + methodname + " " + args + "\n";
        */
}

pub fn help_example_cli_named(
        methodname: &String,
        args:       &RPCArgList) -> String {
    
    todo!();
        /*
            std::string result = "> bitcoin-cli -named " + methodname;
        for (const auto& argpair: args) {
            const auto& value = argpair.second.isStr()
                    ? argpair.second.get_str()
                    : argpair.second.write();
            result += " " + argpair.first + "=" + ShellQuoteIfNeeded(value);
        }
        result += "\n";
        return result;
        */
}

pub fn help_example_rpc(
        methodname: &String,
        args:       &String) -> String {
    
    todo!();
        /*
            return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", "
            "\"method\": \"" + methodname + "\", \"params\": [" + args + "]}' -H 'content-type: text/plain;' http://127.0.0.1:8332/\n";
        */
}

pub fn help_example_rpc_named(
        methodname: &String,
        args:       &RPCArgList) -> String {
    
    todo!();
        /*
            UniValue params(UniValue::VOBJ);
        for (const auto& param: args) {
            params.pushKV(param.first, param.second);
        }

        return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\": \"curltest\", "
               "\"method\": \"" + methodname + "\", \"params\": " + params.write() + "}' -H 'content-type: text/plain;' http://127.0.0.1:8332/\n";
        */
}

/**
  | Converts a hex string to a public key
  | if possible
  |
  */
pub fn hex_to_pub_key(hex_in: &String) -> PubKey {
    
    todo!();
        /*
            if (!IsHex(hex_in)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid public key: " + hex_in);
        }
        CPubKey vchPubKey(ParseHex(hex_in));
        if (!vchPubKey.IsFullyValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid public key: " + hex_in);
        }
        return vchPubKey;
        */
}

/**
  | Retrieves a public key for an address
  | from the given FillableSigningProvider
  |
  */
pub fn addr_to_pub_key<T>(
        keystore: &FillableSigningProvider<T>,
        addr_in:  &String) -> PubKey {
    
    todo!();
        /*
            TxDestination dest = DecodeDestination(addr_in);
        if (!IsValidDestination(dest)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid address: " + addr_in);
        }
        CKeyID key = GetKeyForDestination(keystore, dest);
        if (key.IsNull()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("%s does not refer to a key", addr_in));
        }
        CPubKey vchPubKey;
        if (!keystore.GetPubKey(key, vchPubKey)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("no full public key for address %s", addr_in));
        }
        if (!vchPubKey.IsFullyValid()) {
           throw JSONRPCError(RPC_INTERNAL_ERROR, "Wallet contains an invalid public key");
        }
        return vchPubKey;
        */
}

/**
  | Creates a multisig address from a given
  | list of public keys, number of signatures
  | required, and the address type
  |
  */
pub fn add_and_get_multisig_destination<T>(
        required:   i32,
        pubkeys:    &Vec<PubKey>,
        ty:         OutputType,
        keystore:   &mut FillableSigningProvider<T>,
        script_out: &mut Script) -> TxDestination {
    
    todo!();
        /*
            // Gather public keys
        if (required < 1) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "a multisignature address must require at least one key to redeem");
        }
        if ((int)pubkeys.size() < required) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("not enough keys supplied (got %u keys, but need at least %d to redeem)", pubkeys.size(), required));
        }
        if (pubkeys.size() > MAX_PUBKEYS_PER_MULTISIG) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Number of keys involved in the multisignature address creation > %d\nReduce the number", MAX_PUBKEYS_PER_MULTISIG));
        }

        script_out = GetScriptForMultisig(required, pubkeys);

        // Check if any keys are uncompressed. If so, the type is legacy
        for (const CPubKey& pk : pubkeys) {
            if (!pk.IsCompressed()) {
                type = OutputType::LEGACY;
                break;
            }
        }

        if (type == OutputType::LEGACY && script_out.size() > MAX_SCRIPT_ELEMENT_SIZE) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, (strprintf("redeemScript exceeds size limit: %d > %d", script_out.size(), MAX_SCRIPT_ELEMENT_SIZE)));
        }

        // Make the address
        TxDestination dest = AddAndGetDestinationForScript(keystore, script_out, type);

        return dest;
        */
}

///-----------------------
#[derive(Default)]
pub struct DescribeAddressVisitor {

}

impl DescribeAddressVisitor {

    pub fn invoke_with_nodestination(&self, dest: &NoDestination) -> UniValue {
        
        todo!();
        /*
            return UniValue(UniValue::VOBJ);
        */
    }
    
    pub fn invoke_with_pkhash(&self, keyid: &PKHash) -> UniValue {
        
        todo!();
        /*
            UniValue obj(UniValue::VOBJ);
            obj.pushKV("isscript", false);
            obj.pushKV("iswitness", false);
            return obj;
        */
    }
    
    pub fn invoke_with_scripthash(&self, scriptid: &ScriptHash) -> UniValue {
        
        todo!();
        /*
            UniValue obj(UniValue::VOBJ);
            obj.pushKV("isscript", true);
            obj.pushKV("iswitness", false);
            return obj;
        */
    }
    
    pub fn invoke_with_witnessv0_keyhash(&self, id: &WitnessV0KeyHash) -> UniValue {
        
        todo!();
        /*
            UniValue obj(UniValue::VOBJ);
            obj.pushKV("isscript", false);
            obj.pushKV("iswitness", true);
            obj.pushKV("witness_version", 0);
            obj.pushKV("witness_program", HexStr(id));
            return obj;
        */
    }
    
    pub fn invoke_with_witnessv0_scripthash(&self, id: &WitnessV0ScriptHash) -> UniValue {
        
        todo!();
        /*
            UniValue obj(UniValue::VOBJ);
            obj.pushKV("isscript", true);
            obj.pushKV("iswitness", true);
            obj.pushKV("witness_version", 0);
            obj.pushKV("witness_program", HexStr(id));
            return obj;
        */
    }
    
    pub fn invoke_with_witnessv1_taproo(&self, tap: &WitnessV1Taproot) -> UniValue {
        
        todo!();
        /*
            UniValue obj(UniValue::VOBJ);
            obj.pushKV("isscript", true);
            obj.pushKV("iswitness", true);
            obj.pushKV("witness_version", 1);
            obj.pushKV("witness_program", HexStr(tap));
            return obj;
        */
    }
    
    pub fn invoke_with_witnessunknown(&self, id: &WitnessUnknown) -> UniValue {
        
        todo!();
        /*
            UniValue obj(UniValue::VOBJ);
            obj.pushKV("iswitness", true);
            obj.pushKV("witness_version", (int)id.version);
            obj.pushKV("witness_program", HexStr(Span<const unsigned char>(id.program, id.length)));
            return obj;
        */
    }
}

pub fn describe_address(dest: &TxDestination) -> UniValue {
    
    todo!();
        /*
            return std::visit(DescribeAddressVisitor(), dest);
        */
}

/**
  | Parse a confirm target option and raise
  | an RPC error if it is invalid.
  |
  */
pub fn parse_confirm_target(
        value:      &UniValue,
        max_target: u32) -> u32 {
    
    todo!();
        /*
            const int target{value.get_int()};
        const unsigned int unsigned_target{static_cast<unsigned int>(target)};
        if (target < 1 || unsigned_target > max_target) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid conf_target, must be between %u and %u", 1, max_target));
        }
        return unsigned_target;
        */
}

pub fn rpc_error_from_transaction_error(terr: TransactionError) -> RPCErrorCode {
    
    todo!();
        /*
            switch (terr) {
            case TransactionError::MEMPOOL_REJECTED:
                return RPC_TRANSACTION_REJECTED;
            case TransactionError::ALREADY_IN_CHAIN:
                return RPC_TRANSACTION_ALREADY_IN_CHAIN;
            case TransactionError::P2P_DISABLED:
                return RPC_CLIENT_P2P_DISABLED;
            case TransactionError::INVALID_PSBT:
            case TransactionError::PSBT_MISMATCH:
                return RPC_INVALID_PARAMETER;
            case TransactionError::SIGHASH_MISMATCH:
                return RPC_DESERIALIZATION_ERROR;
            default: break;
        }
        return RPC_TRANSACTION_ERROR;
        */
}

pub fn jsonrpc_transaction_error(
        terr:       TransactionError,
        err_string: Option<&str>) -> UniValue {

    let err_string: &str = err_string.unwrap_or("");
    
    todo!();
        /*
            if (err_string.length() > 0) {
            return JSONRPCError(RPCErrorFromTransactionError(terr), err_string);
        } else {
            return JSONRPCError(RPCErrorFromTransactionError(terr), TransactionErrorString(terr).original);
        }
        */
}

/**
  | A pair of strings that can be aligned
  | (through padding) with other Sections
  | later on
  |
  */
pub struct Section {
    left:  String,
    right: String,
}

impl Section {

    pub fn new(
        left:  &String,
        right: &String) -> Self {
    
        todo!();
        /*
            : m_left{left}, m_right{right}
        */
    }
}

/**
  | Keeps track of RPCArgs by transforming
  | them into sections for the purpose of
  | serializing everything to a single
  | string
  |
  */
pub struct Sections {
    sections: Vec<Section>,
    max_pad:  usize, // default = { 0 }
}

impl Sections {

    pub fn push_section(&mut self, s: &Section)  {
        
        todo!();
        /*
            m_max_pad = std::max(m_max_pad, s.m_left.size());
            m_sections.push_back(s);
        */
    }

    /**
      | Recursive helper to translate an RPCArg
      | into sections
      |
      */
    pub fn push(&mut self, 
        arg:            &RPCArg,
        current_indent: Option<usize>,
        outer_type:     Option<OuterType>)  {

        let current_indent:      usize = current_indent.unwrap_or(5);
        let outer_type:      OuterType = outer_type.unwrap_or(OuterType::NONE);

        todo!();
        /*
            const auto indent = std::string(current_indent, ' ');
            const auto indent_next = std::string(current_indent + 2, ' ');
            const bool push_name{outer_type == OuterType::OBJ}; // Dictionary keys must have a name

            switch (arg.m_type) {
            case RPCArg::Type::STR_HEX:
            case RPCArg::Type::STR:
            case RPCArg::Type::NUM:
            case RPCArg::Type::AMOUNT:
            case RPCArg::Type::RANGE:
            case RPCArg::Type::BOOL: {
                if (outer_type == OuterType::NONE) return; // Nothing more to do for non-recursive types on first recursion
                auto left = indent;
                if (arg.m_type_str.size() != 0 && push_name) {
                    left += "\"" + arg.GetName() + "\": " + arg.m_type_str.at(0);
                } else {
                    left += push_name ? arg.ToStringObj(/* oneline */ false) : arg.ToString(/* oneline */ false);
                }
                left += ",";
                PushSection({left, arg.ToDescriptionString()});
                break;
            }
            case RPCArg::Type::OBJ:
            case RPCArg::Type::OBJ_USER_KEYS: {
                const auto right = outer_type == OuterType::NONE ? "" : arg.ToDescriptionString();
                PushSection({indent + (push_name ? "\"" + arg.GetName() + "\": " : "") + "{", right});
                for (const auto& arg_inner : arg.m_inner) {
                    Push(arg_inner, current_indent + 2, OuterType::OBJ);
                }
                if (arg.m_type != RPCArg::Type::OBJ) {
                    PushSection({indent_next + "...", ""});
                }
                PushSection({indent + "}" + (outer_type != OuterType::NONE ? "," : ""), ""});
                break;
            }
            case RPCArg::Type::ARR: {
                auto left = indent;
                left += push_name ? "\"" + arg.GetName() + "\": " : "";
                left += "[";
                const auto right = outer_type == OuterType::NONE ? "" : arg.ToDescriptionString();
                PushSection({left, right});
                for (const auto& arg_inner : arg.m_inner) {
                    Push(arg_inner, current_indent + 2, OuterType::ARR);
                }
                PushSection({indent_next + "...", ""});
                PushSection({indent + "]" + (outer_type != OuterType::NONE ? "," : ""), ""});
                break;
            }
            } // no default case, so the compiler can warn about missing cases
        */
    }

    /**
      | Concatenate all sections with proper
      | padding
      |
      */
    pub fn to_string(&self) -> String {
        
        todo!();
        /*
            std::string ret;
            const size_t pad = m_max_pad + 4;
            for (const auto& s : m_sections) {
                // The left part of a section is assumed to be a single line, usually it is the name of the JSON struct or a
                // brace like {, }, [, or ]
                CHECK_NONFATAL(s.m_left.find('\n') == std::string::npos);
                if (s.m_right.empty()) {
                    ret += s.m_left;
                    ret += "\n";
                    continue;
                }

                std::string left = s.m_left;
                left.resize(pad, ' ');
                ret += left;

                // Properly pad after newlines
                std::string right;
                size_t begin = 0;
                size_t new_line_pos = s.m_right.find_first_of('\n');
                while (true) {
                    right += s.m_right.substr(begin, new_line_pos - begin);
                    if (new_line_pos == std::string::npos) {
                        break; //No new line
                    }
                    right += "\n" + std::string(pad, ' ');
                    begin = s.m_right.find_first_not_of(' ', new_line_pos + 1);
                    if (begin == std::string::npos) {
                        break; // Empty line
                    }
                    new_line_pos = s.m_right.find_first_of('\n', begin + 1);
                }
                ret += right;
                ret += "\n";
            }
            return ret;
        */
    }
}

impl RPCHelpMan {
    
    pub fn new(
        name:        String,
        description: String,
        args:        Vec<RPCArg>,
        results:     RPCResults,
        examples:    RPCExamples) -> Self {
    
        todo!();
        /*
            : RPCHelpMan{
                std::move(name), 
                std::move(description), 
                std::move(args), 
                std::move(results), 
                std::move(examples), 
                nullptr
            }
        */
    }
    
    pub fn new_with_fun(
        name:        String,
        description: String,
        args:        Vec<RPCArg>,
        results:     RPCResults,
        examples:    RPCExamples,
        fun:         rpc_help_man::RPCMethodImpl) -> Self {
    
        todo!();
        /*


            : m_name{std::move(name)},
          m_fun{std::move(fun)},
          m_description{std::move(description)},
          m_args{std::move(args)},
          m_results{std::move(results)},
          m_examples{std::move(examples)}
        std::set<std::string> named_args;
        for (const auto& arg : m_args) {
            std::vector<std::string> names;
            boost::split(names, arg.m_names, boost::is_any_of("|"));
            // Should have unique named arguments
            for (const std::string& name : names) {
                CHECK_NONFATAL(named_args.insert(name).second);
            }
            // Default value type should match argument type only when defined
            if (arg.m_fallback.index() == 2) {
                const RPCArg::Type type = arg.m_type;
                switch (std::get<RPCArg::Default>(arg.m_fallback).getType()) {
                case UniValue::VOBJ:
                    CHECK_NONFATAL(type == RPCArg::Type::OBJ);
                    break;
                case UniValue::VARR:
                    CHECK_NONFATAL(type == RPCArg::Type::ARR);
                    break;
                case UniValue::VSTR:
                    CHECK_NONFATAL(type == RPCArg::Type::STR || type == RPCArg::Type::STR_HEX || type == RPCArg::Type::AMOUNT);
                    break;
                case UniValue::VNUM:
                    CHECK_NONFATAL(type == RPCArg::Type::NUM || type == RPCArg::Type::AMOUNT || type == RPCArg::Type::RANGE);
                    break;
                case UniValue::VBOOL:
                    CHECK_NONFATAL(type == RPCArg::Type::BOOL);
                    break;
                case UniValue::VNULL:
                    // Null values are accepted in all arguments
                    break;
                default:
                    CHECK_NONFATAL(false);
                    break;
                }
            }
        }
        */
    }
}

impl ToDescriptionString for RPCResults {

    /**
      | Return the description string, including
      | the result type.
      |
      */
    fn to_description_string(&self) -> String {
        
        todo!();
        /*
            std::string result;
        for (const auto& r : m_results) {
            if (r.m_type == RPCResult::Type::ANY) continue; // for testing only
            if (r.m_cond.empty()) {
                result += "\nResult:\n";
            } else {
                result += "\nResult (" + r.m_cond + "):\n";
            }
            Sections sections;
            r.ToSections(sections);
            result += sections.ToString();
        }
        return result;
        */
    }
}

impl ToDescriptionString for RPCExamples {
    
    fn to_description_string(&self) -> String {
        
        todo!();
        /*
            return m_examples.empty() ? m_examples : "\nExamples:\n" + m_examples;
        */
    }
}

impl RPCHelpMan {
    
    pub fn handle_request(&self, request: &JSONRPCRequest) -> UniValue {
        
        todo!();
        /*
            if (request.mode == JSONRPCRequest::GET_ARGS) {
            return GetArgMap();
        }
        /*
         * Check if the given request is valid according to this command or if
         * the user is asking for help information, and throw help when appropriate.
         */
        if (request.mode == JSONRPCRequest::GET_HELP || !IsValidNumArgs(request.params.size())) {
            throw std::runtime_error(ToString());
        }
        const UniValue ret = m_fun(*this, request);
        CHECK_NONFATAL(std::any_of(m_results.m_results.begin(), m_results.m_results.end(), [ret](const RPCResult& res) { return res.MatchesType(ret); }));
        return ret;
        */
    }
    
    /**
      | If the supplied number of args is neither
      | too small nor too high
      |
      */
    pub fn is_valid_num_args(&self, num_args: usize) -> bool {
        
        todo!();
        /*
            size_t num_required_args = 0;
        for (size_t n = m_args.size(); n > 0; --n) {
            if (!m_args.at(n - 1).IsOptional()) {
                num_required_args = n;
                break;
            }
        }
        return num_required_args <= num_args && num_args <= m_args.size();
        */
    }
    
    pub fn get_arg_names(&self) -> Vec<String> {
        
        todo!();
        /*
            std::vector<std::string> ret;
        for (const auto& arg : m_args) {
            ret.emplace_back(arg.m_names);
        }
        return ret;
        */
    }
    
    pub fn to_string(&self) -> String {
        
        todo!();
        /*
            std::string ret;

        // Oneline summary
        ret += m_name;
        bool was_optional{false};
        for (const auto& arg : m_args) {
            if (arg.m_hidden) break; // Any arg that follows is also hidden
            const bool optional = arg.IsOptional();
            ret += " ";
            if (optional) {
                if (!was_optional) ret += "( ";
                was_optional = true;
            } else {
                if (was_optional) ret += ") ";
                was_optional = false;
            }
            ret += arg.ToString(/* oneline */ true);
        }
        if (was_optional) ret += " )";
        ret += "\n";

        // Description
        ret += m_description;

        // Arguments
        Sections sections;
        for (size_t i{0}; i < m_args.size(); ++i) {
            const auto& arg = m_args.at(i);
            if (arg.m_hidden) break; // Any arg that follows is also hidden

            if (i == 0) ret += "\nArguments:\n";

            // Push named argument name and description
            sections.m_sections.emplace_back(::ToString(i + 1) + ". " + arg.GetFirstName(), arg.ToDescriptionString());
            sections.m_max_pad = std::max(sections.m_max_pad, sections.m_sections.back().m_left.size());

            // Recursively push nested args
            sections.Push(arg);
        }
        ret += sections.ToString();

        // Result
        ret += m_results.ToDescriptionString();

        // Examples
        ret += m_examples.ToDescriptionString();

        return ret;
        */
    }
    
    /**
      | Return the named args that need to be
      | converted from string to another JSON
      | type
      |
      */
    pub fn get_arg_map(&self) -> UniValue {
        
        todo!();
        /*
            UniValue arr{UniValue::VARR};
        for (int i{0}; i < int(m_args.size()); ++i) {
            const auto& arg = m_args.at(i);
            std::vector<std::string> arg_names;
            boost::split(arg_names, arg.m_names, boost::is_any_of("|"));
            for (const auto& arg_name : arg_names) {
                UniValue map{UniValue::VARR};
                map.push_back(m_name);
                map.push_back(i);
                map.push_back(arg_name);
                map.push_back(arg.m_type == RPCArg::Type::STR ||
                              arg.m_type == RPCArg::Type::STR_HEX);
                arr.push_back(map);
            }
        }
        return arr;
        */
    }
}

impl RPCArg {
    
    /**
      | Return the first of all aliases
      |
      */
    pub fn get_first_name(&self) -> String {
        
        todo!();
        /*
            return m_names.substr(0, m_names.find("|"));
        */
    }
    
    /**
      | Return the name, throws when there are
      | aliases
      |
      */
    pub fn get_name(&self) -> String {
        
        todo!();
        /*
            CHECK_NONFATAL(std::string::npos == m_names.find("|"));
        return m_names;
        */
    }
    
    pub fn is_optional(&self) -> bool {
        
        todo!();
        /*
            if (m_fallback.index() != 0) {
            return true;
        } else {
            return RPCArg::Optional::NO != std::get<RPCArg::Optional>(m_fallback);
        }
        */
    }
}

pub trait ToDescriptionString {
    fn to_description_string(&self) -> String;
}

impl ToDescriptionString for RPCArg {

    /**
      | Return the description string, including
      | the argument type and whether the argument
      | is required.
      |
      */
    fn to_description_string(&self) -> String {
        
        todo!();
        /*
            std::string ret;
        ret += "(";
        if (m_type_str.size() != 0) {
            ret += m_type_str.at(1);
        } else {
            switch (m_type) {
            case Type::STR_HEX:
            case Type::STR: {
                ret += "string";
                break;
            }
            case Type::NUM: {
                ret += "numeric";
                break;
            }
            case Type::AMOUNT: {
                ret += "numeric or string";
                break;
            }
            case Type::RANGE: {
                ret += "numeric or array";
                break;
            }
            case Type::BOOL: {
                ret += "boolean";
                break;
            }
            case Type::OBJ:
            case Type::OBJ_USER_KEYS: {
                ret += "json object";
                break;
            }
            case Type::ARR: {
                ret += "json array";
                break;
            }
            } // no default case, so the compiler can warn about missing cases
        }
        if (m_fallback.index() == 1) {
            ret += ", optional, default=" + std::get<RPCArg::DefaultHint>(m_fallback);
        } else if (m_fallback.index() == 2) {
            ret += ", optional, default=" + std::get<RPCArg::Default>(m_fallback).write();
        } else {
            switch (std::get<RPCArg::Optional>(m_fallback)) {
            case RPCArg::Optional::OMITTED: {
                // nothing to do. Element is treated as if not present and has no default value
                break;
            }
            case RPCArg::Optional::OMITTED_NAMED_ARG: {
                ret += ", optional"; // Default value is "null"
                break;
            }
            case RPCArg::Optional::NO: {
                ret += ", required";
                break;
            }
            } // no default case, so the compiler can warn about missing cases
        }
        ret += ")";
        ret += m_description.empty() ? "" : " " + m_description;
        return ret;
        */
    }
}

impl RPCResult {

    /**
      | Append the sections of the result.
      |
      */
    pub fn to_sections(&self, 
        sections:       &mut Sections,
        outer_type:     Option<OuterType>,
        current_indent: Option<i32>)  {

        let outer_type:     OuterType = outer_type.unwrap_or(OuterType::NONE);
        let current_indent:       i32 = current_indent.unwrap_or(0);
        
        todo!();
        /*
            // Indentation
        const std::string indent(current_indent, ' ');
        const std::string indent_next(current_indent + 2, ' ');

        // Elements in a JSON structure (dictionary or array) are separated by a comma
        const std::string maybe_separator{outer_type != OuterType::NONE ? "," : ""};

        // The key name if recursed into an dictionary
        const std::string maybe_key{
            outer_type == OuterType::OBJ ?
                "\"" + this->m_key_name + "\" : " :
                ""};

        // Format description with type
        const auto Description = [&](const std::string& type) {
            return "(" + type + (this->m_optional ? ", optional" : "") + ")" +
                   (this->m_description.empty() ? "" : " " + this->m_description);
        };

        switch (m_type) {
        case Type::ELISION: {
            // If the inner result is empty, use three dots for elision
            sections.PushSection({indent + "..." + maybe_separator, m_description});
            return;
        }
        case Type::ANY: {
            CHECK_NONFATAL(false); // Only for testing
        }
        case Type::NONE: {
            sections.PushSection({indent + "null" + maybe_separator, Description("json null")});
            return;
        }
        case Type::STR: {
            sections.PushSection({indent + maybe_key + "\"str\"" + maybe_separator, Description("string")});
            return;
        }
        case Type::STR_AMOUNT: {
            sections.PushSection({indent + maybe_key + "n" + maybe_separator, Description("numeric")});
            return;
        }
        case Type::STR_HEX: {
            sections.PushSection({indent + maybe_key + "\"hex\"" + maybe_separator, Description("string")});
            return;
        }
        case Type::NUM: {
            sections.PushSection({indent + maybe_key + "n" + maybe_separator, Description("numeric")});
            return;
        }
        case Type::NUM_TIME: {
            sections.PushSection({indent + maybe_key + "xxx" + maybe_separator, Description("numeric")});
            return;
        }
        case Type::BOOL: {
            sections.PushSection({indent + maybe_key + "true|false" + maybe_separator, Description("boolean")});
            return;
        }
        case Type::ARR_FIXED:
        case Type::ARR: {
            sections.PushSection({indent + maybe_key + "[", Description("json array")});
            for (const auto& i : m_inner) {
                i.ToSections(sections, OuterType::ARR, current_indent + 2);
            }
            CHECK_NONFATAL(!m_inner.empty());
            if (m_type == Type::ARR && m_inner.back().m_type != Type::ELISION) {
                sections.PushSection({indent_next + "...", ""});
            } else {
                // Remove final comma, which would be invalid JSON
                sections.m_sections.back().m_left.pop_back();
            }
            sections.PushSection({indent + "]" + maybe_separator, ""});
            return;
        }
        case Type::OBJ_DYN:
        case Type::OBJ: {
            sections.PushSection({indent + maybe_key + "{", Description("json object")});
            for (const auto& i : m_inner) {
                i.ToSections(sections, OuterType::OBJ, current_indent + 2);
            }
            CHECK_NONFATAL(!m_inner.empty());
            if (m_type == Type::OBJ_DYN && m_inner.back().m_type != Type::ELISION) {
                // If the dictionary keys are dynamic, use three dots for continuation
                sections.PushSection({indent_next + "...", ""});
            } else {
                // Remove final comma, which would be invalid JSON
                sections.m_sections.back().m_left.pop_back();
            }
            sections.PushSection({indent + "}" + maybe_separator, ""});
            return;
        }
        } // no default case, so the compiler can warn about missing cases
        CHECK_NONFATAL(false);
        */
    }
    
    /**
      | Check whether the result JSON type matches.
      |
      */
    pub fn matches_type(&self, result: &UniValue) -> bool {
        
        todo!();
        /*
            switch (m_type) {
        case Type::ELISION: {
            return false;
        }
        case Type::ANY: {
            return true;
        }
        case Type::NONE: {
            return UniValue::VNULL == result.getType();
        }
        case Type::STR:
        case Type::STR_HEX: {
            return UniValue::VSTR == result.getType();
        }
        case Type::NUM:
        case Type::STR_AMOUNT:
        case Type::NUM_TIME: {
            return UniValue::VNUM == result.getType();
        }
        case Type::BOOL: {
            return UniValue::VBOOL == result.getType();
        }
        case Type::ARR_FIXED:
        case Type::ARR: {
            return UniValue::VARR == result.getType();
        }
        case Type::OBJ_DYN:
        case Type::OBJ: {
            return UniValue::VOBJ == result.getType();
        }
        } // no default case, so the compiler can warn about missing cases
        CHECK_NONFATAL(false);
        */
    }
}

impl RPCArg {
    
    /**
      | Return the type string of the argument
      | when it is in an object (dict).
      | 
      | Set oneline to get the oneline representation
      | (less whitespace)
      |
      */
    pub fn to_string_obj(&self, oneline: bool) -> String {
        
        todo!();
        /*
            std::string res;
        res += "\"";
        res += GetFirstName();
        if (oneline) {
            res += "\":";
        } else {
            res += "\": ";
        }
        switch (m_type) {
        case Type::STR:
            return res + "\"str\"";
        case Type::STR_HEX:
            return res + "\"hex\"";
        case Type::NUM:
            return res + "n";
        case Type::RANGE:
            return res + "n or [n,n]";
        case Type::AMOUNT:
            return res + "amount";
        case Type::BOOL:
            return res + "bool";
        case Type::ARR:
            res += "[";
            for (const auto& i : m_inner) {
                res += i.ToString(oneline) + ",";
            }
            return res + "...]";
        case Type::OBJ:
        case Type::OBJ_USER_KEYS:
            // Currently unused, so avoid writing dead code
            CHECK_NONFATAL(false);
        } // no default case, so the compiler can warn about missing cases
        CHECK_NONFATAL(false);
        */
    }
    
    /**
      | Return the type string of the argument.
      | 
      | Set oneline to allow it to be overridden
      | by a custom oneline type string (m_oneline_description).
      |
      */
    pub fn to_string(&self, oneline: bool) -> String {
        
        todo!();
        /*
            if (oneline && !m_oneline_description.empty()) return m_oneline_description;

        switch (m_type) {
        case Type::STR_HEX:
        case Type::STR: {
            return "\"" + GetFirstName() + "\"";
        }
        case Type::NUM:
        case Type::RANGE:
        case Type::AMOUNT:
        case Type::BOOL: {
            return GetFirstName();
        }
        case Type::OBJ:
        case Type::OBJ_USER_KEYS: {
            const std::string res = Join(m_inner, ",", [&](const RPCArg& i) { return i.ToStringObj(oneline); });
            if (m_type == Type::OBJ) {
                return "{" + res + "}";
            } else {
                return "{" + res + ",...}";
            }
        }
        case Type::ARR: {
            std::string res;
            for (const auto& i : m_inner) {
                res += i.ToString(oneline) + ",";
            }
            return "[" + res + "...]";
        }
        } // no default case, so the compiler can warn about missing cases
        CHECK_NONFATAL(false);
        */
    }
}

pub fn parse_range(value: &UniValue) -> (i64,i64) {
    
    todo!();
        /*
            if (value.isNum()) {
            return {0, value.get_int64()};
        }
        if (value.isArray() && value.size() == 2 && value[0].isNum() && value[1].isNum()) {
            int64_t low = value[0].get_int64();
            int64_t high = value[1].get_int64();
            if (low > high) throw JSONRPCError(RPC_INVALID_PARAMETER, "Range specified as [begin,end] must not have begin after end");
            return {low, high};
        }
        throw JSONRPCError(RPC_INVALID_PARAMETER, "Range must be specified as end or as [begin,end]");
        */
}

/**
  | Parse a JSON range specified as int64,
  | or [int64, int64]
  |
  */
pub fn parse_descriptor_range(value: &UniValue) -> (i64,i64) {
    
    todo!();
        /*
            int64_t low, high;
        std::tie(low, high) = ParseRange(value);
        if (low < 0) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should be greater or equal than 0");
        }
        if ((high >> 31) != 0) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "End of range is too high");
        }
        if (high >= low + 1000000) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "Range is too large");
        }
        return {low, high};
        */
}

/**
  | Evaluate a descriptor given as a string,
  | or as a {"desc":...,"range":...} object,
  | with default range of 1000.
  |
  */
pub fn eval_descriptor_string_or_object(
        scanobject: &UniValue,
        provider:   &mut FlatSigningProvider) -> Vec<Script> {
    
    todo!();
        /*
            std::string desc_str;
        std::pair<int64_t, int64_t> range = {0, 1000};
        if (scanobject.isStr()) {
            desc_str = scanobject.get_str();
        } else if (scanobject.isObject()) {
            UniValue desc_uni = find_value(scanobject, "desc");
            if (desc_uni.isNull()) throw JSONRPCError(RPC_INVALID_PARAMETER, "Descriptor needs to be provided in scan object");
            desc_str = desc_uni.get_str();
            UniValue range_uni = find_value(scanobject, "range");
            if (!range_uni.isNull()) {
                range = ParseDescriptorRange(range_uni);
            }
        } else {
            throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan object needs to be either a string or an object");
        }

        std::string error;
        auto desc = Parse(desc_str, provider, error);
        if (!desc) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
        }
        if (!desc->IsRange()) {
            range.first = 0;
            range.second = 0;
        }
        std::vector<CScript> ret;
        for (int i = range.first; i <= range.second; ++i) {
            std::vector<CScript> scripts;
            if (!desc->Expand(i, provider, scripts, provider)) {
                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Cannot derive script without private keys: '%s'", desc_str));
            }
            std::move(scripts.begin(), scripts.end(), std::back_inserter(ret));
        }
        return ret;
        */
}

/**
  | Returns, given services flags, a list
  | of humanly readable (known) network
  | services
  |
  */
pub fn get_services_names(services: ServiceFlags) -> UniValue {
    
    todo!();
        /*
            UniValue servicesNames(UniValue::VARR);

        for (const auto& flag : serviceFlagsToStr(services)) {
            servicesNames.push_back(flag);
        }

        return servicesNames;
        */
}