{

uint256 hash;

int height;

{

assert(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;

{

// 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("strippedsize", (int)::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS));

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

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

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

result.pushKV("version", block.nVersion);

result.pushKV("versionHex", strprintf("%08x", block.nVersion));

result.pushKV("merkleroot", block.hashMerkleRoot.GetHex());

UniValue txs(UniValue::VARR);

for(const auto& tx : block.vtx)

{

if(txDetails)

{

UniValue objTx(UniValue::VOBJ);

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

txs.push_back(objTx);

}

else

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

}

result.pushKV("tx", txs);

result.pushKV("time", block.GetBlockTime());

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

result.pushKV("nonce", (uint64_t)block.nNonce);

result.pushKV("bits", strprintf("%08x", block.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;

{

RPCHelpMan{"getblockcount",

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

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

{},

RPCResult{

"n (numeric) The current block count\n"

},

RPCExamples{

HelpExampleCli("getblockcount", "")

+ HelpExampleRpc("getblockcount", "")

},

}.Check(request);

LOCK(cs_main);

return ::ChainActive().Height();

{

RPCHelpMan{"getbestblockhash",

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

{},

RPCResult{

"\"hex\" (string) the block hash, hex-encoded\n"

},

RPCExamples{

HelpExampleCli("getbestblockhash", "")

+ HelpExampleRpc("getbestblockhash", "")

},

}.Check(request);

LOCK(cs_main);

return ::ChainActive().Tip()->GetBlockHash().GetHex();

{

if(pindex) {

std::lock_guard<std::mutex> lock(cs_blockchange);

latestblock.hash = pindex->GetBlockHash();

latestblock.height = pindex->nHeight;

}

cond_blockchange.notify_all();

{

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, /* default */ "0", "Time in milliseconds to wait for a response. 0 indicates no timeout."},

},

RPCResult{

"{ (json object)\n"

" \"hash\" : { (string) The blockhash\n"

" \"height\" : { (int) Block height\n"

"}\n"

},

RPCExamples{

HelpExampleCli("waitfornewblock", "1000")

+ HelpExampleRpc("waitfornewblock", "1000")

},

}.Check(request);

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]{return latestblock.height != block.height || latestblock.hash != block.hash || !IsRPCRunning(); });

else

cond_blockchange.wait(lock, [&block]{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;

{

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, /* default */ "0", "Time in milliseconds to wait for a response. 0 indicates no timeout."},

},

RPCResult{

"{ (json object)\n"

" \"hash\" : { (string) The blockhash\n"

" \"height\" : { (int) Block height\n"

"}\n"

},

RPCExamples{

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

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

},

}.Check(request);

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]{return latestblock.hash == hash || !IsRPCRunning();});

else

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

block = latestblock;

}

UniValue ret(UniValue::VOBJ);

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

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

return ret;

{

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, /* default */ "0", "Time in milliseconds to wait for a response. 0 indicates no timeout."},

},

RPCResult{

"{ (json object)\n"

" \"hash\" : { (string) The blockhash\n"

" \"height\" : { (int) Block height\n"

"}\n"

},

RPCExamples{

HelpExampleCli("waitforblockheight", "\"100\", 1000")

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

},

}.Check(request);

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]{return latestblock.height >= height || !IsRPCRunning();});

else

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

block = latestblock;

}

UniValue ret(UniValue::VOBJ);

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

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

return ret;

