751    const std::vector<std::string>& keys = in.params.getKeys();
752    const std::vector<UniValue>& values = in.params.getValues();
753    std::unordered_map<std::string, const UniValue*> argsIn;
754    for (size_t i=0; i<keys.size(); ++i) {
755        auto [_, inserted] = argsIn.emplace(keys[i], &values[i]);
756        if (!inserted) {
757            throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + keys[i] + " specified multiple times");
758        }
759    }
760    // Process expected parameters. If any parameters were left unspecified in
761    // the request before a parameter that was specified, null values need to be
762    // inserted at the unspecified parameter positions, and the "hole" variable
763    // below tracks the number of null values that need to be inserted.
764    // The "initial_hole_size" variable stores the size of the initial hole,
765    // i.e. how many initial positional arguments were left unspecified. This is
766    // used after the for-loop to add initial positional arguments from the
767    // "args" parameter, if present.
768    int hole = 0;
769    int initial_hole_size = 0;
770    const std::string* initial_param = nullptr;
771    UniValue options{UniValue::VOBJ};
772    for (const auto& [argNamePattern, named_only]: argNames) {
773        std::vector<std::string> vargNames = SplitString(argNamePattern, '|');
774        auto fr = argsIn.end();
775        for (const std::string & argName : vargNames) {
776            fr = argsIn.find(argName);
777            if (fr != argsIn.end()) {
778                break;
779            }
780        }
781
782        // Handle named-only parameters by pushing them into a temporary options
783        // object, and then pushing the accumulated options as the next
784        // positional argument.
785        if (named_only) {
786            if (fr != argsIn.end()) {
787                if (options.exists(fr->first)) {
788                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + fr->first + " specified multiple times");
789                }
790                options.pushKVEnd(fr->first, *fr->second);
791                argsIn.erase(fr);
792            }
793            continue;
794        }
795
796        if (!options.empty() || fr != argsIn.end()) {
797            for (int i = 0; i < hole; ++i) {
798                // Fill hole between specified parameters with JSON nulls,
799                // but not at the end (for backwards compatibility with calls
800                // that act based on number of specified parameters).
801                out.params.push_back(UniValue());
802            }
803            hole = 0;
804            if (!initial_param) initial_param = &argNamePattern;
805        } else {
806            hole += 1;
807            if (out.params.empty()) initial_hole_size = hole;
808        }
809
810        // If named input parameter "fr" is present, push it onto out.params. If
811        // options are present, push them onto out.params. If both are present,
812        // throw an error.
813        if (fr != argsIn.end()) {
814            if (!options.empty()) {
815                throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + fr->first + " conflicts with parameter " + options.getKeys().front());
816            }
817            out.params.push_back(*fr->second);
818            argsIn.erase(fr);
819        }
820        if (!options.empty()) {
821            out.params.push_back(std::move(options));
822            options = UniValue{UniValue::VOBJ};
823        }
824    }
825    // If leftover "args" param was found, use it as a source of positional
826    // arguments and add named arguments after. This is a convenience for
827    // clients that want to pass a combination of named and positional
828    // arguments as described in doc/JSON-RPC-interface.md#parameter-passing
829    auto positional_args{argsIn.extract("args")};
830    if (positional_args && positional_args.mapped()->isArray()) {
831        if (initial_hole_size < (int)positional_args.mapped()->size() && initial_param) {
832            throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter " + *initial_param + " specified twice both as positional and named argument");
833        }
834        // Assign positional_args to out.params and append named_args after.
835        UniValue named_args{std::move(out.params)};
836        out.params = *positional_args.mapped();
837        for (size_t i{out.params.size()}; i < named_args.size(); ++i) {
838            out.params.push_back(named_args[i]);
839        }
840    }
841    // If there are still arguments in the argsIn map, this is an error.
842    if (!argsIn.empty()) {
843        throw JSONRPCError(RPC_INVALID_PARAMETER, "Unknown named parameter " + argsIn.begin()->first);
844    }
845    // Return request with named arguments transformed to positional arguments
846    return out;
847}
848
849static bool ExecuteCommands(const std::vector<const CRPCCommand*>& commands, const JSONRPCRequest& request, UniValue& result)
850{
851    for (const auto& command : commands) {
852        if (ExecuteCommand(*command, request, result, &command == &commands.back())) {
853            return true;
854        }
855    }
856    return false;
857}
858
859UniValue CRPCTable::execute(const JSONRPCRequest &request) const
860{
861    // Return immediately if in warmup
862    {
863        LOCK(g_rpc_warmup_mutex);
864        if (fRPCInWarmup)
865            throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
866    }
867
868    // Find method
869    auto it = mapCommands.find(request.strMethod);
870    if (it != mapCommands.end()) {
871        UniValue result;
872        if (ExecuteCommands(it->second, request, result)) {
873            return result;
874        }
875    }
876    throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
877}
878
879static bool ExecuteCommand(const CRPCCommand& command, const JSONRPCRequest& request, UniValue& result, bool last_handler)
880{
881    try {
882        RPCCommandExecution execution(request.strMethod);
883        // Execute, convert arguments to array if necessary
884        if (request.params.isObject()) {
885            return command.actor(transformNamedArguments(request, command.argNames), result, last_handler);
886        } else {
887            return command.actor(request, result, last_handler);
888        }
889    } catch (const UniValue::type_error& e) {
890        throw JSONRPCError(RPC_TYPE_ERROR, e.what());
891    } catch (const std::exception& e) {
892        throw JSONRPCError(RPC_MISC_ERROR, e.what());
893    }
894}
895
896std::vector<std::string> CRPCTable::listCommands() const
897{
898    std::vector<std::string> commandList;
899    commandList.reserve(mapCommands.size());
900    for (const auto& i : mapCommands) commandList.emplace_back(i.first);
901    return commandList;
902}
903
904UniValue CRPCTable::buildOpenRPCDoc(bool include_hidden) const
905{
906    std::vector<std::string> method_names;
907    for (const auto& [name, cmds] : mapCommands) {
908        if (cmds.empty()) continue;
909        const CRPCCommand* cmd{cmds.front()};
910        if ((!include_hidden && cmd->category == "hidden") || !cmd->metadata_fn) continue;
911        method_names.push_back(name);
912    }
913    std::sort(method_names.begin(), method_names.end());
914
915    UniValue methods{UniValue::VARR};
916    for (const auto& method_name : method_names) {
917        const CRPCCommand* cmd{mapCommands.at(method_name).front()};
918        RPCMethod helpman{cmd->metadata_fn()};
919
920        UniValue params{UniValue::VARR};
921        for (const auto& arg : helpman.GetArgs()) {
922            if (!include_hidden && arg.m_opts.hidden) continue;
923            UniValue param{UniValue::VOBJ};
924            param.pushKV("name", arg.GetFirstName());
925            param.pushKV("required", !arg.IsOptional());
926            param.pushKV("schema", OpenRPCArgSchema(arg, include_hidden, /*in_skip_type_check=*/false));
927
928            std::vector<std::string> names{SplitString(arg.m_names, '|')};
929            if (names.size() > 1) {
930                UniValue aliases{UniValue::VARR};
931                for (size_t i{1}; i < names.size(); ++i) aliases.push_back(names[i]);
932                param.pushKV("x-bitcoin-aliases", std::move(aliases));
933            }
934            if (arg.m_opts.placeholder) param.pushKV("x-bitcoin-placeholder", true);
935            if (arg.m_opts.also_positional) param.pushKV("x-bitcoin-also-positional", true);
936            if (!arg.m_description.empty()) param.pushKV("description", arg.m_description);
937            params.push_back(std::move(param));
938        }
939
940        UniValue result_schema{UniValue::VOBJ};
941        const auto& results{helpman.GetResults().m_results};
942        if (results.size() == 1 && results[0].m_type != RPCResult::Type::ANY) {
943            result_schema = OpenRPCResultSchema(results[0]);
944        } else if (results.size() > 1) {
945            UniValue one_of{UniValue::VARR};
946            for (const auto& r : results) {
947                if (r.m_type == RPCResult::Type::ANY) continue;
948                UniValue schema{OpenRPCResultSchema(r)};
949                if (!r.m_cond.empty()) schema.pushKV("description", r.m_cond);
950                one_of.push_back(std::move(schema));
951            }
952            if (one_of.size() == 1) {
953                result_schema = one_of[0];
954            } else if (one_of.size() > 1) {
955                result_schema.pushKV("oneOf", std::move(one_of));
956            }
957        }
958
959        UniValue method{UniValue::VOBJ};
960        method.pushKV("name", method_name);
961        method.pushKV("description", util::TrimString(helpman.GetDescription()));
962        method.pushKV("params", std::move(params));
963        UniValue result{UniValue::VOBJ};
964        result.pushKV("name", "result");
965        result.pushKV("schema", std::move(result_schema));
966        method.pushKV("result", std::move(result));
967        method.pushKV("x-bitcoin-category", cmd->category);
968        methods.push_back(std::move(method));
969    }
970
971    std::string version{"v" CLIENT_VERSION_STRING};
972    if (!CLIENT_VERSION_IS_RELEASE) version += "-dev";
973
974    UniValue info{UniValue::VOBJ};
975    info.pushKV("title", CLIENT_NAME " JSON-RPC");
976    info.pushKV("version", version);
977    info.pushKV("description", "Autogenerated from " CLIENT_NAME " RPC metadata.");
978
979    UniValue doc{UniValue::VOBJ};
980    doc.pushKV("openrpc", "1.4.1");
981    doc.pushKV("info", std::move(info));
982    doc.pushKV("methods", std::move(methods));
983    return doc;
984}
985
986UniValue CRPCTable::dumpArgMap(const JSONRPCRequest& args_request) const
987{
988    JSONRPCRequest request = args_request;
989    request.mode = JSONRPCRequest::GET_ARGS;
990
991    UniValue ret{UniValue::VARR};
992    for (const auto& cmd : mapCommands) {
993        UniValue result;
994        if (ExecuteCommands(cmd.second, request, result)) {
995            for (const auto& values : result.getValues()) {
996                ret.push_back(values);
997            }
998        }
999    }
1000    return ret;