merge bitcoin#25058: Move output script RPCs to separate file, rename misc.cpp

Review with `git log -p -n1 --color-moved=dimmed_zebra`.

Author: kwvg

src/Makefile.am

@@ -546,8 +546,9 @@ libbitcoin_node_a_SOURCES = \
   rpc/mempool.cpp \
   rpc/governance.cpp \
   rpc/mining.cpp \
-  rpc/misc.cpp \
+  rpc/node.cpp \
   rpc/net.cpp \
+  rpc/output_script.cpp \
   rpc/quorums.cpp \
   rpc/rawtransaction.cpp \
   rpc/server.cpp \

src/rpc/misc.cpp renamed to src/rpc/node.cpp

@@ -25,11 +25,9 @@
 #include <rpc/server_util.h>
 #include <rpc/util.h>
 #include <scheduler.h>
-#include <script/descriptor.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/check.h>
-#include <util/strencodings.h>
 #include <util/system.h>
 #include <validation.h>
 
@@ -238,247 +236,6 @@ static RPCHelpMan sporkupdate()
     };
 }
 
-static RPCHelpMan validateaddress()
-{
-    return RPCHelpMan{
-        "validateaddress",
-        "\nReturn information about the given Dash address.\n",
-        {
-            {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The Dash address to validate"},
-        },
-        RPCResult{
-            RPCResult::Type::OBJ, "", "",
-            {
-                {RPCResult::Type::BOOL, "isvalid", "If the address is valid or not"},
-                {RPCResult::Type::STR, "address", /* optional */ true, "The Dash address validated"},
-                {RPCResult::Type::STR_HEX, "scriptPubKey", /* optional */ true, "The hex-encoded scriptPubKey generated by the address"},
-                {RPCResult::Type::BOOL, "isscript", /* optional */ true, "If the key is a script"},
-                {RPCResult::Type::STR, "error", /* optional */ true, "Error message, if any"},
-            }
-        },
-        RPCExamples{
-            HelpExampleCli("validateaddress", "\"" + EXAMPLE_ADDRESS[0] + "\"") +
-            HelpExampleRpc("validateaddress", "\"" + EXAMPLE_ADDRESS[0] + "\"")
-        },
-        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-    std::string error_msg;
-    CTxDestination dest = DecodeDestination(request.params[0].get_str(), error_msg);
-    const bool isValid = IsValidDestination(dest);
-    CHECK_NONFATAL(isValid == error_msg.empty());
-
-    UniValue ret(UniValue::VOBJ);
-    ret.pushKV("isvalid", isValid);
-    if (isValid) {
-        std::string currentAddress = EncodeDestination(dest);
-        ret.pushKV("address", currentAddress);
-
-        CScript scriptPubKey = GetScriptForDestination(dest);
-        ret.pushKV("scriptPubKey", HexStr(scriptPubKey));;
-
-        UniValue detail = DescribeAddress(dest);
-        ret.pushKVs(detail);
-    } else {
-        ret.pushKV("error", error_msg);
-    }
-
-    return ret;
-},
-    };
-}
-
-static RPCHelpMan createmultisig()
-{
-    return RPCHelpMan{"createmultisig",
-                "\nCreates a multi-signature address with n signature of m keys required.\n"
-                "It returns a json object with the address and redeemScript.\n",
-                {
-                    {"nrequired", RPCArg::Type::NUM, RPCArg::Optional::NO, "The number of required signatures out of the n keys."},
-                    {"keys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The hex-encoded public keys.",
-                        {
-                            {"key", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The hex-encoded public key"},
-                        }},
-                },
-                RPCResult{
-                    RPCResult::Type::OBJ, "", "",
-                    {
-                        {RPCResult::Type::STR, "address", "The value of the new multisig address."},
-                        {RPCResult::Type::STR_HEX, "redeemScript", "The string value of the hex-encoded redemption script."},
-                        {RPCResult::Type::STR, "descriptor", "The descriptor for this multisig."},
-                    }
-                },
-                RPCExamples{
-            "\nCreate a multisig address from 2 public keys\n"
-            + HelpExampleCli("createmultisig", "2 \"[\\\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd342cf11ae157a7ace5fd\\\",\\\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e17e107ef3f6aa5a61626\\\"]\"") +
-            "\nAs a JSON-RPC call\n"
-            + HelpExampleRpc("createmultisig", "2, [\"03789ed0bb717d88f7d321a368d905e7430207ebbd82bd342cf11ae157a7ace5fd\",\"03dbc6764b8884a92e871274b87583e6d5c2a58819473e17e107ef3f6aa5a61626\"]")
-                },
-        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-    int required = request.params[0].get_int();
-
-    // Get the public keys
-    const UniValue& keys = request.params[1].get_array();
-    std::vector<CPubKey> pubkeys;
-    for (unsigned int i = 0; i < keys.size(); ++i) {
-        if (IsHex(keys[i].get_str()) && (keys[i].get_str().length() == 66 || keys[i].get_str().length() == 130)) {
-            pubkeys.push_back(HexToPubKey(keys[i].get_str()));
-        } else {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Invalid public key: %s\n.", keys[i].get_str()));
-        }
-    }
-
-    // Construct using pay-to-script-hash:
-    FillableSigningProvider keystore;
-    CScript inner;
-    const CTxDestination dest = AddAndGetMultisigDestination(required, pubkeys, keystore, inner);
-
-    // Make the descriptor
-    std::unique_ptr<Descriptor> descriptor = InferDescriptor(GetScriptForDestination(dest), keystore);
-
-    UniValue result(UniValue::VOBJ);
-    result.pushKV("address", EncodeDestination(dest));
-    result.pushKV("redeemScript", HexStr(inner));
-    result.pushKV("descriptor", descriptor->ToString());
-
-    return result;
-},
-    };
-}
-
-static RPCHelpMan getdescriptorinfo()
-{
-    const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]0279be667ef9dcbbac55a06295Ce870b07029Bfcdb2dce28d959f2815b16f81798)";
-
-    return RPCHelpMan{"getdescriptorinfo",
-        {"\nAnalyses a descriptor.\n"},
-        {
-            {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor"},
-        },
-        RPCResult{
-            RPCResult::Type::OBJ, "", "",
-                {
-                {RPCResult::Type::STR, "descriptor", "The descriptor in canonical form, without private keys"},
-                {RPCResult::Type::STR, "checksum", "The checksum for the input descriptor"},
-                {RPCResult::Type::BOOL, "isrange", "Whether the descriptor is ranged"},
-                {RPCResult::Type::BOOL, "issolvable", "Whether the descriptor is solvable"},
-                {RPCResult::Type::BOOL, "hasprivatekeys", "Whether the input descriptor contained at least one private key"},
-                }
-        },
-        RPCExamples{
-        "\nAnalyse a descriptor\n"
-        +   HelpExampleCli("getdescriptorinfo", "\"" + EXAMPLE_DESCRIPTOR + "\"") +
-            HelpExampleRpc("getdescriptorinfo", "\"" + EXAMPLE_DESCRIPTOR + "\"")
-
-        },
-    [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-
-    RPCTypeCheck(request.params, {UniValue::VSTR});
-
-    FlatSigningProvider provider;
-    std::string error;
-    auto desc = Parse(request.params[0].get_str(), provider, error);
-    if (!desc) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
-    }
-
-    UniValue result(UniValue::VOBJ);
-    result.pushKV("descriptor", desc->ToString());
-    result.pushKV("checksum", GetDescriptorChecksum(request.params[0].get_str()));
-    result.pushKV("isrange", desc->IsRange());
-    result.pushKV("issolvable", desc->IsSolvable());
-    result.pushKV("hasprivatekeys", provider.keys.size() > 0);
-    return result;
-},
-    };
-}
-
-static RPCHelpMan deriveaddresses()
-{
-    const std::string EXAMPLE_DESCRIPTOR = "wpkh([d34db33f/84h/0h/0h]xpub6DJ2dNUysrn5Vt36jH2KLBT2i1auw1tTSSomg8PhqNiUtx8QX2SvC9nrHu81fT41fvDUnhMjEzQgXnQjKEu3oaqMSzhSrHMxyyoEAmUHQbY/0/*)#cjjspncu";
-
-    return RPCHelpMan{"deriveaddresses",
-        "\nDerives one or more addresses corresponding to an output descriptor.\n"
-        "Examples of output descriptors are:\n"
-        "    pkh(<pubkey>)                        P2PKH outputs for the given pubkey\n"
-        "    sh(multi(<n>,<pubkey>,<pubkey>,...)) P2SH-multisig outputs for the given threshold and pubkeys\n"
-        "    raw(<hex script>)                    Outputs whose scriptPubKey equals the specified hex scripts\n"
-        "\nIn the above, <pubkey> either refers to a fixed public key in hexadecimal notation, or to an xpub/xprv optionally followed by one\n"
-        "or more path elements separated by \"/\", where \"h\" represents a hardened child key.\n"
-        "For more information on output descriptors, see the documentation in the doc/descriptors.md file.\n",
-            {
-                {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor"},
-                {"range", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED_NAMED_ARG, "If a ranged descriptor is used, this specifies the end or the range (in [begin,end] notation) to derive."},
-            },
-            RPCResult{
-                RPCResult::Type::ARR, "", "",
-                {
-                    {RPCResult::Type::STR, "address", "the derived addresses"},
-                }
-            },
-            RPCExamples{
-        "\nFirst three receive addresses\n"
-        + HelpExampleCli("deriveaddresses", "\"" + EXAMPLE_DESCRIPTOR + "\" \"[0,2]\"") +
-          HelpExampleRpc("deriveaddresses", "\"" + EXAMPLE_DESCRIPTOR + "\", \"[0,2]\"")
-            },
-    [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
-{
-
-    RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType()}); // Range argument is checked later
-    const std::string desc_str = request.params[0].get_str();
-
-    int64_t range_begin = 0;
-    int64_t range_end = 0;
-
-    if (request.params.size() >= 2 && !request.params[1].isNull()) {
-        std::tie(range_begin, range_end) = ParseDescriptorRange(request.params[1]);
-    }
-
-    FlatSigningProvider key_provider;
-    std::string error;
-    auto desc = Parse(desc_str, key_provider, error, /* require_checksum = */ true);
-    if (!desc) {
-        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
-    }
-
-    if (!desc->IsRange() && request.params.size() > 1) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Range should not be specified for an un-ranged descriptor");
-    }
-
-    if (desc->IsRange() && request.params.size() == 1) {
-        throw JSONRPCError(RPC_INVALID_PARAMETER, "Range must be specified for a ranged descriptor");
-    }
-
-    UniValue addresses(UniValue::VARR);
-
-    for (int64_t i = range_begin; i <= range_end; ++i) {
-        FlatSigningProvider provider;
-        std::vector<CScript> scripts;
-        if (!desc->Expand(i, key_provider, scripts, provider)) {
-            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot derive script without private keys");
-        }
-
-        for (const CScript &script : scripts) {
-            CTxDestination dest;
-            if (!ExtractDestination(script, dest)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Descriptor does not have a corresponding address");
-            }
-
-            addresses.push_back(EncodeDestination(dest));
-        }
-    }
-
-    // This should not be possible, but an assert seems overkill:
-    if (addresses.empty()) {
-        throw JSONRPCError(RPC_MISC_ERROR, "Unexpected empty result");
-    }
-
-    return addresses;
-},
-    };
-}
-
 static RPCHelpMan setmocktime()
 {
     return RPCHelpMan{"setmocktime",
@@ -1393,18 +1150,14 @@ static RPCHelpMan echoipc()
     };
 }
 
-void RegisterMiscRPCCommands(CRPCTable &t)
+void RegisterNodeRPCCommands(CRPCTable &t)
 {
 static const CRPCCommand commands[] =
 { //  category              actor (function)
   //  --------------------- ------------------------
     { "control",            &debug,                   },
     { "control",            &getmemoryinfo,           },
     { "control",            &logging,                 },
-    { "util",               &validateaddress,         },
-    { "util",               &createmultisig,          },
-    { "util",               &deriveaddresses,         },
-    { "util",               &getdescriptorinfo,       },
     { "util",               &getindexinfo,            },
     { "blockchain",         &getspentinfo,            },