{

RPCHelpMan{"syncwithvalidationinterfacequeue",

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

{},

RPCResults{},

RPCExamples{

HelpExampleCli("syncwithvalidationinterfacequeue","")

+ HelpExampleRpc("syncwithvalidationinterfacequeue","")

},

}.Check(request);

SyncWithValidationInterfaceQueue();

return NullUniValue;

{

RPCHelpMan{"getdifficulty",

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

{},

RPCResult{

"n.nnn (numeric) the proof-of-work difficulty as a multiple of the minimum difficulty.\n"

},

RPCExamples{

HelpExampleCli("getdifficulty", "")

+ HelpExampleRpc("getdifficulty", "")

},

}.Check(request);

LOCK(cs_main);

return GetDifficulty(::ChainActive().Tip());

{

return " \"vsize\" : n, (numeric) virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted.\n"

" \"size\" : n, (numeric) (DEPRECATED) same as vsize. Only returned if bitcoind is started with -deprecatedrpc=size\n"

" size will be completely removed in v0.20.\n"

" \"weight\" : n, (numeric) transaction weight as defined in BIP 141.\n"

" \"fee\" : n, (numeric) transaction fee in " + CURRENCY_UNIT + " (DEPRECATED)\n"

" \"modifiedfee\" : n, (numeric) transaction fee with fee deltas used for mining priority (DEPRECATED)\n"

" \"time\" : n, (numeric) local time transaction entered pool in seconds since 1 Jan 1970 GMT\n"

" \"height\" : n, (numeric) block height when transaction entered pool\n"

" \"descendantcount\" : n, (numeric) number of in-mempool descendant transactions (including this one)\n"

" \"descendantsize\" : n, (numeric) virtual transaction size of in-mempool descendants (including this one)\n"

" \"descendantfees\" : n, (numeric) modified fees (see above) of in-mempool descendants (including this one) (DEPRECATED)\n"

" \"ancestorcount\" : n, (numeric) number of in-mempool ancestor transactions (including this one)\n"

" \"ancestorsize\" : n, (numeric) virtual transaction size of in-mempool ancestors (including this one)\n"

" \"ancestorfees\" : n, (numeric) modified fees (see above) of in-mempool ancestors (including this one) (DEPRECATED)\n"

" \"wtxid\" : hash, (string) hash of serialized transaction, including witness data\n"

" \"fees\" : {\n"

" \"base\" : n, (numeric) transaction fee in " + CURRENCY_UNIT + "\n"

" \"modified\" : n, (numeric) transaction fee with fee deltas used for mining priority in " + CURRENCY_UNIT + "\n"

" \"ancestor\" : n, (numeric) modified fees (see above) of in-mempool ancestors (including this one) in " + CURRENCY_UNIT + "\n"

" \"descendant\" : n, (numeric) modified fees (see above) of in-mempool descendants (including this one) in " + CURRENCY_UNIT + "\n"

" }\n"

" \"depends\" : [ (array) unconfirmed transactions used as inputs for this transaction\n"

" \"transactionid\", (string) parent transaction id\n"

" ... ]\n"

" \"spentby\" : [ (array) unconfirmed transactions spending outputs from this transaction\n"

" \"transactionid\", (string) child transaction id\n"

" ... ]\n"

" \"bip125-replaceable\" : true|false, (boolean) Whether this transaction could be replaced due to BIP125 (replace-by-fee)\n";

{

if (verbose) {

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 {

std::vector<uint256> vtxid;

pool.queryHashes(vtxid);

UniValue a(UniValue::VARR);

for (const uint256& hash : vtxid)

a.push_back(hash.ToString());

return a;

}

{

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, /* default */ "false", "True for a json object, false for array of transaction ids"},

},

RPCResult{"for verbose = false",

"[ (json array of string)\n"

" \"transactionid\" (string) The transaction id\n"

" ,...\n"

"]\n"

"\nResult: (for verbose = true):\n"

"{ (json object)\n"

" \"transactionid\" : { (json object)\n"

+ EntryDescriptionString()

+ " }, ...\n"

"}\n"

},

RPCExamples{

HelpExampleCli("getrawmempool", "true")

+ HelpExampleRpc("getrawmempool", "true")

},

}.Check(request);

bool fVerbose = false;

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

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

return MempoolToJSON(::mempool, fVerbose);

{

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, /* default */ "false", "True for a json object, false for array of transaction ids"},

},

{

RPCResult{"for verbose = false",

"[ (json array of strings)\n"

" \"transactionid\" (string) The transaction id of an in-mempool ancestor transaction\n"

" ,...\n"

"]\n"

},

RPCResult{"for verbose = true",

"{ (json object)\n"

" \"transactionid\" : { (json object)\n"

+ EntryDescriptionString()

+ " }, ...\n"

"}\n"

},

},

RPCExamples{

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

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

},

}.Check(request);

bool fVerbose = false;

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

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

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

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;

}

{

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, /* default */ "false", "True for a json object, false for array of transaction ids"},

},

{

RPCResult{"for verbose = false",

"[ (json array of strings)\n"

" \"transactionid\" (string) The transaction id of an in-mempool descendant transaction\n"

" ,...\n"

"]\n"

},

RPCResult{"for verbose = true",

"{ (json object)\n"

" \"transactionid\" : { (json object)\n"

+ EntryDescriptionString()

+ " }, ...\n"

"}\n"

},

},

RPCExamples{

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

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

},

}.Check(request);

bool fVerbose = false;

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

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

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

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;

}

