// Copyright (c) 2010 Satoshi Nakamoto

// Copyright (c) 2009-present The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <rpc/blockchain.h>

#include <blockfilter.h>

#include <chain.h>

#include <chainparams.h>

#include <chainparamsbase.h>

#include <clientversion.h>

#include <coins.h>

#include <common/args.h>

#include <consensus/amount.h>

#include <consensus/params.h>

#include <consensus/validation.h>

#include <core_io.h>

#include <deploymentinfo.h>

#include <deploymentstatus.h>

#include <flatfile.h>

#include <hash.h>

#include <index/blockfilterindex.h>

#include <index/coinstatsindex.h>

#include <interfaces/mining.h>

#include <kernel/coinstats.h>

#include <logging/timer.h>

#include <net.h>

#include <net_processing.h>

#include <node/blockstorage.h>

#include <node/context.h>

#include <node/transaction.h>

#include <node/utxo_snapshot.h>

#include <node/warnings.h>

#include <primitives/transaction.h>

#include <rpc/server.h>

#include <rpc/server_util.h>

#include <rpc/util.h>

#include <script/descriptor.h>

#include <serialize.h>

#include <streams.h>

#include <sync.h>

#include <tinyformat.h>

#include <txdb.h>

#include <txmempool.h>

#include <undo.h>

#include <univalue.h>

#include <util/check.h>

#include <util/fs.h>

#include <util/strencodings.h>

#include <util/syserror.h>

#include <util/translation.h>

#include <validation.h>

#include <validationinterface.h>

#include <versionbits.h>

#include <cstdint>

#include <condition_variable>

#include <iterator>

#include <memory>

#include <mutex>

#include <optional>

#include <string>

#include <string_view>

#include <vector>

using kernel::CCoinsStats;

using kernel::CoinStatsHashType;

using interfaces::BlockRef;

using interfaces::Mining;

using node::BlockManager;

using node::NodeContext;

using node::SnapshotMetadata;

using util::MakeUnorderedList;

std::tuple<std::unique_ptr<CCoinsViewCursor>, CCoinsStats, const CBlockIndex*>

PrepareUTXOSnapshot(

    Chainstate& chainstate,

    const std::function<void()>& interruption_point = {})

    EXCLUSIVE_LOCKS_REQUIRED(::cs_main);

UniValue WriteUTXOSnapshot(

    Chainstate& chainstate,

    CCoinsViewCursor* pcursor,

    CCoinsStats* maybe_stats,

    const CBlockIndex* tip,

    AutoFile&& afile,

    const fs::path& path,

    const fs::path& temppath,

    const std::function<void()>& interruption_point = {});

UniValue CreateRolledBackUTXOSnapshot(

    NodeContext& node,

    Chainstate& chainstate,

    const CBlockIndex* target,

    AutoFile&& afile,

    const fs::path& path,

    const fs::path& tmppath,

    bool in_memory);

/* Calculate the difficulty for a given block index.

 */

double GetDifficulty(const CBlockIndex& 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;

}

static int ComputeNextBlockAndDepth(const CBlockIndex& tip, const CBlockIndex& blockindex, const CBlockIndex*& next)

{

    next = tip.GetAncestor(blockindex.nHeight + 1);

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

        return tip.nHeight - blockindex.nHeight + 1;

    }

    next = nullptr;

    return &blockindex == &tip ? 1 : -1;

}

static const CBlockIndex* ParseHashOrHeight(const UniValue& param, ChainstateManager& chainman)

{

    LOCK(::cs_main);

    CChain& active_chain = chainman.ActiveChain();

    if (param.isNum()) {

        const int height{param.getInt<int>()};

        if (height < 0) {

            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d is negative", height));

        }

        const int current_tip{active_chain.Height()};

        if (height > current_tip) {

            throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Target block height %d after current tip %d", height, current_tip));

        }

        return active_chain[height];

    } else {

        const uint256 hash{ParseHashV(param, "hash_or_height")};

        const CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(hash);

        if (!pindex) {

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

        }

        return pindex;

    }

}

UniValue blockheaderToJSON(const CBlockIndex& tip, const CBlockIndex& blockindex, const uint256 pow_limit)

