{

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, /*block_hash=*/uint256(), /*entry=*/objTx, /*include_hex=*/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());

},

};

{

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");

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

{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 verbosity = 2",

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

{

{RPCResult::Type::ELISION, "", "Same output as verbosity = 1"},

{RPCResult::Type::ARR, "tx", "",

{

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

{

{RPCResult::Type::ELISION, "", "The transactions in the format of the getrawtransaction RPC. Different from verbosity = 1 \"tx\" result"},

{RPCResult::Type::NUM, "fee", "The transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available"},

}},

}},

}},

RPCResult{"for verbosity = 3",

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

{

{RPCResult::Type::ELISION, "", "Same output as verbosity = 2"},

{RPCResult::Type::ARR, "tx", "",

{

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

{

{RPCResult::Type::ARR, "vin", "",

{

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

{

{RPCResult::Type::ELISION, "", "The same output as verbosity = 2"},

{RPCResult::Type::OBJ, "prevout", "(Only if undo information is available)",

{

{RPCResult::Type::BOOL, "generated", "Coinbase or not"},

{RPCResult::Type::NUM, "height", "The height of the prevout"},

{RPCResult::Type::NUM, "value", "The value in " + CURRENCY_UNIT},

{RPCResult::Type::OBJ, "scriptPubKey", "",

{

{RPCResult::Type::STR, "asm", "The asm"},

{RPCResult::Type::STR, "hex", "The hex"},

{RPCResult::Type::STR, "address", /* optional */ true, "The Bitcoin address (only if a well-defined address exists)"},

{RPCResult::Type::STR, "type", "The type (one of: " + GetAllOutputTypes() + ")"},

}},

}},

}},

}},

}},

}},

}},

},

RPCExamples{

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

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

},

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

{

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

int verbosity = 1;

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

if (request.params[1].isBool()) {

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

} else {

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

}

}

CBlock block;

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");

}

block = GetBlockChecked(pblockindex);

}

if (verbosity <= 0)

{

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

ssBlock << block;

std::string strHex = HexStr(ssBlock);

return strHex;

}

TxVerbosity tx_verbosity;

if (verbosity == 1) {

tx_verbosity = TxVerbosity::SHOW_TXID;

} else if (verbosity == 2) {

tx_verbosity = TxVerbosity::SHOW_DETAILS;

} else {

tx_verbosity = TxVerbosity::SHOW_DETAILS_AND_PREVOUT;

}

return blockToJSON(block, tip, pblockindex, tx_verbosity);

},

};

{

return RPCHelpMan{"pruneblockchain", "",

{

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

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

},

RPCResult{

RPCResult::Type::NUM, "", "Height of the last block pruned"},

RPCExamples{

HelpExampleCli("pruneblockchain", "1000")

+ HelpExampleRpc("pruneblockchain", "1000")

},

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

{

if (!node::fPruneMode)

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

ChainstateManager& chainman = EnsureAnyChainman(request.context);

LOCK(cs_main);

CChainState& active_chainstate = chainman.ActiveChainstate();

CChain& active_chain = active_chainstate.m_chain;

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

const CBlockIndex* pindex = active_chain.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) active_chain.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(active_chainstate, height);

const CBlockIndex* block = active_chain.Tip();

CHECK_NONFATAL(block);

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

block = block->pprev;

}

return uint64_t(block->nHeight);

},

};

{

if (hash_type_input == "hash_serialized_2") {

return CoinStatsHashType::HASH_SERIALIZED;

} else if (hash_type_input == "muhash") {

return CoinStatsHashType::MUHASH;

} else if (hash_type_input == "none") {

return CoinStatsHashType::NONE;

} else {

throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("'%s' is not a valid hash_type", hash_type_input));

}