{

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{

"{ (json object)\n"

+ EntryDescriptionString()

+ "}\n"

},

RPCExamples{

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

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

},

}.Check(request);

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

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;

{

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{

"\"hash\" (string) The block hash\n"

},

RPCExamples{

HelpExampleCli("getblockhash", "1000")

+ HelpExampleRpc("getblockhash", "1000")

},

}.Check(request);

LOCK(cs_main);

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

if (nHeight < 0 || nHeight > ::ChainActive().Height())

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

CBlockIndex* pblockindex = ::ChainActive()[nHeight];

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

{

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, /* default */ "true", "true for a json object, false for the hex-encoded data"},

},

{

RPCResult{"for verbose = true",

"{\n"

" \"hash\" : \"hash\", (string) the block hash (same as provided)\n"

" \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n"

" \"height\" : n, (numeric) The block height or index\n"

" \"version\" : n, (numeric) The block version\n"

" \"versionHex\" : \"00000000\", (string) The block version formatted in hexadecimal\n"

" \"merkleroot\" : \"xxxx\", (string) The merkle root\n"

" \"time\" : ttt, (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"mediantime\" : ttt, (numeric) The median block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"nonce\" : n, (numeric) The nonce\n"

" \"bits\" : \"1d00ffff\", (string) The bits\n"

" \"difficulty\" : x.xxx, (numeric) The difficulty\n"

" \"chainwork\" : \"0000...1f3\" (string) Expected number of hashes required to produce the current chain (in hex)\n"

" \"nTx\" : n, (numeric) The number of transactions in the block.\n"

" \"previousblockhash\" : \"hash\", (string) The hash of the previous block\n"

" \"nextblockhash\" : \"hash\", (string) The hash of the next block\n"

"}\n"

},

RPCResult{"for verbose=false",

"\"data\" (string) A string that is serialized, hex-encoded data for block 'hash'.\n"

},

},

RPCExamples{

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

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

},

}.Check(request);

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;

{

LOCK(cs_main);

pblockindex = LookupBlockIndex(hash);

tip = ::ChainActive().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.begin(), ssBlock.end());

return strHex;

}

return blockheaderToJSON(tip, pblockindex);

{

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 don't have the block (for example if a

// non-whitelisted node sends us an unrequested long chain of valid

// blocks, we add the headers to our index, but don't accept the

// block).

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

}

return block;

{

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;

{

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",

{

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

{"verbosity", RPCArg::Type::NUM, /* default */ "1", "0 for hex-encoded data, 1 for a json object, and 2 for json object with transaction data"},

},

{

RPCResult{"for verbosity = 0",

"\"data\" (string) A string that is serialized, hex-encoded data for block 'hash'.\n"

},

RPCResult{"for verbosity = 1",

"{\n"

" \"hash\" : \"hash\", (string) the block hash (same as provided)\n"

" \"confirmations\" : n, (numeric) The number of confirmations, or -1 if the block is not on the main chain\n"

" \"size\" : n, (numeric) The block size\n"

" \"strippedsize\" : n, (numeric) The block size excluding witness data\n"

" \"weight\" : n (numeric) The block weight as defined in BIP 141\n"

" \"height\" : n, (numeric) The block height or index\n"

" \"version\" : n, (numeric) The block version\n"

" \"versionHex\" : \"00000000\", (string) The block version formatted in hexadecimal\n"

" \"merkleroot\" : \"xxxx\", (string) The merkle root\n"

" \"tx\" : [ (array of string) The transaction ids\n"

" \"transactionid\" (string) The transaction id\n"

" ,...\n"

" ],\n"

" \"time\" : ttt, (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"mediantime\" : ttt, (numeric) The median block time in seconds since epoch (Jan 1 1970 GMT)\n"

" \"nonce\" : n, (numeric) The nonce\n"

" \"bits\" : \"1d00ffff\", (string) The bits\n"

" \"difficulty\" : x.xxx, (numeric) The difficulty\n"

" \"chainwork\" : \"xxxx\", (string) Expected number of hashes required to produce the chain up to this block (in hex)\n"

" \"nTx\" : n, (numeric) The number of transactions in the block.\n"

" \"previousblockhash\" : \"hash\", (string) The hash of the previous block\n"

" \"nextblockhash\" : \"hash\" (string) The hash of the next block\n"

"}\n"

},

RPCResult{"for verbosity = 2",

"{\n"

" ..., Same output as verbosity = 1.\n"

" \"tx\" : [ (array of Objects) The transactions in the format of the getrawtransaction RPC. Different from verbosity = 1 \"tx\" result.\n"

" ,...\n"

" ],\n"

" ,... Same output as verbosity = 1.\n"

"}\n"

},

},

RPCExamples{

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

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

},

}.Check(request);

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

int verbosity = 1;

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

if(request.params[1].isNum())

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

else

verbosity = request.params[1].get_bool() ? 1 : 0;

}

