{

uint256 hash;

int height;

{

CHECK_NONFATAL(blockindex);

int nShift = (blockindex->nBits >> 24) & 0xff;

double dDiff =

(double)0x0000ffff / (double)(blockindex->nBits & 0x00ffffff);

while (nShift < 29)

{

dDiff *= 256.0;

nShift++;

}

while (nShift > 29)

{

dDiff /= 256.0;

nShift--;

}

return dDiff;

{

next = tip->GetAncestor(blockindex->nHeight + 1);

if (next && next->pprev == blockindex) {

return tip->nHeight - blockindex->nHeight + 1;

}

next = nullptr;

return blockindex == tip ? 1 : -1;

{

// Serialize passed information without accessing chain state of the active chain!

AssertLockNotHeld(cs_main); // For performance reasons

UniValue result(UniValue::VOBJ);

result.pushKV("hash", blockindex->GetBlockHash().GetHex());

const CBlockIndex* pnext;

int confirmations = ComputeNextBlockAndDepth(tip, blockindex, pnext);

result.pushKV("confirmations", confirmations);

result.pushKV("height", blockindex->nHeight);

result.pushKV("version", blockindex->nVersion);

result.pushKV("versionHex", strprintf("%08x", blockindex->nVersion));

result.pushKV("merkleroot", blockindex->hashMerkleRoot.GetHex());

result.pushKV("time", (int64_t)blockindex->nTime);

result.pushKV("mediantime", (int64_t)blockindex->GetMedianTimePast());

result.pushKV("nonce", (uint64_t)blockindex->nNonce);

result.pushKV("bits", strprintf("%08x", blockindex->nBits));

result.pushKV("difficulty", GetDifficulty(blockindex));

result.pushKV("chainwork", blockindex->nChainWork.GetHex());

result.pushKV("nTx", (uint64_t)blockindex->nTx);

if (blockindex->pprev)

result.pushKV("previousblockhash", blockindex->pprev->GetBlockHash().GetHex());

if (pnext)

result.pushKV("nextblockhash", pnext->GetBlockHash().GetHex());

return result;

{

UniValue result = blockheaderToJSON(tip, blockindex);

result.pushKV("strippedsize", (int)::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS));

result.pushKV("size", (int)::GetSerializeSize(block, PROTOCOL_VERSION));

result.pushKV("weight", (int)::GetBlockWeight(block));

UniValue txs(UniValue::VARR);

switch (verbosity) {

case TxVerbosity::SHOW_TXID:

for (const CTransactionRef& tx : block.vtx) {

txs.push_back(tx->GetHash().GetHex());

}

break;

case TxVerbosity::SHOW_DETAILS:

case TxVerbosity::SHOW_DETAILS_AND_PREVOUT:

CBlockUndo blockUndo;

const bool have_undo{WITH_LOCK(::cs_main, return !IsBlockPruned(blockindex) && UndoReadFromDisk(blockUndo, blockindex))};

for (size_t i = 0; i < block.vtx.size(); ++i) {

const CTransactionRef& tx = block.vtx.at(i);

// coinbase transaction (i.e. i == 0) doesn't have undo data

const CTxUndo* txundo = (have_undo && i > 0) ? &blockUndo.vtxundo.at(i - 1) : nullptr;

UniValue objTx(UniValue::VOBJ);

TxToUniv(*tx, uint256(), objTx, true, RPCSerializationFlags(), txundo, verbosity);

txs.push_back(objTx);

}

break;

}

result.pushKV("tx", txs);

return result;

{

return RPCHelpMan{"getblockcount",

"\nReturns the height of the most-work fully-validated chain.\n"

"The genesis block has height 0.\n",

{},

RPCResult{

RPCResult::Type::NUM, "", "The current block count"},

RPCExamples{

HelpExampleCli("getblockcount", "")

+ HelpExampleRpc("getblockcount", "")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

ChainstateManager& chainman = EnsureAnyChainman(request.context);

LOCK(cs_main);

return chainman.ActiveChain().Height();

},

};

{

return RPCHelpMan{"getbestblockhash",

"\nReturns the hash of the best (tip) block in the most-work fully-validated chain.\n",

{},

RPCResult{

RPCResult::Type::STR_HEX, "", "the block hash, hex-encoded"},

RPCExamples{

HelpExampleCli("getbestblockhash", "")

+ HelpExampleRpc("getbestblockhash", "")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

ChainstateManager& chainman = EnsureAnyChainman(request.context);

LOCK(cs_main);

return chainman.ActiveChain().Tip()->GetBlockHash().GetHex();

},

};

{

if(pindex) {

LOCK(cs_blockchange);

latestblock.hash = pindex->GetBlockHash();

latestblock.height = pindex->nHeight;

}

cond_blockchange.notify_all();

{

return RPCHelpMan{"waitfornewblock",

"\nWaits for a specific new block and returns useful info about it.\n"

"\nReturns the current block on timeout or exit.\n",

{

{"timeout", RPCArg::Type::NUM, RPCArg::Default{0}, "Time in milliseconds to wait for a response. 0 indicates no timeout."},

},

RPCResult{

RPCResult::Type::OBJ, "", "",

{

{RPCResult::Type::STR_HEX, "hash", "The blockhash"},

{RPCResult::Type::NUM, "height", "Block height"},

}},

RPCExamples{

HelpExampleCli("waitfornewblock", "1000")

+ HelpExampleRpc("waitfornewblock", "1000")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

int timeout = 0;

if (!request.params[0].isNull())

timeout = request.params[0].get_int();

CUpdatedBlock block;

{

WAIT_LOCK(cs_blockchange, lock);

block = latestblock;

if(timeout)

cond_blockchange.wait_for(lock, std::chrono::milliseconds(timeout), [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {return latestblock.height != block.height || latestblock.hash != block.hash || !IsRPCRunning(); });

else

cond_blockchange.wait(lock, [&block]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {return latestblock.height != block.height || latestblock.hash != block.hash || !IsRPCRunning(); });

block = latestblock;

}

UniValue ret(UniValue::VOBJ);

ret.pushKV("hash", block.hash.GetHex());

ret.pushKV("height", block.height);

return ret;

},

};

{

return RPCHelpMan{"waitforblock",

"\nWaits for a specific new block and returns useful info about it.\n"

"\nReturns the current block on timeout or exit.\n",

{

{"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "Block hash to wait for."},

{"timeout", RPCArg::Type::NUM, RPCArg::Default{0}, "Time in milliseconds to wait for a response. 0 indicates no timeout."},

},

RPCResult{

RPCResult::Type::OBJ, "", "",

{

{RPCResult::Type::STR_HEX, "hash", "The blockhash"},

{RPCResult::Type::NUM, "height", "Block height"},

}},

RPCExamples{

HelpExampleCli("waitforblock", "\"0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\" 1000")

+ HelpExampleRpc("waitforblock", "\"0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\", 1000")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

int timeout = 0;

uint256 hash(ParseHashV(request.params[0], "blockhash"));

if (!request.params[1].isNull())

timeout = request.params[1].get_int();

CUpdatedBlock block;

{

WAIT_LOCK(cs_blockchange, lock);

if(timeout)

cond_blockchange.wait_for(lock, std::chrono::milliseconds(timeout), [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {return latestblock.hash == hash || !IsRPCRunning();});

else

cond_blockchange.wait(lock, [&hash]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {return latestblock.hash == hash || !IsRPCRunning(); });

block = latestblock;

}

UniValue ret(UniValue::VOBJ);

ret.pushKV("hash", block.hash.GetHex());

ret.pushKV("height", block.height);

return ret;

},

};

{

return RPCHelpMan{"waitforblockheight",

"\nWaits for (at least) block height and returns the height and hash\n"

"of the current tip.\n"

"\nReturns the current block on timeout or exit.\n",

{

{"height", RPCArg::Type::NUM, RPCArg::Optional::NO, "Block height to wait for."},

{"timeout", RPCArg::Type::NUM, RPCArg::Default{0}, "Time in milliseconds to wait for a response. 0 indicates no timeout."},

},

RPCResult{

RPCResult::Type::OBJ, "", "",

{

{RPCResult::Type::STR_HEX, "hash", "The blockhash"},

{RPCResult::Type::NUM, "height", "Block height"},

}},

RPCExamples{

HelpExampleCli("waitforblockheight", "100 1000")

+ HelpExampleRpc("waitforblockheight", "100, 1000")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

int timeout = 0;

int height = request.params[0].get_int();

if (!request.params[1].isNull())

timeout = request.params[1].get_int();

CUpdatedBlock block;

{

WAIT_LOCK(cs_blockchange, lock);

if(timeout)

cond_blockchange.wait_for(lock, std::chrono::milliseconds(timeout), [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {return latestblock.height >= height || !IsRPCRunning();});

else

cond_blockchange.wait(lock, [&height]() EXCLUSIVE_LOCKS_REQUIRED(cs_blockchange) {return latestblock.height >= height || !IsRPCRunning(); });

block = latestblock;

}

UniValue ret(UniValue::VOBJ);

ret.pushKV("hash", block.hash.GetHex());

ret.pushKV("height", block.height);

return ret;

},

};

{

return RPCHelpMan{"syncwithvalidationinterfacequeue",

"\nWaits for the validation interface queue to catch up on everything that was there when we entered this function.\n",

{},

RPCResult{RPCResult::Type::NONE, "", ""},

RPCExamples{

HelpExampleCli("syncwithvalidationinterfacequeue","")

+ HelpExampleRpc("syncwithvalidationinterfacequeue","")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

SyncWithValidationInterfaceQueue();

return NullUniValue;

},

};

{

return RPCHelpMan{"getdifficulty",

"\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\n",

{},

RPCResult{

RPCResult::Type::NUM, "", "the proof-of-work difficulty as a multiple of the minimum difficulty."},

RPCExamples{

HelpExampleCli("getdifficulty", "")

+ HelpExampleRpc("getdifficulty", "")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

ChainstateManager& chainman = EnsureAnyChainman(request.context);

LOCK(cs_main);

return GetDifficulty(chainman.ActiveChain().Tip());

},

};

RPCResult{RPCResult::Type::NUM, "vsize", "virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted."},

RPCResult{RPCResult::Type::NUM, "weight", "transaction weight as defined in BIP 141."},

RPCResult{RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true,

"transaction fee, denominated in " + CURRENCY_UNIT + " (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)"},

RPCResult{RPCResult::Type::STR_AMOUNT, "modifiedfee", /*optional=*/true,

"transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT +

" (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)"},

RPCResult{RPCResult::Type::NUM_TIME, "time", "local time transaction entered pool in seconds since 1 Jan 1970 GMT"},

RPCResult{RPCResult::Type::NUM, "height", "block height when transaction entered pool"},

RPCResult{RPCResult::Type::NUM, "descendantcount", "number of in-mempool descendant transactions (including this one)"},

RPCResult{RPCResult::Type::NUM, "descendantsize", "virtual transaction size of in-mempool descendants (including this one)"},

RPCResult{RPCResult::Type::STR_AMOUNT, "descendantfees", /*optional=*/true,

"transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in " +

CURRENCY_ATOM + "s (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)"},

RPCResult{RPCResult::Type::NUM, "ancestorcount", "number of in-mempool ancestor transactions (including this one)"},

RPCResult{RPCResult::Type::NUM, "ancestorsize", "virtual transaction size of in-mempool ancestors (including this one)"},

RPCResult{RPCResult::Type::STR_AMOUNT, "ancestorfees", /*optional=*/true,

"transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in " +

CURRENCY_ATOM + "s (DEPRECATED, returned only if config option -deprecatedrpc=fees is passed)"},

RPCResult{RPCResult::Type::STR_HEX, "wtxid", "hash of serialized transaction, including witness data"},

RPCResult{RPCResult::Type::OBJ, "fees", "",

{

RPCResult{RPCResult::Type::STR_AMOUNT, "base", "transaction fee, denominated in " + CURRENCY_UNIT},

RPCResult{RPCResult::Type::STR_AMOUNT, "modified", "transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},

RPCResult{RPCResult::Type::STR_AMOUNT, "ancestor", "transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},

RPCResult{RPCResult::Type::STR_AMOUNT, "descendant", "transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},

}},

RPCResult{RPCResult::Type::ARR, "depends", "unconfirmed transactions used as inputs for this transaction",

{RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},

RPCResult{RPCResult::Type::ARR, "spentby", "unconfirmed transactions spending outputs from this transaction",

{RPCResult{RPCResult::Type::STR_HEX, "transactionid", "child transaction id"}}},

RPCResult{RPCResult::Type::BOOL, "bip125-replaceable", "Whether this transaction could be replaced due to BIP125 (replace-by-fee)"},

RPCResult{RPCResult::Type::BOOL, "unbroadcast", "Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},

{

if (verbose) {

if (include_mempool_sequence) {

throw JSONRPCError(RPC_INVALID_PARAMETER, "Verbose results cannot contain mempool sequence values.");

}

LOCK(pool.cs);

UniValue o(UniValue::VOBJ);

for (const CTxMemPoolEntry& e : pool.mapTx) {

const uint256& hash = e.GetTx().GetHash();

UniValue info(UniValue::VOBJ);

entryToJSON(pool, info, e);

// Mempool has unique entries so there is no advantage in using

// UniValue::pushKV, which checks if the key already exists in O(N).

// UniValue::__pushKV is used instead which currently is O(1).

o.__pushKV(hash.ToString(), info);

}

return o;

} else {

uint64_t mempool_sequence;

std::vector<uint256> vtxid;

{

LOCK(pool.cs);

pool.queryHashes(vtxid);

mempool_sequence = pool.GetSequence();

}

UniValue a(UniValue::VARR);

for (const uint256& hash : vtxid)

a.push_back(hash.ToString());

if (!include_mempool_sequence) {

return a;

} else {

UniValue o(UniValue::VOBJ);

o.pushKV("txids", a);

o.pushKV("mempool_sequence", mempool_sequence);

return o;

}

}

{

return RPCHelpMan{"getrawmempool",

"\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"

"\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",

{

{"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},

{"mempool_sequence", RPCArg::Type::BOOL, RPCArg::Default{false}, "If verbose=false, returns a json object with transaction list and mempool sequence number attached."},

},

{

RPCResult{"for verbose = false",

RPCResult::Type::ARR, "", "",

{

{RPCResult::Type::STR_HEX, "", "The transaction id"},

}},

RPCResult{"for verbose = true",

RPCResult::Type::OBJ_DYN, "", "",

{

{RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},

}},

RPCResult{"for verbose = false and mempool_sequence = true",

RPCResult::Type::OBJ, "", "",

{

{RPCResult::Type::ARR, "txids", "",

{

{RPCResult::Type::STR_HEX, "", "The transaction id"},

}},

{RPCResult::Type::NUM, "mempool_sequence", "The mempool sequence value."},

}},

},

RPCExamples{

HelpExampleCli("getrawmempool", "true")

+ HelpExampleRpc("getrawmempool", "true")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

bool fVerbose = false;

if (!request.params[0].isNull())

fVerbose = request.params[0].get_bool();

bool include_mempool_sequence = false;

if (!request.params[1].isNull()) {

include_mempool_sequence = request.params[1].get_bool();

}

return MempoolToJSON(EnsureAnyMemPool(request.context), fVerbose, include_mempool_sequence);

},

};

{

return RPCHelpMan{"getmempoolancestors",

"\nIf txid is in the mempool, returns all in-mempool ancestors.\n",

{

{"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},

{"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},

},

{

RPCResult{"for verbose = false",

RPCResult::Type::ARR, "", "",

{{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool ancestor transaction"}}},

RPCResult{"for verbose = true",

RPCResult::Type::OBJ_DYN, "", "",

{

{RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},

}},

},

RPCExamples{

HelpExampleCli("getmempoolancestors", "\"mytxid\"")

+ HelpExampleRpc("getmempoolancestors", "\"mytxid\"")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

bool fVerbose = false;

if (!request.params[1].isNull())

fVerbose = request.params[1].get_bool();

uint256 hash = ParseHashV(request.params[0], "parameter 1");

const CTxMemPool& mempool = EnsureAnyMemPool(request.context);

LOCK(mempool.cs);

CTxMemPool::txiter it = mempool.mapTx.find(hash);

if (it == mempool.mapTx.end()) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");

}

CTxMemPool::setEntries setAncestors;

uint64_t noLimit = std::numeric_limits<uint64_t>::max();

std::string dummy;

mempool.CalculateMemPoolAncestors(*it, setAncestors, noLimit, noLimit, noLimit, noLimit, dummy, false);

if (!fVerbose) {

UniValue o(UniValue::VARR);

for (CTxMemPool::txiter ancestorIt : setAncestors) {

o.push_back(ancestorIt->GetTx().GetHash().ToString());

}

return o;

} else {

UniValue o(UniValue::VOBJ);

for (CTxMemPool::txiter ancestorIt : setAncestors) {

const CTxMemPoolEntry &e = *ancestorIt;

const uint256& _hash = e.GetTx().GetHash();

UniValue info(UniValue::VOBJ);

entryToJSON(mempool, info, e);

o.pushKV(_hash.ToString(), info);

}

return o;

}

},

};

{

return RPCHelpMan{"getmempooldescendants",

"\nIf txid is in the mempool, returns all in-mempool descendants.\n",

{

{"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},

{"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},

},

{

RPCResult{"for verbose = false",

RPCResult::Type::ARR, "", "",

{{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool descendant transaction"}}},

RPCResult{"for verbose = true",

RPCResult::Type::OBJ_DYN, "", "",

{

{RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},

}},

},

RPCExamples{

HelpExampleCli("getmempooldescendants", "\"mytxid\"")

+ HelpExampleRpc("getmempooldescendants", "\"mytxid\"")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

bool fVerbose = false;

if (!request.params[1].isNull())

fVerbose = request.params[1].get_bool();

uint256 hash = ParseHashV(request.params[0], "parameter 1");

const CTxMemPool& mempool = EnsureAnyMemPool(request.context);

LOCK(mempool.cs);

CTxMemPool::txiter it = mempool.mapTx.find(hash);

if (it == mempool.mapTx.end()) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");

}

CTxMemPool::setEntries setDescendants;

mempool.CalculateDescendants(it, setDescendants);

// CTxMemPool::CalculateDescendants will include the given tx

setDescendants.erase(it);

if (!fVerbose) {

UniValue o(UniValue::VARR);

for (CTxMemPool::txiter descendantIt : setDescendants) {

o.push_back(descendantIt->GetTx().GetHash().ToString());

}

return o;

} else {

UniValue o(UniValue::VOBJ);

for (CTxMemPool::txiter descendantIt : setDescendants) {

const CTxMemPoolEntry &e = *descendantIt;

const uint256& _hash = e.GetTx().GetHash();

UniValue info(UniValue::VOBJ);

entryToJSON(mempool, info, e);

o.pushKV(_hash.ToString(), info);

}

return o;

}

},

};

{

return RPCHelpMan{"getmempoolentry",

"\nReturns mempool data for given transaction\n",

{

{"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},

},

RPCResult{

RPCResult::Type::OBJ, "", "", MempoolEntryDescription()},

RPCExamples{

HelpExampleCli("getmempoolentry", "\"mytxid\"")

+ HelpExampleRpc("getmempoolentry", "\"mytxid\"")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

uint256 hash = ParseHashV(request.params[0], "parameter 1");

const CTxMemPool& mempool = EnsureAnyMemPool(request.context);

LOCK(mempool.cs);

CTxMemPool::txiter it = mempool.mapTx.find(hash);

if (it == mempool.mapTx.end()) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");

}

const CTxMemPoolEntry &e = *it;

UniValue info(UniValue::VOBJ);

entryToJSON(mempool, info, e);

return info;

},

};

{

return RPCHelpMan{

"getblockfrompeer",

"Attempt to fetch block from a given peer.\n\n"

"We must have the header for this block, e.g. using submitheader.\n"

"Subsequent calls for the same block and a new peer will cause the response from the previous peer to be ignored.\n\n"

"Returns an empty JSON object if the request was successfully scheduled.",

{

{"block_hash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash to try to fetch"},

{"peer_id", RPCArg::Type::NUM, RPCArg::Optional::NO, "The peer to fetch it from (see getpeerinfo for peer IDs)"},

},

RPCResult{RPCResult::Type::OBJ, "", /*optional=*/false, "", {}},

RPCExamples{

HelpExampleCli("getblockfrompeer", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 0")

+ HelpExampleRpc("getblockfrompeer", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\" 0")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

const NodeContext& node = EnsureAnyNodeContext(request.context);

ChainstateManager& chainman = EnsureChainman(node);

PeerManager& peerman = EnsurePeerman(node);

const uint256& block_hash{ParseHashV(request.params[0], "block_hash")};

const NodeId peer_id{request.params[1].get_int64()};

const CBlockIndex* const index = WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(block_hash););

if (!index) {

throw JSONRPCError(RPC_MISC_ERROR, "Block header missing");

}

const bool block_has_data = WITH_LOCK(::cs_main, return index->nStatus & BLOCK_HAVE_DATA);

if (block_has_data) {

throw JSONRPCError(RPC_MISC_ERROR, "Block already downloaded");

}

if (const auto err{peerman.FetchBlock(peer_id, *index)}) {

throw JSONRPCError(RPC_MISC_ERROR, err.value());

}

return UniValue::VOBJ;

},

};

{

return RPCHelpMan{"getblockhash",

"\nReturns hash of block in best-block-chain at height provided.\n",

{

{"height", RPCArg::Type::NUM, RPCArg::Optional::NO, "The height index"},

},

RPCResult{

RPCResult::Type::STR_HEX, "", "The block hash"},

RPCExamples{

HelpExampleCli("getblockhash", "1000")

+ HelpExampleRpc("getblockhash", "1000")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

ChainstateManager& chainman = EnsureAnyChainman(request.context);

LOCK(cs_main);

const CChain& active_chain = chainman.ActiveChain();

int nHeight = request.params[0].get_int();

if (nHeight < 0 || nHeight > active_chain.Height())

throw JSONRPCError(RPC_INVALID_PARAMETER, "Block height out of range");

CBlockIndex* pblockindex = active_chain[nHeight];

return pblockindex->GetBlockHash().GetHex();

},

};

{

return RPCHelpMan{"getblockheader",

"\nIf verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\n"

"If verbose is true, returns an Object with information about blockheader <hash>.\n",

{

{"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash"},

{"verbose", RPCArg::Type::BOOL, RPCArg::Default{true}, "true for a json object, false for the hex-encoded data"},

},

{

RPCResult{"for verbose = true",

RPCResult::Type::OBJ, "", "",

{

{RPCResult::Type::STR_HEX, "hash", "the block hash (same as provided)"},

{RPCResult::Type::NUM, "confirmations", "The number of confirmations, or -1 if the block is not on the main chain"},

{RPCResult::Type::NUM, "height", "The block height or index"},

{RPCResult::Type::NUM, "version", "The block version"},

{RPCResult::Type::STR_HEX, "versionHex", "The block version formatted in hexadecimal"},

{RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},

{RPCResult::Type::NUM_TIME, "time", "The block time expressed in " + UNIX_EPOCH_TIME},

{RPCResult::Type::NUM_TIME, "mediantime", "The median block time expressed in " + UNIX_EPOCH_TIME},

{RPCResult::Type::NUM, "nonce", "The nonce"},

{RPCResult::Type::STR_HEX, "bits", "The bits"},

{RPCResult::Type::NUM, "difficulty", "The difficulty"},

{RPCResult::Type::STR_HEX, "chainwork", "Expected number of hashes required to produce the current chain"},

{RPCResult::Type::NUM, "nTx", "The number of transactions in the block"},

{RPCResult::Type::STR_HEX, "previousblockhash", /*optional=*/true, "The hash of the previous block (if available)"},

{RPCResult::Type::STR_HEX, "nextblockhash", /*optional=*/true, "The hash of the next block (if available)"},

}},

RPCResult{"for verbose=false",

RPCResult::Type::STR_HEX, "", "A string that is serialized, hex-encoded data for block 'hash'"},

},

RPCExamples{

HelpExampleCli("getblockheader", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")

+ HelpExampleRpc("getblockheader", "\"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\"")

},

[&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue

{

uint256 hash(ParseHashV(request.params[0], "hash"));

bool fVerbose = true;

if (!request.params[1].isNull())

fVerbose = request.params[1].get_bool();

const CBlockIndex* pblockindex;

const CBlockIndex* tip;

{

ChainstateManager& chainman = EnsureAnyChainman(request.context);

LOCK(cs_main);

pblockindex = chainman.m_blockman.LookupBlockIndex(hash);

tip = chainman.ActiveChain().Tip();

}

if (!pblockindex) {

throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");

}

if (!fVerbose)

{

CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);

ssBlock << pblockindex->GetBlockHeader();

std::string strHex = HexStr(ssBlock);

return strHex;

}

return blockheaderToJSON(tip, pblockindex);

},

};

{

AssertLockHeld(::cs_main);

CBlock block;

if (IsBlockPruned(pblockindex)) {

throw JSONRPCError(RPC_MISC_ERROR, "Block not available (pruned data)");

}

if (!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus())) {

// Block not found on disk. This could be because we have the block

// header in our index but not yet have the block or did not accept the

// block.

throw JSONRPCError(RPC_MISC_ERROR, "Block not found on disk");

}

return block;

{

AssertLockHeld(::cs_main);

CBlockUndo blockUndo;

if (IsBlockPruned(pblockindex)) {

throw JSONRPCError(RPC_MISC_ERROR, "Undo data not available (pruned data)");

}

if (!UndoReadFromDisk(blockUndo, pblockindex)) {

throw JSONRPCError(RPC_MISC_ERROR, "Can't read undo data from disk");

}

return blockUndo;

{

return RPCHelpMan{"getblock",

"\nIf verbosity is 0, returns a string that is serialized, hex-encoded data for block 'hash'.\n"

"If verbosity is 1, returns an Object with information about block <hash>.\n"

"If verbosity is 2, returns an Object with information about block <hash> and information about each transaction.\n"

"If verbosity is 3, returns an Object with information about block <hash> and information about each transaction, including prevout information for inputs (only for unpruned blocks in the current best chain).\n",

{

{"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The block hash"},

{"verbosity|verbose", RPCArg::Type::NUM, RPCArg::Default{1}, "0 for hex-encoded data, 1 for a JSON object, 2 for JSON object with transaction data, and 3 for JSON object with transaction data including prevout information for inputs"},

},

{

RPCResult{"for verbosity = 0",

RPCResult::Type::STR_HEX, "", "A string that is serialized, hex-encoded data for block 'hash'"},

RPCResult{"for verbosity = 1",

RPCResult::Type::OBJ, "", "",

{

{RPCResult::Type::STR_HEX, "hash", "the block hash (same as provided)"},

{RPCResult::Type::NUM, "confirmations", "The number of confirmations, or -1 if the block is not on the main chain"},

{RPCResult::Type::NUM, "size", "The block size"},

{RPCResult::Type::NUM, "strippedsize", "The block size excluding witness data"},

{RPCResult::Type::NUM, "weight", "The block weight as defined in BIP 141"},

{RPCResult::Type::NUM, "height", "The block height or index"},

{RPCResult::Type::NUM, "version", "The block version"},

{RPCResult::Type::STR_HEX, "versionHex", "The block version formatted in hexadecimal"},

{RPCResult::Type::STR_HEX, "merkleroot", "The merkle root"},

{RPCResult::Type::ARR, "tx", "The transaction ids",

{{RPCResult::Type::STR_HEX, "", "The transaction id"}}},

{RPCResult::Type::NUM_TIME, "time", "The block time expressed in " + UNIX_EPOCH_TIME},

{RPCResult::Type::NUM_TIME, "mediantime", "The median block time expressed in " + UNIX_EPOCH_TIME},

{RPCResult::Type::NUM, "nonce", "The nonce"},

{RPCResult::Type::STR_HEX, "bits", "The bits"},

{RPCResult::Type::NUM, "difficulty", "The difficulty"},

{RPCResult::Type::STR_HEX, "chainwork", "Expected number of hashes required to produce the chain up to this block (in hex)"},

{RPCResult::Type::NUM, "nTx", "The number of transactions in the block"},