{

return RPCHelpMan{"gettxoutsetinfo",

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

"Note this call may take some time if you are not using coinstatsindex.\n",

{

{"hash_type", RPCArg::Type::STR, RPCArg::Default{"hash_serialized_2"}, "Which UTXO set hash should be calculated. Options: 'hash_serialized_2' (the legacy algorithm), 'muhash', 'none'."},

{"hash_or_height", RPCArg::Type::NUM, RPCArg::Optional::OMITTED_NAMED_ARG, "The block hash or height of the target height (only available with coinstatsindex).", "", {"", "string or numeric"}},

{"use_index", RPCArg::Type::BOOL, RPCArg::Default{true}, "Use coinstatsindex, if available."},

},

RPCResult{

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

{

{RPCResult::Type::NUM, "height", "The block height (index) of the returned statistics"},

{RPCResult::Type::STR_HEX, "bestblock", "The hash of the block at which these statistics are calculated"},

{RPCResult::Type::NUM, "txouts", "The number of unspent transaction outputs"},

{RPCResult::Type::NUM, "bogosize", "Database-independent, meaningless metric indicating the UTXO set size"},

{RPCResult::Type::STR_HEX, "hash_serialized_2", /*optional=*/true, "The serialized hash (only present if 'hash_serialized_2' hash_type is chosen)"},

{RPCResult::Type::STR_HEX, "muhash", /*optional=*/true, "The serialized hash (only present if 'muhash' hash_type is chosen)"},

{RPCResult::Type::NUM, "transactions", /*optional=*/true, "The number of transactions with unspent outputs (not available when coinstatsindex is used)"},

{RPCResult::Type::NUM, "disk_size", /*optional=*/true, "The estimated size of the chainstate on disk (not available when coinstatsindex is used)"},

{RPCResult::Type::STR_AMOUNT, "total_amount", "The total amount of coins in the UTXO set"},

{RPCResult::Type::STR_AMOUNT, "total_unspendable_amount", /*optional=*/true, "The total amount of coins permanently excluded from the UTXO set (only available if coinstatsindex is used)"},

{RPCResult::Type::OBJ, "block_info", /*optional=*/true, "Info on amounts in the block at this block height (only available if coinstatsindex is used)",

{

{RPCResult::Type::STR_AMOUNT, "prevout_spent", "Total amount of all prevouts spent in this block"},

{RPCResult::Type::STR_AMOUNT, "coinbase", "Coinbase subsidy amount of this block"},

{RPCResult::Type::STR_AMOUNT, "new_outputs_ex_coinbase", "Total amount of new outputs created by this block"},

{RPCResult::Type::STR_AMOUNT, "unspendable", "Total amount of unspendable outputs created in this block"},

{RPCResult::Type::OBJ, "unspendables", "Detailed view of the unspendable categories",

{

{RPCResult::Type::STR_AMOUNT, "genesis_block", "The unspendable amount of the Genesis block subsidy"},

{RPCResult::Type::STR_AMOUNT, "bip30", "Transactions overridden by duplicates (no longer possible with BIP30)"},

{RPCResult::Type::STR_AMOUNT, "scripts", "Amounts sent to scripts that are unspendable (for example OP_RETURN outputs)"},

{RPCResult::Type::STR_AMOUNT, "unclaimed_rewards", "Fee rewards that miners did not claim in their coinbase transaction"},

}}

}},

}},

RPCExamples{

HelpExampleCli("gettxoutsetinfo", "") +

HelpExampleCli("gettxoutsetinfo", R"("none")") +

HelpExampleCli("gettxoutsetinfo", R"("none" 1000)") +

HelpExampleCli("gettxoutsetinfo", R"("none" '"00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09"')") +

HelpExampleRpc("gettxoutsetinfo", "") +

HelpExampleRpc("gettxoutsetinfo", R"("none")") +

HelpExampleRpc("gettxoutsetinfo", R"("none", 1000)") +

HelpExampleRpc("gettxoutsetinfo", R"("none", "00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09")")

},

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

{

UniValue ret(UniValue::VOBJ);

const CBlockIndex* pindex{nullptr};

const CoinStatsHashType hash_type{request.params[0].isNull() ? CoinStatsHashType::HASH_SERIALIZED : ParseHashType(request.params[0].get_str())};

CCoinsStats stats{hash_type};

stats.index_requested = request.params[2].isNull() || request.params[2].get_bool();

NodeContext& node = EnsureAnyNodeContext(request.context);

ChainstateManager& chainman = EnsureChainman(node);

CChainState& active_chainstate = chainman.ActiveChainstate();

active_chainstate.ForceFlushStateToDisk();

CCoinsView* coins_view;

BlockManager* blockman;

{

LOCK(::cs_main);

coins_view = &active_chainstate.CoinsDB();

blockman = &active_chainstate.m_blockman;

pindex = blockman->LookupBlockIndex(coins_view->GetBestBlock());

}

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

if (!g_coin_stats_index) {

throw JSONRPCError(RPC_INVALID_PARAMETER, "Querying specific block heights requires coinstatsindex");

}

if (stats.m_hash_type == CoinStatsHashType::HASH_SERIALIZED) {

throw JSONRPCError(RPC_INVALID_PARAMETER, "hash_serialized_2 hash type cannot be queried for a specific block");

}

pindex = ParseHashOrHeight(request.params[1], chainman);

}

if (stats.index_requested && g_coin_stats_index) {

if (!g_coin_stats_index->BlockUntilSyncedToCurrentChain()) {

const IndexSummary summary{g_coin_stats_index->GetSummary()};

// If a specific block was requested and the index has already synced past that height, we can return the

// data already even though the index is not fully synced yet.

if (pindex->nHeight > summary.best_block_height) {

throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf("Unable to get data because coinstatsindex is still syncing. Current height: %d", summary.best_block_height));

}

}

}

if (GetUTXOStats(coins_view, *blockman, stats, node.rpc_interruption_point, pindex)) {

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

ret.pushKV("bestblock", stats.hashBlock.GetHex());

ret.pushKV("txouts", (int64_t)stats.nTransactionOutputs);

ret.pushKV("bogosize", (int64_t)stats.nBogoSize);

if (hash_type == CoinStatsHashType::HASH_SERIALIZED) {

ret.pushKV("hash_serialized_2", stats.hashSerialized.GetHex());

}

if (hash_type == CoinStatsHashType::MUHASH) {

ret.pushKV("muhash", stats.hashSerialized.GetHex());

}

CHECK_NONFATAL(stats.total_amount.has_value());

ret.pushKV("total_amount", ValueFromAmount(stats.total_amount.value()));

if (!stats.index_used) {

ret.pushKV("transactions", static_cast<int64_t>(stats.nTransactions));

ret.pushKV("disk_size", stats.nDiskSize);

} else {

ret.pushKV("total_unspendable_amount", ValueFromAmount(stats.total_unspendable_amount));

CCoinsStats prev_stats{hash_type};

if (pindex->nHeight > 0) {

GetUTXOStats(coins_view, *blockman, prev_stats, node.rpc_interruption_point, pindex->pprev);

}

UniValue block_info(UniValue::VOBJ);

block_info.pushKV("prevout_spent", ValueFromAmount(stats.total_prevout_spent_amount - prev_stats.total_prevout_spent_amount));

block_info.pushKV("coinbase", ValueFromAmount(stats.total_coinbase_amount - prev_stats.total_coinbase_amount));

block_info.pushKV("new_outputs_ex_coinbase", ValueFromAmount(stats.total_new_outputs_ex_coinbase_amount - prev_stats.total_new_outputs_ex_coinbase_amount));

block_info.pushKV("unspendable", ValueFromAmount(stats.total_unspendable_amount - prev_stats.total_unspendable_amount));

UniValue unspendables(UniValue::VOBJ);

unspendables.pushKV("genesis_block", ValueFromAmount(stats.total_unspendables_genesis_block - prev_stats.total_unspendables_genesis_block));

unspendables.pushKV("bip30", ValueFromAmount(stats.total_unspendables_bip30 - prev_stats.total_unspendables_bip30));

unspendables.pushKV("scripts", ValueFromAmount(stats.total_unspendables_scripts - prev_stats.total_unspendables_scripts));

unspendables.pushKV("unclaimed_rewards", ValueFromAmount(stats.total_unspendables_unclaimed_rewards - prev_stats.total_unspendables_unclaimed_rewards));

block_info.pushKV("unspendables", unspendables);

ret.pushKV("block_info", block_info);

}

} else {

throw JSONRPCError(RPC_INTERNAL_ERROR, "Unable to read UTXO set");

}

return ret;

},

};

