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 <cstdint>
47#include <memory>
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
391 if (BlockValidationState state{TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/false)}; !state.IsValid()) {
392 throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
393 }
394 }
395
396 std::shared_ptr<const CBlock> block_out;
397 uint64_t max_tries{DEFAULT_MAX_TRIES};
398
399 if (!GenerateBlock(chainman, std::move(block), max_tries, block_out, process_new_block) || !block_out) {
400 throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
401 }
402
404 obj.pushKV("hash", block_out->GetHash().GetHex());
405 if (!process_new_block) {
406 DataStream block_ser;
407 block_ser << TX_WITH_WITNESS(*block_out);
408 obj.pushKV("hex", HexStr(block_ser));
409 }
410 return obj;
411},
412 };
413}
414
416{
417 return RPCHelpMan{
418 "getmininginfo",
419 "Returns a json object containing mining-related information.",
420 {},
421 RPCResult{
422 RPCResult::Type::OBJ, "", "",
423 {
424 {RPCResult::Type::NUM, "blocks", "The current block"},
425 {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 {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 {RPCResult::Type::STR_HEX, "bits", "The current nBits, compact representation of the block difficulty target"},
428 {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
429 {RPCResult::Type::STR_HEX, "target", "The current target"},
430 {RPCResult::Type::NUM, "networkhashps", "The network hashes per second"},
431 {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
432 {RPCResult::Type::STR, "chain", "current network name (" LIST_CHAIN_NAMES ")"},
433 {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)"},
434 {RPCResult::Type::OBJ, "next", "The next block",
435 {
436 {RPCResult::Type::NUM, "height", "The next height"},
437 {RPCResult::Type::STR_HEX, "bits", "The next target nBits"},
438 {RPCResult::Type::NUM, "difficulty", "The next difficulty"},
439 {RPCResult::Type::STR_HEX, "target", "The next target"}
440 }},
441 (IsDeprecatedRPCEnabled("warnings") ?
442 RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
443 RPCResult{RPCResult::Type::ARR, "warnings", "any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
444 {
445 {RPCResult::Type::STR, "", "warning"},
446 }
447 }
448 ),
449 }},
451 HelpExampleCli("getmininginfo", "")
452 + HelpExampleRpc("getmininginfo", "")
453 },
454 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
455{
456 NodeContext& node = EnsureAnyNodeContext(request.context);
457 const CTxMemPool& mempool = EnsureMemPool(node);
459 LOCK(cs_main);
460 const CChain& active_chain = chainman.ActiveChain();
461 CBlockIndex& tip{*CHECK_NONFATAL(active_chain.Tip())};
462
464 obj.pushKV("blocks", active_chain.Height());
465 if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
466 if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
467 obj.pushKV("bits", strprintf("%08x", tip.nBits));
468 obj.pushKV("difficulty", GetDifficulty(tip));
469 obj.pushKV("target", GetTarget(tip, chainman.GetConsensus().powLimit).GetHex());
470 obj.pushKV("networkhashps", getnetworkhashps().HandleRequest(request));
471 obj.pushKV("pooledtx", (uint64_t)mempool.size());
472 obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
473
475 CBlockIndex next_index;
476 NextEmptyBlockIndex(tip, chainman.GetConsensus(), next_index);
477
478 next.pushKV("height", next_index.nHeight);
479 next.pushKV("bits", strprintf("%08x", next_index.nBits));
480 next.pushKV("difficulty", GetDifficulty(next_index));
481 next.pushKV("target", GetTarget(next_index, chainman.GetConsensus().powLimit).GetHex());
482 obj.pushKV("next", next);
483
484 if (chainman.GetParams().GetChainType() == ChainType::SIGNET) {
485 const std::vector<uint8_t>& signet_challenge =
487 obj.pushKV("signet_challenge", HexStr(signet_challenge));
488 }
489 obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));
490 return obj;
491},
492 };
493}
494
495
496// NOTE: Unlike wallet RPC (which use BTC values), mining RPCs follow GBT (BIP 22) in using satoshi amounts
498{
499 return RPCHelpMan{"prioritisetransaction",
500 "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
501 {
502 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
503 {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "API-Compatibility for previous API. Must be zero or null.\n"
504 " DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
505 {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO, "The fee value (in satoshis) to add (or subtract, if negative).\n"
506 " Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
507 " The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
508 " considers the transaction as it would have paid a higher (or lower) fee."},
509 },
510 RPCResult{
511 RPCResult::Type::BOOL, "", "Returns true"},
513 HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000")
514 + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")
515 },
516 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
517{
518 LOCK(cs_main);
519
520 uint256 hash(ParseHashV(request.params[0], "txid"));
521 const auto dummy{self.MaybeArg<double>("dummy")};
522 CAmount nAmount = request.params[2].getInt<int64_t>();
523
524 if (dummy && *dummy != 0) {
525 throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.");
526 }
527
528 CTxMemPool& mempool = EnsureAnyMemPool(request.context);
529
530 // Non-0 fee dust transactions are not allowed for entry, and modification not allowed afterwards
531 const auto& tx = mempool.get(hash);
532 if (mempool.m_opts.require_standard && tx && !GetDust(*tx, mempool.m_opts.dust_relay_feerate).empty()) {
533 throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is not supported for transactions with dust outputs.");
534 }
535
536 mempool.PrioritiseTransaction(hash, nAmount);
537 return true;
538},
539 };
540}
541
543{
544 return RPCHelpMan{"getprioritisedtransactions",
545 "Returns a map of all user-created (see prioritisetransaction) fee deltas by txid, and whether the tx is present in mempool.",
546 {},
547 RPCResult{
548 RPCResult::Type::OBJ_DYN, "", "prioritisation keyed by txid",
549 {
550 {RPCResult::Type::OBJ, "<transactionid>", "", {
551 {RPCResult::Type::NUM, "fee_delta", "transaction fee delta in satoshis"},
552 {RPCResult::Type::BOOL, "in_mempool", "whether this transaction is currently in mempool"},
553 {RPCResult::Type::NUM, "modified_fee", /*optional=*/true, "modified fee in satoshis. Only returned if in_mempool=true"},
554 }}
555 },
556 },
558 HelpExampleCli("getprioritisedtransactions", "")
559 + HelpExampleRpc("getprioritisedtransactions", "")
560 },
561 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
562 {
563 NodeContext& node = EnsureAnyNodeContext(request.context);
564 CTxMemPool& mempool = EnsureMemPool(node);
565 UniValue rpc_result{UniValue::VOBJ};
566 for (const auto& delta_info : mempool.GetPrioritisedTransactions()) {
567 UniValue result_inner{UniValue::VOBJ};
568 result_inner.pushKV("fee_delta", delta_info.delta);
569 result_inner.pushKV("in_mempool", delta_info.in_mempool);
570 if (delta_info.in_mempool) {
571 result_inner.pushKV("modified_fee", *delta_info.modified_fee);
572 }
573 rpc_result.pushKV(delta_info.txid.GetHex(), std::move(result_inner));
574 }
575 return rpc_result;
576 },
577 };
578}
579
580
581// NOTE: Assumes a conclusive result; if result is inconclusive, it must be handled by caller
583{
584 if (state.IsValid())
585 return UniValue::VNULL;
586
587 if (state.IsError())
588 throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
589 if (state.IsInvalid())
590 {
591 std::string strRejectReason = state.GetRejectReason();
592 if (strRejectReason.empty())
593 return "rejected";
594 return strRejectReason;
595 }
596 // Should be impossible
597 return "valid?";
598}
599
600// Prefix rule name with ! if not optional, see BIP9
601static std::string gbt_rule_value(const std::string& name, bool gbt_optional_rule)
602{
603 std::string s{name};
604 if (!gbt_optional_rule) {
605 s.insert(s.begin(), '!');
606 }
607 return s;
608}
609
611{
612 return RPCHelpMan{
613 "getblocktemplate",
614 "If the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
615 "It returns data needed to construct a block to work on.\n"
616 "For full specification, see BIPs 22, 23, 9, and 145:\n"
617 " https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
618 " https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
619 " https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
620 " https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n",
621 {
622 {"template_request", RPCArg::Type::OBJ, RPCArg::Optional::NO, "Format of the template",
623 {
624 {"mode", RPCArg::Type::STR, /* treat as named arg */ RPCArg::Optional::OMITTED, "This must be set to \"template\", \"proposal\" (see BIP 23), or omitted"},
625 {"capabilities", RPCArg::Type::ARR, /* treat as named arg */ RPCArg::Optional::OMITTED, "A list of strings",
626 {
627 {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "client side supported feature, 'longpoll', 'coinbasevalue', 'proposal', 'serverlist', 'workid'"},
628 }},
629 {"rules", RPCArg::Type::ARR, RPCArg::Optional::NO, "A list of strings",
630 {
631 {"segwit", RPCArg::Type::STR, RPCArg::Optional::NO, "(literal) indicates client side segwit support"},
632 {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "other client side supported softfork deployment"},
633 }},
634 {"longpollid", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "delay processing request until the result would vary significantly from the \"longpollid\" of a prior template"},
635 {"data", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "proposed block data to check, encoded in hexadecimal; valid only for mode=\"proposal\""},
636 },
637 },
638 },
639 {
640 RPCResult{"If the proposal was accepted with mode=='proposal'", RPCResult::Type::NONE, "", ""},
641 RPCResult{"If the proposal was not accepted with mode=='proposal'", RPCResult::Type::STR, "", "According to BIP22"},
642 RPCResult{"Otherwise", RPCResult::Type::OBJ, "", "",
643 {
644 {RPCResult::Type::NUM, "version", "The preferred block version"},
645 {RPCResult::Type::ARR, "rules", "specific block rules that are to be enforced",
646 {
647 {RPCResult::Type::STR, "", "name of a rule the client must understand to some extent; see BIP 9 for format"},
648 }},
649 {RPCResult::Type::OBJ_DYN, "vbavailable", "set of pending, supported versionbit (BIP 9) softfork deployments",
650 {
651 {RPCResult::Type::NUM, "rulename", "identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
652 }},
653 {RPCResult::Type::ARR, "capabilities", "",
654 {
655 {RPCResult::Type::STR, "value", "A supported feature, for example 'proposal'"},
656 }},
657 {RPCResult::Type::NUM, "vbrequired", "bit mask of versionbits the server requires set in submissions"},
658 {RPCResult::Type::STR, "previousblockhash", "The hash of current highest block"},
659 {RPCResult::Type::ARR, "transactions", "contents of non-coinbase transactions that should be included in the next block",
660 {
661 {RPCResult::Type::OBJ, "", "",
662 {
663 {RPCResult::Type::STR_HEX, "data", "transaction data encoded in hexadecimal (byte-for-byte)"},
664 {RPCResult::Type::STR_HEX, "txid", "transaction hash excluding witness data, shown in byte-reversed hex"},
665 {RPCResult::Type::STR_HEX, "hash", "transaction hash including witness data, shown in byte-reversed hex"},
666 {RPCResult::Type::ARR, "depends", "array of numbers",
667 {
668 {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"},
669 }},
670 {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"},
671 {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"},
672 {RPCResult::Type::NUM, "weight", "total transaction weight, as counted for purposes of block limits"},
673 }},
674 }},
675 {RPCResult::Type::OBJ_DYN, "coinbaseaux", "data that should be included in the coinbase's scriptSig content",
676 {
677 {RPCResult::Type::STR_HEX, "key", "values must be in the coinbase (keys may be ignored)"},
678 }},
679 {RPCResult::Type::NUM, "coinbasevalue", "maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
680 {RPCResult::Type::STR, "longpollid", "an id to include with a request to longpoll on an update to this template"},
681 {RPCResult::Type::STR, "target", "The hash target"},
682 {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."},
683 {RPCResult::Type::ARR, "mutable", "list of ways the block template may be changed",
684 {
685 {RPCResult::Type::STR, "value", "A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
686 }},
687 {RPCResult::Type::STR_HEX, "noncerange", "A range of valid nonces"},
688 {RPCResult::Type::NUM, "sigoplimit", "limit of sigops in blocks"},
689 {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
690 {RPCResult::Type::NUM, "weightlimit", /*optional=*/true, "limit of block weight"},
691 {RPCResult::Type::NUM_TIME, "curtime", "current timestamp in " + UNIX_EPOCH_TIME + ". Adjusted for the proposed BIP94 timewarp rule."},
692 {RPCResult::Type::STR, "bits", "compressed target of next block"},
693 {RPCResult::Type::NUM, "height", "The height of the next block"},
694 {RPCResult::Type::STR_HEX, "signet_challenge", /*optional=*/true, "Only on signet"},
695 {RPCResult::Type::STR_HEX, "default_witness_commitment", /*optional=*/true, "a valid witness commitment for the unmodified block template"},
696 }},
697 },
699 HelpExampleCli("getblocktemplate", "'{\"rules\": [\"segwit\"]}'")
700 + HelpExampleRpc("getblocktemplate", "{\"rules\": [\"segwit\"]}")
701 },
702 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
703{
704 NodeContext& node = EnsureAnyNodeContext(request.context);
706 Mining& miner = EnsureMining(node);
707 LOCK(cs_main);
708 uint256 tip{CHECK_NONFATAL(miner.getTip()).value().hash};
709
710 std::string strMode = "template";
711 UniValue lpval = NullUniValue;
712 std::set<std::string> setClientRules;
713 if (!request.params[0].isNull())
714 {
715 const UniValue& oparam = request.params[0].get_obj();
716 const UniValue& modeval = oparam.find_value("mode");
717 if (modeval.isStr())
718 strMode = modeval.get_str();
719 else if (modeval.isNull())
720 {
721 /* Do nothing */
722 }
723 else
724 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
725 lpval = oparam.find_value("longpollid");
726
727 if (strMode == "proposal")
728 {
729 const UniValue& dataval = oparam.find_value("data");
730 if (!dataval.isStr())
731 throw JSONRPCError(RPC_TYPE_ERROR, "Missing data String key for proposal");
732
733 CBlock block;
734 if (!DecodeHexBlk(block, dataval.get_str()))
735 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
736
737 uint256 hash = block.GetHash();
738 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
739 if (pindex) {
740 if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
741 return "duplicate";
742 if (pindex->nStatus & BLOCK_FAILED_MASK)
743 return "duplicate-invalid";
744 return "duplicate-inconclusive";
745 }
746
747 return BIP22ValidationResult(TestBlockValidity(chainman.ActiveChainstate(), block, /*check_pow=*/false, /*check_merkle_root=*/true));
748 }
749
750 const UniValue& aClientRules = oparam.find_value("rules");
751 if (aClientRules.isArray()) {
752 for (unsigned int i = 0; i < aClientRules.size(); ++i) {
753 const UniValue& v = aClientRules[i];
754 setClientRules.insert(v.get_str());
755 }
756 }
757 }
758
759 if (strMode != "template")
760 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
761
762 if (!miner.isTestChain()) {
763 const CConnman& connman = EnsureConnman(node);
764 if (connman.GetNodeCount(ConnectionDirection::Both) == 0) {
765 throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, CLIENT_NAME " is not connected!");
766 }
767
768 if (miner.isInitialBlockDownload()) {
769 throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, CLIENT_NAME " is in initial sync and waiting for blocks...");
770 }
771 }
772
773 static unsigned int nTransactionsUpdatedLast;
774 const CTxMemPool& mempool = EnsureMemPool(node);
775
776 // Long Polling (BIP22)
777 if (!lpval.isNull()) {
792 uint256 hashWatchedChain;
793 unsigned int nTransactionsUpdatedLastLP;
794
795 if (lpval.isStr())
796 {
797 // Format: <hashBestChain><nTransactionsUpdatedLast>
798 const std::string& lpstr = lpval.get_str();
799
800 // Assume the longpollid is a block hash. If it's not then we return
801 // early below.
802 hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
803 nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
804 }
805 else
806 {
807 // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
808 hashWatchedChain = tip;
809 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
810 }
811
812 // Release lock while waiting
814 {
815 MillisecondsDouble checktxtime{std::chrono::minutes(1)};
816 while (IsRPCRunning()) {
817 // If hashWatchedChain is not a real block hash, this will
818 // return immediately.
819 std::optional<BlockRef> maybe_tip{miner.waitTipChanged(hashWatchedChain, checktxtime)};
820 // Node is shutting down
821 if (!maybe_tip) break;
822 tip = maybe_tip->hash;
823 if (tip != hashWatchedChain) break;
824
825 // Check transactions for update without holding the mempool
826 // lock to avoid deadlocks.
827 if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP) {
828 break;
829 }
830 checktxtime = std::chrono::seconds(10);
831 }
832 }
834
835 tip = CHECK_NONFATAL(miner.getTip()).value().hash;
836
837 if (!IsRPCRunning())
838 throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
839 // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
840 }
841
842 const Consensus::Params& consensusParams = chainman.GetParams().GetConsensus();
843
844 // GBT must be called with 'signet' set in the rules for signet chains
845 if (consensusParams.signet_blocks && setClientRules.count("signet") != 1) {
846 throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the signet rule set (call with {\"rules\": [\"segwit\", \"signet\"]})");
847 }
848
849 // GBT must be called with 'segwit' set in the rules
850 if (setClientRules.count("segwit") != 1) {
851 throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
852 }
853
854 // Update block
855 static CBlockIndex* pindexPrev;
856 static int64_t time_start;
857 static std::unique_ptr<BlockTemplate> block_template;
858 if (!pindexPrev || pindexPrev->GetBlockHash() != tip ||
859 (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - time_start > 5))
860 {
861 // Clear pindexPrev so future calls make a new block, despite any failures from here on
862 pindexPrev = nullptr;
863
864 // Store the pindexBest used before createNewBlock, to avoid races
865 nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
866 CBlockIndex* pindexPrevNew = chainman.m_blockman.LookupBlockIndex(tip);
867 time_start = GetTime();
868
869 // Create new block
870 block_template = miner.createNewBlock();
871 CHECK_NONFATAL(block_template);
872
873
874 // Need to update only after we know createNewBlock succeeded
875 pindexPrev = pindexPrevNew;
876 }
877 CHECK_NONFATAL(pindexPrev);
878 CBlock block{block_template->getBlock()};
879
880 // Update nTime
881 UpdateTime(&block, consensusParams, pindexPrev);
882 block.nNonce = 0;
883
884 // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
885 const bool fPreSegWit = !DeploymentActiveAfter(pindexPrev, chainman, Consensus::DEPLOYMENT_SEGWIT);
886
887 UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
888
889 UniValue transactions(UniValue::VARR);
890 std::map<uint256, int64_t> setTxIndex;
891 std::vector<CAmount> tx_fees{block_template->getTxFees()};
892 std::vector<CAmount> tx_sigops{block_template->getTxSigops()};
893
894 int i = 0;
895 for (const auto& it : block.vtx) {
896 const CTransaction& tx = *it;
897 uint256 txHash = tx.GetHash();
898 setTxIndex[txHash] = i++;
899
900 if (tx.IsCoinBase())
901 continue;
902
904
905 entry.pushKV("data", EncodeHexTx(tx));
906 entry.pushKV("txid", txHash.GetHex());
907 entry.pushKV("hash", tx.GetWitnessHash().GetHex());
908
910 for (const CTxIn &in : tx.vin)
911 {
912 if (setTxIndex.count(in.prevout.hash))
913 deps.push_back(setTxIndex[in.prevout.hash]);
914 }
915 entry.pushKV("depends", std::move(deps));
916
917 int index_in_template = i - 2;
918 entry.pushKV("fee", tx_fees.at(index_in_template));
919 int64_t nTxSigOps{tx_sigops.at(index_in_template)};
920 if (fPreSegWit) {
921 CHECK_NONFATAL(nTxSigOps % WITNESS_SCALE_FACTOR == 0);
922 nTxSigOps /= WITNESS_SCALE_FACTOR;
923 }
924 entry.pushKV("sigops", nTxSigOps);
925 entry.pushKV("weight", GetTransactionWeight(tx));
926
927 transactions.push_back(std::move(entry));
928 }
929
931
932 arith_uint256 hashTarget = arith_uint256().SetCompact(block.nBits);
933
934 UniValue aMutable(UniValue::VARR);
935 aMutable.push_back("time");
936 aMutable.push_back("transactions");
937 aMutable.push_back("prevblock");
938
939 UniValue result(UniValue::VOBJ);
940 result.pushKV("capabilities", std::move(aCaps));
941
942 UniValue aRules(UniValue::VARR);
943 aRules.push_back("csv");
944 if (!fPreSegWit) aRules.push_back("!segwit");
945 if (consensusParams.signet_blocks) {
946 // indicate to miner that they must understand signet rules
947 // when attempting to mine with this template
948 aRules.push_back("!signet");
949 }
950
951 UniValue vbavailable(UniValue::VOBJ);
952 const auto gbtstatus = chainman.m_versionbitscache.GBTStatus(*pindexPrev, consensusParams);
953
954 for (const auto& [name, info] : gbtstatus.signalling) {
955 vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
956 if (!info.gbt_optional_rule && !setClientRules.count(name)) {
957 // If the client doesn't support this, don't indicate it in the [default] version
958 block.nVersion &= ~info.mask;
959 }
960 }
961
962 for (const auto& [name, info] : gbtstatus.locked_in) {
963 block.nVersion |= info.mask;
964 vbavailable.pushKV(gbt_rule_value(name, info.gbt_optional_rule), info.bit);
965 if (!info.gbt_optional_rule && !setClientRules.count(name)) {
966 // If the client doesn't support this, don't indicate it in the [default] version
967 block.nVersion &= ~info.mask;
968 }
969 }
970
971 for (const auto& [name, info] : gbtstatus.active) {
972 aRules.push_back(gbt_rule_value(name, info.gbt_optional_rule));
973 if (!info.gbt_optional_rule && !setClientRules.count(name)) {
974 // Not supported by the client; make sure it's safe to proceed
975 throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", name));
976 }
977 }
978
979 result.pushKV("version", block.nVersion);
980 result.pushKV("rules", std::move(aRules));
981 result.pushKV("vbavailable", std::move(vbavailable));
982 result.pushKV("vbrequired", int(0));
983
984 result.pushKV("previousblockhash", block.hashPrevBlock.GetHex());
985 result.pushKV("transactions", std::move(transactions));
986 result.pushKV("coinbaseaux", std::move(aux));
987 result.pushKV("coinbasevalue", (int64_t)block.vtx[0]->vout[0].nValue);
988 result.pushKV("longpollid", tip.GetHex() + ToString(nTransactionsUpdatedLast));
989 result.pushKV("target", hashTarget.GetHex());
990 result.pushKV("mintime", GetMinimumTime(pindexPrev, consensusParams.DifficultyAdjustmentInterval()));
991 result.pushKV("mutable", std::move(aMutable));
992 result.pushKV("noncerange", "00000000ffffffff");
993 int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
994 int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
995 if (fPreSegWit) {
996 CHECK_NONFATAL(nSigOpLimit % WITNESS_SCALE_FACTOR == 0);
997 nSigOpLimit /= WITNESS_SCALE_FACTOR;
998 CHECK_NONFATAL(nSizeLimit % WITNESS_SCALE_FACTOR == 0);
999 nSizeLimit /= WITNESS_SCALE_FACTOR;
1000 }
1001 result.pushKV("sigoplimit", nSigOpLimit);
1002 result.pushKV("sizelimit", nSizeLimit);
1003 if (!fPreSegWit) {
1004 result.pushKV("weightlimit", (int64_t)MAX_BLOCK_WEIGHT);
1005 }
1006 result.pushKV("curtime", block.GetBlockTime());
1007 result.pushKV("bits", strprintf("%08x", block.nBits));
1008 result.pushKV("height", (int64_t)(pindexPrev->nHeight+1));
1009
1010 if (consensusParams.signet_blocks) {
1011 result.pushKV("signet_challenge", HexStr(consensusParams.signet_challenge));
1012 }
1013
1014 if (!block_template->getCoinbaseCommitment().empty()) {
1015 result.pushKV("default_witness_commitment", HexStr(block_template->getCoinbaseCommitment()));
1016 }
1017
1018 return result;
1019},
1020 };
1021}
1022
1024{
1025public:
1027 bool found{false};
1029
1030 explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), state() {}
1031
1032protected:
1033 void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override {
1034 if (block.GetHash() != hash)
1035 return;
1036 found = true;
1037 state = stateIn;
1038 }
1039};
1040
1042{
1043 // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
1044 return RPCHelpMan{
1045 "submitblock",
1046 "Attempts to submit new block to network.\n"
1047 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1048 {
1049 {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
1050 {"dummy", RPCArg::Type::STR, RPCArg::DefaultHint{"ignored"}, "dummy value, for compatibility with BIP22. This value is ignored."},
1051 },
1052 {
1053 RPCResult{"If the block was accepted", RPCResult::Type::NONE, "", ""},
1054 RPCResult{"Otherwise", RPCResult::Type::STR, "", "According to BIP22"},
1055 },
1057 HelpExampleCli("submitblock", "\"mydata\"")
1058 + HelpExampleRpc("submitblock", "\"mydata\"")
1059 },
1060 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1061{
1062 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1063 CBlock& block = *blockptr;
1064 if (!DecodeHexBlk(block, request.params[0].get_str())) {
1065 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
1066 }
1067
1068 ChainstateManager& chainman = EnsureAnyChainman(request.context);
1069 {
1070 LOCK(cs_main);
1071 const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
1072 if (pindex) {
1073 chainman.UpdateUncommittedBlockStructures(block, pindex);
1074 }
1075 }
1076
1077 bool new_block;
1078 auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
1079 CHECK_NONFATAL(chainman.m_options.signals)->RegisterSharedValidationInterface(sc);
1080 bool accepted = chainman.ProcessNewBlock(blockptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
1081 CHECK_NONFATAL(chainman.m_options.signals)->UnregisterSharedValidationInterface(sc);
1082 if (!new_block && accepted) {
1083 return "duplicate";
1084 }
1085 if (!sc->found) {
1086 return "inconclusive";
1087 }
1088 return BIP22ValidationResult(sc->state);
1089},
1090 };
1091}
1092
1094{
1095 return RPCHelpMan{
1096 "submitheader",
1097 "Decode the given hexdata as a header and submit it as a candidate chain tip if valid."
1098 "\nThrows when the header is invalid.\n",
1099 {
1100 {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
1101 },
1102 RPCResult{
1103 RPCResult::Type::NONE, "", "None"},
1105 HelpExampleCli("submitheader", "\"aabbcc\"") +
1106 HelpExampleRpc("submitheader", "\"aabbcc\"")
1107 },
1108 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1109{
1110 CBlockHeader h;
1111 if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
1112 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
1113 }
1114 ChainstateManager& chainman = EnsureAnyChainman(request.context);
1115 {
1116 LOCK(cs_main);
1117 if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
1118 throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
1119 }
1120 }
1121
1123 chainman.ProcessNewBlockHeaders({{h}}, /*min_pow_checked=*/true, state);
1124 if (state.IsValid()) return UniValue::VNULL;
1125 if (state.IsError()) {
1126 throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
1127 }
1129},
1130 };
1131}
1132
1134{
1135 static const CRPCCommand commands[]{
1136 {"mining", &getnetworkhashps},
1137 {"mining", &getmininginfo},
1138 {"mining", &prioritisetransaction},
1139 {"mining", &getprioritisedtransactions},
1140 {"mining", &getblocktemplate},
1141 {"mining", &submitblock},
1142 {"mining", &submitheader},
1143
1144 {"hidden", &generatetoaddress},
1145 {"hidden", &generatetodescriptor},
1146 {"hidden", &generateblock},
1147 {"hidden", &generate},
1148 };
1149 for (const auto& c : commands) {
1150 t.appendCommand(c.name, &c);
1151 }
1152}
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:881
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:1105
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
Definition: validation.h:1014
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:1016
VersionBitsCache m_versionbitscache
Track versionbit status.
Definition: validation.h:1129
const CChainParams & GetParams() const
Definition: validation.h:989
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:990
const Options m_options
Definition: validation.h:1017
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
Definition: validation.h:1106
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:1020
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:148
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:1033
submitblock_StateCatcher(const uint256 &hashIn)
Definition: mining.cpp:1030
BlockValidationState state
Definition: mining.cpp:1028
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:601
static RPCHelpMan getprioritisedtransactions()
Definition: mining.cpp:542
static UniValue BIP22ValidationResult(const BlockValidationState &state)
Definition: mining.cpp:582
static RPCHelpMan submitblock()
Definition: mining.cpp:1041
static RPCHelpMan getblocktemplate()
Definition: mining.cpp:610
static RPCHelpMan generate()
Definition: mining.cpp:257
static RPCHelpMan submitheader()
Definition: mining.cpp:1093
static RPCHelpMan prioritisetransaction()
Definition: mining.cpp:497
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:415
static RPCHelpMan generatetoaddress()
Definition: mining.cpp:264
void RegisterMiningRPCCommands(CRPCTable &t)
Definition: mining.cpp:1133
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:273
#define LEAVE_CRITICAL_SECTION(cs)
Definition: sync.h:279
#define LOCK(cs)
Definition: sync.h:265
#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
BlockValidationState TestBlockValidity(Chainstate &chainstate, const CBlock &block, const bool check_pow, const bool check_merkle_root)
Verify a block, including transactions.