Bitcoin Core  22.99.0
P2P Digital Currency
mining.cpp
Go to the documentation of this file.
1 // Copyright (c) 2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2021 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 <chain.h>
7 #include <chainparams.h>
8 #include <consensus/amount.h>
9 #include <consensus/consensus.h>
10 #include <consensus/params.h>
11 #include <consensus/validation.h>
12 #include <core_io.h>
13 #include <deploymentinfo.h>
14 #include <deploymentstatus.h>
15 #include <key_io.h>
16 #include <net.h>
17 #include <node/context.h>
18 #include <node/miner.h>
19 #include <policy/fees.h>
20 #include <pow.h>
21 #include <rpc/blockchain.h>
22 #include <rpc/mining.h>
23 #include <rpc/server.h>
24 #include <rpc/server_util.h>
25 #include <rpc/util.h>
26 #include <script/descriptor.h>
27 #include <script/script.h>
28 #include <script/signingprovider.h>
29 #include <shutdown.h>
30 #include <txmempool.h>
31 #include <univalue.h>
32 #include <util/fees.h>
33 #include <util/strencodings.h>
34 #include <util/string.h>
35 #include <util/system.h>
36 #include <util/translation.h>
37 #include <validation.h>
38 #include <validationinterface.h>
39 #include <warnings.h>
40 
41 #include <memory>
42 #include <stdint.h>
43 
47 using node::NodeContext;
49 using node::UpdateTime;
50 
56 static UniValue GetNetworkHashPS(int lookup, int height, const CChain& active_chain) {
57  const CBlockIndex* pb = active_chain.Tip();
58 
59  if (height >= 0 && height < active_chain.Height()) {
60  pb = active_chain[height];
61  }
62 
63  if (pb == nullptr || !pb->nHeight)
64  return 0;
65 
66  // If lookup is -1, then use blocks since last difficulty change.
67  if (lookup <= 0)
69 
70  // If lookup is larger than chain, then set it to chain length.
71  if (lookup > pb->nHeight)
72  lookup = pb->nHeight;
73 
74  const CBlockIndex* pb0 = pb;
75  int64_t minTime = pb0->GetBlockTime();
76  int64_t maxTime = minTime;
77  for (int i = 0; i < lookup; i++) {
78  pb0 = pb0->pprev;
79  int64_t time = pb0->GetBlockTime();
80  minTime = std::min(time, minTime);
81  maxTime = std::max(time, maxTime);
82  }
83 
84  // In case there's a situation where minTime == maxTime, we don't want a divide by zero exception.
85  if (minTime == maxTime)
86  return 0;
87 
88  arith_uint256 workDiff = pb->nChainWork - pb0->nChainWork;
89  int64_t timeDiff = maxTime - minTime;
90 
91  return workDiff.getdouble() / timeDiff;
92 }
93 
95 {
96  return RPCHelpMan{"getnetworkhashps",
97  "\nReturns the estimated network hashes per second based on the last n blocks.\n"
98  "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
99  "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
100  {
101  {"nblocks", RPCArg::Type::NUM, RPCArg::Default{120}, "The number of blocks, or -1 for blocks since last difficulty change."},
102  {"height", RPCArg::Type::NUM, RPCArg::Default{-1}, "To estimate at the time of the given height."},
103  },
104  RPCResult{
105  RPCResult::Type::NUM, "", "Hashes per second estimated"},
106  RPCExamples{
107  HelpExampleCli("getnetworkhashps", "")
108  + HelpExampleRpc("getnetworkhashps", "")
109  },
110  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
111 {
112  ChainstateManager& chainman = EnsureAnyChainman(request.context);
113  LOCK(cs_main);
114  return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 120, !request.params[1].isNull() ? request.params[1].get_int() : -1, chainman.ActiveChain());
115 },
116  };
117 }
118 
119 static bool GenerateBlock(ChainstateManager& chainman, CBlock& block, uint64_t& max_tries, unsigned int& extra_nonce, uint256& block_hash)
120 {
121  block_hash.SetNull();
122 
123  {
124  LOCK(cs_main);
125  IncrementExtraNonce(&block, chainman.ActiveChain().Tip(), extra_nonce);
126  }
127 
128  CChainParams chainparams(Params());
129 
130  while (max_tries > 0 && block.nNonce < std::numeric_limits<uint32_t>::max() && !CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus()) && !ShutdownRequested()) {
131  ++block.nNonce;
132  --max_tries;
133  }
134  if (max_tries == 0 || ShutdownRequested()) {
135  return false;
136  }
137  if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
138  return true;
139  }
140 
141  std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
142  if (!chainman.ProcessNewBlock(chainparams, shared_pblock, true, nullptr)) {
143  throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
144  }
145 
146  block_hash = block.GetHash();
147  return true;
148 }
149 
150 static UniValue generateBlocks(ChainstateManager& chainman, const CTxMemPool& mempool, const CScript& coinbase_script, int nGenerate, uint64_t nMaxTries)
151 {
152  int nHeightEnd = 0;
153  int nHeight = 0;
154 
155  { // Don't keep cs_main locked
156  LOCK(cs_main);
157  nHeight = chainman.ActiveChain().Height();
158  nHeightEnd = nHeight+nGenerate;
159  }
160  unsigned int nExtraNonce = 0;
161  UniValue blockHashes(UniValue::VARR);
162  while (nHeight < nHeightEnd && !ShutdownRequested())
163  {
164  std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(chainman.ActiveChainstate(), mempool, Params()).CreateNewBlock(coinbase_script));
165  if (!pblocktemplate.get())
166  throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
167  CBlock *pblock = &pblocktemplate->block;
168 
169  uint256 block_hash;
170  if (!GenerateBlock(chainman, *pblock, nMaxTries, nExtraNonce, block_hash)) {
171  break;
172  }
173 
174  if (!block_hash.IsNull()) {
175  ++nHeight;
176  blockHashes.push_back(block_hash.GetHex());
177  }
178  }
179  return blockHashes;
180 }
181 
182 static bool getScriptFromDescriptor(const std::string& descriptor, CScript& script, std::string& error)
183 {
184  FlatSigningProvider key_provider;
185  const auto desc = Parse(descriptor, key_provider, error, /* require_checksum = */ false);
186  if (desc) {
187  if (desc->IsRange()) {
188  throw JSONRPCError(RPC_INVALID_PARAMETER, "Ranged descriptor not accepted. Maybe pass through deriveaddresses first?");
189  }
190 
191  FlatSigningProvider provider;
192  std::vector<CScript> scripts;
193  if (!desc->Expand(0, key_provider, scripts, provider)) {
194  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Cannot derive script without private keys");
195  }
196 
197  // Combo descriptors can have 2 or 4 scripts, so we can't just check scripts.size() == 1
198  CHECK_NONFATAL(scripts.size() > 0 && scripts.size() <= 4);
199 
200  if (scripts.size() == 1) {
201  script = scripts.at(0);
202  } else if (scripts.size() == 4) {
203  // For uncompressed keys, take the 3rd script, since it is p2wpkh
204  script = scripts.at(2);
205  } else {
206  // Else take the 2nd script, since it is p2pkh
207  script = scripts.at(1);
208  }
209 
210  return true;
211  } else {
212  return false;
213  }
214 }
215 
217 {
218  return RPCHelpMan{
219  "generatetodescriptor",
220  "\nMine blocks immediately to a specified descriptor (before the RPC call returns)\n",
221  {
222  {"num_blocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},
223  {"descriptor", RPCArg::Type::STR, RPCArg::Optional::NO, "The descriptor to send the newly generated bitcoin to."},
224  {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
225  },
226  RPCResult{
227  RPCResult::Type::ARR, "", "hashes of blocks generated",
228  {
229  {RPCResult::Type::STR_HEX, "", "blockhash"},
230  }
231  },
232  RPCExamples{
233  "\nGenerate 11 blocks to mydesc\n" + HelpExampleCli("generatetodescriptor", "11 \"mydesc\"")},
234  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
235 {
236  const int num_blocks{request.params[0].get_int()};
237  const uint64_t max_tries{request.params[2].isNull() ? DEFAULT_MAX_TRIES : request.params[2].get_int()};
238 
239  CScript coinbase_script;
240  std::string error;
241  if (!getScriptFromDescriptor(request.params[1].get_str(), coinbase_script, error)) {
243  }
244 
245  NodeContext& node = EnsureAnyNodeContext(request.context);
246  const CTxMemPool& mempool = EnsureMemPool(node);
248 
249  return generateBlocks(chainman, mempool, coinbase_script, num_blocks, max_tries);
250 },
251  };
252 }
253 
255 {
256  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 {
258  }};
259 }
260 
262 {
263  return RPCHelpMan{"generatetoaddress",
264  "\nMine blocks immediately to a specified address (before the RPC call returns)\n",
265  {
266  {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},
267  {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated bitcoin to."},
268  {"maxtries", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_MAX_TRIES}, "How many iterations to try."},
269  },
270  RPCResult{
271  RPCResult::Type::ARR, "", "hashes of blocks generated",
272  {
273  {RPCResult::Type::STR_HEX, "", "blockhash"},
274  }},
275  RPCExamples{
276  "\nGenerate 11 blocks to myaddress\n"
277  + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
278  + "If you are using the " PACKAGE_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n"
279  + HelpExampleCli("getnewaddress", "")
280  },
281  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
282 {
283  const int num_blocks{request.params[0].get_int()};
284  const uint64_t max_tries{request.params[2].isNull() ? DEFAULT_MAX_TRIES : request.params[2].get_int()};
285 
286  CTxDestination destination = DecodeDestination(request.params[1].get_str());
287  if (!IsValidDestination(destination)) {
288  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
289  }
290 
291  NodeContext& node = EnsureAnyNodeContext(request.context);
292  const CTxMemPool& mempool = EnsureMemPool(node);
294 
295  CScript coinbase_script = GetScriptForDestination(destination);
296 
297  return generateBlocks(chainman, mempool, coinbase_script, num_blocks, max_tries);
298 },
299  };
300 }
301 
303 {
304  return RPCHelpMan{"generateblock",
305  "\nMine a block with a set of ordered transactions immediately to a specified address or descriptor (before the RPC call returns)\n",
306  {
307  {"output", RPCArg::Type::STR, RPCArg::Optional::NO, "The address or descriptor to send the newly generated bitcoin to."},
308  {"transactions", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings which are either txids or raw transactions.\n"
309  "Txids must reference transactions currently in the mempool.\n"
310  "All transactions must be valid and in valid order, otherwise the block will be rejected.",
311  {
313  },
314  },
315  },
316  RPCResult{
317  RPCResult::Type::OBJ, "", "",
318  {
319  {RPCResult::Type::STR_HEX, "hash", "hash of generated block"},
320  }
321  },
322  RPCExamples{
323  "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n"
324  + HelpExampleCli("generateblock", R"("myaddress" '["rawtx", "mempool_txid"]')")
325  },
326  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
327 {
328  const auto address_or_descriptor = request.params[0].get_str();
329  CScript coinbase_script;
330  std::string error;
331 
332  if (!getScriptFromDescriptor(address_or_descriptor, coinbase_script, error)) {
333  const auto destination = DecodeDestination(address_or_descriptor);
334  if (!IsValidDestination(destination)) {
335  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address or descriptor");
336  }
337 
338  coinbase_script = GetScriptForDestination(destination);
339  }
340 
341  NodeContext& node = EnsureAnyNodeContext(request.context);
342  const CTxMemPool& mempool = EnsureMemPool(node);
343 
344  std::vector<CTransactionRef> txs;
345  const auto raw_txs_or_txids = request.params[1].get_array();
346  for (size_t i = 0; i < raw_txs_or_txids.size(); i++) {
347  const auto str(raw_txs_or_txids[i].get_str());
348 
349  uint256 hash;
351  if (ParseHashStr(str, hash)) {
352 
353  const auto tx = mempool.get(hash);
354  if (!tx) {
355  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Transaction %s not in mempool.", str));
356  }
357 
358  txs.emplace_back(tx);
359 
360  } else if (DecodeHexTx(mtx, str)) {
361  txs.push_back(MakeTransactionRef(std::move(mtx)));
362 
363  } else {
364  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("Transaction decode failed for %s. Make sure the tx has at least one input.", str));
365  }
366  }
367 
368  CChainParams chainparams(Params());
369  CBlock block;
370 
372  {
373  LOCK(cs_main);
374 
375  CTxMemPool empty_mempool;
376  std::unique_ptr<CBlockTemplate> blocktemplate(BlockAssembler(chainman.ActiveChainstate(), empty_mempool, chainparams).CreateNewBlock(coinbase_script));
377  if (!blocktemplate) {
378  throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
379  }
380  block = blocktemplate->block;
381  }
382 
383  CHECK_NONFATAL(block.vtx.size() == 1);
384 
385  // Add transactions
386  block.vtx.insert(block.vtx.end(), txs.begin(), txs.end());
387  RegenerateCommitments(block, chainman);
388 
389  {
390  LOCK(cs_main);
391 
392  BlockValidationState state;
393  if (!TestBlockValidity(state, chainparams, chainman.ActiveChainstate(), block, chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock), false, false)) {
394  throw JSONRPCError(RPC_VERIFY_ERROR, strprintf("TestBlockValidity failed: %s", state.ToString()));
395  }
396  }
397 
398  uint256 block_hash;
399  uint64_t max_tries{DEFAULT_MAX_TRIES};
400  unsigned int extra_nonce{0};
401 
402  if (!GenerateBlock(chainman, block, max_tries, extra_nonce, block_hash) || block_hash.IsNull()) {
403  throw JSONRPCError(RPC_MISC_ERROR, "Failed to make block.");
404  }
405 
407  obj.pushKV("hash", block_hash.GetHex());
408  return obj;
409 },
410  };
411 }
412 
414 {
415  return RPCHelpMan{"getmininginfo",
416  "\nReturns a json object containing mining-related information.",
417  {},
418  RPCResult{
419  RPCResult::Type::OBJ, "", "",
420  {
421  {RPCResult::Type::NUM, "blocks", "The current block"},
422  {RPCResult::Type::NUM, "currentblockweight", /*optional=*/true, "The block weight of the last assembled block (only present if a block was ever assembled)"},
423  {RPCResult::Type::NUM, "currentblocktx", /*optional=*/true, "The number of block transactions of the last assembled block (only present if a block was ever assembled)"},
424  {RPCResult::Type::NUM, "difficulty", "The current difficulty"},
425  {RPCResult::Type::NUM, "networkhashps", "The network hashes per second"},
426  {RPCResult::Type::NUM, "pooledtx", "The size of the mempool"},
427  {RPCResult::Type::STR, "chain", "current network name (main, test, signet, regtest)"},
428  {RPCResult::Type::STR, "warnings", "any network and blockchain warnings"},
429  }},
430  RPCExamples{
431  HelpExampleCli("getmininginfo", "")
432  + HelpExampleRpc("getmininginfo", "")
433  },
434  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
435 {
436  NodeContext& node = EnsureAnyNodeContext(request.context);
437  const CTxMemPool& mempool = EnsureMemPool(node);
439  LOCK(cs_main);
440  const CChain& active_chain = chainman.ActiveChain();
441 
443  obj.pushKV("blocks", active_chain.Height());
444  if (BlockAssembler::m_last_block_weight) obj.pushKV("currentblockweight", *BlockAssembler::m_last_block_weight);
445  if (BlockAssembler::m_last_block_num_txs) obj.pushKV("currentblocktx", *BlockAssembler::m_last_block_num_txs);
446  obj.pushKV("difficulty", (double)GetDifficulty(active_chain.Tip()));
447  obj.pushKV("networkhashps", getnetworkhashps().HandleRequest(request));
448  obj.pushKV("pooledtx", (uint64_t)mempool.size());
449  obj.pushKV("chain", Params().NetworkIDString());
450  obj.pushKV("warnings", GetWarnings(false).original);
451  return obj;
452 },
453  };
454 }
455 
456 
457 // NOTE: Unlike wallet RPC (which use BTC values), mining RPCs follow GBT (BIP 22) in using satoshi amounts
459 {
460  return RPCHelpMan{"prioritisetransaction",
461  "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
462  {
463  {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id."},
464  {"dummy", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "API-Compatibility for previous API. Must be zero or null.\n"
465  " DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
466  {"fee_delta", RPCArg::Type::NUM, RPCArg::Optional::NO, "The fee value (in satoshis) to add (or subtract, if negative).\n"
467  " Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
468  " The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
469  " considers the transaction as it would have paid a higher (or lower) fee."},
470  },
471  RPCResult{
472  RPCResult::Type::BOOL, "", "Returns true"},
473  RPCExamples{
474  HelpExampleCli("prioritisetransaction", "\"txid\" 0.0 10000")
475  + HelpExampleRpc("prioritisetransaction", "\"txid\", 0.0, 10000")
476  },
477  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
478 {
479  LOCK(cs_main);
480 
481  uint256 hash(ParseHashV(request.params[0], "txid"));
482  CAmount nAmount = request.params[2].get_int64();
483 
484  if (!(request.params[1].isNull() || request.params[1].get_real() == 0)) {
485  throw JSONRPCError(RPC_INVALID_PARAMETER, "Priority is no longer supported, dummy argument to prioritisetransaction must be 0.");
486  }
487 
488  EnsureAnyMemPool(request.context).PrioritiseTransaction(hash, nAmount);
489  return true;
490 },
491  };
492 }
493 
494 
495 // NOTE: Assumes a conclusive result; if result is inconclusive, it must be handled by caller
497 {
498  if (state.IsValid())
499  return NullUniValue;
500 
501  if (state.IsError())
502  throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
503  if (state.IsInvalid())
504  {
505  std::string strRejectReason = state.GetRejectReason();
506  if (strRejectReason.empty())
507  return "rejected";
508  return strRejectReason;
509  }
510  // Should be impossible
511  return "valid?";
512 }
513 
514 static std::string gbt_vb_name(const Consensus::DeploymentPos pos) {
515  const struct VBDeploymentInfo& vbinfo = VersionBitsDeploymentInfo[pos];
516  std::string s = vbinfo.name;
517  if (!vbinfo.gbt_force) {
518  s.insert(s.begin(), '!');
519  }
520  return s;
521 }
522 
524 {
525  return RPCHelpMan{"getblocktemplate",
526  "\nIf the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
527  "It returns data needed to construct a block to work on.\n"
528  "For full specification, see BIPs 22, 23, 9, and 145:\n"
529  " https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
530  " https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
531  " https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
532  " https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n",
533  {
534  {"template_request", RPCArg::Type::OBJ, RPCArg::Default{UniValue::VOBJ}, "Format of the template",
535  {
536  {"mode", RPCArg::Type::STR, /* treat as named arg */ RPCArg::Optional::OMITTED_NAMED_ARG, "This must be set to \"template\", \"proposal\" (see BIP 23), or omitted"},
537  {"capabilities", RPCArg::Type::ARR, /* treat as named arg */ RPCArg::Optional::OMITTED_NAMED_ARG, "A list of strings",
538  {
539  {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "client side supported feature, 'longpoll', 'coinbasevalue', 'proposal', 'serverlist', 'workid'"},
540  }},
541  {"rules", RPCArg::Type::ARR, RPCArg::Optional::NO, "A list of strings",
542  {
543  {"segwit", RPCArg::Type::STR, RPCArg::Optional::NO, "(literal) indicates client side segwit support"},
544  {"str", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "other client side supported softfork deployment"},
545  }},
546  },
547  "\"template_request\""},
548  },
549  {
550  RPCResult{"If the proposal was accepted with mode=='proposal'", RPCResult::Type::NONE, "", ""},
551  RPCResult{"If the proposal was not accepted with mode=='proposal'", RPCResult::Type::STR, "", "According to BIP22"},
552  RPCResult{"Otherwise", RPCResult::Type::OBJ, "", "",
553  {
554  {RPCResult::Type::NUM, "version", "The preferred block version"},
555  {RPCResult::Type::ARR, "rules", "specific block rules that are to be enforced",
556  {
557  {RPCResult::Type::STR, "", "name of a rule the client must understand to some extent; see BIP 9 for format"},
558  }},
559  {RPCResult::Type::OBJ_DYN, "vbavailable", "set of pending, supported versionbit (BIP 9) softfork deployments",
560  {
561  {RPCResult::Type::NUM, "rulename", "identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
562  }},
563  {RPCResult::Type::ARR, "capabilities", "",
564  {
565  {RPCResult::Type::STR, "value", "A supported feature, for example 'proposal'"},
566  }},
567  {RPCResult::Type::NUM, "vbrequired", "bit mask of versionbits the server requires set in submissions"},
568  {RPCResult::Type::STR, "previousblockhash", "The hash of current highest block"},
569  {RPCResult::Type::ARR, "transactions", "contents of non-coinbase transactions that should be included in the next block",
570  {
571  {RPCResult::Type::OBJ, "", "",
572  {
573  {RPCResult::Type::STR_HEX, "data", "transaction data encoded in hexadecimal (byte-for-byte)"},
574  {RPCResult::Type::STR_HEX, "txid", "transaction id encoded in little-endian hexadecimal"},
575  {RPCResult::Type::STR_HEX, "hash", "hash encoded in little-endian hexadecimal (including witness data)"},
576  {RPCResult::Type::ARR, "depends", "array of numbers",
577  {
578  {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"},
579  }},
580  {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"},
581  {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"},
582  {RPCResult::Type::NUM, "weight", "total transaction weight, as counted for purposes of block limits"},
583  }},
584  }},
585  {RPCResult::Type::OBJ_DYN, "coinbaseaux", "data that should be included in the coinbase's scriptSig content",
586  {
587  {RPCResult::Type::STR_HEX, "key", "values must be in the coinbase (keys may be ignored)"},
588  }},
589  {RPCResult::Type::NUM, "coinbasevalue", "maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
590  {RPCResult::Type::STR, "longpollid", "an id to include with a request to longpoll on an update to this template"},
591  {RPCResult::Type::STR, "target", "The hash target"},
592  {RPCResult::Type::NUM_TIME, "mintime", "The minimum timestamp appropriate for the next block time, expressed in " + UNIX_EPOCH_TIME},
593  {RPCResult::Type::ARR, "mutable", "list of ways the block template may be changed",
594  {
595  {RPCResult::Type::STR, "value", "A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
596  }},
597  {RPCResult::Type::STR_HEX, "noncerange", "A range of valid nonces"},
598  {RPCResult::Type::NUM, "sigoplimit", "limit of sigops in blocks"},
599  {RPCResult::Type::NUM, "sizelimit", "limit of block size"},
600  {RPCResult::Type::NUM, "weightlimit", /*optional=*/true, "limit of block weight"},
601  {RPCResult::Type::NUM_TIME, "curtime", "current timestamp in " + UNIX_EPOCH_TIME},
602  {RPCResult::Type::STR, "bits", "compressed target of next block"},
603  {RPCResult::Type::NUM, "height", "The height of the next block"},
604  {RPCResult::Type::STR_HEX, "signet_challenge", /*optional=*/true, "Only on signet"},
605  {RPCResult::Type::STR_HEX, "default_witness_commitment", /*optional=*/true, "a valid witness commitment for the unmodified block template"},
606  }},
607  },
608  RPCExamples{
609  HelpExampleCli("getblocktemplate", "'{\"rules\": [\"segwit\"]}'")
610  + HelpExampleRpc("getblocktemplate", "{\"rules\": [\"segwit\"]}")
611  },
612  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
613 {
614  NodeContext& node = EnsureAnyNodeContext(request.context);
616  LOCK(cs_main);
617 
618  std::string strMode = "template";
619  UniValue lpval = NullUniValue;
620  std::set<std::string> setClientRules;
621  int64_t nMaxVersionPreVB = -1;
622  CChainState& active_chainstate = chainman.ActiveChainstate();
623  CChain& active_chain = active_chainstate.m_chain;
624  if (!request.params[0].isNull())
625  {
626  const UniValue& oparam = request.params[0].get_obj();
627  const UniValue& modeval = find_value(oparam, "mode");
628  if (modeval.isStr())
629  strMode = modeval.get_str();
630  else if (modeval.isNull())
631  {
632  /* Do nothing */
633  }
634  else
635  throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
636  lpval = find_value(oparam, "longpollid");
637 
638  if (strMode == "proposal")
639  {
640  const UniValue& dataval = find_value(oparam, "data");
641  if (!dataval.isStr())
642  throw JSONRPCError(RPC_TYPE_ERROR, "Missing data String key for proposal");
643 
644  CBlock block;
645  if (!DecodeHexBlk(block, dataval.get_str()))
646  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
647 
648  uint256 hash = block.GetHash();
649  const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
650  if (pindex) {
651  if (pindex->IsValid(BLOCK_VALID_SCRIPTS))
652  return "duplicate";
653  if (pindex->nStatus & BLOCK_FAILED_MASK)
654  return "duplicate-invalid";
655  return "duplicate-inconclusive";
656  }
657 
658  CBlockIndex* const pindexPrev = active_chain.Tip();
659  // TestBlockValidity only supports blocks built on the current Tip
660  if (block.hashPrevBlock != pindexPrev->GetBlockHash())
661  return "inconclusive-not-best-prevblk";
662  BlockValidationState state;
663  TestBlockValidity(state, Params(), active_chainstate, block, pindexPrev, false, true);
664  return BIP22ValidationResult(state);
665  }
666 
667  const UniValue& aClientRules = find_value(oparam, "rules");
668  if (aClientRules.isArray()) {
669  for (unsigned int i = 0; i < aClientRules.size(); ++i) {
670  const UniValue& v = aClientRules[i];
671  setClientRules.insert(v.get_str());
672  }
673  } else {
674  // NOTE: It is important that this NOT be read if versionbits is supported
675  const UniValue& uvMaxVersion = find_value(oparam, "maxversion");
676  if (uvMaxVersion.isNum()) {
677  nMaxVersionPreVB = uvMaxVersion.get_int64();
678  }
679  }
680  }
681 
682  if (strMode != "template")
683  throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
684 
685  if (!Params().IsTestChain()) {
686  const CConnman& connman = EnsureConnman(node);
687  if (connman.GetNodeCount(ConnectionDirection::Both) == 0) {
688  throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, PACKAGE_NAME " is not connected!");
689  }
690 
691  if (active_chainstate.IsInitialBlockDownload()) {
692  throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, PACKAGE_NAME " is in initial sync and waiting for blocks...");
693  }
694  }
695 
696  static unsigned int nTransactionsUpdatedLast;
697  const CTxMemPool& mempool = EnsureMemPool(node);
698 
699  if (!lpval.isNull())
700  {
701  // Wait to respond until either the best block changes, OR a minute has passed and there are more transactions
702  uint256 hashWatchedChain;
703  std::chrono::steady_clock::time_point checktxtime;
704  unsigned int nTransactionsUpdatedLastLP;
705 
706  if (lpval.isStr())
707  {
708  // Format: <hashBestChain><nTransactionsUpdatedLast>
709  std::string lpstr = lpval.get_str();
710 
711  hashWatchedChain = ParseHashV(lpstr.substr(0, 64), "longpollid");
712  nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
713  }
714  else
715  {
716  // NOTE: Spec does not specify behaviour for non-string longpollid, but this makes testing easier
717  hashWatchedChain = active_chain.Tip()->GetBlockHash();
718  nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
719  }
720 
721  // Release lock while waiting
723  {
724  checktxtime = std::chrono::steady_clock::now() + std::chrono::minutes(1);
725 
727  while (g_best_block == hashWatchedChain && IsRPCRunning())
728  {
729  if (g_best_block_cv.wait_until(lock, checktxtime) == std::cv_status::timeout)
730  {
731  // Timeout: Check transactions for update
732  // without holding the mempool lock to avoid deadlocks
733  if (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLastLP)
734  break;
735  checktxtime += std::chrono::seconds(10);
736  }
737  }
738  }
740 
741  if (!IsRPCRunning())
742  throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "Shutting down");
743  // TODO: Maybe recheck connections/IBD and (if something wrong) send an expires-immediately template to stop miners?
744  }
745 
746  const Consensus::Params& consensusParams = Params().GetConsensus();
747 
748  // GBT must be called with 'signet' set in the rules for signet chains
749  if (consensusParams.signet_blocks && setClientRules.count("signet") != 1) {
750  throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the signet rule set (call with {\"rules\": [\"segwit\", \"signet\"]})");
751  }
752 
753  // GBT must be called with 'segwit' set in the rules
754  if (setClientRules.count("segwit") != 1) {
755  throw JSONRPCError(RPC_INVALID_PARAMETER, "getblocktemplate must be called with the segwit rule set (call with {\"rules\": [\"segwit\"]})");
756  }
757 
758  // Update block
759  static CBlockIndex* pindexPrev;
760  static int64_t nStart;
761  static std::unique_ptr<CBlockTemplate> pblocktemplate;
762  if (pindexPrev != active_chain.Tip() ||
763  (mempool.GetTransactionsUpdated() != nTransactionsUpdatedLast && GetTime() - nStart > 5))
764  {
765  // Clear pindexPrev so future calls make a new block, despite any failures from here on
766  pindexPrev = nullptr;
767 
768  // Store the pindexBest used before CreateNewBlock, to avoid races
769  nTransactionsUpdatedLast = mempool.GetTransactionsUpdated();
770  CBlockIndex* pindexPrevNew = active_chain.Tip();
771  nStart = GetTime();
772 
773  // Create new block
774  CScript scriptDummy = CScript() << OP_TRUE;
775  pblocktemplate = BlockAssembler(active_chainstate, mempool, Params()).CreateNewBlock(scriptDummy);
776  if (!pblocktemplate)
777  throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
778 
779  // Need to update only after we know CreateNewBlock succeeded
780  pindexPrev = pindexPrevNew;
781  }
782  CHECK_NONFATAL(pindexPrev);
783  CBlock* pblock = &pblocktemplate->block; // pointer for convenience
784 
785  // Update nTime
786  UpdateTime(pblock, consensusParams, pindexPrev);
787  pblock->nNonce = 0;
788 
789  // NOTE: If at some point we support pre-segwit miners post-segwit-activation, this needs to take segwit support into consideration
790  const bool fPreSegWit = !DeploymentActiveAfter(pindexPrev, consensusParams, Consensus::DEPLOYMENT_SEGWIT);
791 
792  UniValue aCaps(UniValue::VARR); aCaps.push_back("proposal");
793 
794  UniValue transactions(UniValue::VARR);
795  std::map<uint256, int64_t> setTxIndex;
796  int i = 0;
797  for (const auto& it : pblock->vtx) {
798  const CTransaction& tx = *it;
799  uint256 txHash = tx.GetHash();
800  setTxIndex[txHash] = i++;
801 
802  if (tx.IsCoinBase())
803  continue;
804 
805  UniValue entry(UniValue::VOBJ);
806 
807  entry.pushKV("data", EncodeHexTx(tx));
808  entry.pushKV("txid", txHash.GetHex());
809  entry.pushKV("hash", tx.GetWitnessHash().GetHex());
810 
811  UniValue deps(UniValue::VARR);
812  for (const CTxIn &in : tx.vin)
813  {
814  if (setTxIndex.count(in.prevout.hash))
815  deps.push_back(setTxIndex[in.prevout.hash]);
816  }
817  entry.pushKV("depends", deps);
818 
819  int index_in_template = i - 1;
820  entry.pushKV("fee", pblocktemplate->vTxFees[index_in_template]);
821  int64_t nTxSigOps = pblocktemplate->vTxSigOpsCost[index_in_template];
822  if (fPreSegWit) {
823  CHECK_NONFATAL(nTxSigOps % WITNESS_SCALE_FACTOR == 0);
824  nTxSigOps /= WITNESS_SCALE_FACTOR;
825  }
826  entry.pushKV("sigops", nTxSigOps);
827  entry.pushKV("weight", GetTransactionWeight(tx));
828 
829  transactions.push_back(entry);
830  }
831 
833 
834  arith_uint256 hashTarget = arith_uint256().SetCompact(pblock->nBits);
835 
836  UniValue aMutable(UniValue::VARR);
837  aMutable.push_back("time");
838  aMutable.push_back("transactions");
839  aMutable.push_back("prevblock");
840 
841  UniValue result(UniValue::VOBJ);
842  result.pushKV("capabilities", aCaps);
843 
844  UniValue aRules(UniValue::VARR);
845  aRules.push_back("csv");
846  if (!fPreSegWit) aRules.push_back("!segwit");
847  if (consensusParams.signet_blocks) {
848  // indicate to miner that they must understand signet rules
849  // when attempting to mine with this template
850  aRules.push_back("!signet");
851  }
852 
853  UniValue vbavailable(UniValue::VOBJ);
854  for (int j = 0; j < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++j) {
856  ThresholdState state = g_versionbitscache.State(pindexPrev, consensusParams, pos);
857  switch (state) {
860  // Not exposed to GBT at all
861  break;
863  // Ensure bit is set in block version
864  pblock->nVersion |= g_versionbitscache.Mask(consensusParams, pos);
865  [[fallthrough]];
867  {
868  const struct VBDeploymentInfo& vbinfo = VersionBitsDeploymentInfo[pos];
869  vbavailable.pushKV(gbt_vb_name(pos), consensusParams.vDeployments[pos].bit);
870  if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
871  if (!vbinfo.gbt_force) {
872  // If the client doesn't support this, don't indicate it in the [default] version
873  pblock->nVersion &= ~g_versionbitscache.Mask(consensusParams, pos);
874  }
875  }
876  break;
877  }
879  {
880  // Add to rules only
881  const struct VBDeploymentInfo& vbinfo = VersionBitsDeploymentInfo[pos];
882  aRules.push_back(gbt_vb_name(pos));
883  if (setClientRules.find(vbinfo.name) == setClientRules.end()) {
884  // Not supported by the client; make sure it's safe to proceed
885  if (!vbinfo.gbt_force) {
886  // If we do anything other than throw an exception here, be sure version/force isn't sent to old clients
887  throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Support for '%s' rule requires explicit client support", vbinfo.name));
888  }
889  }
890  break;
891  }
892  }
893  }
894  result.pushKV("version", pblock->nVersion);
895  result.pushKV("rules", aRules);
896  result.pushKV("vbavailable", vbavailable);
897  result.pushKV("vbrequired", int(0));
898 
899  if (nMaxVersionPreVB >= 2) {
900  // If VB is supported by the client, nMaxVersionPreVB is -1, so we won't get here
901  // Because BIP 34 changed how the generation transaction is serialized, we can only use version/force back to v2 blocks
902  // This is safe to do [otherwise-]unconditionally only because we are throwing an exception above if a non-force deployment gets activated
903  // Note that this can probably also be removed entirely after the first BIP9 non-force deployment (ie, probably segwit) gets activated
904  aMutable.push_back("version/force");
905  }
906 
907  result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
908  result.pushKV("transactions", transactions);
909  result.pushKV("coinbaseaux", aux);
910  result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
911  result.pushKV("longpollid", active_chain.Tip()->GetBlockHash().GetHex() + ToString(nTransactionsUpdatedLast));
912  result.pushKV("target", hashTarget.GetHex());
913  result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
914  result.pushKV("mutable", aMutable);
915  result.pushKV("noncerange", "00000000ffffffff");
916  int64_t nSigOpLimit = MAX_BLOCK_SIGOPS_COST;
917  int64_t nSizeLimit = MAX_BLOCK_SERIALIZED_SIZE;
918  if (fPreSegWit) {
919  CHECK_NONFATAL(nSigOpLimit % WITNESS_SCALE_FACTOR == 0);
920  nSigOpLimit /= WITNESS_SCALE_FACTOR;
921  CHECK_NONFATAL(nSizeLimit % WITNESS_SCALE_FACTOR == 0);
922  nSizeLimit /= WITNESS_SCALE_FACTOR;
923  }
924  result.pushKV("sigoplimit", nSigOpLimit);
925  result.pushKV("sizelimit", nSizeLimit);
926  if (!fPreSegWit) {
927  result.pushKV("weightlimit", (int64_t)MAX_BLOCK_WEIGHT);
928  }
929  result.pushKV("curtime", pblock->GetBlockTime());
930  result.pushKV("bits", strprintf("%08x", pblock->nBits));
931  result.pushKV("height", (int64_t)(pindexPrev->nHeight+1));
932 
933  if (consensusParams.signet_blocks) {
934  result.pushKV("signet_challenge", HexStr(consensusParams.signet_challenge));
935  }
936 
937  if (!pblocktemplate->vchCoinbaseCommitment.empty()) {
938  result.pushKV("default_witness_commitment", HexStr(pblocktemplate->vchCoinbaseCommitment));
939  }
940 
941  return result;
942 },
943  };
944 }
945 
947 {
948 public:
950  bool found;
952 
953  explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn), found(false), state() {}
954 
955 protected:
956  void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override {
957  if (block.GetHash() != hash)
958  return;
959  found = true;
960  state = stateIn;
961  }
962 };
963 
965 {
966  // We allow 2 arguments for compliance with BIP22. Argument 2 is ignored.
967  return RPCHelpMan{"submitblock",
968  "\nAttempts to submit new block to network.\n"
969  "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
970  {
971  {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block data to submit"},
972  {"dummy", RPCArg::Type::STR, RPCArg::DefaultHint{"ignored"}, "dummy value, for compatibility with BIP22. This value is ignored."},
973  },
974  {
975  RPCResult{"If the block was accepted", RPCResult::Type::NONE, "", ""},
976  RPCResult{"Otherwise", RPCResult::Type::STR, "", "According to BIP22"},
977  },
978  RPCExamples{
979  HelpExampleCli("submitblock", "\"mydata\"")
980  + HelpExampleRpc("submitblock", "\"mydata\"")
981  },
982  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
983 {
984  std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
985  CBlock& block = *blockptr;
986  if (!DecodeHexBlk(block, request.params[0].get_str())) {
987  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
988  }
989 
990  if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
991  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block does not start with a coinbase");
992  }
993 
994  ChainstateManager& chainman = EnsureAnyChainman(request.context);
995  uint256 hash = block.GetHash();
996  {
997  LOCK(cs_main);
998  const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);
999  if (pindex) {
1000  if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
1001  return "duplicate";
1002  }
1003  if (pindex->nStatus & BLOCK_FAILED_MASK) {
1004  return "duplicate-invalid";
1005  }
1006  }
1007  }
1008 
1009  {
1010  LOCK(cs_main);
1011  const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(block.hashPrevBlock);
1012  if (pindex) {
1013  UpdateUncommittedBlockStructures(block, pindex, Params().GetConsensus());
1014  }
1015  }
1016 
1017  bool new_block;
1018  auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
1020  bool accepted = chainman.ProcessNewBlock(Params(), blockptr, /*force_processing=*/true, /*new_block=*/&new_block);
1022  if (!new_block && accepted) {
1023  return "duplicate";
1024  }
1025  if (!sc->found) {
1026  return "inconclusive";
1027  }
1028  return BIP22ValidationResult(sc->state);
1029 },
1030  };
1031 }
1032 
1034 {
1035  return RPCHelpMan{"submitheader",
1036  "\nDecode the given hexdata as a header and submit it as a candidate chain tip if valid."
1037  "\nThrows when the header is invalid.\n",
1038  {
1039  {"hexdata", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "the hex-encoded block header data"},
1040  },
1041  RPCResult{
1042  RPCResult::Type::NONE, "", "None"},
1043  RPCExamples{
1044  HelpExampleCli("submitheader", "\"aabbcc\"") +
1045  HelpExampleRpc("submitheader", "\"aabbcc\"")
1046  },
1047  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1048 {
1049  CBlockHeader h;
1050  if (!DecodeHexBlockHeader(h, request.params[0].get_str())) {
1051  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block header decode failed");
1052  }
1053  ChainstateManager& chainman = EnsureAnyChainman(request.context);
1054  {
1055  LOCK(cs_main);
1056  if (!chainman.m_blockman.LookupBlockIndex(h.hashPrevBlock)) {
1057  throw JSONRPCError(RPC_VERIFY_ERROR, "Must submit previous header (" + h.hashPrevBlock.GetHex() + ") first");
1058  }
1059  }
1060 
1061  BlockValidationState state;
1062  chainman.ProcessNewBlockHeaders({h}, state, Params());
1063  if (state.IsValid()) return NullUniValue;
1064  if (state.IsError()) {
1065  throw JSONRPCError(RPC_VERIFY_ERROR, state.ToString());
1066  }
1068 },
1069  };
1070 }
1071 
1073 {
1074  return RPCHelpMan{"estimatesmartfee",
1075  "\nEstimates the approximate fee per kilobyte needed for a transaction to begin\n"
1076  "confirmation within conf_target blocks if possible and return the number of blocks\n"
1077  "for which the estimate is valid. Uses virtual transaction size as defined\n"
1078  "in BIP 141 (witness data is discounted).\n",
1079  {
1080  {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks (1 - 1008)"},
1081  {"estimate_mode", RPCArg::Type::STR, RPCArg::Default{"conservative"}, "The fee estimate mode.\n"
1082  " Whether to return a more conservative estimate which also satisfies\n"
1083  " a longer history. A conservative estimate potentially returns a\n"
1084  " higher feerate and is more likely to be sufficient for the desired\n"
1085  " target, but is not as responsive to short term drops in the\n"
1086  " prevailing fee market. Must be one of (case insensitive):\n"
1087  "\"" + FeeModes("\"\n\"") + "\""},
1088  },
1089  RPCResult{
1090  RPCResult::Type::OBJ, "", "",
1091  {
1092  {RPCResult::Type::NUM, "feerate", /*optional=*/true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB (only present if no errors were encountered)"},
1093  {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)",
1094  {
1095  {RPCResult::Type::STR, "", "error"},
1096  }},
1097  {RPCResult::Type::NUM, "blocks", "block number where estimate was found\n"
1098  "The request target will be clamped between 2 and the highest target\n"
1099  "fee estimation is able to return based on how long it has been running.\n"
1100  "An error is returned if not enough transactions and blocks\n"
1101  "have been observed to make an estimate for any number of blocks."},
1102  }},
1103  RPCExamples{
1104  HelpExampleCli("estimatesmartfee", "6") +
1105  HelpExampleRpc("estimatesmartfee", "6")
1106  },
1107  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1108 {
1109  RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VSTR});
1110  RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
1111 
1112  CBlockPolicyEstimator& fee_estimator = EnsureAnyFeeEstimator(request.context);
1113  const NodeContext& node = EnsureAnyNodeContext(request.context);
1114  const CTxMemPool& mempool = EnsureMemPool(node);
1115 
1116  unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
1117  unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
1118  bool conservative = true;
1119  if (!request.params[1].isNull()) {
1120  FeeEstimateMode fee_mode;
1121  if (!FeeModeFromString(request.params[1].get_str(), fee_mode)) {
1123  }
1124  if (fee_mode == FeeEstimateMode::ECONOMICAL) conservative = false;
1125  }
1126 
1127  UniValue result(UniValue::VOBJ);
1128  UniValue errors(UniValue::VARR);
1129  FeeCalculation feeCalc;
1130  CFeeRate feeRate{fee_estimator.estimateSmartFee(conf_target, &feeCalc, conservative)};
1131  if (feeRate != CFeeRate(0)) {
1132  CFeeRate min_mempool_feerate{mempool.GetMinFee(gArgs.GetIntArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000)};
1133  CFeeRate min_relay_feerate{::minRelayTxFee};
1134  feeRate = std::max({feeRate, min_mempool_feerate, min_relay_feerate});
1135  result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
1136  } else {
1137  errors.push_back("Insufficient data or no feerate found");
1138  result.pushKV("errors", errors);
1139  }
1140  result.pushKV("blocks", feeCalc.returnedTarget);
1141  return result;
1142 },
1143  };
1144 }
1145 
1147 {
1148  return RPCHelpMan{"estimaterawfee",
1149  "\nWARNING: This interface is unstable and may disappear or change!\n"
1150  "\nWARNING: This is an advanced API call that is tightly coupled to the specific\n"
1151  " implementation of fee estimation. The parameters it can be called with\n"
1152  " and the results it returns will change if the internal implementation changes.\n"
1153  "\nEstimates the approximate fee per kilobyte needed for a transaction to begin\n"
1154  "confirmation within conf_target blocks if possible. Uses virtual transaction size as\n"
1155  "defined in BIP 141 (witness data is discounted).\n",
1156  {
1157  {"conf_target", RPCArg::Type::NUM, RPCArg::Optional::NO, "Confirmation target in blocks (1 - 1008)"},
1158  {"threshold", RPCArg::Type::NUM, RPCArg::Default{0.95}, "The proportion of transactions in a given feerate range that must have been\n"
1159  " confirmed within conf_target in order to consider those feerates as high enough and proceed to check\n"
1160  " lower buckets."},
1161  },
1162  RPCResult{
1163  RPCResult::Type::OBJ, "", "Results are returned for any horizon which tracks blocks up to the confirmation target",
1164  {
1165  {RPCResult::Type::OBJ, "short", /*optional=*/true, "estimate for short time horizon",
1166  {
1167  {RPCResult::Type::NUM, "feerate", /*optional=*/true, "estimate fee rate in " + CURRENCY_UNIT + "/kvB"},
1168  {RPCResult::Type::NUM, "decay", "exponential decay (per block) for historical moving average of confirmation data"},
1169  {RPCResult::Type::NUM, "scale", "The resolution of confirmation targets at this time horizon"},
1170  {RPCResult::Type::OBJ, "pass", /*optional=*/true, "information about the lowest range of feerates to succeed in meeting the threshold",
1171  {
1172  {RPCResult::Type::NUM, "startrange", "start of feerate range"},
1173  {RPCResult::Type::NUM, "endrange", "end of feerate range"},
1174  {RPCResult::Type::NUM, "withintarget", "number of txs over history horizon in the feerate range that were confirmed within target"},
1175  {RPCResult::Type::NUM, "totalconfirmed", "number of txs over history horizon in the feerate range that were confirmed at any point"},
1176  {RPCResult::Type::NUM, "inmempool", "current number of txs in mempool in the feerate range unconfirmed for at least target blocks"},
1177  {RPCResult::Type::NUM, "leftmempool", "number of txs over history horizon in the feerate range that left mempool unconfirmed after target"},
1178  }},
1179  {RPCResult::Type::OBJ, "fail", /*optional=*/true, "information about the highest range of feerates to fail to meet the threshold",
1180  {
1181  {RPCResult::Type::ELISION, "", ""},
1182  }},
1183  {RPCResult::Type::ARR, "errors", /*optional=*/true, "Errors encountered during processing (if there are any)",
1184  {
1185  {RPCResult::Type::STR, "error", ""},
1186  }},
1187  }},
1188  {RPCResult::Type::OBJ, "medium", /*optional=*/true, "estimate for medium time horizon",
1189  {
1190  {RPCResult::Type::ELISION, "", ""},
1191  }},
1192  {RPCResult::Type::OBJ, "long", /*optional=*/true, "estimate for long time horizon",
1193  {
1194  {RPCResult::Type::ELISION, "", ""},
1195  }},
1196  }},
1197  RPCExamples{
1198  HelpExampleCli("estimaterawfee", "6 0.9")
1199  },
1200  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
1201 {
1202  RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VNUM}, true);
1203  RPCTypeCheckArgument(request.params[0], UniValue::VNUM);
1204 
1205  CBlockPolicyEstimator& fee_estimator = EnsureAnyFeeEstimator(request.context);
1206 
1207  unsigned int max_target = fee_estimator.HighestTargetTracked(FeeEstimateHorizon::LONG_HALFLIFE);
1208  unsigned int conf_target = ParseConfirmTarget(request.params[0], max_target);
1209  double threshold = 0.95;
1210  if (!request.params[1].isNull()) {
1211  threshold = request.params[1].get_real();
1212  }
1213  if (threshold < 0 || threshold > 1) {
1214  throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid threshold");
1215  }
1216 
1217  UniValue result(UniValue::VOBJ);
1218 
1219  for (const FeeEstimateHorizon horizon : ALL_FEE_ESTIMATE_HORIZONS) {
1220  CFeeRate feeRate;
1221  EstimationResult buckets;
1222 
1223  // Only output results for horizons which track the target
1224  if (conf_target > fee_estimator.HighestTargetTracked(horizon)) continue;
1225 
1226  feeRate = fee_estimator.estimateRawFee(conf_target, threshold, horizon, &buckets);
1227  UniValue horizon_result(UniValue::VOBJ);
1228  UniValue errors(UniValue::VARR);
1229  UniValue passbucket(UniValue::VOBJ);
1230  passbucket.pushKV("startrange", round(buckets.pass.start));
1231  passbucket.pushKV("endrange", round(buckets.pass.end));
1232  passbucket.pushKV("withintarget", round(buckets.pass.withinTarget * 100.0) / 100.0);
1233  passbucket.pushKV("totalconfirmed", round(buckets.pass.totalConfirmed * 100.0) / 100.0);
1234  passbucket.pushKV("inmempool", round(buckets.pass.inMempool * 100.0) / 100.0);
1235  passbucket.pushKV("leftmempool", round(buckets.pass.leftMempool * 100.0) / 100.0);
1236  UniValue failbucket(UniValue::VOBJ);
1237  failbucket.pushKV("startrange", round(buckets.fail.start));
1238  failbucket.pushKV("endrange", round(buckets.fail.end));
1239  failbucket.pushKV("withintarget", round(buckets.fail.withinTarget * 100.0) / 100.0);
1240  failbucket.pushKV("totalconfirmed", round(buckets.fail.totalConfirmed * 100.0) / 100.0);
1241  failbucket.pushKV("inmempool", round(buckets.fail.inMempool * 100.0) / 100.0);
1242  failbucket.pushKV("leftmempool", round(buckets.fail.leftMempool * 100.0) / 100.0);
1243 
1244  // CFeeRate(0) is used to indicate error as a return value from estimateRawFee
1245  if (feeRate != CFeeRate(0)) {
1246  horizon_result.pushKV("feerate", ValueFromAmount(feeRate.GetFeePerK()));
1247  horizon_result.pushKV("decay", buckets.decay);
1248  horizon_result.pushKV("scale", (int)buckets.scale);
1249  horizon_result.pushKV("pass", passbucket);
1250  // buckets.fail.start == -1 indicates that all buckets passed, there is no fail bucket to output
1251  if (buckets.fail.start != -1) horizon_result.pushKV("fail", failbucket);
1252  } else {
1253  // Output only information that is still meaningful in the event of error
1254  horizon_result.pushKV("decay", buckets.decay);
1255  horizon_result.pushKV("scale", (int)buckets.scale);
1256  horizon_result.pushKV("fail", failbucket);
1257  errors.push_back("Insufficient data or no feerate found which meets threshold");
1258  horizon_result.pushKV("errors",errors);
1259  }
1260  result.pushKV(StringForFeeEstimateHorizon(horizon), horizon_result);
1261  }
1262  return result;
1263 },
1264  };
1265 }
1266 
1268 {
1269 // clang-format off
1270 static const CRPCCommand commands[] =
1271 { // category actor (function)
1272  // --------------------- -----------------------
1273  { "mining", &getnetworkhashps, },
1274  { "mining", &getmininginfo, },
1275  { "mining", &prioritisetransaction, },
1276  { "mining", &getblocktemplate, },
1277  { "mining", &submitblock, },
1278  { "mining", &submitheader, },
1279 
1280 
1281  { "generating", &generatetoaddress, },
1282  { "generating", &generatetodescriptor, },
1283  { "generating", &generateblock, },
1284 
1285  { "util", &estimatesmartfee, },
1286 
1287  { "hidden", &estimaterawfee, },
1288  { "hidden", &generate, },
1289 };
1290 // clang-format on
1291  for (const auto& c : commands) {
1292  t.appendCommand(c.name, &c);
1293  }
1294 }
RPC_METHOD_NOT_FOUND
@ RPC_METHOD_NOT_FOUND
Definition: protocol.h:31
ThresholdState::STARTED
@ STARTED
CValidationInterface
Implement this to subscribe to events generated in validation.
Definition: validationinterface.h:78
CBlockIndex::GetBlockTime
int64_t GetBlockTime() const
Definition: chain.h:273
CTxIn
An input of a transaction.
Definition: transaction.h:65
RPC_MISC_ERROR
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:39
ParseHashStr
bool ParseHashStr(const std::string &strHex, uint256 &result)
Parse a hex string into 256 bits.
Definition: core_read.cpp:240
ShutdownRequested
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
Definition: shutdown.cpp:87
EstimatorBucket::inMempool
double inMempool
Definition: fees.h:62
VBDeploymentInfo
Definition: deploymentinfo.h:12
submitblock_StateCatcher::state
BlockValidationState state
Definition: mining.cpp:951
CTransaction::vin
const std::vector< CTxIn > vin
Definition: transaction.h:270
RPCResult::Type::ELISION
@ ELISION
Special type to denote elision (...)
CTxMemPool::GetMinFee
CFeeRate GetMinFee(size_t sizelimit) const
The minimum fee to get into the mempool, which may itself not be enough for larger-sized transactions...
Definition: txmempool.cpp:1096
BLOCK_FAILED_MASK
@ BLOCK_FAILED_MASK
Definition: chain.h:130
Parse
std::unique_ptr< Descriptor > Parse(const std::string &descriptor, FlatSigningProvider &out, std::string &error, bool require_checksum)
Parse a descriptor string.
Definition: descriptor.cpp:1394
FeeModeFromString
bool FeeModeFromString(const std::string &mode_string, FeeEstimateMode &fee_estimate_mode)
Definition: fees.cpp:57
submitblock_StateCatcher::found
bool found
Definition: mining.cpp:950
HelpExampleCli
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:156
EstimatorBucket::start
double start
Definition: fees.h:58
ToString
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:87
RegisterSharedValidationInterface
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
Definition: validationinterface.cpp:121
ThresholdState::ACTIVE
@ ACTIVE
UniValue::VOBJ
@ VOBJ
Definition: univalue.h:19
ChainstateManager::ProcessNewBlockHeaders
bool ProcessNewBlockHeaders(const std::vector< CBlockHeader > &block, BlockValidationState &state, const CChainParams &chainparams, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
Definition: validation.cpp:3525
node::BlockManager::LookupBlockIndex
CBlockIndex * LookupBlockIndex(const uint256 &hash) const EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Definition: blockstorage.cpp:35
ParseConfirmTarget
unsigned int ParseConfirmTarget(const UniValue &value, unsigned int max_target)
Parse a confirm target option and raise an RPC error if it is invalid.
Definition: util.cpp:330
pow.h
VersionBitsCache::State
ThresholdState State(const CBlockIndex *pindexPrev, const Consensus::Params &params, Consensus::DeploymentPos pos)
Get the BIP9 state for a given deployment for the block after pindexPrev.
Definition: versionbits.cpp:193
getnetworkhashps
static RPCHelpMan getnetworkhashps()
Definition: mining.cpp:94
EstimatorBucket::leftMempool
double leftMempool
Definition: fees.h:63
Consensus::BIP9Deployment::bit
int bit
Bit position to select the particular bit in nVersion.
Definition: params.h:41
RPC_INTERNAL_ERROR
@ RPC_INTERNAL_ERROR
Definition: protocol.h:35
BIP22ValidationResult
static UniValue BIP22ValidationResult(const BlockValidationState &state)
Definition: mining.cpp:496
CHECK_NONFATAL
#define CHECK_NONFATAL(condition)
Throw a NonFatalCheckError when the condition evaluates to false.
Definition: check.h:32
Consensus::MAX_VERSION_BITS_DEPLOYMENTS
@ MAX_VERSION_BITS_DEPLOYMENTS
Definition: params.h:32
CBlockHeader::nBits
uint32_t nBits
Definition: block.h:28
nHeight
unsigned int nHeight
Definition: mempool_eviction.cpp:14
FeeEstimateHorizon
FeeEstimateHorizon
Definition: fees.h:28
CBlockHeader
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition: block.h:20
BlockValidationState
Definition: validation.h:141
key_io.h
base_uint::GetHex
std::string GetHex() const
Definition: arith_uint256.cpp:147
GetWarnings
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.
Definition: warnings.cpp:31
RPC_VERIFY_ERROR
@ RPC_VERIFY_ERROR
General error during transaction or block submission.
Definition: protocol.h:46
RPCHelpMan
Definition: util.h:345
CBlockHeader::nVersion
int32_t nVersion
Definition: block.h:24
FeeCalculation::returnedTarget
int returnedTarget
Definition: fees.h:80
COutPoint::hash
uint256 hash
Definition: transaction.h:29
NullUniValue
const UniValue NullUniValue
Definition: univalue.cpp:13
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: standard.cpp:310
string.h
CTxMemPool
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:429
RPC_INVALID_PARAMETER
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:43
arith_uint256
256-bit unsigned big integer.
Definition: arith_uint256.h:250
CBlockIndex::pprev
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: chain.h:155
getScriptFromDescriptor
static bool getScriptFromDescriptor(const std::string &descriptor, CScript &script, std::string &error)
Definition: mining.cpp:182
submitheader
static RPCHelpMan submitheader()
Definition: mining.cpp:1033
DeploymentActiveAfter
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const Consensus::Params &params, Consensus::BuriedDeployment dep)
Determine if a deployment is active for the next block.
Definition: deploymentstatus.h:17
ParseHashV
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded Values (throws error if not hex).
Definition: util.cpp:90
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: chain.h:161
node::NodeContext
NodeContext struct containing references to chain state and connection state.
Definition: context.h:40
RPCArg::Optional::NO
@ NO
Required arg.
validationinterface.h
RPCArg::Type::STR
@ STR
validation.h
ConnectionDirection::Both
@ Both
RPCArg::Type::ARR
@ ARR
CChainParams
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
Definition: chainparams.h:69
base_blob::SetNull
void SetNull()
Definition: uint256.h:39
DEFAULT_MAX_TRIES
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
Definition: mining.h:9
CBlockPolicyEstimator::estimateSmartFee
CFeeRate estimateSmartFee(int confTarget, FeeCalculation *feeCalc, bool conservative) const EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator)
Estimate feerate needed to get be included in a block within confTarget blocks.
Definition: fees.cpp:813
minRelayTxFee
CFeeRate minRelayTxFee
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)
Definition: validation.cpp:153
GetTime
int64_t GetTime()
DEPRECATED Use either GetTimeSeconds (not mockable) or GetTime<T> (mockable)
Definition: time.cpp:26
RPC_CLIENT_IN_INITIAL_DOWNLOAD
@ RPC_CLIENT_IN_INITIAL_DOWNLOAD
Still downloading initial blocks.
Definition: protocol.h:59
CBlockIndex::nChainWork
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
Definition: chain.h:173
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:387
CheckProofOfWork
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:74
getblocktemplate
static RPCHelpMan getblocktemplate()
Definition: mining.cpp:523
CChainParams::GetConsensus
const Consensus::Params & GetConsensus() const
Definition: chainparams.h:82
EnsureChainman
ChainstateManager & EnsureChainman(const NodeContext &node)
Definition: server_util.cpp:55
RPCResult::Type::NUM
@ NUM
EnsureAnyFeeEstimator
CBlockPolicyEstimator & EnsureAnyFeeEstimator(const std::any &context)
Definition: server_util.cpp:76
server_util.h
UniValue::isNull
bool isNull() const
Definition: univalue.h:75
VersionBitsDeploymentInfo
const struct VBDeploymentInfo VersionBitsDeploymentInfo[Consensus::MAX_VERSION_BITS_DEPLOYMENTS]
Definition: deploymentinfo.cpp:9
chainparams.h
ChainstateManager::ActiveChainstate
CChainState & ActiveChainstate() const
The most-work chain.
Definition: validation.cpp:4960
UniValue::isNum
bool isNum() const
Definition: univalue.h:80
CTxMemPool::GetTransactionsUpdated
unsigned int GetTransactionsUpdated() const
Definition: txmempool.cpp:466
CChain::Tip
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:434
context.h
RPCTypeCheckArgument
void RPCTypeCheckArgument(const UniValue &value, const UniValueType &typeExpected)
Type-check one argument; throws JSONRPCError if wrong type given.
Definition: util.cpp:41
core_io.h
UniValue::pushKV
bool pushKV(const std::string &key, const UniValue &val)
Definition: univalue.cpp:133
CFeeRate
Fee rate in satoshis per kilobyte: CAmount / kB.
Definition: feerate.h:29
CBlockHeader::GetHash
uint256 GetHash() const
Definition: block.cpp:11
ValueFromAmount
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:21
IsRPCRunning
bool IsRPCRunning()
Query whether RPC is running.
Definition: server.cpp:321
EstimatorBucket::end
double end
Definition: fees.h:59
node::IncrementExtraNonce
void IncrementExtraNonce(CBlock *pblock, const CBlockIndex *pindexPrev, unsigned int &nExtraNonce)
Modify the extranonce in a block.
Definition: miner.cpp:451
UniValue
Definition: univalue.h:17
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:259
MAX_BLOCK_SERIALIZED_SIZE
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
ValidationState::ToString
std::string ToString() const
Definition: validation.h:126
ChainstateManager::ActiveChain
CChain & ActiveChain() const
Definition: validation.h:895
txmempool.h
shutdown.h
estimatesmartfee
static RPCHelpMan estimatesmartfee()
Definition: mining.cpp:1072
RPCArg::Type::NUM
@ NUM
EnsureAnyNodeContext
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:20
deploymentstatus.h
FeeEstimateMode::ECONOMICAL
@ ECONOMICAL
Force estimateSmartFee to use non-conservative estimates.
ValidationState::IsValid
bool IsValid() const
Definition: validation.h:120
gbt_vb_name
static std::string gbt_vb_name(const Consensus::DeploymentPos pos)
Definition: mining.cpp:514
signingprovider.h
CBlockHeader::nNonce
uint32_t nNonce
Definition: block.h:29
UniValue::get_str
const std::string & get_str() const
Definition: univalue_get.cpp:98
RPC_DESERIALIZATION_ERROR
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
Definition: protocol.h:45
strencodings.h
Consensus::Params
Parameters that influence chain consensus.
Definition: params.h:70
FeeEstimateHorizon::LONG_HALFLIFE
@ LONG_HALFLIFE
CTransaction::IsCoinBase
bool IsCoinBase() const
Definition: transaction.h:315
UniValue::isStr
bool isStr() const
Definition: univalue.h:79
ENTER_CRITICAL_SECTION
#define ENTER_CRITICAL_SECTION(cs)
Definition: sync.h:233
FeeCalculation
Definition: fees.h:75
g_versionbitscache
VersionBitsCache g_versionbitscache
Global cache for versionbits deployment status.
Definition: deploymentstatus.cpp:12
EstimationResult::decay
double decay
Definition: fees.h:71
UniValue::get_int64
int64_t get_int64() const
Definition: univalue_get.cpp:115
EstimationResult
Definition: fees.h:67
Consensus::DeploymentPos
DeploymentPos
Definition: params.h:28
Consensus::DEPLOYMENT_SEGWIT
@ DEPLOYMENT_SEGWIT
Definition: params.h:24
CURRENCY_UNIT
const std::string CURRENCY_UNIT
Definition: feerate.h:14
RPCArg::Type::OBJ
@ OBJ
UniValue::get_obj
const UniValue & get_obj() const
Definition: univalue_get.cpp:135
CTxDestination
std::variant< CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script template with a specific destination.
Definition: standard.h:157
CTxMemPool::get
CTransactionRef get(const uint256 &hash) const
Definition: txmempool.cpp:898
RPCArg::DefaultHint
std::string DefaultHint
Definition: util.h:155
IsValidDestination
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
Definition: standard.cpp:332
RPCArg::Optional::OMITTED_NAMED_ARG
@ OMITTED_NAMED_ARG
Optional arg that is a named argument and has a default value of null.
CBlockIndex::nStatus
uint32_t nStatus
Verification status of this block.
Definition: chain.h:198
RPCArg::Type::STR_HEX
@ STR_HEX
Special type that is a STR with only hex chars.
RPCResult::Type::OBJ
@ OBJ
CBlockHeader::GetBlockTime
int64_t GetBlockTime() const
Definition: block.h:55
CRPCCommand
Definition: server.h:89
RPCResult::Type::NONE
@ NONE
RegisterMiningRPCCommands
void RegisterMiningRPCCommands(CRPCTable &t)
Register mining RPC commands.
Definition: mining.cpp:1267
PACKAGE_NAME
#define PACKAGE_NAME
Definition: bitcoin-config.h:363
GetDifficulty
double GetDifficulty(const CBlockIndex *blockindex)
Get the difficulty of the net wrt to the given block index.
Definition: blockchain.cpp:81
estimaterawfee
static RPCHelpMan estimaterawfee()
Definition: mining.cpp:1146
CBlockIndex::GetMedianTimePast
int64_t GetMedianTimePast() const
Definition: chain.h:285
MAX_BLOCK_SIGOPS_COST
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
BLOCK_VALID_SCRIPTS
@ BLOCK_VALID_SCRIPTS
Scripts & signatures ok. Implies all parents are also at least SCRIPTS.
Definition: chain.h:118
deploymentinfo.h
EstimationResult::scale
unsigned int scale
Definition: fees.h:72
EnsureAnyChainman
ChainstateManager & EnsureAnyChainman(const std::any &context)
Definition: server_util.cpp:63
ThresholdState::DEFINED
@ DEFINED
VersionBitsCache::Mask
static uint32_t Mask(const Consensus::Params &params, Consensus::DeploymentPos pos)
Definition: versionbits.cpp:210
FeeEstimateMode
FeeEstimateMode
Definition: feerate.h:18
CBlockIndex::IsValid
bool IsValid(enum BlockStatus nUpTo=BLOCK_VALID_TRANSACTIONS) const
Check whether this block index entry is valid up to the passed validity level.
Definition: chain.h:308
univalue.h
consensus.h
miner.h
node::CBlockTemplate
Definition: miner.h:29
generatetodescriptor
static RPCHelpMan generatetodescriptor()
Definition: mining.cpp:216
RPCResult::Type::STR_HEX
@ STR_HEX
Special string with only hex chars.
DecodeHexBlockHeader
bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header)
Definition: core_read.cpp:209
CBlockPolicyEstimator
Definition: fees.h:131
g_best_block
uint256 g_best_block
Used to notify getblocktemplate RPC of new tips.
Definition: validation.cpp:143
UnregisterSharedValidationInterface
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
Definition: validationinterface.cpp:135
InvalidEstimateModeErrorMessage
const std::string InvalidEstimateModeErrorMessage()
Definition: fees.cpp:52
submitblock
static RPCHelpMan submitblock()
Definition: mining.cpp:964
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
Consensus::Params::signet_challenge
std::vector< uint8_t > signet_challenge
Definition: params.h:116
base_blob::GetHex
std::string GetHex() const
Definition: uint256.cpp:20
RPCExamples
Definition: util.h:335
node::BlockAssembler::CreateNewBlock
std::unique_ptr< CBlockTemplate > CreateNewBlock(const CScript &scriptPubKeyIn)
Construct a new block template with coinbase to scriptPubKeyIn.
Definition: miner.cpp:107
EnsureConnman
CConnman & EnsureConnman(const NodeContext &node)
Definition: server_util.cpp:81
ChainstateManager::ProcessNewBlock
bool ProcessNewBlock(const CChainParams &chainparams, const std::shared_ptr< const CBlock > &block, bool force_processing, bool *new_block) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
Definition: validation.cpp:3638
RPCResult::Type::STR
@ STR
UniValue::VNUM
@ VNUM
Definition: univalue.h:19
generateblock
static RPCHelpMan generateblock()
Definition: mining.cpp:302
uint256
256-bit opaque blob.
Definition: uint256.h:124
RPCResult::Type::NUM_TIME
@ NUM_TIME
Special numeric to denote unix epoch time.
RPCResult::Type::ARR
@ ARR
CChainState
CChainState stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:443
VBDeploymentInfo::gbt_force
bool gbt_force
Whether GBT clients can safely ignore this rule in simplified usage.
Definition: deploymentinfo.h:16
submitblock_StateCatcher::hash
uint256 hash
Definition: mining.cpp:949
node::BlockAssembler
Generate a new block, without valid proof-of-work.
Definition: miner.h:128
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:405
HelpExampleRpc
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:174
UniValue::isArray
bool isArray() const
Definition: univalue.h:81
script.h
CBlockPolicyEstimator::estimateRawFee
CFeeRate estimateRawFee(int confTarget, double successThreshold, FeeEstimateHorizon horizon, EstimationResult *result=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator)
Return a specific fee estimate calculation with a given success threshold and time horizon,...
Definition: fees.cpp:669
g_best_block_mutex
Mutex g_best_block_mutex
Definition: validation.cpp:141
CBlockIndex::GetBlockHash
uint256 GetBlockHash() const
Definition: chain.h:259
gArgs
ArgsManager gArgs
Definition: system.cpp:80
OP_TRUE
@ OP_TRUE
Definition: script.h:77
ThresholdState::FAILED
@ FAILED
StringForFeeEstimateHorizon
std::string StringForFeeEstimateHorizon(FeeEstimateHorizon horizon)
Definition: fees.cpp:20
CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:463
generateBlocks
static UniValue generateBlocks(ChainstateManager &chainman, const CTxMemPool &mempool, const CScript &coinbase_script, int nGenerate, uint64_t nMaxTries)
Definition: mining.cpp:150
CTxMemPool::PrioritiseTransaction
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
Definition: txmempool.cpp:916
ChainstateManager
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:761
CRPCTable
RPC command dispatcher.
Definition: server.h:125
EncodeHexTx
std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags=0)
Definition: core_write.cpp:138
RPC_INVALID_ADDRESS_OR_KEY
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:41
prioritisetransaction
static RPCHelpMan prioritisetransaction()
Definition: mining.cpp:458
CBlockHeader::hashPrevBlock
uint256 hashPrevBlock
Definition: block.h:25
system.h
CBlock
Definition: block.h:62
mining.h
strprintf
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1164
CConnman
Definition: net.h:741
RPC_OUT_OF_MEMORY
@ RPC_OUT_OF_MEMORY
Ran out of memory during operation.
Definition: protocol.h:42
fees.h
CChain
An in-memory indexed chain of blocks.
Definition: chain.h:417
base_blob::IsNull
bool IsNull() const
Definition: uint256.h:31
GetTransactionWeight
static int64_t GetTransactionWeight(const CTransaction &tx)
Definition: validation.h:147
CBlock::vtx
std::vector< CTransactionRef > vtx
Definition: block.h:66
EstimationResult::fail
EstimatorBucket fail
Definition: fees.h:70
RPCResult::Type::BOOL
@ BOOL
VBDeploymentInfo::name
const char * name
Deployment name.
Definition: deploymentinfo.h:14
Consensus::Params::vDeployments
BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS]
Definition: params.h:98
UpdateUncommittedBlockStructures
void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev, const Consensus::Params &consensusParams)
Update uncommitted block structures (currently: only the witness reserved value).
Definition: validation.cpp:3259
UniValue::get_int
int get_int() const
Definition: univalue_get.cpp:105
fees.h
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:138
GetNetworkHashPS
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:56
FeeModes
std::string FeeModes(const std::string &delimiter)
Definition: fees.cpp:47
translation.h
RPCTypeCheck
void RPCTypeCheck(const UniValue &params, const std::list< UniValueType > &typesExpected, bool fAllowNull)
Type-check arguments; throws JSONRPCError if wrong type given.
Definition: util.cpp:24
generatetoaddress
static RPCHelpMan generatetoaddress()
Definition: mining.cpp:261
JSONRPCError
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:51
TestBlockValidity
bool TestBlockValidity(BlockValidationState &state, const CChainParams &chainparams, CChainState &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)
Definition: validation.cpp:3690
LOCK
#define LOCK(cs)
Definition: sync.h:226
arith_uint256::SetCompact
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...
Definition: arith_uint256.cpp:203
MAX_BLOCK_WEIGHT
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
Definition: consensus.h:15
RPCArg::Optional::OMITTED
@ OMITTED
Optional argument with default value omitted because they are implicitly clear.
CTxIn::prevout
COutPoint prevout
Definition: transaction.h:68
node::UpdateTime
int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &consensusParams, const CBlockIndex *pindexPrev)
Definition: miner.cpp:30
DecodeDestination
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
Definition: key_io.cpp:281
params.h
getmininginfo
static RPCHelpMan getmininginfo()
Definition: mining.cpp:413
EstimatorBucket::withinTarget
double withinTarget
Definition: fees.h:60
CTxMemPool::size
unsigned long size() const
Definition: txmempool.h:720
UniValue::push_back
bool push_back(const UniValue &val)
Definition: univalue.cpp:108
node::RegenerateCommitments
void RegenerateCommitments(CBlock &block, ChainstateManager &chainman)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed.
Definition: miner.cpp:47
Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:561
EnsureMemPool
CTxMemPool & EnsureMemPool(const NodeContext &node)
Definition: server_util.cpp:29
EstimationResult::pass
EstimatorBucket pass
Definition: fees.h:69
CBlockPolicyEstimator::HighestTargetTracked
unsigned int HighestTargetTracked(FeeEstimateHorizon horizon) const EXCLUSIVE_LOCKS_REQUIRED(!m_cs_fee_estimator)
Calculation of highest target that estimates are tracked for.
Definition: fees.cpp:705
node
Definition: init.h:22
ThresholdState::LOCKED_IN
@ LOCKED_IN
generate
static RPCHelpMan generate()
Definition: mining.cpp:254
submitblock_StateCatcher::submitblock_StateCatcher
submitblock_StateCatcher(const uint256 &hashIn)
Definition: mining.cpp:953
RPCResult::Type::OBJ_DYN
@ OBJ_DYN
Special dictionary with keys that are not literals.
UniValue::size
size_t size() const
Definition: univalue.h:66
CTransaction::GetWitnessHash
const uint256 & GetWitnessHash() const
Definition: transaction.h:303
ValidationState::GetRejectReason
std::string GetRejectReason() const
Definition: validation.h:124
JSONRPCRequest
Definition: request.h:28
CTransaction::GetHash
const uint256 & GetHash() const
Definition: transaction.h:302
RPCResult
Definition: util.h:231
submitblock_StateCatcher::BlockChecked
void BlockChecked(const CBlock &block, const BlockValidationState &stateIn) override
Notifies listeners of a block validation result.
Definition: mining.cpp:956
LEAVE_CRITICAL_SECTION
#define LEAVE_CRITICAL_SECTION(cs)
Definition: sync.h:239
blockchain.h
DecodeHexBlk
bool DecodeHexBlk(CBlock &, const std::string &strHexBlk)
Definition: core_read.cpp:223
find_value
const UniValue & find_value(const UniValue &obj, const std::string &name)
Definition: univalue.cpp:236
RPC_TYPE_ERROR
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
Definition: protocol.h:40
error
bool error(const char *fmt, const Args &... args)
Definition: system.h:49
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:344
UniValue::VARR
@ VARR
Definition: univalue.h:19
server.h
ThresholdState
ThresholdState
BIP 9 defines a finite-state-machine to deploy a softfork in multiple stages.
Definition: versionbits.h:27
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:148
CFeeRate::GetFeePerK
CAmount GetFeePerK() const
Return the fee in satoshis for a size of 1000 bytes.
Definition: feerate.h:57
HexStr
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: strencodings.cpp:510
ArgsManager::GetIntArg
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
Definition: system.cpp:591
GenerateBlock
static bool GenerateBlock(ChainstateManager &chainman, CBlock &block, uint64_t &max_tries, unsigned int &extra_nonce, uint256 &block_hash)
Definition: mining.cpp:119
Consensus::Params::DifficultyAdjustmentInterval
int64_t DifficultyAdjustmentInterval() const
Definition: params.h:105
amount.h
EnsureAnyMemPool
CTxMemPool & EnsureAnyMemPool(const std::any &context)
Definition: server_util.cpp:37
base_uint::getdouble
double getdouble() const
Definition: arith_uint256.cpp:135
ALL_FEE_ESTIMATE_HORIZONS
static constexpr auto ALL_FEE_ESTIMATE_HORIZONS
Definition: fees.h:34
ValidationState::IsError
bool IsError() const
Definition: validation.h:122
warnings.h
WITNESS_SCALE_FACTOR
static const int WITNESS_SCALE_FACTOR
Definition: consensus.h:21
CConnman::GetNodeCount
size_t GetNodeCount(ConnectionDirection) const
Definition: net.cpp:2801
submitblock_StateCatcher
Definition: mining.cpp:946
UNIX_EPOCH_TIME
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:21
ValidationState::IsInvalid
bool IsInvalid() const
Definition: validation.h:121
WAIT_LOCK
#define WAIT_LOCK(cs, name)
Definition: sync.h:231
CChainState::m_chain
CChain m_chain
The current chain of blockheaders we consult and build on.
Definition: validation.h:521
DEFAULT_MAX_MEMPOOL_SIZE
static const unsigned int DEFAULT_MAX_MEMPOOL_SIZE
Default for -maxmempool, maximum megabytes of mempool memory usage.
Definition: policy.h:32
FlatSigningProvider
Definition: signingprovider.h:72
descriptor.h
ChainstateManager::m_blockman
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:831
ByteUnit::t
@ t
EstimatorBucket::totalConfirmed
double totalConfirmed
Definition: fees.h:61
DecodeHexTx
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
Definition: core_read.cpp:199
Consensus::Params::signet_blocks
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
Definition: params.h:115
RPC_CLIENT_NOT_CONNECTED
@ RPC_CLIENT_NOT_CONNECTED
P2P client errors.
Definition: protocol.h:58
g_best_block_cv
std::condition_variable g_best_block_cv
Definition: validation.cpp:142