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