Bitcoin Core 29.99.0
P2P Digital Currency
mining.cpp
Go to the documentation of this file.
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>
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>
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>
36#include <txmempool.h>
37#include <univalue.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 <memory>
47#include <stdint.h>
48
57using util::ToString;
58
65static UniValue GetNetworkHashPS(int lookup, int height, const CChain& active_chain) {
66 if (lookup < -1 || lookup == 0) {
67 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid nblocks. Must be a positive number or -1.");
68 }
69
70 if (height < -1 || height > active_chain.Height()) {
71 throw JSONRPCError(RPC_INVALID_PARAMETER, "Block does not exist at specified height");
72 }
73
74 const CBlockIndex* pb = active_chain.Tip();
75
76 if (height >= 0) {
77 pb = active_chain[height];
78 }
79
80 if (pb == nullptr || !pb->nHeight)
81 return 0;
82
83 // If lookup is -1, then use blocks since last difficulty change.
84 if (lookup == -1)
86
87 // If lookup is larger than chain, then set it to chain length.
88 if (lookup > pb->nHeight)
89 lookup = pb->nHeight;
90
91 const CBlockIndex* pb0 = pb;
92 int64_t minTime = pb0->GetBlockTime();
93 int64_t maxTime = minTime;
94 for (int i = 0; i < lookup; i++) {
95 pb0 = pb0->pprev;
96 int64_t time = pb0->GetBlockTime();
97 minTime = std::min(time, minTime);
98 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 if (minTime == maxTime)
103 return 0;
104
105 arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
106 int64_t timeDiff = maxTime - minTime;
107
108 return workDiff.getdouble() / timeDiff;
109}
110
112{
113 return RPCHelpMan{
114 "getnetworkhashps",
115 "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 {"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 {"height", RPCArg::Type::NUM, RPCArg::Default{-1}, "To estimate at the time of the given height."},
121 },
122 RPCResult{
123 RPCResult::Type::NUM, "", "Hashes per second estimated"},
125 HelpExampleCli("getnetworkhashps", "")
126 + HelpExampleRpc("getnetworkhashps", "")
127 },
128 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
129{
130 ChainstateManager& chainman = EnsureAnyChainman(request.context);
131 LOCK(cs_main);
132 return GetNetworkHashPS(self.Arg<int>("nblocks"), self.Arg<int>("height"), chainman.ActiveChain());
133},
134 };
135}
136
137static bool GenerateBlock(ChainstateManager& chainman, CBlock&& block, uint64_t& max_tries, std::shared_ptr<const CBlock>& block_out, bool process_new_block)
138{
139 block_out.reset();
140 block.hashMerkleRoot = BlockMerkleRoot(block);
141
142 while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetHash(), block.nBits, chainman.GetConsensus()) && !chainman.m_interrupt) {
143 ++block.nNonce;
144 --max_tries;
145 }
146 if (max_tries == 0 || chainman.m_interrupt) {
147 return false;
148 }
149 if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
150 return true;
151 }
152
153 block_out = std::make_shared<const CBlock>(std::move(block));
154
155 if (!process_new_block) return true;
156
157 if (!chainman.ProcessNewBlock(block_out, /*force_processing=*/true, /*min_pow_checked=*/true, nullptr)) {
158 throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
159 }
160
161 return true;
162}
163
164static UniValue generateBlocks(ChainstateManager& chainman, Mining& miner, const CScript& coinbase_output_script, int nGenerate, uint64_t nMaxTries)
165{
166 UniValue blockHashes(UniValue::VARR);
167 while (nGenerate > 0 && !chainman.m_interrupt) {
168 std::unique_ptr<BlockTemplate> block_template(miner.createNewBlock({ .coinbase_output_script = coinbase_output_script }));
169 CHECK_NONFATAL(block_template);
170
171 std::shared_ptr<const CBlock> block_out;
172 if (!GenerateBlock(chainman, block_template->getBlock(), nMaxTries, block_out, /*process_new_block=*/true)) {
173 break;
174 }
175
176 if (block_out) {
177 --nGenerate;
178 blockHashes.push_back(block_out->GetHash().GetHex());
179 }
180 }
181 return blockHashes;
182}
183
184static bool getScriptFromDescriptor(const std::string& descriptor, CScript& script, std::string& error)
185{
186 FlatSigningProvider key_provider;
187 const auto descs = Parse(descriptor, key_provider, error, /* require_checksum = */ false);
188 if (descs.empty()) return false;
189 if (descs.size() > 1) {
190 throw JSONRPCError(RPC_INVALID_PARAMETER, "Multipath descriptor not accepted");
191 }
192 const auto& desc = descs.at(0);
193 if (desc->IsRange()) {
194 throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptor not accepted. Maybe pass through deriveaddresses first?");
195 }
196
197 FlatSigningProvider provider;
198 std::vector<CScript> scripts;
199 if (!desc->Expand(0, key_provider, scripts, provider)) {
200 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 CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 4);
205
206 if (scripts.size() == 1) {
207 script = scripts.at(0);
208 } else if (scripts.size() == 4) {
209 // For uncompressed keys, take the 3rd script, since it is p2wpkh
210 script = scripts.at(2);
211 } else {
212 // Else take the 2nd script, since it is p2pkh
213 script = scripts.at(1);
214 }
215
216 return true;
217}
218
220{
221 return RPCHelpMan{
222 "generatetodescriptor",
223 "Mine to a specified descriptor and return the block hashes.",
224 {
225 {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated."},
226 {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated bitcoin to."},
227 {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
228 },
229 RPCResult{
230 RPCResult::Type::ARR, "", "hashes of blocks generated",
231 {
232 {RPCResult::Type::STR_HEX, "", "blockhash"},
233 }
234 },
236 "\nGenerate 11 blocks to mydesc\n" + HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
237 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
238{
239 const auto num_blocks{self.Arg<int>("num_blocks")};
240 const auto max_tries{self.Arg<uint64_t>("maxtries")};
241
242 CScript coinbase_output_script;
243 std::string error;
244 if (!getScriptFromDescriptor(self.Arg<std::string>("descriptor"), coinbase_output_script, error)) {
246 }
247
248 NodeContext& node = EnsureAnyNodeContext(request.context);
249 Mining& miner = EnsureMining(node);
251
252 return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
253},
254 };
255}
256
258{
259 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 {
261 }};
262}
263
265{
266 return RPCHelpMan{"generatetoaddress",
267 "Mine to a specified address and return the block hashes.",
268 {
269 {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated."},
270 {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated bitcoin to."},
271 {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
272 },
273 RPCResult{
274 RPCResult::Type::ARR, "", "hashes of blocks generated",
275 {
276 {RPCResult::Type::STR_HEX, "", "blockhash"},
277 }},
279 "\nGenerate 11 blocks to myaddress\n"
280 + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
281 + "If you are using the " CLIENT_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n"
282 + HelpExampleCli("getnewaddress", "")
283 },
284 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
285{
286 const int num_blocks{request.params[0].getInt<int>()};
287 const uint64_t max_tries{request.params[2].isNull() ? DEFAULT_MAX_TRIES : request.params[2].getInt<int>()};
288
289 CTxDestination destination = DecodeDestination(request.params[1].get_str());
290 if (!IsValidDestination(destination)) {
291 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
292 }
293
294 NodeContext& node = EnsureAnyNodeContext(request.context);
295 Mining& miner = EnsureMining(node);
297
298 CScript coinbase_output_script = GetScriptForDestination(destination);
299
300 return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
301},
302 };
303}
304
306{
307 return RPCHelpMan{"generateblock",
308 "Mine a set of ordered transactions to a specified address or descriptor and return the block hash.",
309 {
310 {"output", RPCArg::Type::STR, RPCArg::Optional::NO, "The address or descriptor to send the newly generated bitcoin to."},
311 {"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 {
316 },
317 },
318 {"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 RPCResult{
321 RPCResult::Type::OBJ, "", "",
322 {
323 {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
324 {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "hex of generated block, only present when submit=false"},
325 }
326 },
328 "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n"
329 + HelpExampleCli("generateblock", R"("myaddress" '["rawtx", "mempool_txid"]')")
330 },
331 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
332{
333 const auto address_or_descriptor = request.params[0].get_str();
334 CScript coinbase_output_script;
335 std::string error;
336
337 if (!getScriptFromDescriptor(address_or_descriptor, coinbase_output_script, error)) {
338 const auto destination = DecodeDestination(address_or_descriptor);
339 if (!IsValidDestination(destination)) {
340 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address or descriptor");
341 }
342
343 coinbase_output_script = GetScriptForDestination(destination);
344 }
345
346 NodeContext& node = EnsureAnyNodeContext(request.context);
347 Mining& miner = EnsureMining(node);
348 const CTxMemPool& mempool = EnsureMemPool(node);
349
350 std::vector<CTransactionRef> txs;
351 const auto raw_txs_or_txids = request.params[1].get_array();
352 for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
353 const auto& str{raw_txs_or_txids[i].get_str()};
354
356 if (auto hash{uint256::FromHex(str)}) {
357 const auto tx{mempool.get(*hash)};
358 if (!tx) {
359 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Transaction %s not in mempool.", str));
360 }
361
362 txs.emplace_back(tx);
363
364 } else if (DecodeHexTx(mtx, str)) {
365 txs.push_back(MakeTransactionRef(std::move(mtx)));
366
367 } else {
368 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("Transaction decode failed for %s. Make sure the tx has at least one input.", str));
369 }
370 }
371
372 const bool process_new_block{request.params[2].isNull() ? true : request.params[2].get_bool()};
373 CBlock block;
374
376 {
377 LOCK(chainman.GetMutex());
378 {
379 std::unique_ptr<BlockTemplate> block_template{miner.createNewBlock({.use_mempool = false, .coinbase_output_script = coinbase_output_script})};
380 CHECK_NONFATAL(block_template);
381
382 block = block_template->getBlock();
383 }
384
385 CHECK_NONFATAL(block.vtx.size() == 1);
386
387 // Add transactions
388 block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
389 RegenerateCommitments(block, chainman);
390
392 if (!TestBlockValidity(state, chainman.GetParams(), chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), /*fCheckPOW=*/false, /*fCheckMerkleRoot=*/false)) {
393 throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
394 }
395 }
396
397 std::shared_ptr<const CBlock> block_out;
398 uint64_t max_tries{DEFAULT_MAX_TRIES};
399
400 if (!GenerateBlock(chainman, std::move(block), max_tries, block_out, process_new_block) || !block_out) {
401 throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
402 }
403
405 obj.pushKV("hash", block_out->GetHash().GetHex());
406 if (!process_new_block) {
407 DataStream block_ser;
408 block_ser << TX_WITH_WITNESS(*block_out);
409 obj.pushKV("hex", HexStr(block_ser));
410 }
411 return obj;
412},
413 };
414}
415
417{
418 return RPCHelpMan{
419 "getmininginfo",
420 "Returns a json object containing mining-related information.",
421 {},
422 RPCResult{
423 RPCResult::Type::OBJ, "", "",
424 {
425 {RPCResult::Type::NUM, "blocks", "The current block"},
426 {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)"},
427 {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)"},
428 {RPCResult::Type::STR_HEX, "bits", "The current nBits, compact representation of the block difficulty target"},
429 {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
430 {RPCResult::Type::STR_HEX, "target", "The current target"},
431 {RPCResult::Type::NUM, "networkhashps", "The network hashes per second"},
432 {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
433 {RPCResult::Type::STR, "chain", "current network name (" LIST_CHAIN_NAMES ")"},
434 {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 {RPCResult::Type::OBJ, "next", "The next block",
436 {
437 {RPCResult::Type::NUM, "height", "The next height"},
438 {RPCResult::Type::STR_HEX, "bits", "The next target nBits"},
439 {RPCResult::Type::NUM, "difficulty", "The next difficulty"},
440 {RPCResult::Type::STR_HEX, "target", "The next target"}
441 }},
442 (IsDeprecatedRPCEnabled("warnings") ?
443 RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
444 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 {RPCResult::Type::STR, "", "warning"},
447 }
448 }
449 ),
450 }},
452 HelpExampleCli("getmininginfo", "")
453 + HelpExampleRpc("getmininginfo", "")
454 },
455 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
456{
457 NodeContext& node = EnsureAnyNodeContext(request.context);
458 const CTxMemPool& mempool = EnsureMemPool(node);
460 LOCK(cs_main);
461 const CChain& active_chain = chainman.ActiveChain();
462 CBlockIndex& tip{*CHECK_NONFATAL(active_chain.Tip())};
463
465 obj.pushKV("blocks", active_chain.Height());
466 if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
467 if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
468 obj.pushKV("bits", strprintf("%08x", tip.nBits));
469 obj.pushKV("difficulty", GetDifficulty(tip));
470 obj.pushKV("target", GetTarget(tip, chainman.GetConsensus().powLimit).GetHex());
471 obj.pushKV("networkhashps", getnetworkhashps().HandleRequest(request));
472 obj.pushKV("pooledtx", (uint64_t)mempool.size());
473 obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
474
476 CBlockIndex next_index;
477 NextEmptyBlockIndex(tip, chainman.GetConsensus(), next_index);
478
479 next.pushKV("height", next_index.nHeight);
480 next.pushKV("bits", strprintf("%08x", next_index.nBits));
481 next.pushKV("difficulty", GetDifficulty(next_index));
482 next.pushKV("target", GetTarget(next_index, chainman.GetConsensus().powLimit).GetHex());
483 obj.pushKV("next", next);
484
485 if (chainman.GetParams().GetChainType() == ChainType::SIGNET) {
486 const std::vector<uint8_t>& signet_challenge =
488 obj.pushKV("signet_challenge", HexStr(signet_challenge));
489 }
490 obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
491 return obj;
492},
493 };
494}
495
496
497// NOTE: Unlike wallet RPC (which use BTC values), mining RPCs follow GBT (BIP 22) in using satoshi amounts
499{
500 return RPCHelpMan{"prioritisetransaction",
501 "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
502 {
503 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
504 {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "API-Compatibility for previous API. Must be zero or null.\n"
505 " DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
506 {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO, "The fee value (in satoshis) to add (or subtract, if negative).\n"
507 " Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
508 " The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
509 " considers the transaction as it would have paid a higher (or lower) fee."},
510 },
511 RPCResult{
512 RPCResult::Type::BOOL, "", "Returns true"},
514 HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000")
515 + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")
516 },
517 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
518{
519 LOCK(cs_main);
520
521 uint256 hash(ParseHashV(request.params[0], "txid"));
522 const auto dummy{self.MaybeArg<double>("dummy")};
523 CAmount nAmount = request.params[2].getInt<int64_t>();
524
525 if (dummy && *dummy != 0) {
526 throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.");
527 }
528
529 CTxMemPool& mempool = EnsureAnyMemPool(request.context);
530
531 // Non-0 fee dust transactions are not allowed for entry, and modification not allowed afterwards
532 const auto& tx = mempool.get(hash);
533 if (mempool.m_opts.require_standard && tx && !GetDust(*tx, mempool.m_opts.dust_relay_feerate).empty()) {
534 throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is not supported for transactions with dust outputs.");
535 }
536
537 mempool.PrioritiseTransaction(hash, nAmount);
538 return true;
539},
540 };
541}
542
544{
545 return RPCHelpMan{"getprioritisedtransactions",
546 "Returns a map of all user-created (see prioritisetransaction) fee deltas by txid, and whether the tx is present in mempool.",
547 {},
548 RPCResult{
549 RPCResult::Type::OBJ_DYN, "", "prioritisation keyed by txid",
550 {
551 {RPCResult::Type::OBJ, "<transactionid>", "", {
552 {RPCResult::Type::NUM, "fee_delta", "transaction fee delta in satoshis"},
553 {RPCResult::Type::BOOL, "in_mempool", "whether this transaction is currently in mempool"},
554 {RPCResult::Type::NUM, "modified_fee", /*optional=*/true, "modified fee in satoshis. Only returned if in_mempool=true"},
555 }}
556 },
557 },
559 HelpExampleCli("getprioritisedtransactions", "")
560 + HelpExampleRpc("getprioritisedtransactions", "")
561 },
562 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
563 {
564 NodeContext& node = EnsureAnyNodeContext(request.context);
565 CTxMemPool& mempool = EnsureMemPool(node);
566 UniValue rpc_result{UniValue::VOBJ};
567 for (const auto& delta_info : mempool.GetPrioritisedTransactions()) {
568 UniValue result_inner{UniValue::VOBJ};
569 result_inner.pushKV("fee_delta", delta_info.delta);
570 result_inner.pushKV("in_mempool", delta_info.in_mempool);
571 if (delta_info.in_mempool) {
572 result_inner.pushKV("modified_fee", *delta_info.modified_fee);
573 }
574 rpc_result.pushKV(delta_info.txid.GetHex(), std::move(result_inner));
575 }
576 return rpc_result;
577 },
578 };
579}
580
581
582// NOTE: Assumes a conclusive result; if result is inconclusive, it must be handled by caller
584{
585 if (state.IsValid())
586 return UniValue::VNULL;
587
588 if (state.IsError())
589 throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
590 if (state.IsInvalid())
591 {
592 std::string strRejectReason = state.GetRejectReason();
593 if (strRejectReason.empty())
594 return "rejected";
595 return strRejectReason;
596 }
597 // Should be impossible
598 return "valid?";
599}
600
601// Prefix rule name with ! if not optional, see BIP9
602static std::string gbt_rule_value(const std::string& name, bool gbt_optional_rule)
603{
604 std::string s{name};
605 if (!gbt_optional_rule) {
606 s.insert(s.begin(), '!');
607 }
608 return s;
609}
610
612{
613 return RPCHelpMan{
614 "getblocktemplate",
615 "If the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
616 "It returns data needed to construct a block to work on.\n"
617 "For full specification, see BIPs 22, 23, 9, and 145:\n"
618 " https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
619 " https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
620 " https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
621 " https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n",
622 {
623 {"template_request", RPCArg::Type::OBJ, RPCArg::Optional::NO, "Format of the template",
624 {
625 {"mode", RPCArg::Type::STR, /* treat as named arg */ RPCArg::Optional::OMITTED, "This must be set to \"template\", \"proposal\" (see BIP 23), or omitted"},
626 {"capabilities", RPCArg::Type::ARR, /* treat as named arg */ RPCArg::Optional::OMITTED, "A list of strings",
627 {
628 {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "client side supported feature, 'longpoll', 'coinbasevalue', 'proposal', 'serverlist', 'workid'"},
629 }},
630 {"rules", RPCArg::Type::ARR, RPCArg::Optional::NO, "A list of strings",
631 {
632 {"segwit", RPCArg::Type::STR, RPCArg::Optional::NO, "(literal) indicates client side segwit support"},
633 {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "other client side supported softfork deployment"},
634 }},
635 {"longpollid", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "delay processing request until the result would vary significantly from the \"longpollid\" of a prior template"},
636 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "proposed block data to check, encoded in hexadecimal; valid only for mode=\"proposal\""},
637 },
638 },
639 },
640 {
641 RPCResult{"If the proposal was accepted with mode=='proposal'", RPCResult::Type::NONE, "", ""},
642 RPCResult{"If the proposal was not accepted with mode=='proposal'", RPCResult::Type::STR, "", "According to BIP22"},
643 RPCResult{"Otherwise", RPCResult::Type::OBJ, "", "",
644 {
645 {RPCResult::Type::NUM, "version", "The preferred block version"},
646 {RPCResult::Type::ARR, "rules", "specific block rules that are to be enforced",
647 {
648 {RPCResult::Type::STR, "", "name of a rule the client must understand to some extent; see BIP 9 for format"},
649 }},
650 {RPCResult::Type::OBJ_DYN, "vbavailable", "set of pending, supported versionbit (BIP 9) softfork deployments",
651 {
652 {RPCResult::Type::NUM, "rulename", "identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
653 }},
654 {RPCResult::Type::ARR, "capabilities", "",
655 {
656 {RPCResult::Type::STR, "value", "A supported feature, for example 'proposal'"},
657 }},
658 {RPCResult::Type::NUM, "vbrequired", "bit mask of versionbits the server requires set in submissions"},
659 {RPCResult::Type::STR, "previousblockhash", "The hash of current highest block"},
660 {RPCResult::Type::ARR, "transactions", "contents of non-coinbase transactions that should be included in the next block",
661 {
662 {RPCResult::Type::OBJ, "", "",
663 {
664 {RPCResult::Type::STR_HEX, "data", "transaction data encoded in hexadecimal (byte-for-byte)"},
665 {RPCResult::Type::STR_HEX, "txid", "transaction hash excluding witness data, shown in byte-reversed hex"},
666 {RPCResult::Type::STR_HEX, "hash", "transaction hash including witness data, shown in byte-reversed hex"},
667 {RPCResult::Type::ARR, "depends", "array of numbers",
668 {
669 {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"},
670 }},
671 {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"},
672 {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"},
673 {RPCResult::Type::NUM, "weight", "total transaction weight, as counted for purposes of block limits"},
674 }},
675 }},
676 {RPCResult::Type::OBJ_DYN, "coinbaseaux", "data that should be included in the coinbase's scriptSig content",
677 {
678 {RPCResult::Type::STR_HEX, "key", "values must be in the coinbase (keys may be ignored)"},
679 }},
680 {RPCResult::Type::NUM, "coinbasevalue", "maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
681 {RPCResult::Type::STR, "longpollid", "an id to include with a request to longpoll on an update to this template"},
682 {RPCResult::Type::STR, "target", "The hash target"},
683 {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."},
684 {RPCResult::Type::ARR, "mutable", "list of ways the block template may be changed",
685 {
686 {RPCResult::Type::STR, "value", "A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
687 }},
688 {RPCResult::Type::STR_HEX, "noncerange", "A range of valid nonces"},
689 {RPCResult::Type::NUM, "sigoplimit", "limit of sigops in blocks"},
690 {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
691 {RPCResult::Type::NUM, "weightlimit", /*optional=*/true, "limit of block weight"},
692 {RPCResult::Type::NUM_TIME, "curtime", "current timestamp in " + UNIX_EPOCH_TIME + ". Adjusted for the proposed BIP94 timewarp rule."},
693 {RPCResult::Type::STR, "bits", "compressed target of next block"},
694 {RPCResult::Type::NUM, "height", "The height of the next block"},
695 {RPCResult::Type::STR_HEX, "signet_challenge", /*optional=*/true, "Only on signet"},
696 {RPCResult::Type::STR_HEX, "default_witness_commitment", /*optional=*/true, "a valid witness commitment for the unmodified block template"},
697 }},
698 },
700 HelpExampleCli("getblocktemplate", "'{\"rules\": [\"segwit\"]}'")
701 + HelpExampleRpc("getblocktemplate", "{\"rules\": [\"segwit\"]}")
702 },
703 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
704{
705 NodeContext& node = EnsureAnyNodeContext(request.context);
707 Mining& miner = EnsureMining(node);
708 LOCK(cs_main);
709 uint256 tip{CHECK_NONFATAL(miner.getTip()).value().hash};
710
711 std::string strMode = "template";
712 UniValue lpval = NullUniValue;
713 std::set<std::string> setClientRules;
714 if (!request.params[0].isNull())
715 {
716 const UniValue& oparam = request.params[0].get_obj();
717 const UniValue& modeval = oparam.find_value("mode");
718 if (modeval.isStr())
719 strMode = modeval.get_str();
720 else if (modeval.isNull())
721 {
722 /* Do nothing */
723 }
724 else
725 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
726 lpval = oparam.find_value("longpollid");
727
728 if (strMode == "proposal")
729 {
730 const UniValue& dataval = oparam.find_value("data");
731 if (!dataval.isStr())
732 throw JSONRPCError(RPC_TYPE_ERROR, "Missing data String key for proposal");
733
734 CBlock block;
735 if (!DecodeHexBlk(block, dataval.get_str()))
736 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
737
738 uint256 hash = block.GetHash();
739 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
740 if (pindex) {
741 if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
742 return "duplicate";
743 if (pindex->nStatus & BLOCK_FAILED_MASK)
744 return "duplicate-invalid";
745 return "duplicate-inconclusive";
746 }
747
748 // TestBlockValidity only supports blocks built on the current Tip
749 if (block.hashPrevBlock != tip) {
750 return "inconclusive-not-best-prevblk";
751 }
753 TestBlockValidity(state, chainman.GetParams(), chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), /*fCheckPOW=*/false, /*fCheckMerkleRoot=*/true);
754 return BIP22ValidationResult(state);
755 }
756
757 const UniValue& aClientRules = oparam.find_value("rules");
758 if (aClientRules.isArray()) {
759 for (unsigned int i = 0; i < aClientRules.size(); ++i) {
760 const UniValue& v = aClientRules[i];
761 setClientRules.insert(v.get_str());
762 }
763 }
764 }
765
766 if (strMode != "template")
767 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
768
769 if (!miner.isTestChain()) {
770 const CConnman& connman = EnsureConnman(node);
771 if (connman.GetNodeCount(ConnectionDirection::Both) == 0) {
772 throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, CLIENT_NAME " is not connected!");
773 }
774
775 if (miner.isInitialBlockDownload()) {
776 throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, CLIENT_NAME " is in initial sync and waiting for blocks...");
777 }
778 }
779
780 static unsigned int nTransactionsUpdatedLast;
781 const CTxMemPool& mempool = EnsureMemPool(node);
782
783 // Long Polling (BIP22)
784 if (!lpval.isNull()) {
799 uint256 hashWatchedChain;
800 unsigned int nTransactionsUpdatedLastLP;
801
802 if (lpval.isStr())
803 {
804 // Format: <hashBestChain><nTransactionsUpdatedLast>
805 const std::string& lpstr = lpval.get_str();
806
807 // Assume the longpollid is a block hash. If it's not then we return
808 // early below.
809 hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
810 nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
811 }
812 else
813 {
814 // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
815 hashWatchedChain = tip;
816 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
817 }
818
819 // Release lock while waiting
821 {
822 MillisecondsDouble checktxtime{std::chrono::minutes(1)};
823 while (IsRPCRunning()) {
824 // If hashWatchedChain is not a real block hash, this will
825 // return immediately.
826 std::optional<BlockRef> maybe_tip{miner.waitTipChanged(hashWatchedChain, checktxtime)};
827 // Node is shutting down
828 if (!maybe_tip) break;
829 tip = maybe_tip->hash;
830 if (tip != hashWatchedChain) break;
831
832 // Check transactions for update without holding the mempool
833 // lock to avoid deadlocks.
834 if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP) {
835 break;
836 }
837 checktxtime = std::chrono::seconds(10);
838 }
839 }
841
842 tip = CHECK_NONFATAL(miner.getTip()).value().hash;
843
844 if (!IsRPCRunning())
845 throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
846 // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
847 }
848
849 const Consensus::Params& consensusParams = chainman.GetParams().GetConsensus();
850
851 // GBT must be called with 'signet' set in the rules for signet chains
852 if (consensusParams.signet_blocks && setClientRules.count("signet") != 1) {
853 throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the signet rule set (call with {\"rules\": [\"segwit\", \"signet\"]})");
854 }
855
856 // GBT must be called with 'segwit' set in the rules
857 if (setClientRules.count("segwit") != 1) {
858 throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
859 }
860
861 // Update block
862 static CBlockIndex* pindexPrev;
863 static int64_t time_start;
864 static std::unique_ptr<BlockTemplate> block_template;
865 if (!pindexPrev || pindexPrev->GetBlockHash() != tip ||
866 (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - time_start > 5))
867 {
868 // Clear pindexPrev so future calls make a new block, despite any failures from here on
869 pindexPrev = nullptr;
870
871 // Store the pindexBest used before createNewBlock, to avoid races
872 nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
873 CBlockIndex* pindexPrevNew = chainman.m_blockman.LookupBlockIndex(tip);
874 time_start = GetTime();
875
876 // Create new block
877 block_template = miner.createNewBlock();
878 CHECK_NONFATAL(block_template);
879
880
881 // Need to update only after we know createNewBlock succeeded
882 pindexPrev = pindexPrevNew;
883 }
884 CHECK_NONFATAL(pindexPrev);
885 CBlock block{block_template->getBlock()};
886
887 // Update nTime
888 UpdateTime(&block, consensusParams, pindexPrev);
889 block.nNonce = 0;
890
891 // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
892 const bool fPreSegWit = !DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT);
893
894 UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
895
896 UniValue transactions(UniValue::VARR);
897 std::map<uint256, int64_t> setTxIndex;
898 std::vector<CAmount> tx_fees{block_template->getTxFees()};
899 std::vector<CAmount> tx_sigops{block_template->getTxSigops()};
900
901 int i = 0;
902 for (const auto& it : block.vtx) {
903 const CTransaction& tx = *it;
904 uint256 txHash = tx.GetHash();
905 setTxIndex[txHash] = i++;
906
907 if (tx.IsCoinBase())
908 continue;
909
911
912 entry.pushKV("data", EncodeHexTx(tx));
913 entry.pushKV("txid", txHash.GetHex());
914 entry.pushKV("hash", tx.GetWitnessHash().GetHex());
915
917 for (const CTxIn &in : tx.vin)
918 {
919 if (setTxIndex.count(in.prevout.hash))
920 deps.push_back(setTxIndex[in.prevout.hash]);
921 }
922 entry.pushKV("depends", std::move(deps));
923
924 int index_in_template = i - 2;
925 entry.pushKV("fee", tx_fees.at(index_in_template));
926 int64_t nTxSigOps{tx_sigops.at(index_in_template)};
927 if (fPreSegWit) {
928 CHECK_NONFATAL(nTxSigOps % WITNESS_SCALE_FACTOR == 0);
929 nTxSigOps /= WITNESS_SCALE_FACTOR;
930 }
931 entry.pushKV("sigops", nTxSigOps);
932 entry.pushKV("weight", GetTransactionWeight(tx));
933
934 transactions.push_back(std::move(entry));
935 }
936
938
939 arith_uint256 hashTarget = arith_uint256().SetCompact(block.nBits);
940
941 UniValue aMutable(UniValue::VARR);
942 aMutable.push_back("time");
943 aMutable.push_back("transactions");
944 aMutable.push_back("prevblock");
945
946 UniValue result(UniValue::VOBJ);
947 result.pushKV("capabilities", std::move(aCaps));
948
949 UniValue aRules(UniValue::VARR);
950 aRules.push_back("csv");
951 if (!fPreSegWit) aRules.push_back("!segwit");
952 if (consensusParams.signet_blocks) {
953 // indicate to miner that they must understand signet rules
954 // when attempting to mine with this template
955 aRules.push_back("!signet");
956 }
957
958 UniValue vbavailable(UniValue::VOBJ);
959 const auto gbtstatus = chainman.m_versionbitscache.GBTStatus(*pindexPrev, consensusParams);
960
961 for (const auto& [name, info] : gbtstatus.signalling) {
962 vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
963 if (!info.gbt_optional_rule && !setClientRules.count(name)) {
964 // If the client doesn't support this, don't indicate it in the [default] version
965 block.nVersion &= ~info.mask;
966 }
967 }
968
969 for (const auto& [name, info] : gbtstatus.locked_in) {
970 block.nVersion |= info.mask;
971 vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
972 if (!info.gbt_optional_rule && !setClientRules.count(name)) {
973 // If the client doesn't support this, don't indicate it in the [default] version
974 block.nVersion &= ~info.mask;
975 }
976 }
977
978 for (const auto& [name, info] : gbtstatus.active) {
979 aRules.push_back(gbt_rule_value(name, info.gbt_optional_rule));
980 if (!info.gbt_optional_rule && !setClientRules.count(name)) {
981 // Not supported by the client; make sure it's safe to proceed
982 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", name));
983 }
984 }
985
986 result.pushKV("version", block.nVersion);
987 result.pushKV("rules", std::move(aRules));
988 result.pushKV("vbavailable", std::move(vbavailable));
989 result.pushKV("vbrequired", int(0));
990
991 result.pushKV("previousblockhash", block.hashPrevBlock.GetHex());
992 result.pushKV("transactions", std::move(transactions));
993 result.pushKV("coinbaseaux", std::move(aux));
994 result.pushKV("coinbasevalue", (int64_t)block.vtx[0]->vout[0].nValue);
995 result.pushKV("longpollid", tip.GetHex() + ToString(nTransactionsUpdatedLast));
996 result.pushKV("target", hashTarget.GetHex());
997 result.pushKV("mintime", GetMinimumTime(pindexPrev, consensusParams.DifficultyAdjustmentInterval()));
998 result.pushKV("mutable", std::move(aMutable));
999 result.pushKV("noncerange", "00000000ffffffff");
1000 int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
1001 int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
1002 if (fPreSegWit) {
1003 CHECK_NONFATAL(nSigOpLimit % WITNESS_SCALE_FACTOR == 0);
1004 nSigOpLimit /= WITNESS_SCALE_FACTOR;
1005 CHECK_NONFATAL(nSizeLimit % WITNESS_SCALE_FACTOR == 0);
1006 nSizeLimit /= WITNESS_SCALE_FACTOR;
1007 }
1008 result.pushKV("sigoplimit", nSigOpLimit);
1009 result.pushKV("sizelimit", nSizeLimit);
1010 if (!fPreSegWit) {
1011 result.pushKV("weightlimit", (int64_t)MAX_BLOCK_WEIGHT);
1012 }
1013 result.pushKV("curtime", block.GetBlockTime());
1014 result.pushKV("bits", strprintf("%08x", block.nBits));
1015 result.pushKV("height", (int64_t)(pindexPrev->nHeight+1));
1016
1017 if (consensusParams.signet_blocks) {
1018 result.pushKV("signet_challenge", HexStr(consensusParams.signet_challenge));
1019 }
1020
1021 if (!block_template->getCoinbaseCommitment().empty()) {
1022 result.pushKV("default_witness_commitment", HexStr(block_template->getCoinbaseCommitment()));
1023 }
1024
1025 return result;
1026},
1027 };
1028}
1029
1031{
1032public:
1034 bool found{false};
1036
1037 explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), state() {}
1038
1039protected:
1040 void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override {
1041 if (block.GetHash() != hash)
1042 return;
1043 found = true;
1044 state = stateIn;
1045 }
1046};
1047
1049{
1050 // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
1051 return RPCHelpMan{
1052 "submitblock",
1053 "Attempts to submit new block to network.\n"
1054 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1055 {
1056 {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
1057 {"dummy", RPCArg::Type::STR, RPCArg::DefaultHint{"ignored"}, "dummy value, for compatibility with BIP22. This value is ignored."},
1058 },
1059 {
1060 RPCResult{"If the block was accepted", RPCResult::Type::NONE, "", ""},
1061 RPCResult{"Otherwise", RPCResult::Type::STR, "", "According to BIP22"},
1062 },
1064 HelpExampleCli("submitblock", "\"mydata\"")
1065 + HelpExampleRpc("submitblock", "\"mydata\"")
1066 },
1067 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1068{
1069 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1070 CBlock& block = *blockptr;
1071 if (!DecodeHexBlk(block, request.params[0].get_str())) {
1072 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
1073 }
1074
1075 ChainstateManager& chainman = EnsureAnyChainman(request.context);
1076 {
1077 LOCK(cs_main);
1078 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
1079 if (pindex) {
1080 chainman.UpdateUncommittedBlockStructures(block, pindex);
1081 }
1082 }
1083
1084 bool new_block;
1085 auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
1086 CHECK_NONFATAL(chainman.m_options.signals)->RegisterSharedValidationInterface(sc);
1087 bool accepted = chainman.ProcessNewBlock(blockptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
1088 CHECK_NONFATAL(chainman.m_options.signals)->UnregisterSharedValidationInterface(sc);
1089 if (!new_block && accepted) {
1090 return "duplicate";
1091 }
1092 if (!sc->found) {
1093 return "inconclusive";
1094 }
1095 return BIP22ValidationResult(sc->state);
1096},
1097 };
1098}
1099
1101{
1102 return RPCHelpMan{
1103 "submitheader",
1104 "Decode the given hexdata as a header and submit it as a candidate chain tip if valid."
1105 "\nThrows when the header is invalid.\n",
1106 {
1107 {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
1108 },
1109 RPCResult{
1110 RPCResult::Type::NONE, "", "None"},
1112 HelpExampleCli("submitheader", "\"aabbcc\"") +
1113 HelpExampleRpc("submitheader", "\"aabbcc\"")
1114 },
1115 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1116{
1117 CBlockHeader h;
1118 if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
1119 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
1120 }
1121 ChainstateManager& chainman = EnsureAnyChainman(request.context);
1122 {
1123 LOCK(cs_main);
1124 if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
1125 throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
1126 }
1127 }
1128
1130 chainman.ProcessNewBlockHeaders({{h}}, /*min_pow_checked=*/true, state);
1131 if (state.IsValid()) return UniValue::VNULL;
1132 if (state.IsError()) {
1133 throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
1134 }
1136},
1137 };
1138}
1139
1141{
1142 static const CRPCCommand commands[]{
1143 {"mining", &getnetworkhashps},
1144 {"mining", &getmininginfo},
1145 {"mining", &prioritisetransaction},
1146 {"mining", &getprioritisedtransactions},
1147 {"mining", &getblocktemplate},
1148 {"mining", &submitblock},
1149 {"mining", &submitheader},
1150
1151 {"hidden", &generatetoaddress},
1152 {"hidden", &generatetodescriptor},
1153 {"hidden", &generateblock},
1154 {"hidden", &generate},
1155 };
1156 for (const auto& c : commands) {
1157 t.appendCommand(c.name, &c);
1158 }
1159}
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
Definition: addresstype.h:143
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
double GetDifficulty(const CBlockIndex &blockindex)
Get the difficulty of the net wrt to the given block index.
Definition: blockchain.cpp:92
@ BLOCK_VALID_SCRIPTS
Scripts & signatures ok.
Definition: chain.h:115
@ BLOCK_FAILED_MASK
Definition: chain.h:127
const CChainParams & Params()
Return the currently selected parameters.
#define LIST_CHAIN_NAMES
List of possible chain / network names
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:102
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition: block.h:22
uint256 hashPrevBlock
Definition: block.h:26
uint256 GetHash() const
Definition: block.cpp:11
Definition: block.h:69
std::vector< CTransactionRef > vtx
Definition: block.h:72
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:141
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:147
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
Definition: chain.h:165
uint256 GetBlockHash() const
Definition: chain.h:243
int64_t GetBlockTime() const
Definition: chain.h:266
uint32_t nBits
Definition: chain.h:190
bool IsValid(enum BlockStatus nUpTo=BLOCK_VALID_TRANSACTIONS) const EXCLUSIVE_LOCKS_REQUIRED(
Check whether this block index entry is valid up to the passed validity level.
Definition: chain.h:295
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:153
An in-memory indexed chain of blocks.
Definition: chain.h:417
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:433
int Height() const
Return the maximal height in the chain.
Definition: chain.h:462
std::string GetChainTypeString() const
Return the chain type string.
Definition: chainparams.h:101
const Consensus::Params & GetConsensus() const
Definition: chainparams.h:81
ChainType GetChainType() const
Return the chain type.
Definition: chainparams.h:103
Definition: net.h:1053
size_t GetNodeCount(ConnectionDirection) const
Definition: net.cpp:3592
Txid hash
Definition: transaction.h:31
RPC command dispatcher.
Definition: server.h:127
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:415
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
const Wtxid & GetWitnessHash() const LIFETIMEBOUND
Definition: transaction.h:344
bool IsCoinBase() const
Definition: transaction.h:356
const Txid & GetHash() const LIFETIMEBOUND
Definition: transaction.h:343
const std::vector< CTxIn > vin
Definition: transaction.h:306
An input of a transaction.
Definition: transaction.h:67
COutPoint prevout
Definition: transaction.h:69
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:304
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
Definition: txmempool.cpp:913
CTransactionRef get(const uint256 &hash) const
Definition: txmempool.cpp:884
const Options m_opts
Definition: txmempool.h:439
std::vector< delta_info > GetPrioritisedTransactions() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
Return a vector of all entries in mapDeltas with their corresponding delta_info.
Definition: txmempool.cpp:965
unsigned long size() const
Definition: txmempool.h:629
unsigned int GetTransactionsUpdated() const
Definition: txmempool.cpp:425
Implement this to subscribe to events generated in validation and mempool.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:867
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
Definition: validation.h:1109
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1000
bool ProcessNewBlock(const std::shared_ptr< const CBlock > &block, bool force_processing, bool min_pow_checked, bool *new_block) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
const util::SignalInterrupt & m_interrupt
Definition: validation.h:1002
VersionBitsCache m_versionbitscache
Track versionbit status.
Definition: validation.h:1133
const CChainParams & GetParams() const
Definition: validation.h:975
bool ProcessNewBlockHeaders(std::span< const CBlockHeader > headers, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
const Consensus::Params & GetConsensus() const
Definition: validation.h:976
const Options m_options
Definition: validation.h:1003
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1110
void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev) const
Check to see if caches are out of balance and if so, call ResizeCoinsCaches() as needed.
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1006
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:147
std::string ToString() const
Definition: util.cpp:773
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
Definition: util.h:440
auto MaybeArg(std::string_view key) const
Helper to get an optional request argument.
Definition: util.h:472
void push_back(UniValue val)
Definition: univalue.cpp:104
const std::string & get_str() const
bool isArray() const
Definition: univalue.h:85
const UniValue & find_value(std::string_view key) const
Definition: univalue.cpp:233
@ VNULL
Definition: univalue.h:24
@ VOBJ
Definition: univalue.h:24
@ VARR
Definition: univalue.h:24
bool isNull() const
Definition: univalue.h:79
const UniValue & get_obj() const
size_t size() const
Definition: univalue.h:71
bool isStr() const
Definition: univalue.h:83
Int getInt() const
Definition: univalue.h:138
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:126
bool IsValid() const
Definition: validation.h:105
std::string GetRejectReason() const
Definition: validation.h:109
bool IsError() const
Definition: validation.h:107
std::string ToString() const
Definition: validation.h:111
bool IsInvalid() const
Definition: validation.h:106
BIP9GBTStatus GBTStatus(const CBlockIndex &block_index, const Consensus::Params &params) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
256-bit unsigned big integer.
arith_uint256 & SetCompact(uint32_t nCompact, bool *pfNegative=nullptr, bool *pfOverflow=nullptr)
The "compact" format is a representation of a whole number N using an unsigned 32bit number similar t...
std::string GetHex() const
Definition: uint256.cpp:11
double getdouble() const
std::string GetHex() const
Hex encoding of the number (with the most significant digits first).
Block template interface.
Definition: mining.h:32
Interface giving clients (RPC, Stratum v2 Template Provider in the future) ability to create block te...
Definition: mining.h:80
virtual std::optional< BlockRef > waitTipChanged(uint256 current_tip, MillisecondsDouble timeout=MillisecondsDouble::max())=0
Waits for the connected tip to change.
virtual bool isInitialBlockDownload()=0
Returns whether IBD is still in progress.
virtual std::unique_ptr< BlockTemplate > createNewBlock(const node::BlockCreateOptions &options={})=0
Construct a new block template.
virtual std::optional< BlockRef > getTip()=0
Returns the hash and height for the tip of this chain.
virtual bool isTestChain()=0
If this chain is exclusively used for testing.
Generate a new block, without valid proof-of-work.
Definition: miner.h:151
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void BlockChecked(const CBlock &block, const BlockValidationState &stateIn) override
Notifies listeners of a block validation result.
Definition: mining.cpp:1040
submitblock_StateCatcher(const uint256 &hashIn)
Definition: mining.cpp:1037
BlockValidationState state
Definition: mining.cpp:1035
std::string GetHex() const
256-bit opaque blob.
Definition: uint256.h:196
static std::optional< uint256 > FromHex(std::string_view str)
Definition: uint256.h:198
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:317
static int32_t GetTransactionWeight(const CTransaction &tx)
Definition: validation.h:132
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
Definition: consensus.h:15
static const unsigned int MAX_BLOCK_SERIALIZED_SIZE
The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
Definition: consensus.h:13
static const int64_t MAX_BLOCK_SIGOPS_COST
The maximum allowed number of signature check operations in a block (network rule)
Definition: consensus.h:17
static const int WITNESS_SCALE_FACTOR
Definition: consensus.h:21
std::string EncodeHexTx(const CTransaction &tx)
Definition: core_write.cpp:143
bool DecodeHexBlk(CBlock &, const std::string &strHexBlk)
Definition: core_read.cpp:220
bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header)
Definition: core_read.cpp:206
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
Definition: core_read.cpp:196
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const Consensus::Params &params, Consensus::BuriedDeployment dep, VersionBitsCache &versionbitscache)
Determine if a deployment is active for the next block.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:29
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
Definition: key_io.cpp:299
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition: merkle.cpp:66
@ DEPLOYMENT_SEGWIT
Definition: params.h:29
Definition: messages.h:20
void RegenerateCommitments(CBlock &block, ChainstateManager &chainman)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed.
Definition: miner.cpp:66
int64_t GetMinimumTime(const CBlockIndex *pindexPrev, const int64_t difficulty_adjustment_interval)
Get the minimum time a miner should use in the next block.
Definition: miner.cpp:35
int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &consensusParams, const CBlockIndex *pindexPrev)
Definition: miner.cpp:48
UniValue GetWarningsForRpc(const Warnings &warnings, bool use_deprecated)
RPC helper function that wraps warnings.GetMessages().
Definition: warnings.cpp:54
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:233
std::vector< uint32_t > GetDust(const CTransaction &tx, CFeeRate dust_relay_rate)
Get the vout index numbers of all dust outputs.
Definition: policy.cpp:70
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params &params)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
Definition: pow.cpp:140
static constexpr TransactionSerParams TX_WITH_WITNESS
Definition: transaction.h:195
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:70
const char * name
Definition: rest.cpp:49
static UniValue GetNetworkHashPS(int lookup, int height, const CChain &active_chain)
Return average network hashes per second based on the last 'lookup' blocks, or from the last difficul...
Definition: mining.cpp:65
static RPCHelpMan generateblock()
Definition: mining.cpp:305
static RPCHelpMan generatetodescriptor()
Definition: mining.cpp:219
static bool getScriptFromDescriptor(const std::string &descriptor, CScript &script, std::string &error)
Definition: mining.cpp:184
static UniValue generateBlocks(ChainstateManager &chainman, Mining &miner, const CScript &coinbase_output_script, int nGenerate, uint64_t nMaxTries)
Definition: mining.cpp:164
static RPCHelpMan getnetworkhashps()
Definition: mining.cpp:111
static std::string gbt_rule_value(const std::string &name, bool gbt_optional_rule)
Definition: mining.cpp:602
static RPCHelpMan getprioritisedtransactions()
Definition: mining.cpp:543
static UniValue BIP22ValidationResult(const BlockValidationState &state)
Definition: mining.cpp:583
static RPCHelpMan submitblock()
Definition: mining.cpp:1048
static RPCHelpMan getblocktemplate()
Definition: mining.cpp:611
static RPCHelpMan generate()
Definition: mining.cpp:257
static RPCHelpMan submitheader()
Definition: mining.cpp:1100
static RPCHelpMan prioritisetransaction()
Definition: mining.cpp:498
static bool GenerateBlock(ChainstateManager &chainman, CBlock &&block, uint64_t &max_tries, std::shared_ptr< const CBlock > &block_out, bool process_new_block)
Definition: mining.cpp:137
static RPCHelpMan getmininginfo()
Definition: mining.cpp:416
static RPCHelpMan generatetoaddress()
Definition: mining.cpp:264
void RegisterMiningRPCCommands(CRPCTable &t)
Definition: mining.cpp:1140
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
Definition: mining.h:9
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:40
@ RPC_METHOD_NOT_FOUND
Definition: protocol.h:32
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
Definition: protocol.h:41
@ RPC_CLIENT_NOT_CONNECTED
P2P client errors.
Definition: protocol.h:58
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:44
@ RPC_VERIFY_ERROR
General error during transaction or block submission.
Definition: protocol.h:47
@ RPC_INTERNAL_ERROR
Definition: protocol.h:36
@ RPC_CLIENT_IN_INITIAL_DOWNLOAD
Still downloading initial blocks.
Definition: protocol.h:59
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
Definition: protocol.h:46
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:42
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:186
uint256 GetTarget(const CBlockIndex &blockindex, const uint256 pow_limit)
Definition: util.cpp:1404
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:204
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
Definition: util.cpp:46
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
Definition: util.cpp:120
bool IsDeprecatedRPCEnabled(const std::string &method)
Definition: server.cpp:345
bool IsRPCRunning()
Query whether RPC is running.
Definition: server.cpp:314
ChainstateManager & EnsureAnyChainman(const std::any &context)
Definition: server_util.cpp:82
void NextEmptyBlockIndex(CBlockIndex &tip, const Consensus::Params &consensusParams, CBlockIndex &next_index)
Return an empty block index on top of the tip, with height, time and nBits set.
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:25
CTxMemPool & EnsureMemPool(const NodeContext &node)
Definition: server_util.cpp:34
ChainstateManager & EnsureChainman(const NodeContext &node)
Definition: server_util.cpp:74
CTxMemPool & EnsureAnyMemPool(const std::any &context)
Definition: server_util.cpp:42
interfaces::Mining & EnsureMining(const NodeContext &node)
CConnman & EnsureConnman(const NodeContext &node)
A mutable version of CTransaction.
Definition: transaction.h:378
Parameters that influence chain consensus.
Definition: params.h:83
std::vector< uint8_t > signet_challenge
Definition: params.h:136
int64_t DifficultyAdjustmentInterval() const
Definition: params.h:125
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
Definition: params.h:135
uint256 powLimit
Proof of work parameters.
Definition: params.h:111
@ STR_HEX
Special type that is a STR with only hex chars.
std::string DefaultHint
Hint for default value.
Definition: util.h:216
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ NO
Required arg.
@ NUM_TIME
Special numeric to denote unix epoch time.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
Hash/height pair to help track and identify blocks.
Definition: types.h:13
NodeContext struct containing references to chain state and connection state.
Definition: context.h:56
#define ENTER_CRITICAL_SECTION(cs)
Definition: sync.h:265
#define LEAVE_CRITICAL_SECTION(cs)
Definition: sync.h:271
#define LOCK(cs)
Definition: sync.h:257
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
const UniValue NullUniValue
Definition: univalue.cpp:16
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
Definition: time.cpp:76
std::chrono::duration< double, std::chrono::milliseconds::period > MillisecondsDouble
Definition: time.h:88
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, Chainstate &chainstate, const CBlock &block, CBlockIndex *pindexPrev, bool fCheckPOW, bool fCheckMerkleRoot)
Check a block is completely valid from start to finish (only works on top of our current best block)