6#include <bitcoin-build-config.h>
9#include <chainparams.h>
66 if (lookup < -1 || lookup == 0) {
70 if (height < -1 || height > active_chain.
Height()) {
77 pb = active_chain[height];
80 if (pb ==
nullptr || !pb->
nHeight)
93 int64_t maxTime = minTime;
94 for (
int i = 0; i < lookup; i++) {
97 minTime = std::min(time, minTime);
98 maxTime = std::max(time, maxTime);
102 if (minTime == maxTime)
106 int64_t timeDiff = maxTime - minTime;
115 "Returns the estimated network hashes per second based on the last n blocks.\n"
116 "Pass in [blocks] to override # of blocks, -1 specifies since last difficulty change.\n"
117 "Pass in [height] to estimate the network speed at the time when a certain block was found.\n",
119 {
"nblocks",
RPCArg::Type::NUM,
RPCArg::Default{120},
"The number of previous blocks to calculate estimate from, or -1 for blocks since last difficulty change."},
149 if (block.nNonce == std::numeric_limits<uint32_t>::max()) {
153 block_out = std::make_shared<const CBlock>(std::move(block));
155 if (!process_new_block)
return true;
168 std::unique_ptr<BlockTemplate> block_template(miner.
createNewBlock({ .coinbase_output_script = coinbase_output_script }));
171 std::shared_ptr<const CBlock> block_out;
172 if (!
GenerateBlock(chainman, block_template->getBlock(), nMaxTries, block_out,
true)) {
178 blockHashes.
push_back(block_out->GetHash().GetHex());
187 const auto descs =
Parse(descriptor, key_provider, error,
false);
188 if (descs.empty())
return false;
189 if (descs.size() > 1) {
192 const auto& desc = descs.at(0);
193 if (desc->IsRange()) {
198 std::vector<CScript> scripts;
199 if (!desc->Expand(0, key_provider, scripts, provider)) {
206 if (scripts.size() == 1) {
208 }
else if (scripts.size() == 4) {
222 "generatetodescriptor",
223 "Mine to a specified descriptor and return the block hashes.",
236 "\nGenerate 11 blocks to mydesc\n" +
HelpExampleCli(
"generatetodescriptor",
"11 \"mydesc\"")},
239 const auto num_blocks{self.
Arg<
int>(
"num_blocks")};
240 const auto max_tries{self.
Arg<uint64_t>(
"maxtries")};
242 CScript coinbase_output_script;
252 return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
267 "Mine to a specified address and return the block hashes.",
279 "\nGenerate 11 blocks to myaddress\n"
281 +
"If you are using the " CLIENT_NAME
" wallet, you can get a new address to send the newly generated bitcoin to with:\n"
286 const int num_blocks{request.params[0].
getInt<
int>()};
287 const uint64_t max_tries{request.params[2].isNull() ?
DEFAULT_MAX_TRIES : request.params[2].getInt<
int>()};
300 return generateBlocks(chainman, miner, coinbase_output_script, num_blocks, max_tries);
308 "Mine a set of ordered transactions to a specified address or descriptor and return the block hash.",
312 "Txids must reference transactions currently in the mempool.\n"
313 "All transactions must be valid and in valid order, otherwise the block will be rejected.",
328 "\nGenerate a block to myaddress, with txs rawtx and mempool_txid\n"
329 +
HelpExampleCli(
"generateblock", R
"("myaddress" '["rawtx", "mempool_txid"]')")
333 const auto address_or_descriptor = request.params[0].
get_str();
334 CScript coinbase_output_script;
350 std::vector<CTransactionRef> txs;
351 const auto raw_txs_or_txids = request.params[1].get_array();
352 for (
size_t i = 0; i < raw_txs_or_txids.size(); i++) {
353 const auto& str{raw_txs_or_txids[i].get_str()};
357 const auto tx{mempool.
get(*hash)};
362 txs.emplace_back(tx);
372 const bool process_new_block{request.params[2].isNull() ? true : request.params[2].get_bool()};
379 std::unique_ptr<BlockTemplate> block_template{miner.
createNewBlock({.use_mempool =
false, .coinbase_output_script = coinbase_output_script})};
382 block = block_template->getBlock();
388 block.
vtx.insert(block.
vtx.end(), txs.begin(), txs.end());
396 std::shared_ptr<const CBlock> block_out;
399 if (!
GenerateBlock(chainman, std::move(block), max_tries, block_out, process_new_block) || !block_out) {
404 obj.
pushKV(
"hash", block_out->GetHash().GetHex());
405 if (!process_new_block) {
419 "Returns a json object containing mining-related information.",
425 {
RPCResult::Type::NUM,
"currentblockweight",
true,
"The block weight (including reserved weight for block header, txs count and coinbase tx) of the last assembled block (only present if a block was ever assembled)"},
426 {
RPCResult::Type::NUM,
"currentblocktx",
true,
"The number of block transactions (excluding coinbase) of the last assembled block (only present if a block was ever assembled)"},
433 {
RPCResult::Type::STR_HEX,
"signet_challenge",
true,
"The block challenge (aka. block script), in hexadecimal (only present if the current network is a signet)"},
443 RPCResult{
RPCResult::Type::ARR,
"warnings",
"any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
465 if (BlockAssembler::m_last_block_weight) obj.
pushKV(
"currentblockweight", *BlockAssembler::m_last_block_weight);
466 if (BlockAssembler::m_last_block_num_txs) obj.
pushKV(
"currentblocktx", *BlockAssembler::m_last_block_num_txs);
471 obj.
pushKV(
"pooledtx", (uint64_t)mempool.
size());
485 const std::vector<uint8_t>& signet_challenge =
487 obj.
pushKV(
"signet_challenge",
HexStr(signet_challenge));
500 "Accepts the transaction into mined blocks at a higher (or lower) priority\n",
504 " DEPRECATED. For forward compatibility use named arguments and omit this parameter."},
506 " Note, that this value is not a fee rate. It is a value to modify absolute fee of the TX.\n"
507 " The fee is not actually paid, only the algorithm for selecting transactions into a block\n"
508 " considers the transaction as it would have paid a higher (or lower) fee."},
521 const auto dummy{self.
MaybeArg<
double>(
"dummy")};
522 CAmount nAmount = request.params[2].getInt<int64_t>();
524 if (dummy && *dummy != 0) {
531 const auto& tx = mempool.
get(hash);
544 return RPCHelpMan{
"getprioritisedtransactions",
545 "Returns a map of all user-created (see prioritisetransaction) fee deltas by txid, and whether the tx is present in mempool.",
553 {
RPCResult::Type::NUM,
"modified_fee",
true,
"modified fee in satoshis. Only returned if in_mempool=true"},
568 result_inner.pushKV(
"fee_delta", delta_info.delta);
569 result_inner.pushKV(
"in_mempool", delta_info.in_mempool);
570 if (delta_info.in_mempool) {
571 result_inner.pushKV(
"modified_fee", *delta_info.modified_fee);
573 rpc_result.pushKV(delta_info.txid.GetHex(), std::move(result_inner));
592 if (strRejectReason.empty())
594 return strRejectReason;
604 if (!gbt_optional_rule) {
605 s.insert(
s.begin(),
'!');
614 "If the request parameters include a 'mode' key, that is used to explicitly select between the default 'template' request or a 'proposal'.\n"
615 "It returns data needed to construct a block to work on.\n"
616 "For full specification, see BIPs 22, 23, 9, and 145:\n"
617 " https://github.com/bitcoin/bips/blob/master/bip-0022.mediawiki\n"
618 " https://github.com/bitcoin/bips/blob/master/bip-0023.mediawiki\n"
619 " https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki#getblocktemplate_changes\n"
620 " https://github.com/bitcoin/bips/blob/master/bip-0145.mediawiki\n",
647 {
RPCResult::Type::STR,
"",
"name of a rule the client must understand to some extent; see BIP 9 for format"},
651 {
RPCResult::Type::NUM,
"rulename",
"identifies the bit number as indicating acceptance and readiness for the named softfork rule"},
657 {
RPCResult::Type::NUM,
"vbrequired",
"bit mask of versionbits the server requires set in submissions"},
659 {
RPCResult::Type::ARR,
"transactions",
"contents of non-coinbase transactions that should be included in the next block",
668 {
RPCResult::Type::NUM,
"",
"transactions before this one (by 1-based index in 'transactions' list) that must be present in the final block if this one is"},
670 {
RPCResult::Type::NUM,
"fee",
"difference in value between transaction inputs and outputs (in satoshis); for coinbase transactions, this is a negative Number of the total collected block fees (ie, not including the block subsidy); if key is not present, fee is unknown and clients MUST NOT assume there isn't one"},
671 {
RPCResult::Type::NUM,
"sigops",
"total SigOps cost, as counted for purposes of block limits; if key is not present, sigop cost is unknown and clients MUST NOT assume it is zero"},
672 {
RPCResult::Type::NUM,
"weight",
"total transaction weight, as counted for purposes of block limits"},
679 {
RPCResult::Type::NUM,
"coinbasevalue",
"maximum allowable input to coinbase transaction, including the generation award and transaction fees (in satoshis)"},
680 {
RPCResult::Type::STR,
"longpollid",
"an id to include with a request to longpoll on an update to this template"},
685 {
RPCResult::Type::STR,
"value",
"A way the block template may be changed, e.g. 'time', 'transactions', 'prevblock'"},
695 {
RPCResult::Type::STR_HEX,
"default_witness_commitment",
true,
"a valid witness commitment for the unmodified block template"},
710 std::string strMode =
"template";
712 std::set<std::string> setClientRules;
713 if (!request.params[0].isNull())
719 else if (modeval.
isNull())
727 if (strMode ==
"proposal")
730 if (!dataval.
isStr())
743 return "duplicate-invalid";
744 return "duplicate-inconclusive";
752 for (
unsigned int i = 0; i < aClientRules.
size(); ++i) {
753 const UniValue& v = aClientRules[i];
754 setClientRules.insert(v.
get_str());
759 if (strMode !=
"template")
773 static unsigned int nTransactionsUpdatedLast;
793 unsigned int nTransactionsUpdatedLastLP;
798 const std::string& lpstr = lpval.
get_str();
802 hashWatchedChain =
ParseHashV(lpstr.substr(0, 64),
"longpollid");
803 nTransactionsUpdatedLastLP = LocaleIndependentAtoi<int64_t>(lpstr.substr(64));
808 hashWatchedChain = tip;
809 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
819 std::optional<BlockRef> maybe_tip{miner.
waitTipChanged(hashWatchedChain, checktxtime)};
821 if (!maybe_tip)
break;
822 tip = maybe_tip->hash;
823 if (tip != hashWatchedChain)
break;
830 checktxtime = std::chrono::seconds(10);
845 if (consensusParams.
signet_blocks && setClientRules.count(
"signet") != 1) {
850 if (setClientRules.count(
"segwit") != 1) {
856 static int64_t time_start;
857 static std::unique_ptr<BlockTemplate> block_template;
862 pindexPrev =
nullptr;
875 pindexPrev = pindexPrevNew;
878 CBlock block{block_template->getBlock()};
881 UpdateTime(&block, consensusParams, pindexPrev);
890 std::map<uint256, int64_t> setTxIndex;
891 std::vector<CAmount> tx_fees{block_template->getTxFees()};
892 std::vector<CAmount> tx_sigops{block_template->getTxSigops()};
895 for (
const auto& it : block.vtx) {
898 setTxIndex[txHash] = i++;
915 entry.
pushKV(
"depends", std::move(deps));
917 int index_in_template = i - 2;
918 entry.
pushKV(
"fee", tx_fees.at(index_in_template));
919 int64_t nTxSigOps{tx_sigops.at(index_in_template)};
924 entry.
pushKV(
"sigops", nTxSigOps);
927 transactions.
push_back(std::move(entry));
940 result.
pushKV(
"capabilities", std::move(aCaps));
944 if (!fPreSegWit) aRules.
push_back(
"!segwit");
954 for (
const auto& [
name, info] : gbtstatus.signalling) {
956 if (!info.gbt_optional_rule && !setClientRules.count(
name)) {
958 block.nVersion &= ~info.mask;
962 for (
const auto& [
name, info] : gbtstatus.locked_in) {
963 block.nVersion |= info.mask;
965 if (!info.gbt_optional_rule && !setClientRules.count(
name)) {
967 block.nVersion &= ~info.mask;
971 for (
const auto& [
name, info] : gbtstatus.active) {
973 if (!info.gbt_optional_rule && !setClientRules.count(
name)) {
979 result.
pushKV(
"version", block.nVersion);
980 result.
pushKV(
"rules", std::move(aRules));
981 result.
pushKV(
"vbavailable", std::move(vbavailable));
982 result.
pushKV(
"vbrequired",
int(0));
984 result.
pushKV(
"previousblockhash", block.hashPrevBlock.GetHex());
985 result.
pushKV(
"transactions", std::move(transactions));
986 result.
pushKV(
"coinbaseaux", std::move(aux));
987 result.
pushKV(
"coinbasevalue", (int64_t)block.vtx[0]->vout[0].nValue);
988 result.
pushKV(
"longpollid", tip.GetHex() +
ToString(nTransactionsUpdatedLast));
991 result.
pushKV(
"mutable", std::move(aMutable));
992 result.
pushKV(
"noncerange",
"00000000ffffffff");
1001 result.
pushKV(
"sigoplimit", nSigOpLimit);
1002 result.
pushKV(
"sizelimit", nSizeLimit);
1006 result.
pushKV(
"curtime", block.GetBlockTime());
1014 if (!block_template->getCoinbaseCommitment().empty()) {
1015 result.
pushKV(
"default_witness_commitment",
HexStr(block_template->getCoinbaseCommitment()));
1046 "Attempts to submit new block to network.\n"
1047 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1062 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1063 CBlock& block = *blockptr;
1064 if (!
DecodeHexBlk(block, request.params[0].get_str())) {
1078 auto sc = std::make_shared<submitblock_StateCatcher>(block.
GetHash());
1080 bool accepted = chainman.
ProcessNewBlock(blockptr,
true,
true, &new_block);
1082 if (!new_block && accepted) {
1086 return "inconclusive";
1097 "Decode the given hexdata as a header and submit it as a candidate chain tip if valid."
1098 "\nThrows when the header is invalid.\n",
1149 for (
const auto& c : commands) {
1150 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, PayToAnchor, 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 LIST_CHAIN_NAMES
List of possible chain / network names
#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
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
ChainType GetChainType() const
Return the chain type.
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 Wtxid & GetWitnessHash() const LIFETIMEBOUND
const Txid & GetHash() 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
unsigned int GetTransactionsUpdated() 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...
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
bool ProcessNewBlock(const std::shared_ptr< const CBlock > &block, bool force_processing, bool min_pow_checked, bool *new_block) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
const util::SignalInterrupt & m_interrupt
VersionBitsCache m_versionbitscache
Track versionbit status.
const CChainParams & GetParams() const
bool ProcessNewBlockHeaders(std::span< const CBlockHeader > headers, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
const Consensus::Params & GetConsensus() const
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
void MaybeRebalanceCaches() EXCLUSIVE_LOCKS_REQUIRED(void UpdateUncommittedBlockStructures(CBlock &block, const CBlockIndex *pindexPrev) const
Check to see if caches are out of balance and if so, call ResizeCoinsCaches() as needed.
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Double ended buffer combining vector and stream-like interfaces.
std::string ToString() const
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
auto MaybeArg(std::string_view key) const
Helper to get an optional request argument.
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
BIP9GBTStatus GBTStatus(const CBlockIndex &block_index, const Consensus::Params ¶ms) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
256-bit unsigned big integer.
arith_uint256 & SetCompact(uint32_t nCompact, bool *pfNegative=nullptr, bool *pfOverflow=nullptr)
The "compact" format is a representation of a whole number N using an unsigned 32bit number similar t...
std::string GetHex() const
std::string GetHex() const
Hex encoding of the number (with the most significant digits first).
Block template interface.
Interface giving clients (RPC, Stratum v2 Template Provider in the future) ability to create block te...
virtual std::optional< BlockRef > waitTipChanged(uint256 current_tip, MillisecondsDouble timeout=MillisecondsDouble::max())=0
Waits for the connected tip to change.
virtual bool isInitialBlockDownload()=0
Returns whether IBD is still in progress.
virtual std::unique_ptr< BlockTemplate > createNewBlock(const node::BlockCreateOptions &options={})=0
Construct a new block template.
virtual std::optional< BlockRef > getTip()=0
Returns the hash and height for the tip of this chain.
virtual bool isTestChain()=0
If this chain is exclusively used for testing.
Generate a new block, without valid proof-of-work.
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.
bool DeploymentActiveAfter(const CBlockIndex *pindexPrev, const Consensus::Params ¶ms, Consensus::BuriedDeployment dep, VersionBitsCache &versionbitscache)
Determine if a deployment is active for the next block.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
CTxDestination DecodeDestination(const std::string &str, std::string &error_msg, std::vector< int > *error_locations)
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
void RegenerateCommitments(CBlock &block, ChainstateManager &chainman)
Update an old GenerateCoinbaseCommitment from CreateNewBlock after the block txs have changed.
int64_t GetMinimumTime(const CBlockIndex *pindexPrev, const int64_t difficulty_adjustment_interval)
Get the minimum time a miner should use in the next block.
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.
std::vector< uint32_t > GetDust(const CTransaction &tx, CFeeRate dust_relay_rate)
Get the vout index numbers of all dust outputs.
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 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 UniValue generateBlocks(ChainstateManager &chainman, Mining &miner, const CScript &coinbase_output_script, int nGenerate, uint64_t nMaxTries)
static RPCHelpMan getnetworkhashps()
static std::string gbt_rule_value(const std::string &name, bool gbt_optional_rule)
static RPCHelpMan getprioritisedtransactions()
static UniValue BIP22ValidationResult(const BlockValidationState &state)
static RPCHelpMan submitblock()
static RPCHelpMan getblocktemplate()
static RPCHelpMan generate()
static RPCHelpMan submitheader()
static RPCHelpMan prioritisetransaction()
static bool GenerateBlock(ChainstateManager &chainman, CBlock &&block, uint64_t &max_tries, std::shared_ptr< const CBlock > &block_out, bool process_new_block)
static RPCHelpMan getmininginfo()
static RPCHelpMan generatetoaddress()
void RegisterMiningRPCCommands(CRPCTable &t)
static const uint64_t DEFAULT_MAX_TRIES
Default max iterations to try in RPC generatetodescriptor, generatetoaddress, and generateblock.
@ 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)
uint256 GetTarget(const CBlockIndex &blockindex, const uint256 pow_limit)
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)
void NextEmptyBlockIndex(CBlockIndex &tip, const Consensus::Params &consensusParams, CBlockIndex &next_index)
Return an empty block index on top of the tip, with height, time and nBits set.
NodeContext & EnsureAnyNodeContext(const std::any &context)
CTxMemPool & EnsureMemPool(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
CTxMemPool & EnsureAnyMemPool(const std::any &context)
interfaces::Mining & EnsureMining(const NodeContext &node)
CConnman & EnsureConnman(const NodeContext &node)
A mutable version of CTransaction.
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...
uint256 powLimit
Proof of work parameters.
@ 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.
Hash/height pair to help track and identify blocks.
ValidationSignals * signals
CFeeRate dust_relay_feerate
NodeContext struct containing references to chain state and connection state.
#define ENTER_CRITICAL_SECTION(cs)
#define LEAVE_CRITICAL_SECTION(cs)
const UniValue NullUniValue
int64_t GetTime()
DEPRECATED Use either ClockType::now() or Now<TimePointType>() if a cast is needed.
std::chrono::duration< double, std::chrono::milliseconds::period > MillisecondsDouble
BlockValidationState TestBlockValidity(Chainstate &chainstate, const CBlock &block, const bool check_pow, const bool check_merkle_root)
Verify a block, including transactions.