CBlock block;

const CBlockIndex* pblockindex;

const CBlockIndex* tip;

{

LOCK(cs_main);

pblockindex = LookupBlockIndex(hash);

tip = ::ChainActive().Tip();

if (!pblockindex) {

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

}

block = GetBlockChecked(pblockindex);

}

if (verbosity <= 0)

{

CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION | RPCSerializationFlags());

ssBlock << block;

std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());

return strHex;

}

return blockToJSON(block, tip, pblockindex, verbosity >= 2);

{

RPCHelpMan{"pruneblockchain", "",

{

{"height", RPCArg::Type::NUM, RPCArg::Optional::NO, "The block height to prune up to. May be set to a discrete height, or a unix timestamp\n"

" to prune blocks whose block time is at least 2 hours older than the provided timestamp."},

},

RPCResult{

"n (numeric) Height of the last block pruned.\n"

},

RPCExamples{

HelpExampleCli("pruneblockchain", "1000")

+ HelpExampleRpc("pruneblockchain", "1000")

},

}.Check(request);

if (!fPruneMode)

throw JSONRPCError(RPC_MISC_ERROR, "Cannot prune blocks because node is not in prune mode.");

LOCK(cs_main);

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

if (heightParam < 0)

throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative block height.");

// Height value more than a billion is too high to be a block height, and

// too low to be a block time (corresponds to timestamp from Sep 2001).

if (heightParam > 1000000000) {

// Add a 2 hour buffer to include blocks which might have had old timestamps

CBlockIndex* pindex = ::ChainActive().FindEarliestAtLeast(heightParam - TIMESTAMP_WINDOW, 0);

if (!pindex) {

throw JSONRPCError(RPC_INVALID_PARAMETER, "Could not find block with at least the specified timestamp.");

}

heightParam = pindex->nHeight;

}

unsigned int height = (unsigned int) heightParam;

unsigned int chainHeight = (unsigned int) ::ChainActive().Height();

if (chainHeight < Params().PruneAfterHeight())

throw JSONRPCError(RPC_MISC_ERROR, "Blockchain is too short for pruning.");

else if (height > chainHeight)

throw JSONRPCError(RPC_INVALID_PARAMETER, "Blockchain is shorter than the attempted prune height.");

else if (height > chainHeight - MIN_BLOCKS_TO_KEEP) {

LogPrint(BCLog::RPC, "Attempt to prune blocks close to the tip. Retaining the minimum number of blocks.\n");

height = chainHeight - MIN_BLOCKS_TO_KEEP;

}

PruneBlockFilesManual(height);

const CBlockIndex* block = ::ChainActive().Tip();

assert(block);

while (block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA)) {

block = block->pprev;

}

return uint64_t(block->nHeight);

{

RPCHelpMan{"gettxoutsetinfo",

"\nReturns statistics about the unspent transaction output set.\n"

"Note this call may take some time.\n",

{},

RPCResult{

"{\n"

" \"height\":n, (numeric) The current block height (index)\n"

" \"bestblock\": \"hex\", (string) The hash of the block at the tip of the chain\n"

" \"transactions\": n, (numeric) The number of transactions with unspent outputs\n"

" \"txouts\": n, (numeric) The number of unspent transaction outputs\n"

" \"bogosize\": n, (numeric) A meaningless metric for UTXO set size\n"

" \"hash_serialized_2\": \"hash\", (string) The serialized hash\n"

" \"disk_size\": n, (numeric) The estimated size of the chainstate on disk\n"

" \"total_amount\": x.xxx (numeric) The total amount\n"

"}\n"

},

RPCExamples{

HelpExampleCli("gettxoutsetinfo", "")

+ HelpExampleRpc("gettxoutsetinfo", "")

},

}.Check(request);

UniValue ret(UniValue::VOBJ);

CCoinsStats stats;

::ChainstateActive().ForceFlushStateToDisk();

CCoinsView* coins_view = WITH_LOCK(cs_main, return &ChainstateActive().CoinsDB());

if (GetUTXOStats(coins_view, stats)) {

ret.pushKV("height", (int64_t)stats.nHeight);