10 #include <chainparams.h>
21 #include <minerfund.h>
59 const CChain &active_chain) {
62 if (height >= 0 && height < active_chain.
Height()) {
63 pb = active_chain[height];
66 if (pb ==
nullptr || !pb->
nHeight) {
84 int64_t maxTime = minTime;
85 for (
int i = 0; i < lookup; i++) {
88 minTime = std::min(time, minTime);
89 maxTime = std::max(time, maxTime);
94 if (minTime == maxTime) {
99 int64_t timeDiff = maxTime - minTime;
107 "Returns the estimated network hashes per second based on the last n "
109 "Pass in [blocks] to override # of blocks, -1 specifies since last "
110 "difficulty change.\n"
111 "Pass in [height] to estimate the network speed at the time when a "
112 "certain block was found.\n",
115 "The number of blocks, or -1 for blocks since last difficulty "
118 "To estimate at the time of the given height."},
128 !request.params[0].isNull() ? request.params[0].getInt<
int>()
130 !request.params[1].isNull() ? request.params[1].getInt<
int>()
139 uint64_t &max_tries,
BlockHash &block_hash) {
145 while (max_tries > 0 &&
146 block.
nNonce < std::numeric_limits<uint32_t>::max() &&
155 if (block.
nNonce == std::numeric_limits<uint32_t>::max()) {
159 std::shared_ptr<const CBlock> shared_pblock =
160 std::make_shared<const CBlock>(block);
166 "ProcessNewBlock, block not accepted");
176 const CScript &coinbase_script,
int nGenerate,
177 uint64_t nMaxTries) {
180 std::unique_ptr<CBlockTemplate> pblocktemplate(
183 .CreateNewBlock(coinbase_script));
185 if (!pblocktemplate.get()) {
189 CBlock *pblock = &pblocktemplate->block;
197 if (!block_hash.
IsNull()) {
213 Parse(descriptor, key_provider,
error,
false);
215 if (desc->IsRange()) {
217 "Ranged descriptor not accepted. Maybe pass "
218 "through deriveaddresses first?");
222 std::vector<CScript> scripts;
223 if (!desc->Expand(0, key_provider, scripts, provider)) {
226 strprintf(
"Cannot derive script without private keys"));
233 if (scripts.size() == 1) {
234 script = scripts.at(0);
237 script = scripts.at(1);
248 "generatetodescriptor",
249 "Mine blocks immediately to a specified descriptor (before the RPC "
253 "How many blocks are generated immediately."},
255 "The descriptor to send the newly generated bitcoin to."},
257 "How many iterations to try."},
261 "hashes of blocks generated",
269 const int num_blocks{request.params[0].
getInt<
int>()};
270 const uint64_t max_tries{request.params[2].isNull()
272 : request.params[2].getInt<
int>()};
277 coinbase_script,
error)) {
286 coinbase_script, num_blocks, max_tries);
293 "has been replaced by the -generate cli option. Refer to "
294 "-help for more information.",
308 "Mine blocks immediately to a specified address before the "
309 "RPC call returns)\n",
312 "How many blocks are generated immediately."},
314 "The address to send the newly generated bitcoin to."},
316 "How many iterations to try."},
320 "hashes of blocks generated",
325 "\nGenerate 11 blocks to myaddress\n" +
327 "If you are using the " PACKAGE_NAME
" wallet, you can "
328 "get a new address to send the newly generated bitcoin to with:\n" +
332 const int num_blocks{request.params[0].
getInt<
int>()};
333 const uint64_t max_tries{request.params[2].isNull()
335 : request.params[2].getInt<int64_t>()};
338 request.params[1].get_str(), config.GetChainParams());
341 "Error: Invalid address");
351 coinbase_script, num_blocks, max_tries);
359 "Mine a block with a set of ordered transactions immediately to a "
360 "specified address or descriptor (before the RPC call returns)\n",
363 "The address or descriptor to send the newly generated bitcoin "
369 "An array of hex strings which are either txids or raw "
371 "Txids must reference transactions currently in the mempool.\n"
372 "All transactions must be valid and in valid order, otherwise "
373 "the block will be rejected.",
388 "\nGenerate a block to myaddress, with txs rawtx and "
391 R
"("myaddress" '["rawtx", "mempool_txid"]')")},
394 const auto address_or_descriptor = request.params[0].
get_str();
398 const CChainParams &chainparams = config.GetChainParams();
402 const auto destination =
406 "Error: Invalid address or descriptor");
415 std::vector<CTransactionRef> txs;
416 const auto raw_txs_or_txids = request.params[1].get_array();
417 for (
size_t i = 0; i < raw_txs_or_txids.size(); i++) {
418 const auto str(raw_txs_or_txids[i].get_str());
423 const auto tx = mempool.
get(
TxId(hash));
427 strprintf(
"Transaction %s not in mempool.", str));
430 txs.emplace_back(tx);
437 strprintf(
"Transaction decode failed for %s", str));
447 std::unique_ptr<CBlockTemplate> blocktemplate(
449 node.avalanche.get()}
450 .CreateNewBlock(coinbase_script));
451 if (!blocktemplate) {
453 "Couldn't create new block");
455 block = blocktemplate->block;
461 block.
vtx.insert(block.
vtx.end(), txs.begin(), txs.end());
468 chainman.ActiveChainstate(), block,
474 .withCheckMerkleRoot(
false))) {
476 strprintf(
"TestBlockValidity failed: %s",
503 "Returns a json object containing mining-related "
513 "The block size of the last assembled block (only present if "
514 "a block was ever assembled)"},
516 "The number of block transactions of the last assembled block "
517 "(only present if a block was ever assembled)"},
520 "The network hashes per second"},
523 "current network name (main, test, regtest)"},
525 "any network and blockchain warnings"},
539 if (BlockAssembler::m_last_block_size) {
540 obj.
pushKV(
"currentblocksize",
541 *BlockAssembler::m_last_block_size);
543 if (BlockAssembler::m_last_block_num_txs) {
544 obj.
pushKV(
"currentblocktx",
545 *BlockAssembler::m_last_block_num_txs);
548 obj.
pushKV(
"networkhashps",
550 obj.
pushKV(
"pooledtx", uint64_t(mempool.
size()));
551 obj.
pushKV(
"chain", config.GetChainParams().NetworkIDString());
562 "prioritisetransaction",
563 "Accepts the transaction into mined blocks at a higher "
564 "(or lower) priority\n",
567 "The transaction id."},
569 "API-Compatibility for previous API. Must be zero or null.\n"
570 " DEPRECATED. For forward compatibility "
571 "use named arguments and omit this parameter."},
573 "The fee value (in satoshis) to add (or subtract, if negative).\n"
574 " The fee is not actually paid, only the "
575 "algorithm for selecting transactions into a block\n"
576 " considers the transaction as it would "
577 "have paid a higher (or lower) fee."},
588 Amount nAmount = request.params[2].getInt<int64_t>() *
SATOSHI;
590 if (!(request.params[1].isNull() ||
591 request.params[1].get_real() == 0)) {
594 "Priority is no longer supported, dummy argument to "
595 "prioritisetransaction must be 0.");
619 if (strRejectReason.empty()) {
622 return strRejectReason;
632 "If the request parameters include a 'mode' key, that is used to "
633 "explicitly select between the default 'template' request or a "
635 "It returns data needed to construct a block to work on.\n"
636 "For full specification, see BIPs 22, 23, 9, and 145:\n"
638 "https://github.com/bitcoin/bips/blob/master/"
639 "bip-0022.mediawiki\n"
641 "https://github.com/bitcoin/bips/blob/master/"
642 "bip-0023.mediawiki\n"
644 "https://github.com/bitcoin/bips/blob/master/"
645 "bip-0009.mediawiki#getblocktemplate_changes\n"
651 "Format of the template",
655 "This must be set to \"template\", \"proposal\" (see BIP "
666 "client side supported feature, 'longpoll', "
667 "'coinbasetxn', 'coinbasevalue', 'proposal', "
668 "'serverlist', 'workid'"},
675 RPCResult{
"If the proposal was accepted with mode=='proposal'",
677 RPCResult{
"If the proposal was not accepted with mode=='proposal'",
686 "The preferred block version"},
688 "The hash of current highest block"},
691 "contents of non-coinbase transactions that should be "
692 "included in the next block",
699 "transaction data encoded in hexadecimal "
702 "transaction id encoded in little-endian "
705 "hash encoded in little-endian hexadecimal"},
711 "transactions before this one (by 1-based "
712 "index in 'transactions' list) that must "
713 "be present in the final block if this one "
717 "difference in value between transaction inputs "
718 "and outputs (in satoshis); for coinbase "
719 "transactions, this is a negative Number of the "
720 "total collected block fees (ie, not including "
721 "the block subsidy); "
722 "if key is not present, fee is unknown and "
723 "clients MUST NOT assume there isn't one"},
725 "total sigChecks, as counted for purposes of "
726 "block limits; if key is not present, sigChecks "
727 "are unknown and clients MUST NOT assume it is "
733 "data that should be included in the coinbase's scriptSig "
739 "maximum allowable input to coinbase transaction, "
740 "including the generation award and transaction fees (in "
744 "information for coinbase transaction",
748 "information related to the coinbase miner fund",
753 "List of valid addresses for the miner fund "
760 "The minimum value the miner fund output must "
766 "information related to the coinbase staking reward "
767 "output, only set after the Nov. 15, 2023 upgrade "
768 "activated and the -avalanchestakingrewards option "
774 "The proof payout script",
777 "Decoded payout script"},
779 "Raw payout script in hex format"},
781 "The output type (e.g. " +
784 "The required signatures"},
794 "The minimum value the staking reward output "
801 "The minimum timestamp appropriate for the next block "
802 "time, expressed in " +
806 "list of ways the block template may be changed",
809 "A way the block template may be changed, e.g. "
810 "'time', 'transactions', 'prevblock'"},
813 "A range of valid nonces"},
815 "limit of sigChecks in blocks"},
820 "compressed target of next block"},
822 "The height of the next block"},
833 const CChainParams &chainparams = config.GetChainParams();
835 std::string strMode =
"template";
837 std::set<std::string> setClientRules;
838 Chainstate &active_chainstate = chainman.ActiveChainstate();
840 if (!request.params[0].isNull()) {
843 if (modeval.
isStr()) {
845 }
else if (modeval.
isNull()) {
852 if (strMode ==
"proposal") {
854 if (!dataval.
isStr()) {
857 "Missing data String key for proposal");
863 "Block decode failed");
873 if (pindex->nStatus.isInvalid()) {
874 return "duplicate-invalid";
876 return "duplicate-inconclusive";
883 return "inconclusive-not-best-prevblk";
890 .withCheckMerkleRoot(
true));
895 if (strMode !=
"template") {
902 "Bitcoin is not connected!");
908 " is in initial sync and waiting for blocks...");
911 static unsigned int nTransactionsUpdatedLast;
921 std::chrono::steady_clock::time_point checktxtime;
922 unsigned int nTransactionsUpdatedLastLP;
926 std::string lpstr = lpval.
get_str();
929 ParseHashV(lpstr.substr(0, 64),
"longpollid");
930 nTransactionsUpdatedLastLP =
atoi64(lpstr.substr(64));
935 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
941 checktxtime = std::chrono::steady_clock::now() +
942 std::chrono::minutes(1);
949 std::cv_status::timeout) {
954 nTransactionsUpdatedLastLP) {
957 checktxtime += std::chrono::seconds(10);
986 static int64_t nStart;
987 static std::unique_ptr<CBlockTemplate> pblocktemplate;
988 if (pindexPrev != active_chain.
Tip() ||
993 pindexPrev =
nullptr;
1004 &mempool,
node.avalanche.get()}
1005 .CreateNewBlock(scriptDummy);
1006 if (!pblocktemplate) {
1011 pindexPrev = pindexPrevNew;
1016 CBlock *pblock = &pblocktemplate->block;
1029 int index_in_template = 0;
1030 for (
const auto &it : pblock->
vtx) {
1035 index_in_template++;
1037 for (
const auto &o : pblock->
vtx[0]->vout) {
1038 coinbasevalue += o.nValue;
1051 pblocktemplate->entries[index_in_template].fees /
SATOSHI);
1053 pblocktemplate->entries[index_in_template].sigChecks;
1057 index_in_template++;
1063 for (
const auto &fundDestination :
1069 int64_t minerFundMinValue = 0;
1078 minerFund.
pushKV(
"addresses", minerFundList);
1079 minerFund.
pushKV(
"minimumvalue", minerFundMinValue);
1082 coinbasetxn.
pushKV(
"minerfund", minerFund);
1084 std::vector<CScript> stakingRewardsPayoutScripts;
1085 if (
node.avalanche &&
1087 node.avalanche->getStakingRewardWinners(
1088 pindexPrev->
GetBlockHash(), stakingRewardsPayoutScripts)) {
1092 stakingRewardsPayoutScriptObj,
1094 stakingRewards.
pushKV(
"payoutscript",
1095 stakingRewardsPayoutScriptObj);
1100 coinbasetxn.
pushKV(
"stakingrewards", stakingRewards);
1112 result.
pushKV(
"capabilities", aCaps);
1117 result.
pushKV(
"transactions", transactions);
1118 result.
pushKV(
"coinbaseaux", aux);
1119 result.
pushKV(
"coinbasetxn", coinbasetxn);
1120 result.
pushKV(
"coinbasevalue", int64_t(coinbasevalue /
SATOSHI));
1121 result.
pushKV(
"longpollid",
1123 ToString(nTransactionsUpdatedLast));
1127 result.
pushKV(
"mutable", aMutable);
1128 result.
pushKV(
"noncerange",
"00000000ffffffff");
1129 const uint64_t sigCheckLimit =
1131 result.
pushKV(
"sigchecklimit", sigCheckLimit);
1167 "Attempts to submit new block to network.\n"
1168 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1171 "the hex-encoded block data to submit"},
1173 "dummy value, for compatibility with BIP22. This value is "
1180 "According to BIP22"},
1186 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1187 CBlock &block = *blockptr;
1188 if (!
DecodeHexBlk(block, request.params[0].get_str())) {
1190 "Block decode failed");
1193 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
1195 "Block does not start with a coinbase");
1209 if (pindex->nStatus.isInvalid()) {
1210 return "duplicate-invalid";
1217 std::make_shared<submitblock_StateCatcher>(block.
GetHash());
1223 node.avalanche.get());
1225 if (!new_block && accepted) {
1230 return "inconclusive";
1244 "Decode the given hexdata as a header and submit it as a candidate "
1245 "chain tip if valid."
1246 "\nThrows when the header is invalid.\n",
1249 "the hex-encoded block header data"},
1259 "Block header decode failed");
1266 "Must submit previous header (" +
1289 "Estimates the approximate fee per kilobyte needed for a "
1323 for (
const auto &c : commands) {
static bool IsAxionEnabled(const Consensus::Params ¶ms, int32_t nHeight)
static constexpr Amount SATOSHI
double GetDifficulty(const CBlockIndex *blockindex)
Calculate the difficulty for a given block index.
@ 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,...
bool IsValid(enum BlockValidity nUpTo=BlockValidity::TRANSACTIONS) const EXCLUSIVE_LOCKS_REQUIRED(
Check whether this block index entry is valid up to the passed validity level.
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 ...
int64_t GetBlockTime() const
int64_t GetMedianTimePast() const
BlockHash GetBlockHash() const
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.
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
const Consensus::Params & GetConsensus() const
size_t GetNodeCount(NumConnections num) const
Amount GetFeePerK() const
Return the fee in satoshis for a size of 1000 bytes.
A mutable version of CTransaction.
void appendCommand(const std::string &name, const CRPCCommand *pcmd)
Appends a CRPCCommand to the dispatch table.
Serialized script, used inside transaction inputs and outputs.
The basic transaction that is broadcasted on the network and contained in blocks.
const TxHash GetHash() const
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
CFeeRate estimateFee() const
CTransactionRef get(const TxId &txid) const
void PrioritiseTransaction(const TxId &txid, const Amount nFeeDelta)
Affect CreateNewBlock prioritisation of transactions.
unsigned long size() const
unsigned int GetTransactionsUpdated() const
Implement this to subscribe to events generated in validation.
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CChain m_chain
The current chain of blockheaders we consult and build on.
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
const Config & GetConfig() const
bool ProcessNewBlock(const std::shared_ptr< const CBlock > &block, bool force_processing, bool min_pow_checked, bool *new_block, avalanche::Processor *const avalanche=nullptr) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
bool ProcessNewBlockHeaders(const std::vector< CBlockHeader > &block, bool min_pow_checked, BlockValidationState &state, const CBlockIndex **ppindex=nullptr, const std::optional< CCheckpointData > &test_checkpoints=std::nullopt) 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...
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 pushKVEnd(std::string key, UniValue val)
void pushKV(std::string key, UniValue val)
std::string GetRejectReason() const
std::string ToString() const
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
Generate a new block, without valid proof-of-work.
CBlockIndex * LookupBlockIndex(const BlockHash &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
static UniValue Parse(std::string_view raw)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
static const uint64_t DEFAULT_MAX_BLOCK_SIZE
Default setting for maximum allowed size for a block, in bytes.
uint64_t GetMaxBlockSigChecksCount(uint64_t maxBlockSize)
Compute the maximum number of sigchecks that can be contained in a block given the MAXIMUM block size...
void ScriptPubKeyToUniv(const CScript &scriptPubKey, UniValue &out, bool fIncludeHex)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &strHexTx)
bool DecodeHexBlk(CBlock &, const std::string &strHexBlk)
bool ParseHashStr(const std::string &strHex, uint256 &result)
Parse a hex string into 256 bits.
bool DecodeHexBlockHeader(CBlockHeader &, const std::string &hex_header)
std::string EncodeHexTx(const CTransaction &tx, const int serializeFlags=0)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
std::string EncodeDestination(const CTxDestination &dest, const Config &config)
CTxDestination DecodeDestination(const std::string &addr, const CChainParams ¶ms)
bool error(const char *fmt, const Args &...args)
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Compute the Merkle root of the transactions in a block.
Amount GetMinerFundAmount(const Consensus::Params ¶ms, const Amount &coinbaseValue, const CBlockIndex *pprev)
std::unordered_set< CTxDestination, TxDestinationHasher > GetMinerFundWhitelist(const Consensus::Params ¶ms)
static RPCHelpMan estimatefee()
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 BIP22ValidationResult(const Config &config, const BlockValidationState &state)
static RPCHelpMan getnetworkhashps()
static RPCHelpMan submitblock()
static RPCHelpMan getblocktemplate()
static RPCHelpMan generate()
static RPCHelpMan submitheader()
static RPCHelpMan prioritisetransaction()
static bool GenerateBlock(ChainstateManager &chainman, avalanche::Processor *const avalanche, CBlock &block, uint64_t &max_tries, BlockHash &block_hash)
static UniValue generateBlocks(ChainstateManager &chainman, const CTxMemPool &mempool, avalanche::Processor *const avalanche, const CScript &coinbase_script, int nGenerate, uint64_t nMaxTries)
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.
int64_t UpdateTime(CBlockHeader *pblock, const CChainParams &chainParams, const CBlockIndex *pindexPrev)
bool CheckProofOfWork(const BlockHash &hash, uint32_t nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static CTransactionRef MakeTransactionRef()
UniValue JSONRPCError(int code, const std::string &message)
@ RPC_OUT_OF_MEMORY
Ran out of memory during operation.
@ RPC_MISC_ERROR
General application defined errors std::exception thrown in command handling.
@ RPC_TYPE_ERROR
Unexpected type was passed as parameter.
@ RPC_CLIENT_NOT_CONNECTED
P2P client errors Bitcoin is not connected.
@ 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.
std::string GetAllOutputTypes()
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded values (throws error if not hex).
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)
CConnman & EnsureConnman(const NodeContext &node)
CTxMemPool & EnsureMemPool(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
bool ShutdownRequested()
Returns true if a shutdown is requested, false otherwise.
bool IsStakingRewardsActivated(const Consensus::Params ¶ms, const CBlockIndex *pprev)
Amount GetStakingRewardsAmount(const Amount &coinbaseValue)
bool IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
std::variant< CNoDestination, PKHash, ScriptHash > CTxDestination
A txout script template with a specific destination.
int64_t atoi64(const std::string &str)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
static constexpr Amount zero() noexcept
A BlockHash is a unqiue identifier for a block.
Parameters that influence chain consensus.
int64_t DifficultyAdjustmentInterval() const
@ STR_HEX
Special type that is a STR with only hex chars.
@ OMITTED
The arg is optional for one of two reasons:
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
@ ELISION
Special type to denote elision (...)
@ NUM_TIME
Special numeric to denote unix epoch time.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
A TxId is the identifier of a transaction.
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)
NodeClock::time_point GetAdjustedTime()
const UniValue NullUniValue
GlobalMutex g_best_block_mutex
std::condition_variable g_best_block_cv
const CBlockIndex * g_best_block
Used to notify getblocktemplate RPC of new tips.
bool ContextualCheckTransactionForCurrentBlock(const CBlockIndex &active_chain_tip, const Consensus::Params ¶ms, const CTransaction &tx, TxValidationState &state) EXCLUSIVE_LOCKS_REQUIRED(bool TestBlockValidity(BlockValidationState &state, const CChainParams ¶ms, Chainstate &chainstate, const CBlock &block, CBlockIndex *pindexPrev, const std::function< NodeClock::time_point()> &adjusted_time_callback, BlockValidationOptions validationOptions) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
This is a variant of ContextualCheckTransaction which computes the contextual check for a transaction...
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
void SyncWithValidationInterfaceQueue()
This is a synonym for the following, which asserts certain locks are not held: std::promise<void> pro...
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
bilingual_str GetWarnings(bool verbose)
Format a string that describes several potential problems detected by the core.