{

    // 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", blockindex.nTime);

    result.pushKV("mediantime", blockindex.GetMedianTimePast());

    result.pushKV("nonce", blockindex.nNonce);

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

    result.pushKV("target", GetTarget(blockindex, pow_limit).GetHex());

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

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

    result.pushKV("nTx", blockindex.nTx);

    if (blockindex.pprev)

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

    if (pnext)

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

    return result;

}

/** Serialize coinbase transaction metadata */

UniValue coinbaseTxToJSON(const CTransaction& coinbase_tx)

{

    CHECK_NONFATAL(!coinbase_tx.vin.empty());

    const CTxIn& vin_0{coinbase_tx.vin[0]};

    UniValue coinbase_tx_obj(UniValue::VOBJ);

    coinbase_tx_obj.pushKV("version", coinbase_tx.version);

    coinbase_tx_obj.pushKV("locktime", coinbase_tx.nLockTime);

    coinbase_tx_obj.pushKV("sequence", vin_0.nSequence);

    coinbase_tx_obj.pushKV("coinbase", HexStr(vin_0.scriptSig));

    const auto& witness_stack{vin_0.scriptWitness.stack};

    if (!witness_stack.empty()) {

        CHECK_NONFATAL(witness_stack.size() == 1);

        coinbase_tx_obj.pushKV("witness", HexStr(witness_stack[0]));

    }

    return coinbase_tx_obj;

}

UniValue blockToJSON(BlockManager& blockman, const CBlock& block, const CBlockIndex& tip, const CBlockIndex& blockindex, TxVerbosity verbosity, const uint256 pow_limit)

{

    UniValue result = blockheaderToJSON(tip, blockindex, pow_limit);

    result.pushKV("strippedsize", ::GetSerializeSize(TX_NO_WITNESS(block)));

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

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

    CHECK_NONFATAL(!block.vtx.empty());

    result.pushKV("coinbase_tx", coinbaseTxToJSON(*block.vtx[0]));

    UniValue txs(UniValue::VARR);

    txs.reserve(block.vtx.size());

    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 is_not_pruned{WITH_LOCK(::cs_main, return !blockman.IsBlockPruned(blockindex))};

            bool have_undo{is_not_pruned && WITH_LOCK(::cs_main, return blockindex.nStatus & BLOCK_HAVE_UNDO)};

            if (have_undo && !blockman.ReadBlockUndo(blockUndo, blockindex)) {

                throw JSONRPCError(RPC_INTERNAL_ERROR, "Undo data expected but can't be read. This could be due to disk corruption or a conflict with a pruning event.");

            }

            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, txundo, verbosity);

                txs.push_back(std::move(objTx));

            }

            break;

    }

    result.pushKV("tx", std::move(txs));

    return result;

}

static RPCMethod getblockcount()

{

    return RPCMethod{

        "getblockcount",

        "Returns 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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    ChainstateManager& chainman = EnsureAnyChainman(request.context);

    LOCK(cs_main);

    return chainman.ActiveChain().Height();

},

    };

}

static RPCMethod getbestblockhash()

{

    return RPCMethod{

        "getbestblockhash",

        "Returns 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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    ChainstateManager& chainman = EnsureAnyChainman(request.context);

    LOCK(cs_main);

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

},

    };

}

static RPCMethod waitfornewblock()

{

    return RPCMethod{

        "waitfornewblock",

        "Waits for any new block and returns useful info about it.\n"

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

                "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",

                {

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

                    {"current_tip", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "Method waits for the chain tip to differ from this."},

                },

                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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    int timeout = 0;

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

        timeout = request.params[0].getInt<int>();

    if (timeout < 0) throw JSONRPCError(RPC_MISC_ERROR, "Negative timeout");

    NodeContext& node = EnsureAnyNodeContext(request.context);

    Mining& miner = EnsureMining(node);

    // If the caller provided a current_tip value, pass it to waitTipChanged().

    //

    // If the caller did not provide a current tip hash, call getTip() to get

    // one and wait for the tip to be different from this value. This mode is

    // less reliable because if the tip changed between waitfornewblock calls,

    // it will need to change a second time before this call returns.

    BlockRef current_block{CHECK_NONFATAL(miner.getTip()).value()};

    uint256 tip_hash{request.params[1].isNull()

        ? current_block.hash

        : ParseHashV(request.params[1], "current_tip")};

    // If the user provided an invalid current_tip then this call immediately

    // returns the current tip.

    std::optional<BlockRef> block = timeout ? miner.waitTipChanged(tip_hash, std::chrono::milliseconds(timeout)) :

                                              miner.waitTipChanged(tip_hash);

    // Return current block upon shutdown

    if (block) current_block = *block;

    UniValue ret(UniValue::VOBJ);

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

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

    return ret;

},

    };

}

