Blockchain information through RPC

2751        ret.pushKV("relevant_blocks", std::move(blocks));
2752        ret.pushKV("completed", completed);
2753    } else {
2754        throw JSONRPCError(RPC_INVALID_PARAMETER, tfm::format("Invalid action '%s'", action));
2755    }
2756    return ret;
2757},
2758    };
2759}
2760
2761static RPCMethod getdescriptoractivity()
2762{
2763    return RPCMethod{
2764        "getdescriptoractivity",
2765        "Get spend and receive activity associated with a set of descriptors for a set of blocks. "
2766        "This command pairs well with the `relevant_blocks` output of `scanblocks()`.\n"
2767        "This call may take several minutes. If you encounter timeouts, try specifying no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
2768        {
2769            RPCArg{"blockhashes", RPCArg::Type::ARR, RPCArg::Optional::NO, "The list of blockhashes to examine for activity. Order doesn't matter. Must be along main chain or an error is thrown.\n", {
2770                {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A valid blockhash"},
2771            }},
2772            RPCArg{"scanobjects", RPCArg::Type::ARR, RPCArg::Optional::NO, "The list of descriptors (scan objects) to examine for activity. Every scan object is either a string descriptor or an object:",
2773                {
2774                    {"descriptor", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "An output descriptor"},
2775                    output_descriptor_obj,
2776                },
2777                RPCArgOptions{.oneline_description="[scanobjects,...]"},
2778            },
2779            {"include_mempool", RPCArg::Type::BOOL, RPCArg::Default{true}, "Whether to include unconfirmed activity"},
2780        },
2781        RPCResult{
2782            RPCResult::Type::OBJ, "", "", {
2783                {RPCResult::Type::ARR, "activity", "events", {
2784                    {RPCResult::Type::OBJ, "", "", {
2785                        {RPCResult::Type::STR, "type", "always 'spend'"},
2786                        {RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " of the spent output"},
2787                        {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "The blockhash this spend appears in (omitted if unconfirmed)"},
2788                        {RPCResult::Type::NUM, "height", /*optional=*/true, "Height of the spend (omitted if unconfirmed)"},
2789                        {RPCResult::Type::STR_HEX, "spend_txid", "The txid of the spending transaction"},
2790                        {RPCResult::Type::NUM, "spend_vin", "The input index of the spend"},
2791                        {RPCResult::Type::STR_HEX, "prevout_txid", "The txid of the prevout"},
2792                        {RPCResult::Type::NUM, "prevout_vout", "The vout of the prevout"},
2793                        {RPCResult::Type::OBJ, "prevout_spk", "", ScriptPubKeyDoc()},
2794                    }},
2795                    {RPCResult::Type::OBJ, "", "", {
2796                        {RPCResult::Type::STR, "type", "always 'receive'"},
2797                        {RPCResult::Type::STR_AMOUNT, "amount", "The total amount in " + CURRENCY_UNIT + " of the new output"},
2798                        {RPCResult::Type::STR_HEX, "blockhash", /*optional=*/true, "The block that this receive is in (omitted if unconfirmed)"},
2799                        {RPCResult::Type::NUM, "height", /*optional=*/true, "The height of the receive (omitted if unconfirmed)"},
2800                        {RPCResult::Type::STR_HEX, "txid", "The txid of the receiving transaction"},
2801                        {RPCResult::Type::NUM, "vout", "The vout of the receiving output"},
2802                        {RPCResult::Type::OBJ, "output_spk", "", ScriptPubKeyDoc()},
2803                    }},
2804                    // TODO is the skip_type_check avoidable with a heterogeneous ARR?
2805                }, {.skip_type_check=true}, },
2806            },
2807        },
2808        RPCExamples{
2809            HelpExampleCli("getdescriptoractivity", "'[\"000000000000000000001347062c12fded7c528943c8ce133987e2e2f5a840ee\"]' '[\"addr(bc1qzl6nsgqzu89a66l50cvwapnkw5shh23zarqkw9)\"]'")
2810        },
2811        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
2812{
2813    UniValue ret(UniValue::VOBJ);
2814    UniValue activity(UniValue::VARR);
2815    NodeContext& node = EnsureAnyNodeContext(request.context);
2816    ChainstateManager& chainman = EnsureChainman(node);
2817
2818    struct CompareByHeightAscending {
2819        bool operator()(const CBlockIndex* a, const CBlockIndex* b) const {
2820            return a->nHeight < b->nHeight;
2821        }
2822    };
2823
2824    std::set<const CBlockIndex*, CompareByHeightAscending> blockindexes_sorted;
2825
2826    {
2827        // Validate all given blockhashes, and ensure blocks are along a single chain.
2828        LOCK(::cs_main);
2829        for (const UniValue& blockhash : request.params[0].get_array().getValues()) {
2830            uint256 bhash = ParseHashV(blockhash, "blockhash");
2831            CBlockIndex* pindex = chainman.m_blockman.LookupBlockIndex(bhash);
2832            if (!pindex) {
2833                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
2834            }
2835            if (!chainman.ActiveChain().Contains(*pindex)) {
2836                throw JSONRPCError(RPC_INVALID_PARAMETER, "Block is not in main chain");
2837            }
2838            blockindexes_sorted.insert(pindex);
2839        }
2840    }
2841
2842    std::set<CScript> scripts_to_watch;
2843
2844    // Determine scripts to watch.
2845    for (const UniValue& scanobject : request.params[1].get_array().getValues()) {
2846        FlatSigningProvider provider;
2847        std::vector<CScript> scripts = EvalDescriptorStringOrObject(scanobject, provider);
2848
2849        for (const CScript& script : scripts) {
2850            scripts_to_watch.insert(script);
2851        }
2852    }
2853
2854    const auto AddSpend = [&](
2855            const CScript& spk,
2856            const CAmount val,
2857            const CTransactionRef& tx,
2858            int vin,
2859            const CTxIn& txin,
2860            const CBlockIndex* index
2861            ) {
2862        UniValue event(UniValue::VOBJ);
2863        UniValue spkUv(UniValue::VOBJ);
2864        ScriptToUniv(spk, /*out=*/spkUv, /*include_hex=*/true, /*include_address=*/true);
2865
2866        event.pushKV("type", "spend");
2867        event.pushKV("amount", ValueFromAmount(val));
2868        if (index) {
2869            event.pushKV("blockhash", index->GetBlockHash().ToString());
2870            event.pushKV("height", index->nHeight);
2871        }
2872        event.pushKV("spend_txid", tx->GetHash().ToString());
2873        event.pushKV("spend_vin", vin);
2874        event.pushKV("prevout_txid", txin.prevout.hash.ToString());
2875        event.pushKV("prevout_vout", txin.prevout.n);
2876        event.pushKV("prevout_spk", spkUv);
2877
2878        return event;
2879    };
2880
2881    const auto AddReceive = [&](const CTxOut& txout, const CBlockIndex* index, int vout, const CTransactionRef& tx) {
2882        UniValue event(UniValue::VOBJ);
2883        UniValue spkUv(UniValue::VOBJ);
2884        ScriptToUniv(txout.scriptPubKey, /*out=*/spkUv, /*include_hex=*/true, /*include_address=*/true);
2885
2886        event.pushKV("type", "receive");
2887        event.pushKV("amount", ValueFromAmount(txout.nValue));
2888        if (index) {
2889            event.pushKV("blockhash", index->GetBlockHash().ToString());
2890            event.pushKV("height", index->nHeight);
2891        }
2892        event.pushKV("txid", tx->GetHash().ToString());
2893        event.pushKV("vout", vout);
2894        event.pushKV("output_spk", spkUv);
2895
2896        return event;
2897    };
2898
2899    BlockManager* blockman;
2900    Chainstate& active_chainstate = chainman.ActiveChainstate();
2901    {
2902        LOCK(::cs_main);
2903        blockman = CHECK_NONFATAL(&active_chainstate.m_blockman);
2904    }
2905
2906    for (const CBlockIndex* blockindex : blockindexes_sorted) {
2907        const CBlock block{GetBlockChecked(chainman.m_blockman, *blockindex)};
2908        const CBlockUndo block_undo{GetUndoChecked(*blockman, *blockindex)};
2909
2910        for (size_t i = 0; i < block.vtx.size(); ++i) {
2911            const auto& tx = block.vtx.at(i);
2912
2913            if (!tx->IsCoinBase()) {
2914                // skip coinbase; spends can't happen there.
2915                const auto& txundo = block_undo.vtxundo.at(i - 1);
2916
2917                for (size_t vin_idx = 0; vin_idx < tx->vin.size(); ++vin_idx) {
2918                    const auto& coin = txundo.vprevout.at(vin_idx);
2919                    const auto& txin = tx->vin.at(vin_idx);
2920                    if (scripts_to_watch.contains(coin.out.scriptPubKey)) {
2921                        activity.push_back(AddSpend(
2922                                    coin.out.scriptPubKey, coin.out.nValue, tx, vin_idx, txin, blockindex));
2923                    }
2924                }
2925            }
2926
2927            for (size_t vout_idx = 0; vout_idx < tx->vout.size(); ++vout_idx) {
2928                const auto& vout = tx->vout.at(vout_idx);
2929                if (scripts_to_watch.contains(vout.scriptPubKey)) {
2930                    activity.push_back(AddReceive(vout, blockindex, vout_idx, tx));
2931                }
2932            }
2933        }
2934    }
2935
2936    bool search_mempool = true;
2937    if (!request.params[2].isNull()) {
2938        search_mempool = request.params[2].get_bool();
2939    }
2940
2941    if (search_mempool) {
2942        const CTxMemPool& mempool = EnsureMemPool(node);
2943        LOCK(::cs_main);
2944        LOCK(mempool.cs);
2945        const CCoinsViewCache& coins_view = &active_chainstate.CoinsTip();
2946
2947        for (const CTxMemPoolEntry& e : mempool.entryAll()) {
2948            const auto& tx = e.GetSharedTx();
2949
2950            for (size_t vin_idx = 0; vin_idx < tx->vin.size(); ++vin_idx) {
2951                CScript scriptPubKey;
2952                CAmount value;
2953                const auto& txin = tx->vin.at(vin_idx);
2954                std::optional<Coin> coin = coins_view.GetCoin(txin.prevout);
2955
2956                // Check if the previous output is in the chain
2957                if (!coin) {
2958                    // If not found in the chain, check the mempool. Likely, this is a
2959                    // child transaction of another transaction in the mempool.
2960                    CTransactionRef prev_tx = CHECK_NONFATAL(mempool.get(txin.prevout.hash));
2961
2962                    if (txin.prevout.n >= prev_tx->vout.size()) {
2963                        throw std::runtime_error("Invalid output index");
2964                    }
2965                    const CTxOut& out = prev_tx->vout[txin.prevout.n];
2966                    scriptPubKey = out.scriptPubKey;
2967                    value = out.nValue;
2968                } else {
2969                    // Coin found in the chain
2970                    const CTxOut& out = coin->out;
2971                    scriptPubKey = out.scriptPubKey;
2972                    value = out.nValue;
2973                }
2974
2975                if (scripts_to_watch.contains(scriptPubKey)) {
2976                    UniValue event(UniValue::VOBJ);
2977                    activity.push_back(AddSpend(
2978                                scriptPubKey, value, tx, vin_idx, txin, nullptr));
2979                }
2980            }
2981
2982            for (size_t vout_idx = 0; vout_idx < tx->vout.size(); ++vout_idx) {
2983                const auto& vout = tx->vout.at(vout_idx);
2984                if (scripts_to_watch.contains(vout.scriptPubKey)) {
2985                    activity.push_back(AddReceive(vout, nullptr, vout_idx, tx));
2986                }
2987            }
2988        }
2989    }
2990
2991    ret.pushKV("activity", activity);
2992    return ret;
2993},
2994    };
2995}
2996
2997static RPCMethod getblockfilter()
2998{
2999    return RPCMethod{
3000        "getblockfilter",