251{
252    return RPCMethod{
253        "generatetodescriptor",
254        "Mine to a specified descriptor and return the block hashes.",
255        {
256            {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated."},
257            {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated bitcoin to."},
258            {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
259        },
260        RPCResult{
261            RPCResult::Type::ARR, "", "hashes of blocks generated",
262            {
263                {RPCResult::Type::STR_HEX, "", "blockhash"},
264            }
265        },
266        RPCExamples{
267            "\nGenerate 11 blocks to mydesc\n" + HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
268        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
269{
270    const auto num_blocks{self.Arg<int>("num_blocks")};
271    const auto max_tries{self.Arg<uint64_t>("maxtries")};
272
273    CScript coinbase_output_script;
274    std::string error;
275    if (!getScriptFromDescriptor(self.Arg<std::string_view>("descriptor"), coinbase_output_script, error)) {
276        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
277    }
278
279    NodeContext& node = EnsureAnyNodeContext(request.context);
280    Mining& miner = EnsureMining(node);
281    ChainstateManager& chainman = EnsureChainman(node);
282
283    return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
284},
285    };
286}
287
288static RPCMethod generate()
289{
290    return RPCMethod{"generate", "has been replaced by the -generate cli option. Refer to -help for more information.", {}, {}, RPCExamples{""}, [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue {
291        throw JSONRPCError(RPC_METHOD_NOT_FOUND, self.ToString());
292    }};
293}
294
295static RPCMethod generatetoaddress()
296{
297    return RPCMethod{"generatetoaddress",
298        "Mine to a specified address and return the block hashes.",
299         {
300             {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated."},
301             {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated bitcoin to."},
302             {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
303         },
304         RPCResult{
305             RPCResult::Type::ARR, "", "hashes of blocks generated",
306             {
307                 {RPCResult::Type::STR_HEX, "", "blockhash"},
308             }},
309         RPCExamples{
310            "\nGenerate 11 blocks to myaddress\n"
311            + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
312            + "If you are using the " CLIENT_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n"
313            + HelpExampleCli("getnewaddress", "")
314                },
315        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
316{
317    const int num_blocks{request.params[0].getInt<int>()};
318    const uint64_t max_tries{request.params[2].isNull() ? DEFAULT_MAX_TRIES : request.params[2].getInt<int>()};
319
320    CTxDestination destination = DecodeDestination(request.params[1].get_str());
321    if (!IsValidDestination(destination)) {
322        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
323    }
324
325    NodeContext& node = EnsureAnyNodeContext(request.context);
326    Mining& miner = EnsureMining(node);
327    ChainstateManager& chainman = EnsureChainman(node);
328
329    CScript coinbase_output_script = GetScriptForDestination(destination);
330
331    return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
332},
333    };
334}
335
336static RPCMethod generateblock()
337{
338    return RPCMethod{"generateblock",
339        "Mine a set of ordered transactions to a specified address or descriptor and return the block hash.\n"
340        "Transaction fees are not collected in the block reward.",
341        {
342            {"output", RPCArg::Type::STR, RPCArg::Optional::NO, "The address or descriptor to send the newly generated bitcoin to."},
343            {"transactions", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings which are either txids or raw transactions.\n"
344                "Txids must reference transactions currently in the mempool.\n"
345                "All transactions must be valid and in valid order, otherwise the block will be rejected.",
346                {
347                    {"rawtx/txid", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, ""},
348                },
349            },
350            {"submit", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether to submit the block before the RPC call returns or to return it as hex."},
351        },
352        RPCResult{
353            RPCResult::Type::OBJ, "", "",
354            {
355                {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
356                {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "hex of generated block, only present when submit=false"},
357            }
358        },
359        RPCExamples{
360            "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n"
361            + HelpExampleCli("generateblock", R"("myaddress" '["rawtx", "mempool_txid"]')")
362        },
363        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
364{
365    const auto address_or_descriptor = request.params[0].get_str();
366    CScript coinbase_output_script;
367    std::string error;
368
369    if (!getScriptFromDescriptor(address_or_descriptor, coinbase_output_script, error)) {
370        const auto destination = DecodeDestination(address_or_descriptor);
371        if (!IsValidDestination(destination)) {
372            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address or descriptor");
373        }
374
375        coinbase_output_script = GetScriptForDestination(destination);
376    }
377
378    NodeContext& node = EnsureAnyNodeContext(request.context);
379    Mining& miner = EnsureMining(node);
380    const CTxMemPool& mempool = EnsureMemPool(node);
381
382    std::vector<CTransactionRef> txs;
383    const auto raw_txs_or_txids = request.params[1].get_array();
384    for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
385        const auto& str{raw_txs_or_txids[i].get_str()};
386
387        CMutableTransaction mtx;
388        if (auto txid{Txid::FromHex(str)}) {
389            const auto tx{mempool.get(*txid)};
390            if (!tx) {
391                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Transaction %s not in mempool.", str));
392            }
393
394            txs.emplace_back(tx);
395
396        } else if (DecodeHexTx(mtx, str)) {
397            txs.push_back(MakeTransactionRef(std::move(mtx)));
398
399        } else {
400            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("Transaction decode failed for %s. Make sure the tx has at least one input.", str));
401        }
402    }
403
404    const bool process_new_block{request.params[2].isNull() ? true : request.params[2].get_bool()};
405    CBlock block;
406
407    ChainstateManager& chainman = EnsureChainman(node);
408    {
409        LOCK(chainman.GetMutex());
410        {
411            std::unique_ptr<BlockTemplate> block_template{miner.createNewBlock({.use_mempool = false, .coinbase_output_script = coinbase_output_script}, /*cooldown=*/false)};
412            CHECK_NONFATAL(block_template);
413
414            block = block_template->getBlock();
415        }
416
417        CHECK_NONFATAL(block.vtx.size() == 1);
418
419        // Add transactions
420        block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
421        RegenerateCommitments(block, chainman);
422
423        if (BlockValidationState state{TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/false)}; !state.IsValid()) {
424            throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
425        }
426    }
427
428    std::shared_ptr<const CBlock> block_out;
429    uint64_t max_tries{DEFAULT_MAX_TRIES};
430
431    if (!GenerateBlock(chainman, std::move(block), max_tries, block_out, process_new_block) || !block_out) {
432        throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
433    }
434
435    UniValue obj(UniValue::VOBJ);
436    obj.pushKV("hash", block_out->GetHash().GetHex());
437    if (!process_new_block) {
438        DataStream block_ser;
439        block_ser << TX_WITH_WITNESS(*block_out);
440        obj.pushKV("hex", HexStr(block_ser));
441    }
442    return obj;
443},
444    };
445}
446
447static RPCMethod getmininginfo()
448{
449    return RPCMethod{
450        "getmininginfo",
451        "Returns a json object containing mining-related information.",
452                {},
453                RPCResult{
454                    RPCResult::Type::OBJ, "", "",
455                    {
456                        {RPCResult::Type::NUM, "blocks", "The current block"},
457                        {RPCResult::Type::NUM, "currentblockweight", /*optional=*/true, "The block weight (including reserved weight for block header, txs count and coinbase tx) of the last assembled block (only present if a block was ever assembled)"},
458                        {RPCResult::Type::NUM, "currentblocktx", /*optional=*/true, "The number of block transactions (excluding coinbase) of the last assembled block (only present if a block was ever assembled)"},
459                        {RPCResult::Type::STR_HEX, "bits", "The current nBits, compact representation of the block difficulty target"},
460                        {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
461                        {RPCResult::Type::STR_HEX, "target", "The current target"},
462                        {RPCResult::Type::NUM, "networkhashps", "The network hashes per second"},
463                        {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
464                        {RPCResult::Type::STR_AMOUNT, "blockmintxfee", "Minimum feerate of packages selected for block inclusion in " + CURRENCY_UNIT + "/kvB"},
465                        {RPCResult::Type::STR, "chain", "current network name (" LIST_CHAIN_NAMES ")"},
466                        {RPCResult::Type::STR_HEX, "signet_challenge", /*optional=*/true, "The block challenge (aka. block script), in hexadecimal (only present if the current network is a signet)"},
467                        {RPCResult::Type::OBJ, "next", "The next block",
468                        {
469                            {RPCResult::Type::NUM, "height", "The next height"},
470                            {RPCResult::Type::STR_HEX, "bits", "The next target nBits"},
471                            {RPCResult::Type::NUM, "difficulty", "The next difficulty"},
472                            {RPCResult::Type::STR_HEX, "target", "The next target"}
473                        }},
474                        (IsDeprecatedRPCEnabled("warnings") ?
475                            RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
476                            RPCResult{RPCResult::Type::ARR, "warnings", "any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
477                            {
478                                {RPCResult::Type::STR, "", "warning"},
479                            }
480                            }
481                        ),
482                    }},
483                RPCExamples{
484                    HelpExampleCli("getmininginfo", "")
485            + HelpExampleRpc("getmininginfo", "")
486                },
487        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
488{
489    NodeContext& node = EnsureAnyNodeContext(request.context);
490    const CTxMemPool& mempool = EnsureMemPool(node);
491    ChainstateManager& chainman = EnsureChainman(node);
492    LOCK(cs_main);
493    const CChain& active_chain = chainman.ActiveChain();
494    CBlockIndex& tip{*CHECK_NONFATAL(active_chain.Tip())};
495
496    UniValue obj(UniValue::VOBJ);
497    obj.pushKV("blocks", active_chain.Height());
498    if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
499    if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
500    obj.pushKV("bits", strprintf("%08x", tip.nBits));