{

return RPCHelpMan{"gettxout",

"\nReturns details about an unspent transaction output.\n",

{

{"txid", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction id"},

{"n", RPCArg::Type::NUM, RPCArg::Optional::NO, "vout number"},

{"include_mempool", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether to include the mempool. Note that an unspent output that is spent in the mempool won't appear."},

},

{

RPCResult{"If the UTXO was not found", RPCResult::Type::NONE, "", ""},

RPCResult{"Otherwise", RPCResult::Type::OBJ, "", "", {

{RPCResult::Type::STR_HEX, "bestblock", "The hash of the block at the tip of the chain"},

{RPCResult::Type::NUM, "confirmations", "The number of confirmations"},

{RPCResult::Type::STR_AMOUNT, "value", "The transaction value in " + CURRENCY_UNIT},

{RPCResult::Type::OBJ, "scriptPubKey", "", {

{RPCResult::Type::STR, "asm", ""},

{RPCResult::Type::STR, "desc", "Inferred descriptor for the output"},

{RPCResult::Type::STR_HEX, "hex", ""},

{RPCResult::Type::STR, "type", "The type, eg pubkeyhash"},

{RPCResult::Type::STR, "address", /*optional=*/true, "The Bitcoin address (only if a well-defined address exists)"},

}},

{RPCResult::Type::BOOL, "coinbase", "Coinbase or not"},

}},

},

RPCExamples{

"\nGet unspent transactions\n"

+ HelpExampleCli("listunspent", "") +

"\nView the details\n"

+ HelpExampleCli("gettxout", "\"txid\" 1") +

"\nAs a JSON-RPC call\n"

+ HelpExampleRpc("gettxout", "\"txid\", 1")

},

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

{

NodeContext& node = EnsureAnyNodeContext(request.context);

ChainstateManager& chainman = EnsureChainman(node);

LOCK(cs_main);

UniValue ret(UniValue::VOBJ);

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

int n = request.params[1].get_int();

COutPoint out(hash, n);

bool fMempool = true;

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