static RPCMethod waitforblock()

{

    return RPCMethod{

        "waitforblock",

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

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

                "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",

                {

                    {"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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    int timeout = 0;

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

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

        timeout = request.params[1].getInt<int>();

    if (timeout < 0) throw JSONRPCError(RPC_MISC_ERROR, "Negative timeout");

    NodeContext& node = EnsureAnyNodeContext(request.context);

    Mining& miner = EnsureMining(node);

    // Abort if RPC came out of warmup too early

    BlockRef current_block{CHECK_NONFATAL(miner.getTip()).value()};

    const auto deadline{std::chrono::steady_clock::now() + 1ms * timeout};

    while (current_block.hash != hash) {

        std::optional<BlockRef> block;

        if (timeout) {

            auto now{std::chrono::steady_clock::now()};

            if (now >= deadline) break;

            const MillisecondsDouble remaining{deadline - now};

            block = miner.waitTipChanged(current_block.hash, remaining);

        } else {

            block = miner.waitTipChanged(current_block.hash);

        }

        // Return current block upon shutdown

        if (!block) break;

        current_block = *block;

    }

    UniValue ret(UniValue::VOBJ);

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

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

    return ret;

},

    };

}

static RPCMethod waitforblockheight()

{

    return RPCMethod{

        "waitforblockheight",

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

                "\nMake sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",

                {

                    {"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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    int timeout = 0;

    int height = request.params[0].getInt<int>();

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

        timeout = request.params[1].getInt<int>();

    if (timeout < 0) throw JSONRPCError(RPC_MISC_ERROR, "Negative timeout");

    NodeContext& node = EnsureAnyNodeContext(request.context);

    Mining& miner = EnsureMining(node);

    // Abort if RPC came out of warmup too early

    BlockRef current_block{CHECK_NONFATAL(miner.getTip()).value()};

    const auto deadline{std::chrono::steady_clock::now() + 1ms * timeout};

    while (current_block.height < height) {

        std::optional<BlockRef> block;

        if (timeout) {

            auto now{std::chrono::steady_clock::now()};

            if (now >= deadline) break;

            const MillisecondsDouble remaining{deadline - now};

            block = miner.waitTipChanged(current_block.hash, remaining);

        } else {

            block = miner.waitTipChanged(current_block.hash);

        }

        // Return current block on shutdown

        if (!block) break;

        current_block = *block;

    }

    UniValue ret(UniValue::VOBJ);

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

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

    return ret;

},

    };

}

static RPCMethod syncwithvalidationinterfacequeue()

{

    return RPCMethod{

        "syncwithvalidationinterfacequeue",

        "Waits 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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    NodeContext& node = EnsureAnyNodeContext(request.context);

    CHECK_NONFATAL(node.validation_signals)->SyncWithValidationInterfaceQueue();

    return UniValue::VNULL;

},

    };

}

static RPCMethod getdifficulty()

{

    return RPCMethod{

        "getdifficulty",

        "Returns 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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    ChainstateManager& chainman = EnsureAnyChainman(request.context);

    LOCK(cs_main);

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

},

    };

}

static RPCMethod getblockfrompeer()

{

    return RPCMethod{

        "getblockfrompeer",

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

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

        "The block will not have any undo data which can limit the usage of the block data in a context where the undo data is needed.\n"

        "Subsequent calls for the same block may cause the response from the previous peer to be ignored.\n"

        "Peers generally ignore requests for a stale block that they never fully verified, or one that is more than a month old.\n"

        "When a peer does not respond with a block, we will disconnect.\n"

        "Note: The block could be re-pruned as soon as it is received.\n\n"

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

        {

            {"blockhash", 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 RPCMethod& 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], "blockhash")};

    const NodeId peer_id{request.params[1].getInt<int64_t>()};

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

    }

    // Fetching blocks before the node has syncing past their height can prevent block files from

    // being pruned, so we avoid it if the node is in prune mode.

    if (chainman.m_blockman.IsPruneMode() && index->nHeight > WITH_LOCK(chainman.GetMutex(), return chainman.ActiveTip()->nHeight)) {

        throw JSONRPCError(RPC_MISC_ERROR, "In prune mode, only blocks that the node has already synced previously can be fetched from a peer");

    }

    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 res{peerman.FetchBlock(peer_id, *index)}; !res) {

        throw JSONRPCError(RPC_MISC_ERROR, res.error());

    }

    return UniValue::VOBJ;

},

    };

}

