LCOV - code coverage report
Current view: top level - src/rpc - mining.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 55.2 % 707 390
Test Date: 2025-09-10 04:04:06 Functions: 90.3 % 31 28
Branches: 31.9 % 2402 767

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2010 Satoshi Nakamoto
       2                 :             : // Copyright (c) 2009-present The Bitcoin Core developers
       3                 :             : // Distributed under the MIT software license, see the accompanying
       4                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :             : 
       6                 :             : #include <bitcoin-build-config.h> // IWYU pragma: keep
       7                 :             : 
       8                 :             : #include <chain.h>
       9                 :             : #include <chainparams.h>
      10                 :             : #include <chainparamsbase.h>
      11                 :             : #include <common/system.h>
      12                 :             : #include <consensus/amount.h>
      13                 :             : #include <consensus/consensus.h>
      14                 :             : #include <consensus/merkle.h>
      15                 :             : #include <consensus/params.h>
      16                 :             : #include <consensus/validation.h>
      17                 :             : #include <core_io.h>
      18                 :             : #include <deploymentinfo.h>
      19                 :             : #include <deploymentstatus.h>
      20                 :             : #include <interfaces/mining.h>
      21                 :             : #include <key_io.h>
      22                 :             : #include <net.h>
      23                 :             : #include <node/context.h>
      24                 :             : #include <node/miner.h>
      25                 :             : #include <node/warnings.h>
      26                 :             : #include <policy/ephemeral_policy.h>
      27                 :             : #include <pow.h>
      28                 :             : #include <rpc/blockchain.h>
      29                 :             : #include <rpc/mining.h>
      30                 :             : #include <rpc/server.h>
      31                 :             : #include <rpc/server_util.h>
      32                 :             : #include <rpc/util.h>
      33                 :             : #include <script/descriptor.h>
      34                 :             : #include <script/script.h>
      35                 :             : #include <script/signingprovider.h>
      36                 :             : #include <txmempool.h>
      37                 :             : #include <univalue.h>
      38                 :             : #include <util/signalinterrupt.h>
      39                 :             : #include <util/strencodings.h>
      40                 :             : #include <util/string.h>
      41                 :             : #include <util/time.h>
      42                 :             : #include <util/translation.h>
      43                 :             : #include <validation.h>
      44                 :             : #include <validationinterface.h>
      45                 :             : 
      46                 :             : #include <cstdint>
      47                 :             : #include <memory>
      48                 :             : 
      49                 :             : using interfaces::BlockRef;
      50                 :             : using interfaces::BlockTemplate;
      51                 :             : using interfaces::Mining;
      52                 :             : using node::BlockAssembler;
      53                 :             : using node::GetMinimumTime;
      54                 :             : using node::NodeContext;
      55                 :             : using node::RegenerateCommitments;
      56                 :             : using node::UpdateTime;
      57                 :             : using util::ToString;
      58                 :             : 
      59                 :             : /**
      60                 :             :  * Return average network hashes per second based on the last 'lookup' blocks,
      61                 :             :  * or from the last difficulty change if 'lookup' is -1.
      62                 :             :  * If 'height' is -1, compute the estimate from current chain tip.
      63                 :             :  * If 'height' is a valid block height, compute the estimate at the time when a given block was found.
      64                 :             :  */
      65                 :           7 : static UniValue GetNetworkHashPS(int lookup, int height, const CChain& active_chain) {
      66         [ +  + ]:           7 :     if (lookup < -1 || lookup == 0) {
      67   [ +  -  +  - ]:           4 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid nblocks. Must be a positive number or -1.");
      68                 :             :     }
      69                 :             : 
      70   [ +  +  +  + ]:           9 :     if (height < -1 || height > active_chain.Height()) {
      71   [ +  -  +  - ]:           4 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Block does not exist at specified height");
      72                 :             :     }
      73                 :             : 
      74         [ +  - ]:           3 :     const CBlockIndex* pb = active_chain.Tip();
      75                 :             : 
      76         [ +  + ]:           3 :     if (height >= 0) {
      77                 :           1 :         pb = active_chain[height];
      78                 :             :     }
      79                 :             : 
      80   [ +  -  +  - ]:           3 :     if (pb == nullptr || !pb->nHeight)
      81                 :           3 :         return 0;
      82                 :             : 
      83                 :             :     // If lookup is -1, then use blocks since last difficulty change.
      84         [ #  # ]:           0 :     if (lookup == -1)
      85                 :           0 :         lookup = pb->nHeight % Params().GetConsensus().DifficultyAdjustmentInterval() + 1;
      86                 :             : 
      87                 :             :     // If lookup is larger than chain, then set it to chain length.
      88         [ #  # ]:           0 :     if (lookup > pb->nHeight)
      89                 :           0 :         lookup = pb->nHeight;
      90                 :             : 
      91                 :           0 :     const CBlockIndex* pb0 = pb;
      92                 :           0 :     int64_t minTime = pb0->GetBlockTime();
      93                 :           0 :     int64_t maxTime = minTime;
      94         [ #  # ]:           0 :     for (int i = 0; i < lookup; i++) {
      95                 :           0 :         pb0 = pb0->pprev;
      96         [ #  # ]:           0 :         int64_t time = pb0->GetBlockTime();
      97         [ #  # ]:           0 :         minTime = std::min(time, minTime);
      98         [ #  # ]:           0 :         maxTime = std::max(time, maxTime);
      99                 :             :     }
     100                 :             : 
     101                 :             :     // In case there's a situation where minTime == maxTime, we don't want a divide by zero exception.
     102         [ #  # ]:           0 :     if (minTime == maxTime)
     103                 :           0 :         return 0;
     104                 :             : 
     105                 :           0 :     arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
     106                 :           0 :     int64_t timeDiff = maxTime - minTime;
     107                 :             : 
     108                 :           0 :     return workDiff.getdouble() / timeDiff;
     109                 :             : }
     110                 :             : 
     111                 :          65 : static RPCHelpMan getnetworkhashps()
     112                 :             : {
     113                 :          65 :     return RPCHelpMan{
     114                 :          65 :         "getnetworkhashps",
     115         [ +  - ]:         130 :         "Returns the estimated network hashes per second based on the last n blocks.\n"
     116                 :             :                 "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
     117                 :             :                 "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
     118                 :             :                 {
     119   [ +  -  +  -  :         195 :                     {"nblocks", RPCArg::Type::NUM, RPCArg::Default{120}, "The number of previous blocks to calculate estimate from, or -1 for blocks since last difficulty change."},
                   +  - ]
     120   [ +  -  +  -  :         195 :                     {"height", RPCArg::Type::NUM, RPCArg::Default{-1}, "To estimate at the time of the given height."},
                   +  - ]
     121                 :             :                 },
     122         [ +  - ]:         130 :                 RPCResult{
     123   [ +  -  +  -  :         130 :                     RPCResult::Type::NUM, "", "Hashes per second estimated"},
                   +  - ]
     124                 :          65 :                 RPCExamples{
     125   [ +  -  +  -  :         130 :                     HelpExampleCli("getnetworkhashps", "")
                   +  - ]
     126   [ +  -  +  -  :         260 :             + HelpExampleRpc("getnetworkhashps", "")
             +  -  +  - ]
     127         [ +  - ]:          65 :                 },
     128                 :          65 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     129                 :             : {
     130                 :           9 :     ChainstateManager& chainman = EnsureAnyChainman(request.context);
     131                 :           9 :     LOCK(cs_main);
     132   [ +  -  +  +  :           9 :     return GetNetworkHashPS(self.Arg<int>("nblocks"), self.Arg<int>("height"), chainman.ActiveChain());
             +  +  +  + ]
     133                 :           3 : },
     134   [ +  -  +  -  :         390 :     };
             +  +  -  - ]
     135   [ +  -  +  -  :         260 : }
                   -  - ]
     136                 :             : 
     137                 :           0 : static bool GenerateBlock(ChainstateManager& chainman, CBlock&& block, uint64_t& max_tries, std::shared_ptr<const CBlock>& block_out, bool process_new_block)
     138                 :             : {
     139                 :           0 :     block_out.reset();
     140                 :           0 :     block.hashMerkleRoot = BlockMerkleRoot(block);
     141                 :             : 
     142   [ #  #  #  #  :           0 :     while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetHash(), block.nBits, chainman.GetConsensus()) && !chainman.m_interrupt) {
             #  #  #  # ]
     143                 :           0 :         ++block.nNonce;
     144                 :           0 :         --max_tries;
     145                 :             :     }
     146   [ #  #  #  # ]:           0 :     if (max_tries == 0 || chainman.m_interrupt) {
     147                 :           0 :         return false;
     148                 :             :     }
     149         [ #  # ]:           0 :     if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
     150                 :             :         return true;
     151                 :             :     }
     152                 :             : 
     153         [ #  # ]:           0 :     block_out = std::make_shared<const CBlock>(std::move(block));
     154                 :             : 
     155         [ #  # ]:           0 :     if (!process_new_block) return true;
     156                 :             : 
     157         [ #  # ]:           0 :     if (!chainman.ProcessNewBlock(block_out, /*force_processing=*/true, /*min_pow_checked=*/true, nullptr)) {
     158   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
     159                 :             :     }
     160                 :             : 
     161                 :             :     return true;
     162                 :             : }
     163                 :             : 
     164                 :           0 : static UniValue generateBlocks(ChainstateManager& chainman, Mining& miner, const CScript& coinbase_output_script, int nGenerate, uint64_t nMaxTries)
     165                 :             : {
     166                 :           0 :     UniValue blockHashes(UniValue::VARR);
     167   [ #  #  #  #  :           0 :     while (nGenerate > 0 && !chainman.m_interrupt) {
                   #  # ]
     168                 :           0 :         std::unique_ptr<BlockTemplate> block_template(miner.createNewBlock({ .coinbase_output_script = coinbase_output_script }));
     169         [ #  # ]:           0 :         CHECK_NONFATAL(block_template);
     170                 :             : 
     171                 :           0 :         std::shared_ptr<const CBlock> block_out;
     172   [ #  #  #  #  :           0 :         if (!GenerateBlock(chainman, block_template->getBlock(), nMaxTries, block_out, /*process_new_block=*/true)) {
                   #  # ]
     173                 :             :             break;
     174                 :             :         }
     175                 :             : 
     176         [ #  # ]:           0 :         if (block_out) {
     177                 :           0 :             --nGenerate;
     178   [ #  #  #  #  :           0 :             blockHashes.push_back(block_out->GetHash().GetHex());
             #  #  #  # ]
     179                 :             :         }
     180                 :           0 :     }
     181                 :           0 :     return blockHashes;
     182         [ #  # ]:           0 : }
     183                 :             : 
     184                 :         203 : static bool getScriptFromDescriptor(const std::string& descriptor, CScript& script, std::string& error)
     185                 :             : {
     186                 :         203 :     FlatSigningProvider key_provider;
     187         [ +  - ]:         203 :     const auto descs = Parse(descriptor, key_provider, error, /* require_checksum = */ false);
     188         [ +  + ]:         203 :     if (descs.empty()) return false;
     189   [ -  +  -  + ]:          18 :     if (descs.size() > 1) {
     190   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Multipath descriptor not accepted");
     191                 :             :     }
     192         [ +  - ]:          18 :     const auto& desc = descs.at(0);
     193   [ +  -  -  + ]:          18 :     if (desc->IsRange()) {
     194   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptor not accepted. Maybe pass through deriveaddresses first?");
     195                 :             :     }
     196                 :             : 
     197                 :          18 :     FlatSigningProvider provider;
     198                 :          18 :     std::vector<CScript> scripts;
     199   [ +  -  -  + ]:          18 :     if (!desc->Expand(0, key_provider, scripts, provider)) {
     200   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot derive script without private keys");
     201                 :             :     }
     202                 :             : 
     203                 :             :     // Combo descriptors can have 2 or 4 scripts, so we can't just check scripts.size() == 1
     204   [ -  +  +  -  :          18 :     CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 4);
             -  +  +  - ]
     205                 :             : 
     206   [ -  +  +  - ]:          18 :     if (scripts.size() == 1) {
     207         [ +  - ]:          18 :         script = scripts.at(0);
     208         [ #  # ]:           0 :     } else if (scripts.size() == 4) {
     209                 :             :         // For uncompressed keys, take the 3rd script, since it is p2wpkh
     210         [ #  # ]:           0 :         script = scripts.at(2);
     211                 :             :     } else {
     212                 :             :         // Else take the 2nd script, since it is p2pkh
     213         [ #  # ]:           0 :         script = scripts.at(1);
     214                 :             :     }
     215                 :             : 
     216                 :          18 :     return true;
     217                 :         203 : }
     218                 :             : 
     219                 :          52 : static RPCHelpMan generatetodescriptor()
     220                 :             : {
     221                 :          52 :     return RPCHelpMan{
     222                 :          52 :         "generatetodescriptor",
     223         [ +  - ]:         104 :         "Mine to a specified descriptor and return the block hashes.",
     224                 :             :         {
     225   [ +  -  +  - ]:         104 :             {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated."},
     226   [ +  -  +  - ]:         104 :             {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated bitcoin to."},
     227   [ +  -  +  -  :         156 :             {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
                   +  - ]
     228                 :             :         },
     229         [ +  - ]:         104 :         RPCResult{
     230   [ +  -  +  - ]:         104 :             RPCResult::Type::ARR, "", "hashes of blocks generated",
     231                 :             :             {
     232   [ +  -  +  - ]:         104 :                 {RPCResult::Type::STR_HEX, "", "blockhash"},
     233                 :             :             }
     234   [ +  -  +  -  :         156 :         },
             +  +  -  - ]
     235                 :          52 :         RPCExamples{
     236   [ +  -  +  -  :         156 :             "\nGenerate 11 blocks to mydesc\n" + HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
          +  -  +  -  +  
                      - ]
     237                 :          52 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     238                 :             : {
     239                 :           0 :     const auto num_blocks{self.Arg<int>("num_blocks")};
     240                 :           0 :     const auto max_tries{self.Arg<uint64_t>("maxtries")};
     241                 :             : 
     242                 :           0 :     CScript coinbase_output_script;
     243         [ #  # ]:           0 :     std::string error;
     244   [ #  #  #  #  :           0 :     if (!getScriptFromDescriptor(self.Arg<std::string>("descriptor"), coinbase_output_script, error)) {
                   #  # ]
     245         [ #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
     246                 :             :     }
     247                 :             : 
     248         [ #  # ]:           0 :     NodeContext& node = EnsureAnyNodeContext(request.context);
     249         [ #  # ]:           0 :     Mining& miner = EnsureMining(node);
     250         [ #  # ]:           0 :     ChainstateManager& chainman = EnsureChainman(node);
     251                 :             : 
     252         [ #  # ]:           0 :     return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
     253                 :           0 : },
     254   [ +  -  +  -  :         364 :     };
             +  +  -  - ]
     255   [ +  -  +  -  :         364 : }
          +  -  +  -  -  
                      - ]
     256                 :             : 
     257                 :          60 : static RPCHelpMan generate()
     258                 :             : {
     259   [ +  -  +  - ]:         240 :     return RPCHelpMan{"generate", "has been replaced by the -generate cli option. Refer to -help for more information.", {}, {}, RPCExamples{""}, [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
     260   [ +  -  +  - ]:           2 :         throw JSONRPCError(RPC_METHOD_NOT_FOUND, self.ToString());
     261   [ +  -  +  -  :         300 :     }};
                   +  - ]
     262                 :             : }
     263                 :             : 
     264                 :          51 : static RPCHelpMan generatetoaddress()
     265                 :             : {
     266                 :          51 :     return RPCHelpMan{"generatetoaddress",
     267         [ +  - ]:         102 :         "Mine to a specified address and return the block hashes.",
     268                 :             :          {
     269   [ +  -  +  - ]:         102 :              {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated."},
     270   [ +  -  +  - ]:         102 :              {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated bitcoin to."},
     271   [ +  -  +  -  :         153 :              {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
                   +  - ]
     272                 :             :          },
     273         [ +  - ]:         102 :          RPCResult{
     274   [ +  -  +  - ]:         102 :              RPCResult::Type::ARR, "", "hashes of blocks generated",
     275                 :             :              {
     276   [ +  -  +  - ]:         102 :                  {RPCResult::Type::STR_HEX, "", "blockhash"},
     277   [ +  -  +  -  :         153 :              }},
             +  +  -  - ]
     278                 :          51 :          RPCExamples{
     279                 :             :             "\nGenerate 11 blocks to myaddress\n"
     280   [ +  -  +  -  :         102 :             + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
             +  -  +  - ]
     281                 :          51 :             + "If you are using the " CLIENT_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n"
     282   [ +  -  +  -  :         204 :             + HelpExampleCli("getnewaddress", "")
             +  -  +  - ]
     283         [ +  - ]:          51 :                 },
     284                 :          51 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     285                 :             : {
     286                 :           0 :     const int num_blocks{request.params[0].getInt<int>()};
     287         [ #  # ]:           0 :     const uint64_t max_tries{request.params[2].isNull() ? DEFAULT_MAX_TRIES : request.params[2].getInt<int>()};
     288                 :             : 
     289                 :           0 :     CTxDestination destination = DecodeDestination(request.params[1].get_str());
     290   [ #  #  #  # ]:           0 :     if (!IsValidDestination(destination)) {
     291   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
     292                 :             :     }
     293                 :             : 
     294         [ #  # ]:           0 :     NodeContext& node = EnsureAnyNodeContext(request.context);
     295         [ #  # ]:           0 :     Mining& miner = EnsureMining(node);
     296         [ #  # ]:           0 :     ChainstateManager& chainman = EnsureChainman(node);
     297                 :             : 
     298         [ #  # ]:           0 :     CScript coinbase_output_script = GetScriptForDestination(destination);
     299                 :             : 
     300         [ #  # ]:           0 :     return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
     301                 :           0 : },
     302   [ +  -  +  -  :         357 :     };
             +  +  -  - ]
     303   [ +  -  +  -  :         357 : }
          +  -  +  -  -  
                      - ]
     304                 :             : 
     305                 :         256 : static RPCHelpMan generateblock()
     306                 :             : {
     307                 :         256 :     return RPCHelpMan{"generateblock",
     308         [ +  - ]:         512 :         "Mine a set of ordered transactions to a specified address or descriptor and return the block hash.",
     309                 :             :         {
     310   [ +  -  +  - ]:         512 :             {"output", RPCArg::Type::STR, RPCArg::Optional::NO, "The address or descriptor to send the newly generated bitcoin to."},
     311   [ +  -  +  - ]:         512 :             {"transactions", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings which are either txids or raw transactions.\n"
     312                 :             :                 "Txids must reference transactions currently in the mempool.\n"
     313                 :             :                 "All transactions must be valid and in valid order, otherwise the block will be rejected.",
     314                 :             :                 {
     315   [ +  -  +  - ]:         512 :                     {"rawtx/txid", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, ""},
     316                 :             :                 },
     317                 :             :             },
     318   [ +  -  +  -  :         768 :             {"submit", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether to submit the block before the RPC call returns or to return it as hex."},
                   +  - ]
     319                 :             :         },
     320         [ +  - ]:         512 :         RPCResult{
     321   [ +  -  +  - ]:         512 :             RPCResult::Type::OBJ, "", "",
     322                 :             :             {
     323   [ +  -  +  - ]:         512 :                 {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
     324   [ +  -  +  - ]:         512 :                 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "hex of generated block, only present when submit=false"},
     325                 :             :             }
     326   [ +  -  +  -  :        1280 :         },
             +  +  -  - ]
     327                 :         256 :         RPCExamples{
     328                 :             :             "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n"
     329   [ +  -  +  -  :         512 :             + HelpExampleCli("generateblock", R"("myaddress" '["rawtx", "mempool_txid"]')")
             +  -  +  - ]
     330         [ +  - ]:         256 :         },
     331                 :         256 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     332                 :             : {
     333         [ -  + ]:         203 :     const auto address_or_descriptor = request.params[0].get_str();
     334                 :         203 :     CScript coinbase_output_script;
     335         [ +  - ]:         203 :     std::string error;
     336                 :             : 
     337   [ +  -  +  + ]:         203 :     if (!getScriptFromDescriptor(address_or_descriptor, coinbase_output_script, error)) {
     338         [ +  - ]:         185 :         const auto destination = DecodeDestination(address_or_descriptor);
     339   [ +  -  +  + ]:         185 :         if (!IsValidDestination(destination)) {
     340   [ +  -  +  - ]:         356 :             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address or descriptor");
     341                 :             :         }
     342                 :             : 
     343         [ +  - ]:          14 :         coinbase_output_script = GetScriptForDestination(destination);
     344                 :         185 :     }
     345                 :             : 
     346         [ +  - ]:          25 :     NodeContext& node = EnsureAnyNodeContext(request.context);
     347         [ -  + ]:          25 :     Mining& miner = EnsureMining(node);
     348         [ #  # ]:           0 :     const CTxMemPool& mempool = EnsureMemPool(node);
     349                 :             : 
     350                 :           0 :     std::vector<CTransactionRef> txs;
     351   [ #  #  #  #  :           0 :     const auto raw_txs_or_txids = request.params[1].get_array();
                   #  # ]
     352   [ #  #  #  # ]:           0 :     for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
     353   [ #  #  #  # ]:           0 :         const auto& str{raw_txs_or_txids[i].get_str()};
     354                 :             : 
     355         [ #  # ]:           0 :         CMutableTransaction mtx;
     356   [ #  #  #  #  :           0 :         if (auto txid{Txid::FromHex(str)}) {
                   #  # ]
     357         [ #  # ]:           0 :             const auto tx{mempool.get(*txid)};
     358         [ #  # ]:           0 :             if (!tx) {
     359   [ #  #  #  # ]:           0 :                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Transaction %s not in mempool.", str));
     360                 :             :             }
     361                 :             : 
     362         [ #  # ]:           0 :             txs.emplace_back(tx);
     363                 :             : 
     364   [ #  #  #  # ]:           0 :         } else if (DecodeHexTx(mtx, str)) {
     365   [ #  #  #  #  :           0 :             txs.push_back(MakeTransactionRef(std::move(mtx)));
                   #  # ]
     366                 :             : 
     367                 :             :         } else {
     368   [ #  #  #  # ]:           0 :             throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("Transaction decode failed for %s. Make sure the tx has at least one input.", str));
     369                 :             :         }
     370                 :           0 :     }
     371                 :             : 
     372   [ #  #  #  #  :           0 :     const bool process_new_block{request.params[2].isNull() ? true : request.params[2].get_bool()};
             #  #  #  # ]
     373                 :           0 :     CBlock block;
     374                 :             : 
     375         [ #  # ]:           0 :     ChainstateManager& chainman = EnsureChainman(node);
     376                 :           0 :     {
     377         [ #  # ]:           0 :         LOCK(chainman.GetMutex());
     378                 :           0 :         {
     379                 :           0 :             std::unique_ptr<BlockTemplate> block_template{miner.createNewBlock({.use_mempool = false, .coinbase_output_script = coinbase_output_script})};
     380         [ #  # ]:           0 :             CHECK_NONFATAL(block_template);
     381                 :             : 
     382         [ #  # ]:           0 :             block = block_template->getBlock();
     383                 :           0 :         }
     384                 :             : 
     385   [ #  #  #  # ]:           0 :         CHECK_NONFATAL(block.vtx.size() == 1);
     386                 :             : 
     387                 :             :         // Add transactions
     388         [ #  # ]:           0 :         block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
     389         [ #  # ]:           0 :         RegenerateCommitments(block, chainman);
     390                 :             : 
     391   [ #  #  #  #  :           0 :         if (BlockValidationState state{TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/false)}; !state.IsValid()) {
                   #  # ]
     392   [ #  #  #  #  :           0 :             throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
                   #  # ]
     393         [ #  # ]:           0 :         }
     394                 :           0 :     }
     395                 :             : 
     396                 :           0 :     std::shared_ptr<const CBlock> block_out;
     397                 :           0 :     uint64_t max_tries{DEFAULT_MAX_TRIES};
     398                 :             : 
     399   [ #  #  #  #  :           0 :     if (!GenerateBlock(chainman, std::move(block), max_tries, block_out, process_new_block) || !block_out) {
                   #  # ]
     400   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
     401                 :             :     }
     402                 :             : 
     403                 :           0 :     UniValue obj(UniValue::VOBJ);
     404   [ #  #  #  #  :           0 :     obj.pushKV("hash", block_out->GetHash().GetHex());
          #  #  #  #  #  
                      # ]
     405         [ #  # ]:           0 :     if (!process_new_block) {
     406                 :           0 :         DataStream block_ser;
     407         [ #  # ]:           0 :         block_ser << TX_WITH_WITNESS(*block_out);
     408   [ #  #  #  #  :           0 :         obj.pushKV("hex", HexStr(block_ser));
          #  #  #  #  #  
                      # ]
     409                 :           0 :     }
     410         [ #  # ]:           0 :     return obj;
     411         [ -  - ]:         406 : },
     412   [ +  -  +  -  :        2560 :     };
          +  -  +  +  +  
             +  -  -  -  
                      - ]
     413   [ +  -  +  -  :        2560 : }
          +  -  +  -  +  
          -  +  -  -  -  
                   -  - ]
     414                 :             : 
     415                 :          62 : static RPCHelpMan getmininginfo()
     416                 :             : {
     417                 :          62 :     return RPCHelpMan{
     418                 :          62 :         "getmininginfo",
     419         [ +  - ]:         124 :         "Returns a json object containing mining-related information.",
     420                 :             :                 {},
     421         [ +  - ]:         124 :                 RPCResult{
     422         [ +  - ]:         124 :                     RPCResult::Type::OBJ, "", "",
     423                 :             :                     {
     424   [ +  -  +  - ]:         124 :                         {RPCResult::Type::NUM, "blocks", "The current block"},
     425   [ +  -  +  - ]:         124 :                         {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)"},
     426   [ +  -  +  - ]:         124 :                         {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)"},
     427   [ +  -  +  - ]:         124 :                         {RPCResult::Type::STR_HEX, "bits", "The current nBits, compact representation of the block difficulty target"},
     428   [ +  -  +  - ]:         124 :                         {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
     429   [ +  -  +  - ]:         124 :                         {RPCResult::Type::STR_HEX, "target", "The current target"},
     430   [ +  -  +  - ]:         124 :                         {RPCResult::Type::NUM, "networkhashps", "The network hashes per second"},
     431   [ +  -  +  - ]:         124 :                         {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
     432   [ +  -  +  - ]:         124 :                         {RPCResult::Type::STR_AMOUNT, "blockmintxfee", "Minimum feerate of packages selected for block inclusion in " + CURRENCY_UNIT + "/kvB"},
     433   [ +  -  +  - ]:         124 :                         {RPCResult::Type::STR, "chain", "current network name (" LIST_CHAIN_NAMES ")"},
     434   [ +  -  +  - ]:         124 :                         {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)"},
     435   [ +  -  +  - ]:         124 :                         {RPCResult::Type::OBJ, "next", "The next block",
     436                 :             :                         {
     437   [ +  -  +  - ]:         124 :                             {RPCResult::Type::NUM, "height", "The next height"},
     438   [ +  -  +  - ]:         124 :                             {RPCResult::Type::STR_HEX, "bits", "The next target nBits"},
     439   [ +  -  +  - ]:         124 :                             {RPCResult::Type::NUM, "difficulty", "The next difficulty"},
     440   [ +  -  +  - ]:         124 :                             {RPCResult::Type::STR_HEX, "target", "The next target"}
     441                 :             :                         }},
     442   [ +  -  +  -  :          62 :                         (IsDeprecatedRPCEnabled("warnings") ?
                   -  + ]
     443   [ -  -  -  -  :          62 :                             RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
          -  +  -  +  -  
          +  -  -  -  -  
                   -  - ]
     444   [ +  -  +  -  :         248 :                             RPCResult{RPCResult::Type::ARR, "warnings", "any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
          +  -  +  -  -  
                -  -  - ]
     445                 :             :                             {
     446   [ +  -  +  -  :         248 :                                 {RPCResult::Type::STR, "", "warning"},
          +  -  +  -  -  
                -  -  - ]
     447                 :             :                             }
     448   [ +  -  +  -  :         248 :                             }
          +  -  +  +  +  
          -  -  -  -  -  
             -  -  -  - ]
     449                 :             :                         ),
     450   [ +  -  +  -  :        2170 :                     }},
          +  -  +  +  +  
             +  -  -  -  
                      - ]
     451                 :          62 :                 RPCExamples{
     452   [ +  -  +  -  :         124 :                     HelpExampleCli("getmininginfo", "")
                   +  - ]
     453   [ +  -  +  -  :         248 :             + HelpExampleRpc("getmininginfo", "")
             +  -  +  - ]
     454         [ +  - ]:          62 :                 },
     455                 :          62 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     456                 :             : {
     457                 :           2 :     NodeContext& node = EnsureAnyNodeContext(request.context);
     458                 :           2 :     const CTxMemPool& mempool = EnsureMemPool(node);
     459                 :           2 :     ChainstateManager& chainman = EnsureChainman(node);
     460                 :           2 :     LOCK(cs_main);
     461         [ +  - ]:           2 :     const CChain& active_chain = chainman.ActiveChain();
     462   [ -  +  +  - ]:           4 :     CBlockIndex& tip{*CHECK_NONFATAL(active_chain.Tip())};
     463                 :             : 
     464                 :           2 :     UniValue obj(UniValue::VOBJ);
     465   [ -  +  +  -  :           4 :     obj.pushKV("blocks",           active_chain.Height());
             +  -  +  - ]
     466   [ -  +  -  -  :           2 :     if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
             -  -  -  - ]
     467   [ -  +  -  -  :           2 :     if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
             -  -  -  - ]
     468   [ +  -  +  -  :           4 :     obj.pushKV("bits", strprintf("%08x", tip.nBits));
             +  -  +  - ]
     469   [ +  -  +  -  :           4 :     obj.pushKV("difficulty", GetDifficulty(tip));
             +  -  +  - ]
     470   [ +  -  +  -  :           4 :     obj.pushKV("target", GetTarget(tip, chainman.GetConsensus().powLimit).GetHex());
          +  -  +  -  +  
                      - ]
     471   [ +  -  +  -  :           4 :     obj.pushKV("networkhashps",    getnetworkhashps().HandleRequest(request));
             +  -  +  - ]
     472   [ +  -  +  -  :           4 :     obj.pushKV("pooledtx",         (uint64_t)mempool.size());
             +  -  +  - ]
     473         [ +  - ]:           2 :     BlockAssembler::Options assembler_options;
     474         [ +  - ]:           2 :     ApplyArgsManOptions(*node.args, assembler_options);
     475   [ +  -  +  -  :           4 :     obj.pushKV("blockmintxfee", ValueFromAmount(assembler_options.blockMinFeeRate.GetFeePerK()));
                   +  - ]
     476   [ +  -  +  -  :           4 :     obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
             +  -  +  - ]
     477                 :             : 
     478                 :           2 :     UniValue next(UniValue::VOBJ);
     479                 :           2 :     CBlockIndex next_index;
     480         [ +  - ]:           2 :     NextEmptyBlockIndex(tip, chainman.GetConsensus(), next_index);
     481                 :             : 
     482   [ +  -  +  -  :           4 :     next.pushKV("height", next_index.nHeight);
                   +  - ]
     483   [ +  -  +  -  :           4 :     next.pushKV("bits", strprintf("%08x", next_index.nBits));
             +  -  +  - ]
     484   [ +  -  +  -  :           4 :     next.pushKV("difficulty", GetDifficulty(next_index));
             +  -  +  - ]
     485   [ +  -  +  -  :           4 :     next.pushKV("target", GetTarget(next_index, chainman.GetConsensus().powLimit).GetHex());
          +  -  +  -  +  
                      - ]
     486   [ +  -  +  -  :           4 :     obj.pushKV("next", next);
                   +  - ]
     487                 :             : 
     488         [ -  + ]:           2 :     if (chainman.GetParams().GetChainType() == ChainType::SIGNET) {
     489         [ #  # ]:           0 :         const std::vector<uint8_t>& signet_challenge =
     490                 :           0 :             chainman.GetConsensus().signet_challenge;
     491   [ #  #  #  #  :           0 :         obj.pushKV("signet_challenge", HexStr(signet_challenge));
          #  #  #  #  #  
                      # ]
     492                 :             :     }
     493   [ +  -  +  -  :           4 :     obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
          +  -  +  -  +  
                -  +  - ]
     494                 :           4 :     return obj;
     495         [ +  - ]:           4 : },
     496   [ +  -  +  - ]:         248 :     };
     497   [ +  -  +  -  :        1116 : }
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  -  -  
          +  -  +  -  -  
                -  -  - ]
     498                 :             : 
     499                 :             : 
     500                 :             : // NOTE: Unlike wallet RPC (which use BTC values), mining RPCs follow GBT (BIP 22) in using satoshi amounts
     501                 :          82 : static RPCHelpMan prioritisetransaction()
     502                 :             : {
     503                 :          82 :     return RPCHelpMan{"prioritisetransaction",
     504         [ +  - ]:         164 :                 "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
     505                 :             :                 {
     506   [ +  -  +  - ]:         164 :                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
     507   [ +  -  +  - ]:         164 :                     {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "API-Compatibility for previous API. Must be zero or null.\n"
     508                 :             :             "                  DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
     509   [ +  -  +  - ]:         164 :                     {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO, "The fee value (in satoshis) to add (or subtract, if negative).\n"
     510                 :             :             "                  Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
     511                 :             :             "                  The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
     512                 :             :             "                  considers the transaction as it would have paid a higher (or lower) fee."},
     513                 :             :                 },
     514         [ +  - ]:         164 :                 RPCResult{
     515   [ +  -  +  -  :         164 :                     RPCResult::Type::BOOL, "", "Returns true"},
                   +  - ]
     516                 :          82 :                 RPCExamples{
     517   [ +  -  +  -  :         164 :                     HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000")
                   +  - ]
     518   [ +  -  +  -  :         328 :             + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")
             +  -  +  - ]
     519         [ +  - ]:          82 :                 },
     520                 :          82 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     521                 :             : {
     522                 :          26 :     LOCK(cs_main);
     523                 :             : 
     524   [ +  -  +  + ]:          26 :     auto txid{Txid::FromUint256(ParseHashV(request.params[0], "txid"))};
     525         [ +  + ]:          25 :     const auto dummy{self.MaybeArg<double>("dummy")};
     526   [ +  -  +  + ]:          24 :     CAmount nAmount = request.params[2].getInt<int64_t>();
     527                 :             : 
     528   [ +  +  +  + ]:          23 :     if (dummy && *dummy != 0) {
     529   [ +  -  +  - ]:           2 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.");
     530                 :             :     }
     531                 :             : 
     532         [ +  - ]:          22 :     CTxMemPool& mempool = EnsureAnyMemPool(request.context);
     533                 :             : 
     534                 :             :     // Non-0 fee dust transactions are not allowed for entry, and modification not allowed afterwards
     535         [ +  - ]:          22 :     const auto& tx = mempool.get(txid);
     536   [ +  -  -  +  :          22 :     if (mempool.m_opts.require_standard && tx && !GetDust(*tx, mempool.m_opts.dust_relay_feerate).empty()) {
          -  -  -  -  -  
                      + ]
     537   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is not supported for transactions with dust outputs.");
     538                 :             :     }
     539                 :             : 
     540         [ +  - ]:          22 :     mempool.PrioritiseTransaction(txid, nAmount);
     541         [ +  - ]:          22 :     return true;
     542         [ +  - ]:          44 : },
     543   [ +  -  +  -  :         574 :     };
             +  +  -  - ]
     544   [ +  -  +  -  :         492 : }
             +  -  -  - ]
     545                 :             : 
     546                 :          83 : static RPCHelpMan getprioritisedtransactions()
     547                 :             : {
     548                 :          83 :     return RPCHelpMan{"getprioritisedtransactions",
     549         [ +  - ]:         166 :         "Returns a map of all user-created (see prioritisetransaction) fee deltas by txid, and whether the tx is present in mempool.",
     550                 :             :         {},
     551         [ +  - ]:         166 :         RPCResult{
     552         [ +  - ]:         166 :             RPCResult::Type::OBJ_DYN, "", "prioritisation keyed by txid",
     553                 :             :             {
     554   [ +  -  +  - ]:         166 :                 {RPCResult::Type::OBJ, "<transactionid>", "", {
     555   [ +  -  +  - ]:         166 :                     {RPCResult::Type::NUM, "fee_delta", "transaction fee delta in satoshis"},
     556   [ +  -  +  - ]:         166 :                     {RPCResult::Type::BOOL, "in_mempool", "whether this transaction is currently in mempool"},
     557   [ +  -  +  - ]:         166 :                     {RPCResult::Type::NUM, "modified_fee", /*optional=*/true, "modified fee in satoshis. Only returned if in_mempool=true"},
     558                 :             :                 }}
     559                 :             :             },
     560   [ +  -  +  -  :         747 :         },
          +  -  +  +  +  
             +  -  -  -  
                      - ]
     561                 :          83 :         RPCExamples{
     562   [ +  -  +  -  :         166 :             HelpExampleCli("getprioritisedtransactions", "")
                   +  - ]
     563   [ +  -  +  -  :         332 :             + HelpExampleRpc("getprioritisedtransactions", "")
             +  -  +  - ]
     564         [ +  - ]:          83 :         },
     565                 :          83 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     566                 :             :         {
     567                 :          12 :             NodeContext& node = EnsureAnyNodeContext(request.context);
     568                 :          12 :             CTxMemPool& mempool = EnsureMemPool(node);
     569                 :          12 :             UniValue rpc_result{UniValue::VOBJ};
     570   [ +  -  +  + ]:          69 :             for (const auto& delta_info : mempool.GetPrioritisedTransactions()) {
     571                 :          57 :                 UniValue result_inner{UniValue::VOBJ};
     572   [ +  -  +  -  :         114 :                 result_inner.pushKV("fee_delta", delta_info.delta);
                   +  - ]
     573   [ +  -  +  -  :         114 :                 result_inner.pushKV("in_mempool", delta_info.in_mempool);
                   +  - ]
     574         [ -  + ]:          57 :                 if (delta_info.in_mempool) {
     575   [ #  #  #  #  :           0 :                     result_inner.pushKV("modified_fee", *delta_info.modified_fee);
                   #  # ]
     576                 :             :                 }
     577   [ +  -  +  - ]:         114 :                 rpc_result.pushKV(delta_info.txid.GetHex(), std::move(result_inner));
     578                 :          57 :             }
     579                 :          12 :             return rpc_result;
     580                 :           0 :         },
     581   [ +  -  +  - ]:         332 :     };
     582   [ +  -  +  -  :         332 : }
          +  -  +  -  -  
                      - ]
     583                 :             : 
     584                 :             : 
     585                 :             : // NOTE: Assumes a conclusive result; if result is inconclusive, it must be handled by caller
     586                 :          45 : static UniValue BIP22ValidationResult(const BlockValidationState& state)
     587                 :             : {
     588         [ -  + ]:          45 :     if (state.IsValid())
     589                 :           0 :         return UniValue::VNULL;
     590                 :             : 
     591         [ -  + ]:          45 :     if (state.IsError())
     592   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
     593         [ +  - ]:          45 :     if (state.IsInvalid())
     594                 :             :     {
     595         [ -  + ]:          45 :         std::string strRejectReason = state.GetRejectReason();
     596         [ -  + ]:          45 :         if (strRejectReason.empty())
     597         [ #  # ]:           0 :             return "rejected";
     598         [ +  - ]:          45 :         return strRejectReason;
     599                 :          45 :     }
     600                 :             :     // Should be impossible
     601                 :           0 :     return "valid?";
     602                 :             : }
     603                 :             : 
     604                 :             : // Prefix rule name with ! if not optional, see BIP9
     605                 :           0 : static std::string gbt_rule_value(const std::string& name, bool gbt_optional_rule)
     606                 :             : {
     607         [ #  # ]:           0 :     std::string s{name};
     608         [ #  # ]:           0 :     if (!gbt_optional_rule) {
     609         [ #  # ]:           0 :         s.insert(s.begin(), '!');
     610                 :             :     }
     611                 :           0 :     return s;
     612                 :           0 : }
     613                 :             : 
     614                 :          58 : static RPCHelpMan getblocktemplate()
     615                 :             : {
     616                 :          58 :     return RPCHelpMan{
     617                 :          58 :         "getblocktemplate",
     618         [ +  - ]:         116 :         "If the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
     619                 :             :         "It returns data needed to construct a block to work on.\n"
     620                 :             :         "For full specification, see BIPs 22, 23, 9, and 145:\n"
     621                 :             :         "    https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
     622                 :             :         "    https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
     623                 :             :         "    https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
     624                 :             :         "    https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n",
     625                 :             :         {
     626   [ +  -  +  - ]:         116 :             {"template_request", RPCArg::Type::OBJ, RPCArg::Optional::NO, "Format of the template",
     627                 :             :             {
     628   [ +  -  +  - ]:         116 :                 {"mode", RPCArg::Type::STR, /* treat as named arg */ RPCArg::Optional::OMITTED, "This must be set to \"template\", \"proposal\" (see BIP 23), or omitted"},
     629   [ +  -  +  - ]:         116 :                 {"capabilities", RPCArg::Type::ARR, /* treat as named arg */ RPCArg::Optional::OMITTED, "A list of strings",
     630                 :             :                 {
     631   [ +  -  +  - ]:         116 :                     {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "client side supported feature, 'longpoll', 'coinbasevalue', 'proposal', 'serverlist', 'workid'"},
     632                 :             :                 }},
     633   [ +  -  +  - ]:         116 :                 {"rules", RPCArg::Type::ARR, RPCArg::Optional::NO, "A list of strings",
     634                 :             :                 {
     635   [ +  -  +  - ]:         116 :                     {"segwit", RPCArg::Type::STR, RPCArg::Optional::NO, "(literal) indicates client side segwit support"},
     636   [ +  -  +  - ]:         116 :                     {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "other client side supported softfork deployment"},
     637                 :             :                 }},
     638   [ +  -  +  - ]:         116 :                 {"longpollid", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "delay processing request until the result would vary significantly from the \"longpollid\" of a prior template"},
     639   [ +  -  +  - ]:         116 :                 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "proposed block data to check, encoded in hexadecimal; valid only for mode=\"proposal\""},
     640                 :             :             },
     641                 :             :             },
     642                 :             :         },
     643                 :             :         {
     644   [ +  -  +  -  :         116 :             RPCResult{"If the proposal was accepted with mode=='proposal'", RPCResult::Type::NONE, "", ""},
                   +  - ]
     645   [ +  -  +  -  :         116 :             RPCResult{"If the proposal was not accepted with mode=='proposal'", RPCResult::Type::STR, "", "According to BIP22"},
                   +  - ]
     646   [ +  -  +  -  :         116 :             RPCResult{"Otherwise", RPCResult::Type::OBJ, "", "",
                   +  - ]
     647                 :             :             {
     648   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "version", "The preferred block version"},
     649   [ +  -  +  - ]:         116 :                 {RPCResult::Type::ARR, "rules", "specific block rules that are to be enforced",
     650                 :             :                 {
     651   [ +  -  +  - ]:         116 :                     {RPCResult::Type::STR, "", "name of a rule the client must understand to some extent; see BIP 9 for format"},
     652                 :             :                 }},
     653   [ +  -  +  - ]:         116 :                 {RPCResult::Type::OBJ_DYN, "vbavailable", "set of pending, supported versionbit (BIP 9) softfork deployments",
     654                 :             :                 {
     655   [ +  -  +  - ]:         116 :                     {RPCResult::Type::NUM, "rulename", "identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
     656                 :             :                 }},
     657   [ +  -  +  - ]:         116 :                 {RPCResult::Type::ARR, "capabilities", "",
     658                 :             :                 {
     659   [ +  -  +  - ]:         116 :                     {RPCResult::Type::STR, "value", "A supported feature, for example 'proposal'"},
     660                 :             :                 }},
     661   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "vbrequired", "bit mask of versionbits the server requires set in submissions"},
     662   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR, "previousblockhash", "The hash of current highest block"},
     663   [ +  -  +  - ]:         116 :                 {RPCResult::Type::ARR, "transactions", "contents of non-coinbase transactions that should be included in the next block",
     664                 :             :                 {
     665   [ +  -  +  - ]:         116 :                     {RPCResult::Type::OBJ, "", "",
     666                 :             :                     {
     667   [ +  -  +  - ]:         116 :                         {RPCResult::Type::STR_HEX, "data", "transaction data encoded in hexadecimal (byte-for-byte)"},
     668   [ +  -  +  - ]:         116 :                         {RPCResult::Type::STR_HEX, "txid", "transaction hash excluding witness data, shown in byte-reversed hex"},
     669   [ +  -  +  - ]:         116 :                         {RPCResult::Type::STR_HEX, "hash", "transaction hash including witness data, shown in byte-reversed hex"},
     670   [ +  -  +  - ]:         116 :                         {RPCResult::Type::ARR, "depends", "array of numbers",
     671                 :             :                         {
     672   [ +  -  +  - ]:         116 :                             {RPCResult::Type::NUM, "", "transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is"},
     673                 :             :                         }},
     674   [ +  -  +  - ]:         116 :                         {RPCResult::Type::NUM, "fee", "difference in value between transaction inputs and outputs (in satoshis); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one"},
     675   [ +  -  +  - ]:         116 :                         {RPCResult::Type::NUM, "sigops", "total SigOps cost, as counted for purposes of block limits; if key is not present, sigop cost is unknown and clients MUST NOT assume it is zero"},
     676   [ +  -  +  - ]:         116 :                         {RPCResult::Type::NUM, "weight", "total transaction weight, as counted for purposes of block limits"},
     677                 :             :                     }},
     678                 :             :                 }},
     679   [ +  -  +  - ]:         116 :                 {RPCResult::Type::OBJ_DYN, "coinbaseaux", "data that should be included in the coinbase's scriptSig content",
     680                 :             :                 {
     681   [ +  -  +  - ]:         116 :                     {RPCResult::Type::STR_HEX, "key", "values must be in the coinbase (keys may be ignored)"},
     682                 :             :                 }},
     683   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "coinbasevalue", "maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
     684   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR, "longpollid", "an id to include with a request to longpoll on an update to this template"},
     685   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR, "target", "The hash target"},
     686   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM_TIME, "mintime", "The minimum timestamp appropriate for the next block time, expressed in " + UNIX_EPOCH_TIME + ". Adjusted for the proposed BIP94 timewarp rule."},
     687   [ +  -  +  - ]:         116 :                 {RPCResult::Type::ARR, "mutable", "list of ways the block template may be changed",
     688                 :             :                 {
     689   [ +  -  +  - ]:         116 :                     {RPCResult::Type::STR, "value", "A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
     690                 :             :                 }},
     691   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR_HEX, "noncerange", "A range of valid nonces"},
     692   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "sigoplimit", "limit of sigops in blocks"},
     693   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
     694   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "weightlimit", /*optional=*/true, "limit of block weight"},
     695   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM_TIME, "curtime", "current timestamp in " + UNIX_EPOCH_TIME + ". Adjusted for the proposed BIP94 timewarp rule."},
     696   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR, "bits", "compressed target of next block"},
     697   [ +  -  +  - ]:         116 :                 {RPCResult::Type::NUM, "height", "The height of the next block"},
     698   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR_HEX, "signet_challenge", /*optional=*/true, "Only on signet"},
     699   [ +  -  +  - ]:         116 :                 {RPCResult::Type::STR_HEX, "default_witness_commitment", /*optional=*/true, "a valid witness commitment for the unmodified block template"},
     700   [ +  -  +  -  :        4234 :             }},
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
             -  -  -  -  
                      - ]
     701                 :             :         },
     702                 :          58 :         RPCExamples{
     703   [ +  -  +  -  :         116 :                     HelpExampleCli("getblocktemplate", "'{\"rules\": [\"segwit\"]}'")
                   +  - ]
     704   [ +  -  +  -  :         232 :             + HelpExampleRpc("getblocktemplate", "{\"rules\": [\"segwit\"]}")
                   +  - ]
     705         [ +  - ]:          58 :                 },
     706                 :          58 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
     707                 :             : {
     708                 :           1 :     NodeContext& node = EnsureAnyNodeContext(request.context);
     709                 :           1 :     ChainstateManager& chainman = EnsureChainman(node);
     710                 :           1 :     Mining& miner = EnsureMining(node);
     711                 :             : 
     712                 :           0 :     std::string strMode = "template";
     713         [ #  # ]:           0 :     UniValue lpval = NullUniValue;
     714         [ #  # ]:           0 :     std::set<std::string> setClientRules;
     715   [ #  #  #  # ]:           0 :     if (!request.params[0].isNull())
     716                 :             :     {
     717   [ #  #  #  # ]:           0 :         const UniValue& oparam = request.params[0].get_obj();
     718         [ #  # ]:           0 :         const UniValue& modeval = oparam.find_value("mode");
     719         [ #  # ]:           0 :         if (modeval.isStr())
     720   [ #  #  #  # ]:           0 :             strMode = modeval.get_str();
     721         [ #  # ]:           0 :         else if (modeval.isNull())
     722                 :             :         {
     723                 :             :             /* Do nothing */
     724                 :             :         }
     725                 :             :         else
     726   [ #  #  #  # ]:           0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
     727   [ #  #  #  # ]:           0 :         lpval = oparam.find_value("longpollid");
     728                 :             : 
     729         [ #  # ]:           0 :         if (strMode == "proposal")
     730                 :             :         {
     731         [ #  # ]:           0 :             const UniValue& dataval = oparam.find_value("data");
     732         [ #  # ]:           0 :             if (!dataval.isStr())
     733   [ #  #  #  # ]:           0 :                 throw JSONRPCError(RPC_TYPE_ERROR, "Missing data String key for proposal");
     734                 :             : 
     735                 :           0 :             CBlock block;
     736   [ #  #  #  #  :           0 :             if (!DecodeHexBlk(block, dataval.get_str()))
                   #  # ]
     737   [ #  #  #  # ]:           0 :                 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
     738                 :             : 
     739         [ #  # ]:           0 :             uint256 hash = block.GetHash();
     740         [ #  # ]:           0 :             LOCK(cs_main);
     741         [ #  # ]:           0 :             const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
     742         [ #  # ]:           0 :             if (pindex) {
     743   [ #  #  #  # ]:           0 :                 if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
     744         [ #  # ]:           0 :                     return "duplicate";
     745         [ #  # ]:           0 :                 if (pindex->nStatus & BLOCK_FAILED_MASK)
     746         [ #  # ]:           0 :                     return "duplicate-invalid";
     747         [ #  # ]:           0 :                 return "duplicate-inconclusive";
     748                 :             :             }
     749                 :             : 
     750   [ #  #  #  #  :           0 :             return BIP22ValidationResult(TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/true));
                   #  # ]
     751                 :           0 :         }
     752                 :             : 
     753         [ #  # ]:           0 :         const UniValue& aClientRules = oparam.find_value("rules");
     754         [ #  # ]:           0 :         if (aClientRules.isArray()) {
     755   [ #  #  #  # ]:           0 :             for (unsigned int i = 0; i < aClientRules.size(); ++i) {
     756         [ #  # ]:           0 :                 const UniValue& v = aClientRules[i];
     757   [ #  #  #  # ]:           0 :                 setClientRules.insert(v.get_str());
     758                 :             :             }
     759                 :             :         }
     760                 :             :     }
     761                 :             : 
     762         [ #  # ]:           0 :     if (strMode != "template")
     763   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
     764                 :             : 
     765   [ #  #  #  # ]:           0 :     if (!miner.isTestChain()) {
     766         [ #  # ]:           0 :         const CConnman& connman = EnsureConnman(node);
     767   [ #  #  #  # ]:           0 :         if (connman.GetNodeCount(ConnectionDirection::Both) == 0) {
     768   [ #  #  #  # ]:           0 :             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, CLIENT_NAME " is not connected!");
     769                 :             :         }
     770                 :             : 
     771   [ #  #  #  # ]:           0 :         if (miner.isInitialBlockDownload()) {
     772   [ #  #  #  # ]:           0 :             throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, CLIENT_NAME " is in initial sync and waiting for blocks...");
     773                 :             :         }
     774                 :             :     }
     775                 :             : 
     776                 :           0 :     static unsigned int nTransactionsUpdatedLast;
     777         [ #  # ]:           0 :     const CTxMemPool& mempool = EnsureMemPool(node);
     778                 :             : 
     779         [ #  # ]:           0 :     WAIT_LOCK(cs_main, cs_main_lock);
     780   [ #  #  #  #  :           0 :     uint256 tip{CHECK_NONFATAL(miner.getTip()).value().hash};
                   #  # ]
     781                 :             : 
     782                 :             :     // Long Polling (BIP22)
     783         [ #  # ]:           0 :     if (!lpval.isNull()) {
     784                 :             :         /**
     785                 :             :          * Wait to respond until either the best block changes, OR there are more
     786                 :             :          * transactions.
     787                 :             :          *
     788                 :             :          * The check for new transactions first happens after 1 minute and
     789                 :             :          * subsequently every 10 seconds. BIP22 does not require this particular interval.
     790                 :             :          * On mainnet the mempool changes frequently enough that in practice this RPC
     791                 :             :          * returns after 60 seconds, or sooner if the best block changes.
     792                 :             :          *
     793                 :             :          * getblocktemplate is unlikely to be called by bitcoin-cli, so
     794                 :             :          * -rpcclienttimeout is not a concern. BIP22 recommends a long request timeout.
     795                 :             :          *
     796                 :             :          * The longpollid is assumed to be a tip hash if it has the right format.
     797                 :             :          */
     798                 :           0 :         uint256 hashWatchedChain;
     799                 :           0 :         unsigned int nTransactionsUpdatedLastLP;
     800                 :             : 
     801         [ #  # ]:           0 :         if (lpval.isStr())
     802                 :             :         {
     803                 :             :             // Format: <hashBestChain><nTransactionsUpdatedLast>
     804         [ #  # ]:           0 :             const std::string& lpstr = lpval.get_str();
     805                 :             : 
     806                 :             :             // Assume the longpollid is a block hash. If it's not then we return
     807                 :             :             // early below.
     808   [ #  #  #  #  :           0 :             hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
                   #  # ]
     809   [ #  #  #  # ]:           0 :             nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
     810                 :             :         }
     811                 :             :         else
     812                 :             :         {
     813                 :             :             // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
     814                 :           0 :             hashWatchedChain = tip;
     815                 :           0 :             nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
     816                 :             :         }
     817                 :             : 
     818                 :             :         // Release lock while waiting
     819                 :           0 :         {
     820         [ #  # ]:           0 :             REVERSE_LOCK(cs_main_lock, cs_main);
     821                 :           0 :             MillisecondsDouble checktxtime{std::chrono::minutes(1)};
     822   [ #  #  #  # ]:           0 :             while (IsRPCRunning()) {
     823                 :             :                 // If hashWatchedChain is not a real block hash, this will
     824                 :             :                 // return immediately.
     825         [ #  # ]:           0 :                 std::optional<BlockRef> maybe_tip{miner.waitTipChanged(hashWatchedChain, checktxtime)};
     826                 :             :                 // Node is shutting down
     827         [ #  # ]:           0 :                 if (!maybe_tip) break;
     828         [ #  # ]:           0 :                 tip = maybe_tip->hash;
     829         [ #  # ]:           0 :                 if (tip != hashWatchedChain) break;
     830                 :             : 
     831                 :             :                 // Check transactions for update without holding the mempool
     832                 :             :                 // lock to avoid deadlocks.
     833   [ #  #  #  # ]:           0 :                 if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP) {
     834                 :             :                     break;
     835                 :             :                 }
     836                 :           0 :                 checktxtime = std::chrono::seconds(10);
     837                 :             :             }
     838                 :           0 :         }
     839   [ #  #  #  #  :           0 :         tip = CHECK_NONFATAL(miner.getTip()).value().hash;
                   #  # ]
     840                 :             : 
     841   [ #  #  #  # ]:           0 :         if (!IsRPCRunning())
     842   [ #  #  #  # ]:           0 :             throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
     843                 :             :         // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
     844                 :             :     }
     845                 :             : 
     846         [ #  # ]:           0 :     const Consensus::Params& consensusParams = chainman.GetParams().GetConsensus();
     847                 :             : 
     848                 :             :     // GBT must be called with 'signet' set in the rules for signet chains
     849   [ #  #  #  #  :           0 :     if (consensusParams.signet_blocks && setClientRules.count("signet") != 1) {
             #  #  #  # ]
     850   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the signet rule set (call with {\"rules\": [\"segwit\", \"signet\"]})");
     851                 :             :     }
     852                 :             : 
     853                 :             :     // GBT must be called with 'segwit' set in the rules
     854   [ #  #  #  # ]:           0 :     if (setClientRules.count("segwit") != 1) {
     855   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
     856                 :             :     }
     857                 :             : 
     858                 :             :     // Update block
     859                 :           0 :     static CBlockIndex* pindexPrev;
     860                 :           0 :     static int64_t time_start;
     861   [ -  -  -  - ]:          25 :     static std::unique_ptr<BlockTemplate> block_template;
     862   [ #  #  #  # ]:           0 :     if (!pindexPrev || pindexPrev->GetBlockHash() != tip ||
     863   [ #  #  #  #  :           0 :         (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - time_start > 5))
             #  #  #  # ]
     864                 :             :     {
     865                 :             :         // Clear pindexPrev so future calls make a new block, despite any failures from here on
     866                 :           0 :         pindexPrev = nullptr;
     867                 :             : 
     868                 :             :         // Store the pindexBest used before createNewBlock, to avoid races
     869         [ #  # ]:           0 :         nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
     870         [ #  # ]:           0 :         CBlockIndex* pindexPrevNew = chainman.m_blockman.LookupBlockIndex(tip);
     871         [ #  # ]:           0 :         time_start = GetTime();
     872                 :             : 
     873                 :             :         // Create new block
     874                 :           0 :         block_template = miner.createNewBlock();
     875         [ #  # ]:           0 :         CHECK_NONFATAL(block_template);
     876                 :             : 
     877                 :             : 
     878                 :             :         // Need to update only after we know createNewBlock succeeded
     879                 :           0 :         pindexPrev = pindexPrevNew;
     880                 :             :     }
     881         [ #  # ]:           0 :     CHECK_NONFATAL(pindexPrev);
     882         [ #  # ]:           0 :     CBlock block{block_template->getBlock()};
     883                 :             : 
     884                 :             :     // Update nTime
     885         [ #  # ]:           0 :     UpdateTime(&block, consensusParams, pindexPrev);
     886                 :           0 :     block.nNonce = 0;
     887                 :             : 
     888                 :             :     // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
     889                 :           0 :     const bool fPreSegWit = !DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT);
     890                 :             : 
     891   [ #  #  #  # ]:           0 :     UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
     892                 :             : 
     893                 :           0 :     UniValue transactions(UniValue::VARR);
     894         [ #  # ]:           0 :     std::map<Txid, int64_t> setTxIndex;
     895         [ #  # ]:           0 :     std::vector<CAmount> tx_fees{block_template->getTxFees()};
     896         [ #  # ]:           0 :     std::vector<CAmount> tx_sigops{block_template->getTxSigops()};
     897                 :             : 
     898                 :           0 :     int i = 0;
     899         [ #  # ]:           0 :     for (const auto& it : block.vtx) {
     900         [ #  # ]:           0 :         const CTransaction& tx = *it;
     901                 :           0 :         Txid txHash = tx.GetHash();
     902         [ #  # ]:           0 :         setTxIndex[txHash] = i++;
     903                 :             : 
     904         [ #  # ]:           0 :         if (tx.IsCoinBase())
     905                 :           0 :             continue;
     906                 :             : 
     907                 :           0 :         UniValue entry(UniValue::VOBJ);
     908                 :             : 
     909   [ #  #  #  #  :           0 :         entry.pushKV("data", EncodeHexTx(tx));
             #  #  #  # ]
     910   [ #  #  #  #  :           0 :         entry.pushKV("txid", txHash.GetHex());
             #  #  #  # ]
     911   [ #  #  #  #  :           0 :         entry.pushKV("hash", tx.GetWitnessHash().GetHex());
             #  #  #  # ]
     912                 :             : 
     913                 :           0 :         UniValue deps(UniValue::VARR);
     914         [ #  # ]:           0 :         for (const CTxIn &in : tx.vin)
     915                 :             :         {
     916         [ #  # ]:           0 :             if (setTxIndex.count(in.prevout.hash))
     917   [ #  #  #  #  :           0 :                 deps.push_back(setTxIndex[in.prevout.hash]);
                   #  # ]
     918                 :             :         }
     919   [ #  #  #  # ]:           0 :         entry.pushKV("depends", std::move(deps));
     920                 :             : 
     921                 :           0 :         int index_in_template = i - 2;
     922   [ #  #  #  #  :           0 :         entry.pushKV("fee", tx_fees.at(index_in_template));
             #  #  #  # ]
     923         [ #  # ]:           0 :         int64_t nTxSigOps{tx_sigops.at(index_in_template)};
     924         [ #  # ]:           0 :         if (fPreSegWit) {
     925         [ #  # ]:           0 :             CHECK_NONFATAL(nTxSigOps % WITNESS_SCALE_FACTOR == 0);
     926                 :           0 :             nTxSigOps /= WITNESS_SCALE_FACTOR;
     927                 :             :         }
     928   [ #  #  #  #  :           0 :         entry.pushKV("sigops", nTxSigOps);
                   #  # ]
     929   [ #  #  #  #  :           0 :         entry.pushKV("weight", GetTransactionWeight(tx));
                   #  # ]
     930                 :             : 
     931         [ #  # ]:           0 :         transactions.push_back(std::move(entry));
     932                 :           0 :     }
     933                 :             : 
     934                 :           0 :     UniValue aux(UniValue::VOBJ);
     935                 :             : 
     936         [ #  # ]:           0 :     arith_uint256 hashTarget = arith_uint256().SetCompact(block.nBits);
     937                 :             : 
     938                 :           0 :     UniValue aMutable(UniValue::VARR);
     939   [ #  #  #  # ]:           0 :     aMutable.push_back("time");
     940   [ #  #  #  # ]:           0 :     aMutable.push_back("transactions");
     941   [ #  #  #  # ]:           0 :     aMutable.push_back("prevblock");
     942                 :             : 
     943                 :           0 :     UniValue result(UniValue::VOBJ);
     944   [ #  #  #  # ]:           0 :     result.pushKV("capabilities", std::move(aCaps));
     945                 :             : 
     946                 :           0 :     UniValue aRules(UniValue::VARR);
     947   [ #  #  #  # ]:           0 :     aRules.push_back("csv");
     948   [ #  #  #  #  :           0 :     if (!fPreSegWit) aRules.push_back("!segwit");
                   #  # ]
     949         [ #  # ]:           0 :     if (consensusParams.signet_blocks) {
     950                 :             :         // indicate to miner that they must understand signet rules
     951                 :             :         // when attempting to mine with this template
     952   [ #  #  #  # ]:           0 :         aRules.push_back("!signet");
     953                 :             :     }
     954                 :             : 
     955                 :           0 :     UniValue vbavailable(UniValue::VOBJ);
     956         [ #  # ]:           0 :     const auto gbtstatus = chainman.m_versionbitscache.GBTStatus(*pindexPrev, consensusParams);
     957                 :             : 
     958   [ #  #  #  # ]:           0 :     for (const auto& [name, info] : gbtstatus.signalling) {
     959   [ #  #  #  #  :           0 :         vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
                   #  # ]
     960   [ #  #  #  # ]:           0 :         if (!info.gbt_optional_rule && !setClientRules.count(name)) {
     961                 :             :             // If the client doesn't support this, don't indicate it in the [default] version
     962                 :           0 :             block.nVersion &= ~info.mask;
     963                 :             :         }
     964                 :             :     }
     965                 :             : 
     966   [ #  #  #  # ]:           0 :     for (const auto& [name, info] : gbtstatus.locked_in) {
     967                 :           0 :         block.nVersion |= info.mask;
     968   [ #  #  #  #  :           0 :         vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
                   #  # ]
     969   [ #  #  #  # ]:           0 :         if (!info.gbt_optional_rule && !setClientRules.count(name)) {
     970                 :             :             // If the client doesn't support this, don't indicate it in the [default] version
     971                 :           0 :             block.nVersion &= ~info.mask;
     972                 :             :         }
     973                 :             :     }
     974                 :             : 
     975   [ #  #  #  # ]:           0 :     for (const auto& [name, info] : gbtstatus.active) {
     976   [ #  #  #  #  :           0 :         aRules.push_back(gbt_rule_value(name, info.gbt_optional_rule));
                   #  # ]
     977   [ #  #  #  # ]:           0 :         if (!info.gbt_optional_rule && !setClientRules.count(name)) {
     978                 :             :             // Not supported by the client; make sure it's safe to proceed
     979   [ #  #  #  # ]:           0 :             throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", name));
     980                 :             :         }
     981                 :             :     }
     982                 :             : 
     983   [ #  #  #  #  :           0 :     result.pushKV("version", block.nVersion);
                   #  # ]
     984   [ #  #  #  # ]:           0 :     result.pushKV("rules", std::move(aRules));
     985   [ #  #  #  # ]:           0 :     result.pushKV("vbavailable", std::move(vbavailable));
     986   [ #  #  #  #  :           0 :     result.pushKV("vbrequired", int(0));
                   #  # ]
     987                 :             : 
     988   [ #  #  #  #  :           0 :     result.pushKV("previousblockhash", block.hashPrevBlock.GetHex());
             #  #  #  # ]
     989   [ #  #  #  # ]:           0 :     result.pushKV("transactions", std::move(transactions));
     990   [ #  #  #  # ]:           0 :     result.pushKV("coinbaseaux", std::move(aux));
     991   [ #  #  #  #  :           0 :     result.pushKV("coinbasevalue", (int64_t)block.vtx[0]->vout[0].nValue);
                   #  # ]
     992   [ #  #  #  #  :           0 :     result.pushKV("longpollid", tip.GetHex() + ToString(nTransactionsUpdatedLast));
          #  #  #  #  #  
                #  #  # ]
     993   [ #  #  #  #  :           0 :     result.pushKV("target", hashTarget.GetHex());
             #  #  #  # ]
     994   [ #  #  #  #  :           0 :     result.pushKV("mintime", GetMinimumTime(pindexPrev, consensusParams.DifficultyAdjustmentInterval()));
             #  #  #  # ]
     995   [ #  #  #  # ]:           0 :     result.pushKV("mutable", std::move(aMutable));
     996   [ #  #  #  #  :           0 :     result.pushKV("noncerange", "00000000ffffffff");
                   #  # ]
     997                 :           0 :     int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
     998                 :           0 :     int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
     999         [ #  # ]:           0 :     if (fPreSegWit) {
    1000         [ #  # ]:           0 :         CHECK_NONFATAL(nSigOpLimit % WITNESS_SCALE_FACTOR == 0);
    1001                 :           0 :         nSigOpLimit /= WITNESS_SCALE_FACTOR;
    1002         [ #  # ]:           0 :         CHECK_NONFATAL(nSizeLimit % WITNESS_SCALE_FACTOR == 0);
    1003                 :           0 :         nSizeLimit /= WITNESS_SCALE_FACTOR;
    1004                 :             :     }
    1005   [ #  #  #  #  :           0 :     result.pushKV("sigoplimit", nSigOpLimit);
                   #  # ]
    1006   [ #  #  #  #  :           0 :     result.pushKV("sizelimit", nSizeLimit);
                   #  # ]
    1007         [ #  # ]:           0 :     if (!fPreSegWit) {
    1008   [ #  #  #  #  :           0 :         result.pushKV("weightlimit", (int64_t)MAX_BLOCK_WEIGHT);
                   #  # ]
    1009                 :             :     }
    1010   [ #  #  #  #  :           0 :     result.pushKV("curtime", block.GetBlockTime());
                   #  # ]
    1011   [ #  #  #  #  :           0 :     result.pushKV("bits", strprintf("%08x", block.nBits));
             #  #  #  # ]
    1012   [ #  #  #  #  :           0 :     result.pushKV("height", (int64_t)(pindexPrev->nHeight+1));
                   #  # ]
    1013                 :             : 
    1014         [ #  # ]:           0 :     if (consensusParams.signet_blocks) {
    1015   [ #  #  #  #  :           0 :         result.pushKV("signet_challenge", HexStr(consensusParams.signet_challenge));
          #  #  #  #  #  
                      # ]
    1016                 :             :     }
    1017                 :             : 
    1018   [ #  #  #  # ]:           0 :     if (!block_template->getCoinbaseCommitment().empty()) {
    1019   [ #  #  #  #  :           0 :         result.pushKV("default_witness_commitment", HexStr(block_template->getCoinbaseCommitment()));
          #  #  #  #  #  
                      # ]
    1020                 :             :     }
    1021                 :             : 
    1022                 :           0 :     return result;
    1023   [ #  #  #  #  :           0 : },
                   #  # ]
    1024   [ +  -  +  -  :        1450 :     };
          +  -  +  -  +  
          -  +  -  +  -  
          +  +  +  +  +  
          +  +  +  +  +  
          -  -  -  -  -  
             -  -  -  -  
                      - ]
    1025   [ +  -  +  -  :        3306 : }
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  -  -  -  
          -  -  -  -  -  
                   -  - ]
    1026                 :             : 
    1027                 :             : class submitblock_StateCatcher final : public CValidationInterface
    1028                 :             : {
    1029                 :             : public:
    1030                 :             :     uint256 hash;
    1031                 :             :     bool found{false};
    1032                 :             :     BlockValidationState state;
    1033                 :             : 
    1034                 :          45 :     explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), state() {}
    1035                 :             : 
    1036                 :             : protected:
    1037                 :          45 :     void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& stateIn) override
    1038                 :             :     {
    1039         [ +  - ]:          45 :         if (block->GetHash() != hash) return;
    1040                 :          45 :         found = true;
    1041                 :          45 :         state = stateIn;
    1042                 :             :     }
    1043                 :             : };
    1044                 :             : 
    1045                 :         107 : static RPCHelpMan submitblock()
    1046                 :             : {
    1047                 :             :     // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
    1048                 :         107 :     return RPCHelpMan{
    1049                 :         107 :         "submitblock",
    1050         [ +  - ]:         214 :         "Attempts to submit new block to network.\n"
    1051                 :             :         "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
    1052                 :             :         {
    1053   [ +  -  +  - ]:         214 :             {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
    1054   [ +  -  +  -  :         321 :             {"dummy", RPCArg::Type::STR, RPCArg::DefaultHint{"ignored"}, "dummy value, for compatibility with BIP22. This value is ignored."},
                   +  - ]
    1055                 :             :         },
    1056                 :             :         {
    1057   [ +  -  +  -  :         214 :             RPCResult{"If the block was accepted", RPCResult::Type::NONE, "", ""},
                   +  - ]
    1058   [ +  -  +  -  :         214 :             RPCResult{"Otherwise", RPCResult::Type::STR, "", "According to BIP22"},
                   +  - ]
    1059                 :             :         },
    1060                 :         107 :         RPCExamples{
    1061   [ +  -  +  -  :         214 :                     HelpExampleCli("submitblock", "\"mydata\"")
                   +  - ]
    1062   [ +  -  +  -  :         428 :             + HelpExampleRpc("submitblock", "\"mydata\"")
                   +  - ]
    1063         [ +  - ]:         107 :                 },
    1064                 :         107 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
    1065                 :             : {
    1066                 :          50 :     std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
    1067         [ +  - ]:          50 :     CBlock& block = *blockptr;
    1068   [ +  -  +  -  :          50 :     if (!DecodeHexBlk(block, request.params[0].get_str())) {
             +  -  +  + ]
    1069   [ +  -  +  - ]:          10 :         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
    1070                 :             :     }
    1071                 :             : 
    1072         [ +  - ]:          45 :     ChainstateManager& chainman = EnsureAnyChainman(request.context);
    1073                 :          45 :     {
    1074         [ +  - ]:          45 :         LOCK(cs_main);
    1075         [ +  - ]:          45 :         const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
    1076         [ +  + ]:          45 :         if (pindex) {
    1077         [ +  - ]:          25 :             chainman.UpdateUncommittedBlockStructures(block, pindex);
    1078                 :             :         }
    1079                 :           0 :     }
    1080                 :             : 
    1081                 :          45 :     bool new_block;
    1082         [ +  - ]:          45 :     auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
    1083   [ +  -  +  -  :          90 :     CHECK_NONFATAL(chainman.m_options.signals)->RegisterSharedValidationInterface(sc);
                   +  - ]
    1084   [ +  -  +  -  :          90 :     bool accepted = chainman.ProcessNewBlock(blockptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
                   +  - ]
    1085   [ +  -  +  -  :          90 :     CHECK_NONFATAL(chainman.m_options.signals)->UnregisterSharedValidationInterface(sc);
                   +  - ]
    1086   [ +  -  -  + ]:          45 :     if (!new_block && accepted) {
    1087         [ #  # ]:           0 :         return "duplicate";
    1088                 :             :     }
    1089         [ -  + ]:          45 :     if (!sc->found) {
    1090         [ #  # ]:           0 :         return "inconclusive";
    1091                 :             :     }
    1092         [ +  - ]:          45 :     return BIP22ValidationResult(sc->state);
    1093         [ +  - ]:          90 : },
    1094   [ +  -  +  -  :        1177 :     };
          +  -  +  -  +  
          +  +  +  -  -  
                   -  - ]
    1095   [ +  -  +  -  :         642 : }
          +  -  +  -  -  
                -  -  - ]
    1096                 :             : 
    1097                 :         109 : static RPCHelpMan submitheader()
    1098                 :             : {
    1099                 :         109 :     return RPCHelpMan{
    1100                 :         109 :         "submitheader",
    1101         [ +  - ]:         218 :         "Decode the given hexdata as a header and submit it as a candidate chain tip if valid."
    1102                 :             :                 "\nThrows when the header is invalid.\n",
    1103                 :             :                 {
    1104   [ +  -  +  - ]:         218 :                     {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
    1105                 :             :                 },
    1106         [ +  - ]:         218 :                 RPCResult{
    1107   [ +  -  +  -  :         218 :                     RPCResult::Type::NONE, "", "None"},
                   +  - ]
    1108                 :         109 :                 RPCExamples{
    1109   [ +  -  +  -  :         218 :                     HelpExampleCli("submitheader", "\"aabbcc\"") +
                   +  - ]
    1110   [ +  -  +  -  :         327 :                     HelpExampleRpc("submitheader", "\"aabbcc\"")
             +  -  +  - ]
    1111         [ +  - ]:         109 :                 },
    1112                 :         109 :         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
    1113                 :             : {
    1114                 :          51 :     CBlockHeader h;
    1115         [ +  + ]:          51 :     if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
    1116   [ +  -  +  - ]:           4 :         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
    1117                 :             :     }
    1118                 :          49 :     ChainstateManager& chainman = EnsureAnyChainman(request.context);
    1119                 :          49 :     {
    1120                 :          49 :         LOCK(cs_main);
    1121   [ +  -  +  + ]:          49 :         if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
    1122   [ +  -  +  -  :           3 :             throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
                   +  - ]
    1123                 :             :         }
    1124                 :           1 :     }
    1125                 :             : 
    1126         [ +  - ]:          48 :     BlockValidationState state;
    1127         [ +  - ]:          48 :     chainman.ProcessNewBlockHeaders({{h}}, /*min_pow_checked=*/true, state);
    1128         [ +  + ]:          48 :     if (state.IsValid()) return UniValue::VNULL;
    1129         [ -  + ]:           8 :     if (state.IsError()) {
    1130   [ #  #  #  # ]:           0 :         throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
    1131                 :             :     }
    1132   [ -  +  +  - ]:          24 :     throw JSONRPCError(RPC_VERIFY_ERROR, state.GetRejectReason());
    1133                 :          40 : },
    1134   [ +  -  +  -  :         545 :     };
             +  +  -  - ]
    1135         [ +  - ]:         218 : }
    1136                 :             : 
    1137                 :          27 : void RegisterMiningRPCCommands(CRPCTable& t)
    1138                 :             : {
    1139                 :          27 :     static const CRPCCommand commands[]{
    1140         [ +  - ]:          50 :         {"mining", &getnetworkhashps},
    1141         [ +  - ]:          50 :         {"mining", &getmininginfo},
    1142         [ +  - ]:          50 :         {"mining", &prioritisetransaction},
    1143         [ +  - ]:          50 :         {"mining", &getprioritisedtransactions},
    1144         [ +  - ]:          50 :         {"mining", &getblocktemplate},
    1145         [ +  - ]:          50 :         {"mining", &submitblock},
    1146         [ +  - ]:          50 :         {"mining", &submitheader},
    1147                 :             : 
    1148         [ +  - ]:          50 :         {"hidden", &generatetoaddress},
    1149         [ +  - ]:          50 :         {"hidden", &generatetodescriptor},
    1150         [ +  - ]:          50 :         {"hidden", &generateblock},
    1151         [ +  - ]:          50 :         {"hidden", &generate},
    1152   [ +  +  +  -  :         327 :     };
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  +  -  +  -  
             +  -  -  - ]
    1153         [ +  + ]:         324 :     for (const auto& c : commands) {
    1154                 :         297 :         t.appendCommand(c.name, &c);
    1155                 :             :     }
    1156                 :          27 : }
        

Generated by: LCOV version 2.0-1