50 if (height >= 0 && height < ::
ChainActive().Height())
53 if (pb ==
nullptr || !pb->
nHeight)
66 int64_t maxTime = minTime;
67 for (
int i = 0; i < lookup; i++) {
70 minTime = std::min(time, minTime);
71 maxTime = std::max(time, maxTime);
75 if (minTime == maxTime)
79 int64_t timeDiff = maxTime - minTime;
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",
91 {
"nblocks",
RPCArg::Type::NUM,
"120",
"The number of blocks, or -1 for blocks since last difficulty change."},
92 {
"height",
RPCArg::Type::NUM,
"-1",
"To estimate at the time of the given height."},
103 return GetNetworkHashPS(!request.params[0].isNull() ? request.params[0].get_int() : 120, !request.params[1].isNull() ? request.params[1].get_int() : -1);
126 if (block.
nNonce == std::numeric_limits<uint32_t>::max()) {
130 std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
131 if (!chainman.
ProcessNewBlock(chainparams, shared_pblock,
true,
nullptr)) {
147 nHeightEnd = nHeight+nGenerate;
149 unsigned int nExtraNonce = 0;
153 std::unique_ptr<CBlockTemplate> pblocktemplate(
BlockAssembler(mempool,
Params()).CreateNewBlock(coinbase_script));
154 if (!pblocktemplate.get())
156 CBlock *pblock = &pblocktemplate->block;
159 if (!
GenerateBlock(chainman, *pblock, nMaxTries, nExtraNonce, block_hash)) {
163 if (!block_hash.
IsNull()) {
174 const auto desc =
Parse(descriptor, key_provider, error,
false);
176 if (desc->IsRange()) {
181 std::vector<CScript> scripts;
182 if (!desc->Expand(0, key_provider, scripts, provider)) {
189 if (scripts.size() == 1) {
190 script = scripts.at(0);
191 }
else if (scripts.size() == 4) {
193 script = scripts.at(2);
196 script = scripts.at(1);
208 "generatetodescriptor",
209 "\nMine blocks immediately to a specified descriptor (before the RPC call returns)\n",
222 "\nGenerate 11 blocks to mydesc\n" +
HelpExampleCli(
"generatetodescriptor",
"11 \"mydesc\"")},
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()};
237 return generateBlocks(chainman, mempool, coinbase_script, num_blocks, max_tries);
252 "\nMine blocks immediately to a specified address (before the RPC call returns)\n",
264 "\nGenerate 11 blocks to myaddress\n" 266 +
"If you are using the " PACKAGE_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n" 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()};
284 return generateBlocks(chainman, mempool, coinbase_script, num_blocks, max_tries);
292 "\nMine a block with a set of ordered transactions immediately to a specified address or descriptor (before the RPC call returns)\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.",
310 "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n" 311 +
HelpExampleCli(
"generateblock", R
"("myaddress" '["rawtx", "mempool_txid"]')") 315 const auto address_or_descriptor = request.params[0].
get_str();
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());
339 const auto tx = mempool.
get(hash);
344 txs.emplace_back(tx);
361 std::unique_ptr<CBlockTemplate> blocktemplate(
BlockAssembler(empty_mempool, chainparams).CreateNewBlock(coinbase_script));
362 if (!blocktemplate) {
365 block = blocktemplate->block;
371 block.
vtx.insert(block.
vtx.end(), txs.begin(), txs.end());
385 unsigned int extra_nonce{0};
401 "\nReturns a json object containing mining-related information.",
407 {
RPCResult::Type::NUM,
"currentblockweight",
true,
"The block weight of the last assembled block (only present if a block was ever assembled)"},
408 {
RPCResult::Type::NUM,
"currentblocktx",
true,
"The number of block transactions of the last assembled block (only present if a block was ever assembled)"},
430 obj.
pushKV(
"pooledtx", (uint64_t)mempool.
size());
443 "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
447 " DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
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."},
464 CAmount nAmount = request.params[2].get_int64();
466 if (!(request.params[1].isNull() || request.params[1].get_real() == 0)) {
488 if (strRejectReason.empty())
490 return strRejectReason;
498 std::string s = vbinfo.
name;
500 s.insert(s.begin(),
'!');
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",
531 "\"template_request\""},
539 {
RPCResult::Type::STR,
"",
"name of a rule the client must understand to some extent; see BIP 9 for format"},
543 {
RPCResult::Type::NUM,
"rulename",
"identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
545 {
RPCResult::Type::NUM,
"vbrequired",
"bit mask of versionbits the server requires set in submissions"},
547 {
RPCResult::Type::ARR,
"transactions",
"contents of non-coinbase transactions that should be included in the next block",
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"},
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"},
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"},
573 {
RPCResult::Type::STR,
"value",
"A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
582 {
RPCResult::Type::STR,
"default_witness_commitment",
true,
"a valid witness commitment for the unmodified block template"}
592 std::string strMode =
"template";
594 std::set<std::string> setClientRules;
595 int64_t nMaxVersionPreVB = -1;
596 if (!request.params[0].isNull())
602 else if (modeval.
isNull())
610 if (strMode ==
"proposal")
613 if (!dataval.
isStr())
626 return "duplicate-invalid";
627 return "duplicate-inconclusive";
633 return "inconclusive-not-best-prevblk";
641 for (
unsigned int i = 0; i < aClientRules.
size(); ++i) {
642 const UniValue& v = aClientRules[i];
643 setClientRules.insert(v.
get_str());
648 if (uvMaxVersion.
isNum()) {
649 nMaxVersionPreVB = uvMaxVersion.
get_int64();
654 if (strMode !=
"template")
661 if (!
Params().IsTestChain()) {
671 static unsigned int nTransactionsUpdatedLast;
678 std::chrono::steady_clock::time_point checktxtime;
679 unsigned int nTransactionsUpdatedLastLP;
684 std::string lpstr = lpval.
get_str();
686 hashWatchedChain =
ParseHashV(lpstr.substr(0, 64),
"longpollid");
687 nTransactionsUpdatedLastLP =
atoi64(lpstr.substr(64));
693 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
704 if (
g_best_block_cv.wait_until(lock, checktxtime) == std::cv_status::timeout)
710 checktxtime += std::chrono::seconds(10);
724 if (consensusParams.
signet_blocks && setClientRules.count(
"signet") != 1) {
729 if (setClientRules.count(
"segwit") != 1) {
735 static int64_t nStart;
736 static std::unique_ptr<CBlockTemplate> pblocktemplate;
741 pindexPrev =
nullptr;
755 pindexPrev = pindexPrevNew;
758 CBlock* pblock = &pblocktemplate->block;
761 UpdateTime(pblock, consensusParams, pindexPrev);
770 std::map<uint256, int64_t> setTxIndex;
772 for (
const auto&
it : pblock->
vtx) {
775 setTxIndex[txHash] = i++;
792 entry.
pushKV(
"depends", deps);
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];
801 entry.
pushKV(
"sigops", nTxSigOps);
817 result.
pushKV(
"capabilities", aCaps);
821 if (!fPreSegWit) aRules.
push_back(
"!segwit");
845 if (setClientRules.find(vbinfo.
name) == setClientRules.end()) {
858 if (setClientRules.find(vbinfo.
name) == setClientRules.end()) {
870 result.
pushKV(
"rules", aRules);
871 result.
pushKV(
"vbavailable", vbavailable);
872 result.
pushKV(
"vbrequired",
int(0));
874 if (nMaxVersionPreVB >= 2) {
883 result.
pushKV(
"transactions", transactions);
884 result.
pushKV(
"coinbaseaux", aux);
885 result.
pushKV(
"coinbasevalue", (int64_t)pblock->
vtx[0]->vout[0].nValue);
889 result.
pushKV(
"mutable", aMutable);
890 result.
pushKV(
"noncerange",
"00000000ffffffff");
899 result.
pushKV(
"sigoplimit", nSigOpLimit);
900 result.
pushKV(
"sizelimit", nSizeLimit);
912 if (!pblocktemplate->vchCoinbaseCommitment.empty()) {
913 result.
pushKV(
"default_witness_commitment",
HexStr(pblocktemplate->vchCoinbaseCommitment));
943 "\nAttempts to submit new block to network.\n" 944 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
947 {
"dummy",
RPCArg::Type::STR,
"ignored",
"dummy value, for compatibility with BIP22. This value is ignored."},
956 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
957 CBlock& block = *blockptr;
958 if (!
DecodeHexBlk(block, request.params[0].get_str())) {
962 if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
975 return "duplicate-invalid";
989 auto sc = std::make_shared<submitblock_StateCatcher>(block.GetHash());
993 if (!new_block && accepted) {
997 return "inconclusive";
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",
1034 if (state.IsError()) {
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",
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" 1063 {
RPCResult::Type::ARR,
"errors",
true,
"Errors encountered during processing (if there are any)",
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."},
1078 RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VSTR});
1085 bool conservative =
true;
1086 if (!request.params[1].isNull()) {
1101 errors.
push_back(
"Insufficient data or no feerate found");
1102 result.
pushKV(
"errors", errors);
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",
1122 {
"threshold",
RPCArg::Type::NUM,
"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" 1127 RPCResult::Type::OBJ,
"",
"Results are returned for any horizon which tracks blocks up to the confirmation target",
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",
true,
"information about the lowest range of feerates to succeed in meeting the threshold",
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"},
1143 {
RPCResult::Type::OBJ,
"fail",
true,
"information about the highest range of feerates to fail to meet the threshold",
1147 {
RPCResult::Type::ARR,
"errors",
true,
"Errors encountered during processing (if there are any)",
1166 RPCTypeCheck(request.params, {UniValue::VNUM, UniValue::VNUM},
true);
1173 double threshold = 0.95;
1174 if (!request.params[1].isNull()) {
1175 threshold = request.params[1].get_real();
1177 if (threshold < 0 || threshold > 1) {
1190 feeRate = fee_estimator.
estimateRawFee(conf_target, threshold, horizon, &buckets);
1212 horizon_result.
pushKV(
"scale", (
int)buckets.
scale);
1213 horizon_result.
pushKV(
"pass", passbucket);
1215 if (buckets.
fail.
start != -1) horizon_result.
pushKV(
"fail", failbucket);
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);
1241 {
"mining",
"submitblock", &
submitblock, {
"hexdata",
"dummy"} },
1242 {
"mining",
"submitheader", &
submitheader, {
"hexdata"} },
1245 {
"generating",
"generatetoaddress", &
generatetoaddress, {
"nblocks",
"address",
"maxtries"} },
1246 {
"generating",
"generatetodescriptor", &
generatetodescriptor, {
"num_blocks",
"descriptor",
"maxtries"} },
1247 {
"generating",
"generateblock", &
generateblock, {
"output",
"transactions"} },
1249 {
"util",
"estimatesmartfee", &
estimatesmartfee, {
"conf_target",
"estimate_mode"} },
1251 {
"hidden",
"estimaterawfee", &
estimaterawfee, {
"conf_target",
"threshold"} },
1252 {
"hidden",
"generate", &
generate, {} },
1255 for (
const auto& c : commands) {
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
static int64_t GetTransactionWeight(const CTransaction &tx)
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) ...
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
static Optional< int64_t > m_last_block_num_txs
void RPCTypeCheck(const UniValue ¶ms, const std::list< UniValueType > &typesExpected, bool fAllowNull)
Type-check arguments; throws JSONRPCError if wrong type given.
std::deque< CInv >::iterator it
static UniValue BIP22ValidationResult(const BlockValidationState &state)
bool DecodeHexBlk(CBlock &, const std::string &strHexBlk)
const std::chrono::seconds now
std::condition_variable g_best_block_cv
Ran out of memory during operation.
static const int WITNESS_SCALE_FACTOR
int64_t GetBlockTime() const
CBlockIndex * pprev
pointer to the index of the predecessor of this block
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.
int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &consensusParams, const CBlockIndex *pindexPrev)
bool IsRPCRunning()
Query whether RPC is running.
BlockValidationState state
static bool getScriptFromDescriptor(const std::string &descriptor, CScript &script, std::string &error)
CChain & ChainActive()
Please prefer the identical ChainstateManager::ActiveChain.
bool gbt_force
Whether GBT clients can safely ignore this rule in simplified usage.
ChainstateManager & EnsureChainman(const util::Ref &context)
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
static RPCHelpMan getblocktemplate()
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency...
void RegisterMiningRPCCommands(CRPCTable &t)
Register mining RPC commands.
#define CHECK_NONFATAL(condition)
Throw a NonFatalCheckError when the condition evaluates to false.
int Height() const
Return the maximal height in the chain.
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
UniValue ValueFromAmount(const CAmount &amount)
void BlockChecked(const CBlock &block, const BlockValidationState &stateIn) override
Notifies listeners of a block validation result.
unsigned long size() const
void RPCTypeCheckArgument(const UniValue &value, const UniValueType &typeExpected)
Type-check one argument; throws JSONRPCError if wrong type given.
Force estimateSmartFee to use non-conservative estimates.
std::string StringForFeeEstimateHorizon(FeeEstimateHorizon horizon)
const std::string & get_str() const
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system...
static RPCHelpMan generatetodescriptor()
double GetDifficulty(const CBlockIndex *blockindex)
Get the difficulty of the net wrt to the given block index.
int64_t get_int64() const
ThresholdState
BIP 9 defines a finite-state-machine to deploy a softfork in multiple stages.
uint32_t VersionBitsMask(const Consensus::Params ¶ms, Consensus::DeploymentPos pos)
CTxMemPool & EnsureMemPool(const util::Ref &context)
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.
bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header)
submitblock_StateCatcher(const uint256 &hashIn)
static const int64_t MAX_BLOCK_SIGOPS_COST
The maximum allowed number of signature check operations in a block (network rule) ...
static RPCHelpMan submitheader()
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
Implement this to subscribe to events generated in validation.
static RPCHelpMan getnetworkhashps()
static RPCHelpMan generatetoaddress()
const std::vector< CTxIn > vin
Invalid, missing or duplicate parameter.
const UniValue & find_value(const UniValue &obj, const std::string &name)
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
int64_t CAmount
Amount in satoshis (Can be negative)
uint256 GetBlockHash() const
General error during transaction or block submission.
bool IsValid(enum BlockStatus nUpTo=BLOCK_VALID_TRANSACTIONS) const
Check whether this block index entry is valid up to the passed validity level.
std::unique_ptr< Descriptor > Parse(const std::string &descriptor, FlatSigningProvider &out, std::string &error, bool require_checksum)
Parse a descriptor string.
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Special type that is a STR with only hex chars.
static RPCHelpMan estimaterawfee()
UniValue JSONRPCError(int code, const std::string &message)
bool push_back(const UniValue &val)
Special string with only hex chars.
NodeContext struct containing references to chain state and connection state.
std::unique_ptr< CConnman > connman
Scripts & signatures ok. Implies all parents are also at least SCRIPTS.
#define LEAVE_CRITICAL_SECTION(cs)
static constexpr auto ALL_FEE_ESTIMATE_HORIZONS
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...
An input of a transaction.
const uint256 & GetWitnessHash() const
The BlockPolicyEstimator is used for estimating the feerate needed for a transaction to be included i...
const uint256 & GetHash() const
std::string ToString() const
CFeeRate estimateSmartFee(int confTarget, FeeCalculation *feeCalc, bool conservative) const
Estimate feerate needed to get be included in a block within confTarget blocks.
unsigned int ParseConfirmTarget(const UniValue &value, unsigned int max_target)
Parse a confirm target option and raise an RPC error if it is invalid.
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate...
Unexpected type was passed as parameter.
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock...
const std::string CURRENCY_UNIT
static bool GenerateBlock(ChainstateManager &chainman, CBlock &block, uint64_t &max_tries, unsigned int &extra_nonce, uint256 &block_hash)
Generate a new block, without valid proof-of-work.
General application defined errors.
static UniValue generateBlocks(ChainstateManager &chainman, const CTxMemPool &mempool, const CScript &coinbase_script, int nGenerate, uint64_t nMaxTries)
bool pushKV(const std::string &key, const UniValue &val)
#define WAIT_LOCK(cs, name)
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::unique_ptr< CBlockTemplate > CreateNewBlock(const CScript &scriptPubKeyIn)
Construct a new block template with coinbase to scriptPubKeyIn.
const std::string InvalidEstimateModeErrorMessage()
Parameters that influence chain consensus.
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static Optional< int64_t > m_last_block_weight
static RPCHelpMan getmininginfo()
Special numeric to denote unix epoch time.
256-bit unsigned big integer.
int64_t GetMedianTimePast() const
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)
int64_t atoi64(const std::string &str)
static std::string gbt_vb_name(const Consensus::DeploymentPos pos)
static CTransactionRef MakeTransactionRef(Tx &&txIn)
int64_t DifficultyAdjustmentInterval() const
NodeContext & EnsureNodeContext(const util::Ref &context)
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.
#define ENTER_CRITICAL_SECTION(cs)
CBlockIndex * LookupBlockIndex(const uint256 &hash)
unsigned int HighestTargetTracked(FeeEstimateHorizon horizon) const
Calculation of highest target that estimates are tracked for.
Optional argument with default value omitted because they are implicitly clear.
CTxDestination DecodeDestination(const std::string &str)
static RPCHelpMan generate()
CChainState & ChainstateActive()
Please prefer the identical ChainstateManager::ActiveChainstate.
void RegenerateCommitments(CBlock &block)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed...
std::vector< CTransactionRef > vtx
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.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
const char * name
Deployment name.
static RPCHelpMan prioritisetransaction()
The block chain is a tree shaped structure starting with the genesis block at the root...
const CChainParams & Params()
Return the currently selected parameters.
Serialized script, used inside transaction inputs and outputs.
const UniValue & get_obj() const
std::vector< uint8_t > signet_challenge
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
std::string GetHex() const
static RPCHelpMan submitblock()
std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags=0)
Fee rate in satoshis per kilobyte: CAmount / kB.
const UniValue NullUniValue
unsigned int GetTransactionsUpdated() const
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)
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
A mutable version of CTransaction.
CTransactionRef get(const uint256 &hash) const
static const unsigned int MAX_BLOCK_SERIALIZED_SIZE
The maximum allowed size for a serialized block, in bytes (only for buffer size limits) ...
int SegwitHeight
Block height at which Segwit (BIP141, BIP143 and BIP147) becomes active.
No valid connection manager instance found.
std::string GetHex() const
bool ParseHashStr(const std::string &strHex, uint256 &result)
Parse a hex string into 256 bits.
The basic transaction that is broadcasted on the network and contained in blocks. ...
int nHeight
height of the entry in the chain. The genesis block has height 0
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded Values (throws error if not hex).
const Consensus::Params & GetConsensus() const
bool FeeModeFromString(const std::string &mode_string, FeeEstimateMode &fee_estimate_mode)
int bit
Bit position to select the particular bit in nVersion.
static RPCHelpMan estimatesmartfee()
Special dictionary with keys that are not literals.
std::string GetRejectReason() const
Still downloading initial blocks.
int64_t GetTime()
Return system time (or mocked time, if set)
static RPCHelpMan generateblock()
ThresholdState VersionBitsState(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms, Consensus::DeploymentPos pos, VersionBitsCache &cache)
VersionBitsCache versionbitscache
bool error(const char *fmt, const Args &... args)
static UniValue GetNetworkHashPS(int lookup, int height)
Return average network hashes per second based on the last 'lookup' blocks, or from the last difficul...
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
CAmount GetFeePerK() const
Return the fee in satoshis for a size of 1000 bytes.
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]
Error parsing or validating structure in raw format.
Special type to denote elision (...)