static RPCMethod getblockhash()

{

    return RPCMethod{

        "getblockhash",

        "Returns 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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    ChainstateManager& chainman = EnsureAnyChainman(request.context);

    LOCK(cs_main);

    const CChain& active_chain = chainman.ActiveChain();

    int nHeight = request.params[0].getInt<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();

},

    };

}

static RPCMethod getblockheader()

{

    return RPCMethod{

        "getblockheader",

        "If 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", "nBits: compact representation of the block difficulty target"},

                            {RPCResult::Type::STR_HEX, "target", "The difficulty target"},

                            {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 RPCMethod& 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)

    {

        DataStream ssBlock{};

        ssBlock << pblockindex->GetBlockHeader();

        std::string strHex = HexStr(ssBlock);

        return strHex;

    }

    return blockheaderToJSON(*tip, *pblockindex, chainman.GetConsensus().powLimit);

},

    };

}

void CheckBlockDataAvailability(BlockManager& blockman, const CBlockIndex& blockindex, bool check_for_undo)

{

    AssertLockHeld(cs_main);

    uint32_t flag = check_for_undo ? BLOCK_HAVE_UNDO : BLOCK_HAVE_DATA;

    if (!(blockindex.nStatus & flag)) {

        if (blockman.IsBlockPruned(blockindex)) {

            throw JSONRPCError(RPC_MISC_ERROR, strprintf("%s not available (pruned data)", check_for_undo ? "Undo data" : "Block"));

        }

        if (check_for_undo) {

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

        }

        throw JSONRPCError(RPC_MISC_ERROR, "Block not available (not fully downloaded)");

    }

}

static CBlock GetBlockChecked(BlockManager& blockman, const CBlockIndex& blockindex)

{

    CBlock block;

    {

        LOCK(cs_main);

        CheckBlockDataAvailability(blockman, blockindex, /*check_for_undo=*/false);

    }

    if (!blockman.ReadBlock(block, blockindex)) {

        // Block not found on disk. This shouldn't normally happen unless the block was

        // pruned right after we released the lock above.

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

    }

    return block;

}

static std::vector<std::byte> GetRawBlockChecked(BlockManager& blockman, const CBlockIndex& blockindex)

{

    FlatFilePos pos{};

    {

        LOCK(cs_main);

        CheckBlockDataAvailability(blockman, blockindex, /*check_for_undo=*/false);

        pos = blockindex.GetBlockPos();

    }

    if (auto data{blockman.ReadRawBlock(pos)}) return std::move(*data);

    // Block not found on disk. This shouldn't normally happen unless the block was

    // pruned right after we released the lock above.

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

}

static CBlockUndo GetUndoChecked(BlockManager& blockman, const CBlockIndex& blockindex)

{

    CBlockUndo blockUndo;

    // The Genesis block does not have undo data

    if (blockindex.nHeight == 0) return blockUndo;

    {

        LOCK(cs_main);

        CheckBlockDataAvailability(blockman, blockindex, /*check_for_undo=*/true);

    }

    if (!blockman.ReadBlockUndo(blockUndo, blockindex)) {

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

    }

    return blockUndo;

}

const RPCResult& GetBlockVin()

{

    static const RPCResult getblock_vin{

        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::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},

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

                    {

                        {RPCResult::Type::STR, "asm", "Disassembly of the output script"},

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

                        {RPCResult::Type::STR_HEX, "hex", "The raw output script bytes, hex-encoded"},

                        {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() + ")"},

                    }},

                }},

            }},

        }

    };

    return getblock_vin;

}

static RPCMethod getblock()

