Blockchain information through RPC

1251        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1252{
1253    NodeContext& node = EnsureAnyNodeContext(request.context);
1254    ChainstateManager& chainman = EnsureChainman(node);
1255    LOCK(cs_main);
1256
1257    UniValue ret(UniValue::VOBJ);
1258
1259    auto hash{Txid::FromUint256(ParseHashV(request.params[0], "txid"))};
1260    COutPoint out{hash, request.params[1].getInt<uint32_t>()};
1261    bool fMempool = true;
1262    if (!request.params[2].isNull())
1263        fMempool = request.params[2].get_bool();
1264
1265    Chainstate& active_chainstate = chainman.ActiveChainstate();
1266    CCoinsViewCache* coins_view = &active_chainstate.CoinsTip();
1267
1268    std::optional<Coin> coin;
1269    if (fMempool) {
1270        const CTxMemPool& mempool = EnsureMemPool(node);
1271        LOCK(mempool.cs);
1272        CCoinsViewMemPool view(coins_view, mempool);
1273        if (!mempool.isSpent(out)) coin = view.GetCoin(out);
1274    } else {
1275        coin = coins_view->GetCoin(out);
1276    }
1277    if (!coin) return UniValue::VNULL;
1278
1279    const CBlockIndex* pindex = active_chainstate.m_blockman.LookupBlockIndex(coins_view->GetBestBlock());
1280    ret.pushKV("bestblock", pindex->GetBlockHash().GetHex());
1281    if (coin->nHeight == MEMPOOL_HEIGHT) {
1282        ret.pushKV("confirmations", 0);
1283    } else {
1284        ret.pushKV("confirmations", pindex->nHeight - coin->nHeight + 1);
1285    }
1286    ret.pushKV("value", ValueFromAmount(coin->out.nValue));
1287    UniValue o(UniValue::VOBJ);
1288    ScriptToUniv(coin->out.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
1289    ret.pushKV("scriptPubKey", std::move(o));
1290    ret.pushKV("coinbase", coin->IsCoinBase());
1291
1292    return ret;
1293},
1294    };
1295}
1296
1297static RPCMethod verifychain()
1298{
1299    return RPCMethod{
1300        "verifychain",
1301        "Verifies blockchain database.\n",
1302                {
1303                    {"checklevel", RPCArg::Type::NUM, RPCArg::DefaultHint{strprintf("%d, range=0-4", DEFAULT_CHECKLEVEL)},
1304                        strprintf("How thorough the block verification is:\n%s", MakeUnorderedList(CHECKLEVEL_DOC))},
1305                    {"nblocks", RPCArg::Type::NUM, RPCArg::DefaultHint{strprintf("%d, 0=all", DEFAULT_CHECKBLOCKS)}, "The number of blocks to check."},
1306                },
1307                RPCResult{
1308                    RPCResult::Type::BOOL, "", "Verification finished successfully. If false, check debug log for reason."},
1309                RPCExamples{
1310                    HelpExampleCli("verifychain", "")
1311            + HelpExampleRpc("verifychain", "")
1312                },
1313        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1314{
1315    const int check_level{request.params[0].isNull() ? DEFAULT_CHECKLEVEL : request.params[0].getInt<int>()};
1316    const int check_depth{request.params[1].isNull() ? DEFAULT_CHECKBLOCKS : request.params[1].getInt<int>()};
1317
1318    ChainstateManager& chainman = EnsureAnyChainman(request.context);
1319    LOCK(cs_main);
1320
1321    Chainstate& active_chainstate = chainman.ActiveChainstate();
1322    return CVerifyDB(chainman.GetNotifications()).VerifyDB(
1323               active_chainstate, chainman.GetParams().GetConsensus(), active_chainstate.CoinsTip(), check_level, check_depth) == VerifyDBResult::SUCCESS;
1324},
1325    };
1326}
1327
1328static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman, Consensus::BuriedDeployment dep)
1329{
1330    // For buried deployments.
1331
1332    if (!DeploymentEnabled(chainman, dep)) return;
1333
1334    UniValue rv(UniValue::VOBJ);
1335    rv.pushKV("type", "buried");
1336    // getdeploymentinfo reports the softfork as active from when the chain height is
1337    // one below the activation height
1338    rv.pushKV("active", DeploymentActiveAfter(blockindex, chainman, dep));
1339    rv.pushKV("height", chainman.GetConsensus().DeploymentHeight(dep));
1340    softforks.pushKV(DeploymentName(dep), std::move(rv));
1341}
1342
1343static void SoftForkDescPushBack(const CBlockIndex* blockindex, UniValue& softforks, const ChainstateManager& chainman, Consensus::DeploymentPos id)
1344{
1345    // For BIP9 deployments.
1346    if (!DeploymentEnabled(chainman, id)) return;
1347    if (blockindex == nullptr) return;
1348
1349    UniValue bip9(UniValue::VOBJ);
1350    BIP9Info info{chainman.m_versionbitscache.Info(*blockindex, chainman.GetConsensus(), id)};
1351    const auto& depparams{chainman.GetConsensus().vDeployments[id]};
1352
1353    // BIP9 parameters
1354    if (info.stats.has_value()) {
1355        bip9.pushKV("bit", depparams.bit);
1356    }
1357    bip9.pushKV("start_time", depparams.nStartTime);
1358    bip9.pushKV("timeout", depparams.nTimeout);
1359    bip9.pushKV("min_activation_height", depparams.min_activation_height);
1360
1361    // BIP9 status
1362    bip9.pushKV("status", info.current_state);
1363    bip9.pushKV("since", info.since);
1364    bip9.pushKV("status_next", info.next_state);
1365
1366    // BIP9 signalling status, if applicable
1367    if (info.stats.has_value()) {
1368        UniValue statsUV(UniValue::VOBJ);
1369        statsUV.pushKV("period", info.stats->period);
1370        statsUV.pushKV("elapsed", info.stats->elapsed);
1371        statsUV.pushKV("count", info.stats->count);
1372        if (info.stats->threshold > 0 || info.stats->possible) {
1373            statsUV.pushKV("threshold", info.stats->threshold);
1374            statsUV.pushKV("possible", info.stats->possible);
1375        }
1376        bip9.pushKV("statistics", std::move(statsUV));
1377
1378        std::string sig;
1379        sig.reserve(info.signalling_blocks.size());
1380        for (const bool s : info.signalling_blocks) {
1381            sig.push_back(s ? '#' : '-');
1382        }
1383        bip9.pushKV("signalling", sig);
1384    }
1385
1386    UniValue rv(UniValue::VOBJ);
1387    rv.pushKV("type", "bip9");
1388    bool is_active = false;
1389    if (info.active_since.has_value()) {
1390        rv.pushKV("height", *info.active_since);
1391        is_active = (*info.active_since <= blockindex->nHeight + 1);
1392    }
1393    rv.pushKV("active", is_active);
1394    rv.pushKV("bip9", bip9);
1395    softforks.pushKV(DeploymentName(id), std::move(rv));
1396}
1397
1398// used by rest.cpp:rest_chaininfo, so cannot be static
1399RPCMethod getblockchaininfo()
1400{
1401    return RPCMethod{"getblockchaininfo",
1402        "Returns an object containing various state info regarding blockchain processing.\n",
1403        {},
1404        RPCResult{
1405            RPCResult::Type::OBJ, "", "",
1406            {
1407                {RPCResult::Type::STR, "chain", "current network name (" LIST_CHAIN_NAMES ")"},
1408                {RPCResult::Type::NUM, "blocks", "the height of the most-work fully-validated chain. The genesis block has height 0"},
1409                {RPCResult::Type::NUM, "headers", "the current number of headers we have validated"},
1410                {RPCResult::Type::STR, "bestblockhash", "the hash of the currently best block"},
1411                {RPCResult::Type::STR_HEX, "bits", "nBits: compact representation of the block difficulty target"},
1412                {RPCResult::Type::STR_HEX, "target", "the difficulty target"},
1413                {RPCResult::Type::NUM, "difficulty", "the current difficulty"},
1414                {RPCResult::Type::NUM_TIME, "time", "the block time expressed in " + UNIX_EPOCH_TIME},
1415                {RPCResult::Type::NUM_TIME, "mediantime", "the median block time expressed in " + UNIX_EPOCH_TIME},
1416                {RPCResult::Type::NUM, "verificationprogress", "estimate of verification progress [0..1]"},
1417                {RPCResult::Type::BOOL, "initialblockdownload", "(debug information) estimate of whether this node is in Initial Block Download mode"},
1418                {RPCResult::Type::OBJ, "backgroundvalidation", /*optional=*/true, "state info regarding background validation process",
1419                {
1420                    {RPCResult::Type::NUM, "snapshotheight", "the height of the snapshot block. Background validation verifies the chain from genesis up to this height"},
1421                    {RPCResult::Type::NUM, "blocks", "the height of the most-work background fully-validated chain. The genesis block has height 0"},
1422                    {RPCResult::Type::STR, "bestblockhash", "the hash of the currently best block validated in the background"},
1423                    {RPCResult::Type::NUM_TIME, "mediantime", "the median block time expressed in " + UNIX_EPOCH_TIME},
1424                    {RPCResult::Type::NUM, "verificationprogress", "estimate of background verification progress [0..1]"},
1425                    {RPCResult::Type::STR_HEX, "chainwork", "total amount of work in background validated chain, in hexadecimal"},
1426                }},
1427                {RPCResult::Type::STR_HEX, "chainwork", "total amount of work in active chain, in hexadecimal"},
1428                {RPCResult::Type::NUM, "size_on_disk", "the estimated size of the block and undo files on disk"},
1429                {RPCResult::Type::BOOL, "pruned", "if the blocks are subject to pruning"},
1430                {RPCResult::Type::NUM, "pruneheight", /*optional=*/true, "the first block unpruned, all previous blocks were pruned (only present if pruning is enabled)"},
1431                {RPCResult::Type::BOOL, "automatic_pruning", /*optional=*/true, "whether automatic pruning is enabled (only present if pruning is enabled)"},
1432                {RPCResult::Type::NUM, "prune_target_size", /*optional=*/true, "the target size used by pruning (only present if automatic pruning is enabled)"},
1433                {RPCResult::Type::STR_HEX, "signet_challenge", /*optional=*/true, "the block challenge (aka. block script), in hexadecimal (only present if the current network is a signet)"},
1434                (IsDeprecatedRPCEnabled("warnings") ?
1435                    RPCResult{RPCResult::Type::STR, "warnings", "any network and blockchain warnings (DEPRECATED)"} :
1436                    RPCResult{RPCResult::Type::ARR, "warnings", "any network and blockchain warnings (run with `-deprecatedrpc=warnings` to return the latest warning as a single string)",
1437                    {
1438                        {RPCResult::Type::STR, "", "warning"},
1439                    }
1440                    }
1441                ),
1442            }},
1443        RPCExamples{
1444            HelpExampleCli("getblockchaininfo", "")
1445            + HelpExampleRpc("getblockchaininfo", "")
1446        },
1447        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1448{
1449    ChainstateManager& chainman = EnsureAnyChainman(request.context);
1450    LOCK(cs_main);
1451    Chainstate& active_chainstate = chainman.ActiveChainstate();
1452
1453    const CBlockIndex& tip{*CHECK_NONFATAL(active_chainstate.m_chain.Tip())};
1454    const int height{tip.nHeight};
1455    UniValue obj(UniValue::VOBJ);
1456    obj.pushKV("chain", chainman.GetParams().GetChainTypeString());
1457    obj.pushKV("blocks", height);
1458    obj.pushKV("headers", chainman.m_best_header ? chainman.m_best_header->nHeight : -1);
1459    obj.pushKV("bestblockhash", tip.GetBlockHash().GetHex());
1460    obj.pushKV("bits", strprintf("%08x", tip.nBits));
1461    obj.pushKV("target", GetTarget(tip, chainman.GetConsensus().powLimit).GetHex());
1462    obj.pushKV("difficulty", GetDifficulty(tip));
1463    obj.pushKV("time", tip.GetBlockTime());
1464    obj.pushKV("mediantime", tip.GetMedianTimePast());
1465    obj.pushKV("verificationprogress", chainman.GuessVerificationProgress(&tip));
1466    obj.pushKV("initialblockdownload", chainman.IsInitialBlockDownload());
1467    auto historical_blocks{chainman.GetHistoricalBlockRange()};
1468    if (historical_blocks) {
1469        UniValue background_validation(UniValue::VOBJ);
1470        const CBlockIndex& btip{*CHECK_NONFATAL(historical_blocks->first)};
1471        const CBlockIndex& btarget{*CHECK_NONFATAL(historical_blocks->second)};
1472        background_validation.pushKV("snapshotheight", btarget.nHeight);
1473        background_validation.pushKV("blocks", btip.nHeight);
1474        background_validation.pushKV("bestblockhash", btip.GetBlockHash().GetHex());
1475        background_validation.pushKV("mediantime", btip.GetMedianTimePast());
1476        background_validation.pushKV("chainwork", btip.nChainWork.GetHex());
1477        background_validation.pushKV("verificationprogress", chainman.GetBackgroundVerificationProgress(btip));
1478        obj.pushKV("backgroundvalidation", std::move(background_validation));
1479    }
1480    obj.pushKV("chainwork", tip.nChainWork.GetHex());
1481    obj.pushKV("size_on_disk", chainman.m_blockman.CalculateCurrentUsage());
1482    obj.pushKV("pruned", chainman.m_blockman.IsPruneMode());
1483    if (chainman.m_blockman.IsPruneMode()) {
1484        const auto prune_height{GetPruneHeight(chainman.m_blockman, active_chainstate.m_chain)};
1485        obj.pushKV("pruneheight", prune_height ? prune_height.value() + 1 : 0);
1486
1487        const bool automatic_pruning{chainman.m_blockman.GetPruneTarget() != BlockManager::PRUNE_TARGET_MANUAL};
1488        obj.pushKV("automatic_pruning",  automatic_pruning);
1489        if (automatic_pruning) {
1490            obj.pushKV("prune_target_size", chainman.m_blockman.GetPruneTarget());
1491        }
1492    }
1493    if (chainman.GetParams().GetChainType() == ChainType::SIGNET) {
1494        const std::vector<uint8_t>& signet_challenge =
1495            chainman.GetParams().GetConsensus().signet_challenge;
1496        obj.pushKV("signet_challenge", HexStr(signet_challenge));
1497    }
1498
1499    NodeContext& node = EnsureAnyNodeContext(request.context);
1500    obj.pushKV("warnings", node::GetWarningsForRpc(*CHECK_NONFATAL(node.warnings), IsDeprecatedRPCEnabled("warnings")));