9 #include <chainparams.h>
34 #include <txmempool.h>
62 if (lookup < -1 || lookup == 0) {
66 if (height < -1 || height > active_chain.
Height()) {
73 pb = active_chain[height];
76 if (pb ==
nullptr || !pb->
nHeight)
89 int64_t maxTime = minTime;
90 for (
int i = 0; i < lookup; i++) {
93 minTime = std::min(time, minTime);
94 maxTime = std::max(time, maxTime);
98 if (minTime == maxTime)
102 int64_t timeDiff = maxTime - minTime;
110 "\nReturns the estimated network hashes per second based on the last n blocks.\n"
111 "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
112 "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
114 {
"nblocks",
RPCArg::Type::NUM,
RPCArg::Default{120},
"The number of previous blocks to calculate estimate from, or -1 for blocks since last difficulty change."},
144 if (block.
nNonce == std::numeric_limits<uint32_t>::max()) {
148 block_out = std::make_shared<const CBlock>(block);
150 if (!process_new_block)
return true;
163 std::unique_ptr<CBlockTemplate> pblocktemplate(miner.
createNewBlock(coinbase_script));
164 if (!pblocktemplate.get())
167 std::shared_ptr<const CBlock> block_out;
168 if (!
GenerateBlock(chainman, miner, pblocktemplate->block, nMaxTries, block_out,
true)) {
174 blockHashes.
push_back(block_out->GetHash().GetHex());
183 const auto desc =
Parse(descriptor, key_provider, error,
false);
185 if (desc->IsRange()) {
190 std::vector<CScript> scripts;
191 if (!desc->Expand(0, key_provider, scripts, provider)) {
198 if (scripts.size() == 1) {
200 }
else if (scripts.size() == 4) {
217 "generatetodescriptor",
218 "Mine to a specified descriptor and return the block hashes.",
231 "\nGenerate 11 blocks to mydesc\n" +
HelpExampleCli(
"generatetodescriptor",
"11 \"mydesc\"")},
234 const auto num_blocks{
self.Arg<
int>(
"num_blocks")};
235 const auto max_tries{
self.Arg<uint64_t>(
"maxtries")};
247 return generateBlocks(chainman, miner, coinbase_script, num_blocks, max_tries);
262 "Mine to a specified address and return the block hashes.",
274 "\nGenerate 11 blocks to myaddress\n"
276 +
"If you are using the " PACKAGE_NAME " wallet, you can get a new address to send the newly generated bitcoin to with:\n"
281 const int num_blocks{request.params[0].
getInt<
int>()};
282 const uint64_t max_tries{request.params[2].isNull() ?
DEFAULT_MAX_TRIES : request.params[2].getInt<
int>()};
295 return generateBlocks(chainman, miner, coinbase_script, num_blocks, max_tries);
303 "Mine a set of ordered transactions to a specified address or descriptor and return the block hash.",
307 "Txids must reference transactions currently in the mempool.\n"
308 "All transactions must be valid and in valid order, otherwise the block will be rejected.",
323 "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n"
324 +
HelpExampleCli(
"generateblock", R
"("myaddress" '["rawtx", "mempool_txid"]')")
328 const auto address_or_descriptor = request.params[0].
get_str();
345 std::vector<CTransactionRef> txs;
346 const auto raw_txs_or_txids = request.params[1].get_array();
347 for (
size_t i = 0; i < raw_txs_or_txids.size(); i++) {
348 const auto& str{raw_txs_or_txids[i].get_str()};
352 const auto tx{mempool.
get(*hash)};
357 txs.emplace_back(tx);
367 const bool process_new_block{request.params[2].isNull() ? true : request.params[2].get_bool()};
372 std::unique_ptr<CBlockTemplate> blocktemplate{miner.
createNewBlock(coinbase_script, {.use_mempool =
false})};
373 if (!blocktemplate) {
376 block = blocktemplate->block;
382 block.
vtx.insert(block.
vtx.end(), txs.begin(), txs.end());
392 std::shared_ptr<const CBlock> block_out;
395 if (!
GenerateBlock(chainman, miner, block, max_tries, block_out, process_new_block) || !block_out) {
400 obj.
pushKV(
"hash", block_out->GetHash().GetHex());
401 if (!process_new_block) {
414 "\nReturns a json object containing mining-related information.",
420 {
RPCResult::Type::NUM,
"currentblockweight",
true,
"The block weight of the last assembled block (only present if a block was ever assembled)"},
421 {
RPCResult::Type::NUM,
"currentblocktx",
true,
"The number of block transactions of the last assembled block (only present if a block was ever assembled)"},
428 RPCResult{
RPCResult::Type::ARR,
"warnings",
"any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
449 if (BlockAssembler::m_last_block_weight) obj.
pushKV(
"currentblockweight", *BlockAssembler::m_last_block_weight);
450 if (BlockAssembler::m_last_block_num_txs) obj.
pushKV(
"currentblocktx", *BlockAssembler::m_last_block_num_txs);
453 obj.
pushKV(
"pooledtx", (uint64_t)mempool.
size());
466 "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
470 " DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
472 " Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
473 " The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
474 " considers the transaction as it would have paid a higher (or lower) fee."},
487 const auto dummy{
self.MaybeArg<
double>(
"dummy")};
488 CAmount nAmount = request.params[2].getInt<int64_t>();
490 if (dummy && *dummy != 0) {
502 return RPCHelpMan{
"getprioritisedtransactions",
503 "Returns a map of all user-created (see prioritisetransaction) fee deltas by txid, and whether the tx is present in mempool.",
511 {
RPCResult::Type::NUM,
"modified_fee",
true,
"modified fee in satoshis. Only returned if in_mempool=true"},
526 result_inner.pushKV(
"fee_delta", delta_info.delta);
527 result_inner.pushKV(
"in_mempool", delta_info.in_mempool);
528 if (delta_info.in_mempool) {
529 result_inner.pushKV(
"modified_fee", *delta_info.modified_fee);
531 rpc_result.pushKV(delta_info.txid.GetHex(), std::move(result_inner));
550 if (strRejectReason.empty())
552 return strRejectReason;
560 std::string s = vbinfo.
name;
562 s.insert(s.begin(),
'!');
570 "\nIf the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
571 "It returns data needed to construct a block to work on.\n"
572 "For full specification, see BIPs 22, 23, 9, and 145:\n"
573 " https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
574 " https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
575 " https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
576 " https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n",
603 {
RPCResult::Type::STR,
"",
"name of a rule the client must understand to some extent; see BIP 9 for format"},
607 {
RPCResult::Type::NUM,
"rulename",
"identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
613 {
RPCResult::Type::NUM,
"vbrequired",
"bit mask of versionbits the server requires set in submissions"},
615 {
RPCResult::Type::ARR,
"transactions",
"contents of non-coinbase transactions that should be included in the next block",
624 {
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"},
626 {
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"},
627 {
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"},
628 {
RPCResult::Type::NUM,
"weight",
"total transaction weight, as counted for purposes of block limits"},
635 {
RPCResult::Type::NUM,
"coinbasevalue",
"maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
636 {
RPCResult::Type::STR,
"longpollid",
"an id to include with a request to longpoll on an update to this template"},
641 {
RPCResult::Type::STR,
"value",
"A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
651 {
RPCResult::Type::STR_HEX,
"default_witness_commitment",
true,
"a valid witness commitment for the unmodified block template"},
666 std::string strMode =
"template";
668 std::set<std::string> setClientRules;
669 if (!request.params[0].isNull())
675 else if (modeval.
isNull())
683 if (strMode ==
"proposal")
686 if (!dataval.
isStr())
699 return "duplicate-invalid";
700 return "duplicate-inconclusive";
705 return "inconclusive-not-best-prevblk";
714 for (
unsigned int i = 0; i < aClientRules.
size(); ++i) {
715 const UniValue& v = aClientRules[i];
716 setClientRules.insert(v.
get_str());
721 if (strMode !=
"template")
735 static unsigned int nTransactionsUpdatedLast;
741 std::chrono::steady_clock::time_point checktxtime;
742 unsigned int nTransactionsUpdatedLastLP;
747 const std::string& lpstr = lpval.
get_str();
749 hashWatchedChain =
ParseHashV(lpstr.substr(0, 64),
"longpollid");
750 nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
755 hashWatchedChain = tip;
756 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
762 checktxtime = std::chrono::steady_clock::now() + std::chrono::minutes(1);
767 if (
g_best_block_cv.wait_until(lock, checktxtime) == std::cv_status::timeout)
773 checktxtime += std::chrono::seconds(10);
789 if (consensusParams.
signet_blocks && setClientRules.count(
"signet") != 1) {
794 if (setClientRules.count(
"segwit") != 1) {
800 static int64_t time_start;
801 static std::unique_ptr<CBlockTemplate> pblocktemplate;
806 pindexPrev =
nullptr;
816 if (!pblocktemplate) {
821 pindexPrev = pindexPrevNew;
824 CBlock* pblock = &pblocktemplate->block;
827 UpdateTime(pblock, consensusParams, pindexPrev);
836 std::map<uint256, int64_t> setTxIndex;
838 for (
const auto& it : pblock->
vtx) {
841 setTxIndex[txHash] = i++;
858 entry.
pushKV(
"depends", std::move(deps));
860 int index_in_template = i - 1;
861 entry.
pushKV(
"fee", pblocktemplate->vTxFees[index_in_template]);
862 int64_t nTxSigOps = pblocktemplate->vTxSigOpsCost[index_in_template];
867 entry.
pushKV(
"sigops", nTxSigOps);
870 transactions.
push_back(std::move(entry));
883 result.
pushKV(
"capabilities", std::move(aCaps));
887 if (!fPreSegWit) aRules.
push_back(
"!segwit");
911 if (setClientRules.find(vbinfo.
name) == setClientRules.end()) {
924 if (setClientRules.find(vbinfo.
name) == setClientRules.end()) {
935 result.
pushKV(
"rules", std::move(aRules));
936 result.
pushKV(
"vbavailable", std::move(vbavailable));
937 result.
pushKV(
"vbrequired",
int(0));
940 result.
pushKV(
"transactions", std::move(transactions));
941 result.
pushKV(
"coinbaseaux", std::move(aux));
942 result.
pushKV(
"coinbasevalue", (int64_t)pblock->
vtx[0]->vout[0].nValue);
943 result.
pushKV(
"longpollid", tip.GetHex() +
ToString(nTransactionsUpdatedLast));
946 result.
pushKV(
"mutable", std::move(aMutable));
947 result.
pushKV(
"noncerange",
"00000000ffffffff");
956 result.
pushKV(
"sigoplimit", nSigOpLimit);
957 result.
pushKV(
"sizelimit", nSizeLimit);
969 if (!pblocktemplate->vchCoinbaseCommitment.empty()) {
970 result.
pushKV(
"default_witness_commitment",
HexStr(pblocktemplate->vchCoinbaseCommitment));
1000 "\nAttempts to submit new block to network.\n"
1001 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1016 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1017 CBlock& block = *blockptr;
1018 if (!
DecodeHexBlk(block, request.params[0].get_str())) {
1022 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
1036 return "duplicate-invalid";
1045 chainman.UpdateUncommittedBlockStructures(block, pindex);
1053 auto sc = std::make_shared<submitblock_StateCatcher>(block.
GetHash());
1057 if (!new_block && accepted) {
1061 return "inconclusive";
1071 "\nDecode the given hexdata as a header and submit it as a candidate chain tip if valid."
1072 "\nThrows when the header is invalid.\n",
1123 for (
const auto& c : commands) {
1124 t.appendCommand(c.name, &c);
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination corresponds to one with an address.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown > CTxDestination
A txout script categorized into standard templates.
int64_t CAmount
Amount in satoshis (Can be negative)
double GetDifficulty(const CBlockIndex &blockindex)
Get the difficulty of the net wrt to the given block index.
@ BLOCK_VALID_SCRIPTS
Scripts & signatures ok.
const CChainParams & Params()
Return the currently selected parameters.
#define CHECK_NONFATAL(condition)
Identity function.
std::vector< CTransactionRef > vtx
The block chain is a tree shaped structure starting with the genesis block at the root,...
CBlockIndex * pprev
pointer to the index of the predecessor of this block
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
uint256 GetBlockHash() const
int64_t GetBlockTime() const
int64_t GetMedianTimePast() const
bool IsValid(enum BlockStatus nUpTo=BLOCK_VALID_TRANSACTIONS) const EXCLUSIVE_LOCKS_REQUIRED(
Check whether this block index entry is valid up to the passed validity level.
int nHeight
height of the entry in the chain. The genesis block has height 0
An in-memory indexed chain of blocks.
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
int Height() const
Return the maximal height in the chain.
std::string GetChainTypeString() const
Return the chain type string.
const Consensus::Params & GetConsensus() const
size_t GetNodeCount(ConnectionDirection) const
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
const Txid & GetHash() const LIFETIMEBOUND
const Wtxid & GetWitnessHash() const LIFETIMEBOUND
const std::vector< CTxIn > vin
An input of a transaction.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
void PrioritiseTransaction(const uint256 &hash, const CAmount &nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
CTransactionRef get(const uint256 &hash) const
std::vector< delta_info > GetPrioritisedTransactions() const EXCLUSIVE_LOCKS_REQUIRED(!cs)
Return a vector of all entries in mapDeltas with their corresponding delta_info.
unsigned long size() const
Implement this to subscribe to events generated in validation and mempool.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
const CChainParams & GetParams() const
const util::SignalInterrupt & m_interrupt
VersionBitsCache m_versionbitscache
Track versionbit status.
bool ProcessNewBlockHeaders(const std::vector< CBlockHeader > &block, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
const Consensus::Params & GetConsensus() const
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Double ended buffer combining vector and stream-like interfaces.
void push_back(UniValue val)
const std::string & get_str() const
const UniValue & find_value(std::string_view key) const
const UniValue & get_obj() const
void pushKV(std::string key, UniValue val)
std::string GetRejectReason() const
std::string ToString() const
static uint32_t Mask(const Consensus::Params ¶ms, Consensus::DeploymentPos pos)
ThresholdState State(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms, Consensus::DeploymentPos pos) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Get the BIP9 state for a given deployment for the block after pindexPrev.
256-bit unsigned big integer.
arith_uint256 & SetCompact(uint32_t nCompact, bool *pfNegative=nullptr, bool *pfOverflow=nullptr)
The "compact" format is a representation of a whole number N using an unsigned 32bit number similar t...
std::string GetHex() const
std::string GetHex() const
Interface giving clients (RPC, Stratum v2 Template Provider in the future) ability to create block te...
virtual std::unique_ptr< node::CBlockTemplate > createNewBlock(const CScript &script_pub_key, const node::BlockCreateOptions &options={})=0
Construct a new block template.
virtual bool testBlockValidity(const CBlock &block, bool check_merkle_root, BlockValidationState &state)=0
Check a block is completely valid from start to finish.
virtual bool processNewBlock(const std::shared_ptr< const CBlock > &block, bool *new_block)=0
Processes new block.
virtual bool isInitialBlockDownload()=0
Returns whether IBD is still in progress.
virtual unsigned int getTransactionsUpdated()=0
Return the number of transaction updates in the mempool, used to decide whether to make a new block t...
virtual bool isTestChain()=0
If this chain is exclusively used for testing.
virtual std::optional< uint256 > getTipHash()=0
Returns the hash for the tip of this chain.
Generate a new block, without valid proof-of-work.
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
void BlockChecked(const CBlock &block, const BlockValidationState &stateIn) override
Notifies listeners of a block validation result.
submitblock_StateCatcher(const uint256 &hashIn)
BlockValidationState state
std::string GetHex() const
static std::optional< uint256 > FromHex(std::string_view str)
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
static int32_t GetTransactionWeight(const CTransaction &tx)
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
static const unsigned int MAX_BLOCK_SERIALIZED_SIZE
The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
static const int64_t MAX_BLOCK_SIGOPS_COST
The maximum allowed number of signature check operations in a block (network rule)
static const int WITNESS_SCALE_FACTOR
std::string EncodeHexTx(const CTransaction &tx)
bool DecodeHexBlk(CBlock &, const std::string &strHexBlk)
bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
const struct VBDeploymentInfo VersionBitsDeploymentInfo[Consensus::MAX_VERSION_BITS_DEPLOYMENTS]
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, [[maybe_unused]] VersionBitsCache &versionbitscache)
Determine if a deployment is active for the next block.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
@ MAX_VERSION_BITS_DEPLOYMENTS
void RegenerateCommitments(CBlock &block, ChainstateManager &chainman)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed.
int64_t UpdateTime(CBlockHeader *pblock, const Consensus::Params &consensusParams, const CBlockIndex *pindexPrev)
UniValue GetWarningsForRpc(const Warnings &warnings, bool use_deprecated)
RPC helper function that wraps warnings.GetMessages().
std::string ToString(const T &t)
Locale-independent version of std::to_string.
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 constexpr TransactionSerParams TX_WITH_WITNESS
static CTransactionRef MakeTransactionRef(Tx &&txIn)
UniValue JSONRPCError(int code, const std::string &message)
static UniValue generateBlocks(ChainstateManager &chainman, Mining &miner, const CScript &coinbase_script, int nGenerate, uint64_t nMaxTries)
static UniValue GetNetworkHashPS(int lookup, int height, const CChain &active_chain)
Return average network hashes per second based on the last 'lookup' blocks, or from the last difficul...
static RPCHelpMan generateblock()
static RPCHelpMan generatetodescriptor()
static bool getScriptFromDescriptor(const std::string &descriptor, CScript &script, std::string &error)
static RPCHelpMan getnetworkhashps()
static RPCHelpMan getprioritisedtransactions()
static UniValue BIP22ValidationResult(const BlockValidationState &state)
static RPCHelpMan submitblock()
static RPCHelpMan getblocktemplate()
static bool GenerateBlock(ChainstateManager &chainman, Mining &miner, CBlock &block, uint64_t &max_tries, std::shared_ptr< const CBlock > &block_out, bool process_new_block)
static RPCHelpMan generate()
static RPCHelpMan submitheader()
static RPCHelpMan prioritisetransaction()
static RPCHelpMan getmininginfo()
static RPCHelpMan generatetoaddress()
static std::string gbt_vb_name(const Consensus::DeploymentPos pos)
void RegisterMiningRPCCommands(CRPCTable &t)
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
@ RPC_OUT_OF_MEMORY
Ran out of memory during operation.
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
@ RPC_CLIENT_NOT_CONNECTED
P2P client errors.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_VERIFY_ERROR
General error during transaction or block submission.
@ RPC_CLIENT_IN_INITIAL_DOWNLOAD
Still downloading initial blocks.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
bool IsDeprecatedRPCEnabled(const std::string &method)
bool IsRPCRunning()
Query whether RPC is running.
ChainstateManager & EnsureAnyChainman(const std::any &context)
CTxMemPool & EnsureAnyMemPool(const std::any &context)
NodeContext & EnsureAnyNodeContext(const std::any &context)
interfaces::Mining & EnsureMining(const NodeContext &node)
CConnman & EnsureConnman(const NodeContext &node)
CTxMemPool & EnsureMemPool(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
A mutable version of CTransaction.
int bit
Bit position to select the particular bit in nVersion.
Parameters that influence chain consensus.
std::vector< uint8_t > signet_challenge
int64_t DifficultyAdjustmentInterval() const
bool signet_blocks
If true, witness commitments contain a payload equal to a Bitcoin Script solution to the signet chall...
BIP9Deployment vDeployments[MAX_VERSION_BITS_DEPLOYMENTS]
@ STR_HEX
Special type that is a STR with only hex chars.
std::string DefaultHint
Hint for default value.
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ NUM_TIME
Special numeric to denote unix epoch time.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
bool gbt_force
Whether GBT clients can safely ignore this rule in simplified usage.
const char * name
Deployment name.
ValidationSignals * signals
NodeContext struct containing references to chain state and connection state.
#define WAIT_LOCK(cs, name)
#define ENTER_CRITICAL_SECTION(cs)
#define LEAVE_CRITICAL_SECTION(cs)
const UniValue NullUniValue
GlobalMutex g_best_block_mutex
std::condition_variable g_best_block_cv
uint256 g_best_block
Used to notify getblocktemplate RPC of new tips.
ThresholdState
BIP 9 defines a finite-state-machine to deploy a softfork in multiple stages.