{

    return RPCMethod{

        "getblock",

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

                     RPCArgOptions{.skip_type_check = true}},

                },

                {

                    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::OBJ, "coinbase_tx", "Coinbase transaction metadata",

                    {

                        {RPCResult::Type::NUM, "version", "The coinbase transaction version"},

                        {RPCResult::Type::NUM, "locktime", "The coinbase transaction's locktime (nLockTime)"},

                        {RPCResult::Type::NUM, "sequence", "The coinbase input's sequence number (nSequence)"},

                        {RPCResult::Type::STR_HEX, "coinbase", "The coinbase input's script"},

                        {RPCResult::Type::STR_HEX, "witness", /*optional=*/true, "The coinbase input's first (and only) witness stack element, if present"},

                    }},

                    {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", "nBits: compact representation of the block difficulty target"},

                    {RPCResult::Type::STR_HEX, "target", "The difficulty target"},

                    {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", /*optional=*/true, "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, "", "",

                        {

                            GetBlockVin(),

                        }},

                    }},

                }},

        },

                RPCExamples{

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

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

                },

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

{

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

    int verbosity{ParseVerbosity(request.params[1], /*default_verbosity=*/1, /*allow_bool=*/true)};

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

        }

    }

    const std::vector<std::byte> block_data{GetRawBlockChecked(chainman.m_blockman, *pblockindex)};

    if (verbosity <= 0) {

        return HexStr(block_data);

    }

    CBlock block{};

    SpanReader{block_data} >> TX_WITH_WITNESS(block);

    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(chainman.m_blockman, block, *tip, *pblockindex, tx_verbosity, chainman.GetConsensus().powLimit);

},

    };

}

//! Return height of highest block that has been pruned, or std::nullopt if no blocks have been pruned

std::optional<int> GetPruneHeight(const BlockManager& blockman, const CChain& chain) {

    AssertLockHeld(::cs_main);

    // Search for the last block missing block data or undo data. Don't let the

    // search consider the genesis block, because the genesis block does not

    // have undo data, but should not be considered pruned.

    const CBlockIndex* first_block{chain[1]};

    const CBlockIndex* chain_tip{chain.Tip()};

    // If there are no blocks after the genesis block, or no blocks at all, nothing is pruned.

    if (!first_block || !chain_tip) return std::nullopt;

    // If the chain tip is pruned, everything is pruned.

    if ((chain_tip->nStatus & BLOCK_HAVE_MASK) != BLOCK_HAVE_MASK) return chain_tip->nHeight;

    const auto& first_unpruned{blockman.GetFirstBlock(*chain_tip, /*status_mask=*/BLOCK_HAVE_MASK, first_block)};

    if (&first_unpruned == first_block) {

        // All blocks between first_block and chain_tip have data, so nothing is pruned.

        return std::nullopt;

    }

    // Block before the first unpruned block is the last pruned block.

    return CHECK_NONFATAL(first_unpruned.pprev)->nHeight;

}

static RPCMethod pruneblockchain()

{

    return RPCMethod{"pruneblockchain",

                "Attempts to delete block and undo data up to a specified height or timestamp, if eligible for pruning.\n"

                "Requires `-prune` to be enabled at startup. While pruned data may be re-fetched in some cases (e.g., via `getblockfrompeer`), local deletion is irreversible.\n",

                {

                    {"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 RPCMethod& self, const JSONRPCRequest& request) -> UniValue

{

    ChainstateManager& chainman = EnsureAnyChainman(request.context);

    if (!chainman.m_blockman.IsPruneMode()) {

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

    }

    LOCK(cs_main);

    Chainstate& active_chainstate = chainman.ActiveChainstate();

    CChain& active_chain = active_chainstate.m_chain;

    int heightParam = request.params[0].getInt<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 < chainman.GetParams().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) {

        LogDebug(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);

    return GetPruneHeight(chainman.m_blockman, active_chain).value_or(-1);

},

    };

}

CoinStatsHashType ParseHashType(std::string_view hash_type_input)

{

    if (hash_type_input == "hash_serialized_3") {

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

    }

}

/**

 * Calculate statistics about the unspent transaction output set

 *

 * @param[in] index_requested Signals if the coinstatsindex should be used (when available).

 */

static std::optional<kernel::CCoinsStats> GetUTXOStats(CCoinsView* view, node::BlockManager& blockman,

                                                       kernel::CoinStatsHashType hash_type,

                                                       const std::function<void()>& interruption_point = {},

                                                       const CBlockIndex* pindex = nullptr,

                                                       bool index_requested = true)

{