56 const CChain &active_chain) {
59 if (height >= 0 && height < active_chain.
Height()) {
60 pb = active_chain[height];
63 if (pb ==
nullptr || !pb->
nHeight) {
81 int64_t maxTime = minTime;
82 for (
int i = 0; i < lookup; i++) {
85 minTime = std::min(time, minTime);
86 maxTime = std::max(time, maxTime);
91 if (minTime == maxTime) {
96 int64_t timeDiff = maxTime - minTime;
104 "Returns the estimated network hashes per second based on the last n "
106 "Pass in [blocks] to override # of blocks, -1 specifies since last "
107 "difficulty change.\n"
108 "Pass in [height] to estimate the network speed at the time when a "
109 "certain block was found.\n",
112 "The number of blocks, or -1 for blocks since last difficulty "
115 "To estimate at the time of the given height."},
125 !request.params[0].isNull() ? request.params[0].get_int() : 120,
126 !request.params[1].isNull() ? request.params[1].get_int() : -1,
133 CBlock &block, uint64_t &max_tries,
134 unsigned int &extra_nonce,
BlockHash &block_hash) {
146 while (max_tries > 0 &&
147 block.
nNonce < std::numeric_limits<uint32_t>::max() &&
156 if (block.
nNonce == std::numeric_limits<uint32_t>::max()) {
160 std::shared_ptr<const CBlock> shared_pblock =
161 std::make_shared<const CBlock>(block);
164 "ProcessNewBlock, block not accepted");
174 const CScript &coinbase_script,
int nGenerate,
175 uint64_t nMaxTries) {
183 nHeightEnd =
nHeight + nGenerate;
186 unsigned int nExtraNonce = 0;
189 std::unique_ptr<CBlockTemplate> pblocktemplate(
193 if (!pblocktemplate.get()) {
197 CBlock *pblock = &pblocktemplate->block;
200 if (!
GenerateBlock(config, chainman, *pblock, nMaxTries, nExtraNonce,
205 if (!block_hash.
IsNull()) {
217 Parse(descriptor, key_provider,
error,
false);
219 if (desc->IsRange()) {
221 "Ranged descriptor not accepted. Maybe pass "
222 "through deriveaddresses first?");
226 std::vector<CScript> scripts;
227 if (!desc->Expand(0, key_provider, scripts, provider)) {
230 strprintf(
"Cannot derive script without private keys"));
237 if (scripts.size() == 1) {
238 script = scripts.at(0);
241 script = scripts.at(1);
252 "generatetodescriptor",
253 "Mine blocks immediately to a specified descriptor (before the RPC "
257 "How many blocks are generated immediately."},
259 "The descriptor to send the newly generated bitcoin to."},
262 "How many iterations to try."},
266 "hashes of blocks generated",
274 const int num_blocks{request.params[0].
get_int()};
275 const uint64_t max_tries{request.params[2].isNull()
277 : request.params[2].get_int()};
282 coinbase_script,
error)) {
291 num_blocks, max_tries);
298 "has been replaced by the -generate cli option. Refer to "
299 "-help for more information.",
313 "Mine blocks immediately to a specified address before the "
314 "RPC call returns)\n",
317 "How many blocks are generated immediately."},
319 "The address to send the newly generated bitcoin to."},
322 "How many iterations to try."},
326 "hashes of blocks generated",
331 "\nGenerate 11 blocks to myaddress\n" +
333 "If you are using the " PACKAGE_NAME
" wallet, you can "
334 "get a new address to send the newly generated bitcoin to with:\n" +
338 const int num_blocks{request.params[0].
get_int()};
339 const uint64_t max_tries{request.params[2].isNull()
341 : request.params[2].get_int64()};
344 request.params[1].get_str(), config.GetChainParams());
347 "Error: Invalid address");
357 num_blocks, max_tries);
365 "Mine a block with a set of ordered transactions immediately to a "
366 "specified address or descriptor (before the RPC call returns)\n",
369 "The address or descriptor to send the newly generated bitcoin "
375 "An array of hex strings which are either txids or raw "
377 "Txids must reference transactions currently in the mempool.\n"
378 "All transactions must be valid and in valid order, otherwise "
379 "the block will be rejected.",
394 "\nGenerate a block to myaddress, with txs rawtx and "
397 R
"("myaddress" '["rawtx", "mempool_txid"]')")},
400 const auto address_or_descriptor = request.params[0].
get_str();
404 const CChainParams &chainparams = config.GetChainParams();
408 const auto destination =
412 "Error: Invalid address or descriptor");
421 std::vector<CTransactionRef> txs;
422 const auto raw_txs_or_txids = request.params[1].get_array();
423 for (
size_t i = 0; i < raw_txs_or_txids.size(); i++) {
424 const auto str(raw_txs_or_txids[i].get_str());
429 const auto tx = mempool.
get(
TxId(hash));
433 strprintf(
"Transaction %s not in mempool.", str));
436 txs.emplace_back(tx);
443 strprintf(
"Transaction decode failed for %s", str));
454 std::unique_ptr<CBlockTemplate> blocktemplate(
458 if (!blocktemplate) {
460 "Couldn't create new block");
462 block = blocktemplate->block;
468 block.
vtx.insert(block.
vtx.end(), txs.begin(), txs.end());
480 .withCheckMerkleRoot(
false))) {
482 strprintf(
"TestBlockValidity failed: %s",
489 unsigned int extra_nonce{0};
491 if (!
GenerateBlock(config, chainman, block, max_tries, extra_nonce,
507 "Returns a json object containing mining-related "
517 "The block size of the last assembled block (only present if "
518 "a block was ever assembled)"},
520 "The number of block transactions of the last assembled block "
521 "(only present if a block was ever assembled)"},
524 "The network hashes per second"},
527 "current network name (main, test, regtest)"},
529 "any network and blockchain warnings"},
543 if (BlockAssembler::m_last_block_size) {
544 obj.
pushKV(
"currentblocksize",
545 *BlockAssembler::m_last_block_size);
547 if (BlockAssembler::m_last_block_num_txs) {
548 obj.
pushKV(
"currentblocktx",
549 *BlockAssembler::m_last_block_num_txs);
552 obj.
pushKV(
"networkhashps",
554 obj.
pushKV(
"pooledtx", uint64_t(mempool.
size()));
555 obj.
pushKV(
"chain", config.GetChainParams().NetworkIDString());
566 "prioritisetransaction",
567 "Accepts the transaction into mined blocks at a higher "
568 "(or lower) priority\n",
571 "The transaction id."},
573 "API-Compatibility for previous API. Must be zero or null.\n"
574 " DEPRECATED. For forward compatibility "
575 "use named arguments and omit this parameter."},
577 "The fee value (in satoshis) to add (or subtract, if negative).\n"
578 " The fee is not actually paid, only the "
579 "algorithm for selecting transactions into a block\n"
580 " considers the transaction as it would "
581 "have paid a higher (or lower) fee."},
594 if (!(request.params[1].isNull() ||
595 request.params[1].get_real() == 0)) {
598 "Priority is no longer supported, dummy argument to "
599 "prioritisetransaction must be 0.");
623 if (strRejectReason.empty()) {
626 return strRejectReason;
636 "If the request parameters include a 'mode' key, that is used to "
637 "explicitly select between the default 'template' request or a "
639 "It returns data needed to construct a block to work on.\n"
640 "For full specification, see BIPs 22, 23, 9, and 145:\n"
642 "https://github.com/bitcoin/bips/blob/master/"
643 "bip-0022.mediawiki\n"
645 "https://github.com/bitcoin/bips/blob/master/"
646 "bip-0023.mediawiki\n"
648 "https://github.com/bitcoin/bips/blob/master/"
649 "bip-0009.mediawiki#getblocktemplate_changes\n"
655 "Format of the template",
659 "This must be set to \"template\", \"proposal\" (see BIP "
670 "client side supported feature, 'longpoll', "
671 "'coinbasetxn', 'coinbasevalue', 'proposal', "
672 "'serverlist', 'workid'"},
676 "\"template_request\""},
679 RPCResult{
"If the proposal was accepted with mode=='proposal'",
681 RPCResult{
"If the proposal was not accepted with mode=='proposal'",
690 "The preferred block version"},
692 "The hash of current highest block"},
695 "contents of non-coinbase transactions that should be "
696 "included in the next block",
703 "transaction data encoded in hexadecimal "
706 "transaction id encoded in little-endian "
709 "hash encoded in little-endian hexadecimal"},
715 "transactions before this one (by 1-based "
716 "index in 'transactions' list) that must "
717 "be present in the final block if this one "
721 "difference in value between transaction inputs "
722 "and outputs (in satoshis); for coinbase "
723 "transactions, this is a negative Number of the "
724 "total collected block fees (ie, not including "
725 "the block subsidy); "
726 "if key is not present, fee is unknown and "
727 "clients MUST NOT assume there isn't one"},
729 "DEPRECATED: total sigChecks, as counted for "
730 "purposes of block limits; if key is not present"
731 ", sigChecks are unknown and clients MUST NOT "
732 "assume it is zero. This value is deprecated "
733 "since v0.26.8 and must be read from the "
734 "sigchecks field instead. It is only printed if "
735 "the -deprecatedrpc=getblocktemplate_sigops "
738 "total sigChecks, as counted for purposes of "
739 "block limits; if key is not present, sigChecks "
740 "are unknown and clients MUST NOT assume it is "
746 "data that should be included in the coinbase's scriptSig "
752 "maximum allowable input to coinbase transaction, "
753 "including the generation award and transaction fees (in "
757 "information for coinbase transaction",
761 "information related to the coinbase miner fund",
766 "List of valid addresses for the miner fund "
773 "The minimum value the miner fund output must "
781 "The minimum timestamp appropriate for the next block "
782 "time, expressed in " +
786 "list of ways the block template may be changed",
789 "A way the block template may be changed, e.g. "
790 "'time', 'transactions', 'prevblock'"},
793 "A range of valid nonces"},
795 "limit of sigChecks in blocks"},
797 "DEPRECATED: limit of sigChecks in blocks. This value is "
798 "deprecated since v0.26.8 and must be read from the "
799 "sigchecklimit field instead. It is only printed if the "
800 "-deprecatedrpc=getblocktemplate_sigops option is set"},
805 "compressed target of next block"},
807 "The height of the next block"},
818 const CChainParams &chainparams = config.GetChainParams();
820 std::string strMode =
"template";
822 std::set<std::string> setClientRules;
825 if (!request.params[0].isNull()) {
828 if (modeval.
isStr()) {
830 }
else if (modeval.
isNull()) {
837 if (strMode ==
"proposal") {
839 if (!dataval.
isStr()) {
842 "Missing data String key for proposal");
848 "Block decode failed");
858 if (pindex->nStatus.isInvalid()) {
859 return "duplicate-invalid";
861 return "duplicate-inconclusive";
868 return "inconclusive-not-best-prevblk";
875 .withCheckMerkleRoot(
true));
880 if (strMode !=
"template") {
887 "Bitcoin is not connected!");
893 " is in initial sync and waiting for blocks...");
896 static unsigned int nTransactionsUpdatedLast;
903 std::chrono::steady_clock::time_point checktxtime;
904 unsigned int nTransactionsUpdatedLastLP;
908 std::string lpstr = lpval.
get_str();
911 ParseHashV(lpstr.substr(0, 64),
"longpollid");
912 nTransactionsUpdatedLastLP =
atoi64(lpstr.substr(64));
917 nTransactionsUpdatedLastLP = nTransactionsUpdatedLast;
923 checktxtime = std::chrono::steady_clock::now() +
924 std::chrono::minutes(1);
929 std::cv_status::timeout) {
934 nTransactionsUpdatedLastLP) {
937 checktxtime += std::chrono::seconds(10);
953 static int64_t nStart;
954 static std::unique_ptr<CBlockTemplate> pblocktemplate;
955 if (pindexPrev != active_chain.
Tip() ||
960 pindexPrev =
nullptr;
973 if (!pblocktemplate) {
978 pindexPrev = pindexPrevNew;
983 CBlock *pblock = &pblocktemplate->block;
994 const bool printSigops{
999 int index_in_template = 0;
1000 for (
const auto &it : pblock->
vtx) {
1005 index_in_template++;
1007 for (
const auto &o : pblock->
vtx[0]->vout) {
1008 coinbasevalue += o.nValue;
1015 entry.
reserve(printSigops ? 6 : 5);
1020 pblocktemplate->entries[index_in_template].fees /
1023 pblocktemplate->entries[index_in_template].sigChecks;
1030 index_in_template++;
1038 for (
const auto &fundDestination :
1044 int64_t minerFundMinValue = 0;
1051 minerFund.
pushKV(
"addresses", minerFundList);
1052 minerFund.
pushKV(
"minimumvalue", minerFundMinValue);
1055 coinbasetxn.
pushKV(
"minerfund", minerFund);
1066 result.
pushKV(
"capabilities", aCaps);
1071 result.
pushKV(
"transactions", transactions);
1072 result.
pushKV(
"coinbaseaux", aux);
1073 result.
pushKV(
"coinbasetxn", coinbasetxn);
1074 result.
pushKV(
"coinbasevalue", int64_t(coinbasevalue /
SATOSHI));
1075 result.
pushKV(
"longpollid",
1077 ToString(nTransactionsUpdatedLast));
1081 result.
pushKV(
"mutable", aMutable);
1082 result.
pushKV(
"noncerange",
"00000000ffffffff");
1083 const uint64_t sigCheckLimit =
1085 result.
pushKV(
"sigchecklimit", sigCheckLimit);
1087 result.
pushKV(
"sigoplimit", sigCheckLimit);
1124 "Attempts to submit new block to network.\n"
1125 "See https://en.bitcoin.it/wiki/BIP_0022 for full specification.\n",
1128 "the hex-encoded block data to submit"},
1130 "dummy value, for compatibility with BIP22. This value is "
1137 "According to BIP22"},
1143 std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
1144 CBlock &block = *blockptr;
1145 if (!
DecodeHexBlk(block, request.params[0].get_str())) {
1147 "Block decode failed");
1150 if (block.
vtx.empty() || !block.
vtx[0]->IsCoinBase()) {
1152 "Block does not start with a coinbase");
1165 if (pindex->nStatus.isInvalid()) {
1166 return "duplicate-invalid";
1173 std::make_shared<submitblock_StateCatcher>(block.
GetHash());
1180 if (!new_block && accepted) {
1185 return "inconclusive";
1196 "Decode the given hexdata as a header and submit it as a candidate "
1197 "chain tip if valid."
1198 "\nThrows when the header is invalid.\n",
1201 "the hex-encoded block header data"},
1211 "Block header decode failed");
1218 "Must submit previous header (" +
1240 "Estimates the approximate fee per kilobyte needed for a "
1274 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.
RecursiveMutex cs_main
Global state.
@ 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
CChainState stores and provides an API to update our local knowledge of the current best chain.
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
CChain m_chain
The current chain of blockheaders we consult and build on.
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.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChainState & ActiveChainstate() const
The most-work chain.
CBlockIndex * ActiveTip() const
CChain & ActiveChain() const
bool ProcessNewBlock(const Config &config, const std::shared_ptr< const CBlock > &block, bool force_processing, bool *new_block) LOCKS_EXCLUDED(cs_main)
Process an incoming block.
bool ProcessNewBlockHeaders(const Config &config, const std::vector< CBlockHeader > &block, BlockValidationState &state, const CBlockIndex **ppindex=nullptr) LOCKS_EXCLUDED(cs_main)
Process incoming block headers.
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
virtual uint64_t GetMaxBlockSize() const =0
virtual const CChainParams & GetChainParams() const =0
const std::string & get_str() const
const UniValue & get_obj() const
void __pushKV(const std::string &key, const UniValue &val)
bool push_back(const UniValue &val)
bool pushKV(const std::string &key, const 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.
std::unique_ptr< CBlockTemplate > CreateNewBlock(const CScript &scriptPubKeyIn)
Construct a new block template with coinbase to scriptPubKeyIn.
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 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...
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)
std::unique_ptr< Descriptor > Parse(const std::string &descriptor, FlatSigningProvider &out, std::string &error, bool require_checksum)
Parse a descriptor string.
std::string EncodeDestination(const CTxDestination &dest, const Config &config)
CTxDestination DecodeDestination(const std::string &addr, const CChainParams ¶ms)
std::vector< CTxDestination > GetMinerFundWhitelist(const Consensus::Params ¶ms, const CBlockIndex *pindexPrev)
Amount GetMinerFundAmount(const Amount &coinbaseValue)
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 bool GenerateBlock(const Config &config, ChainstateManager &chainman, CBlock &block, uint64_t &max_tries, unsigned int &extra_nonce, BlockHash &block_hash)
static RPCHelpMan submitheader()
static UniValue generateBlocks(const Config &config, ChainstateManager &chainman, const CTxMemPool &mempool, const CScript &coinbase_script, int nGenerate, uint64_t nMaxTries)
static RPCHelpMan prioritisetransaction()
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.
void IncrementExtraNonce(CBlock *pblock, const CBlockIndex *pindexPrev, uint64_t nExcessiveBlockSize, unsigned int &nExtraNonce)
Modify the extranonce in a block.
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.
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded values (throws error if not hex).
bool IsDeprecatedRPCEnabled(const ArgsManager &args, 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)
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 IsValidDestination(const CTxDestination &dest)
Check whether a CTxDestination is a CNoDestination.
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
boost::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()
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_NAMED_ARG
Optional arg that is a named argument and has a default value of null.
@ OMITTED
Optional argument with default value omitted because they are implicitly clear.
@ 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)
bool error(const char *fmt, const Args &...args)
T GetTime()
Return system time (or mocked time, if set)
const UniValue & find_value(const UniValue &obj, const std::string &name)
const UniValue NullUniValue
std::condition_variable g_best_block_cv
uint256 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(boo TestBlockValidity)(BlockValidationState &state, const CChainParams ¶ms, CChainState &chainstate, const CBlock &block, CBlockIndex *pindexPrev, 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 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.