Blockchain information through RPC

2501            unspent.pushKV("confirmations", tip->nHeight - coin.nHeight + 1);
2502
2503            unspents.push_back(std::move(unspent));
2504        }
2505        result.pushKV("unspents", std::move(unspents));
2506        result.pushKV("total_amount", ValueFromAmount(total_in));
2507    } else {
2508        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid action '%s'", action));
2509    }
2510    return result;
2511},
2512    };
2513}
2514
2515/** RAII object to prevent concurrency issue when scanning blockfilters */
2516static std::atomic<int> g_scanfilter_progress;
2517static std::atomic<int> g_scanfilter_progress_height;
2518static std::atomic<bool> g_scanfilter_in_progress;
2519static std::atomic<bool> g_scanfilter_should_abort_scan;
2520class BlockFiltersScanReserver
2521{
2522private:
2523    bool m_could_reserve{false};
2524public:
2525    explicit BlockFiltersScanReserver() = default;
2526
2527    bool reserve() {
2528        CHECK_NONFATAL(!m_could_reserve);
2529        if (g_scanfilter_in_progress.exchange(true)) {
2530            return false;
2531        }
2532        m_could_reserve = true;
2533        return true;
2534    }
2535
2536    ~BlockFiltersScanReserver() {
2537        if (m_could_reserve) {
2538            g_scanfilter_in_progress = false;
2539        }
2540    }
2541};
2542
2543static bool CheckBlockFilterMatches(BlockManager& blockman, const CBlockIndex& blockindex, const GCSFilter::ElementSet& needles)
2544{
2545    const CBlock block{GetBlockChecked(blockman, blockindex)};
2546    const CBlockUndo block_undo{GetUndoChecked(blockman, blockindex)};
2547
2548    // Check if any of the outputs match the scriptPubKey
2549    for (const auto& tx : block.vtx) {
2550        if (std::any_of(tx->vout.cbegin(), tx->vout.cend(), [&](const auto& txout) {
2551                return needles.contains(std::vector<unsigned char>(txout.scriptPubKey.begin(), txout.scriptPubKey.end()));
2552            })) {
2553            return true;
2554        }
2555    }
2556    // Check if any of the inputs match the scriptPubKey
2557    for (const auto& txundo : block_undo.vtxundo) {
2558        if (std::any_of(txundo.vprevout.cbegin(), txundo.vprevout.cend(), [&](const auto& coin) {
2559                return needles.contains(std::vector<unsigned char>(coin.out.scriptPubKey.begin(), coin.out.scriptPubKey.end()));
2560            })) {
2561            return true;
2562        }
2563    }
2564
2565    return false;
2566}
2567
2568static RPCMethod scanblocks()
2569{
2570    return RPCMethod{
2571        "scanblocks",
2572        "Return relevant blockhashes for given descriptors (requires blockfilterindex).\n"
2573        "This call may take several minutes. Make sure to use no RPC timeout (bitcoin-cli -rpcclienttimeout=0)",
2574        {
2575            scan_action_arg_desc,
2576            scan_objects_arg_desc,
2577            RPCArg{"start_height", RPCArg::Type::NUM, RPCArg::Default{0}, "Height to start to scan from"},
2578            RPCArg{"stop_height", RPCArg::Type::NUM, RPCArg::DefaultHint{"chain tip"}, "Height to stop to scan"},
2579            RPCArg{"filtertype", RPCArg::Type::STR, RPCArg::Default{BlockFilterTypeName(BlockFilterType::BASIC)}, "The type name of the filter"},
2580            RPCArg{"options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "",
2581                {
2582                    {"filter_false_positives", RPCArg::Type::BOOL, RPCArg::Default{false}, "Filter false positives (slower and may fail on pruned nodes). Otherwise they may occur at a rate of 1/M"},
2583                },
2584                RPCArgOptions{.oneline_description="options"}},
2585        },
2586        {
2587            scan_result_status_none,
2588            RPCResult{"When action=='start'; only returns after scan completes", RPCResult::Type::OBJ, "", "", {
2589                {RPCResult::Type::NUM, "from_height", "The height we started the scan from"},
2590                {RPCResult::Type::NUM, "to_height", "The height we ended the scan at"},
2591                {RPCResult::Type::ARR, "relevant_blocks", "Blocks that may have matched a scanobject.", {
2592                    {RPCResult::Type::STR_HEX, "blockhash", "A relevant blockhash"},
2593                }},
2594                {RPCResult::Type::BOOL, "completed", "true if the scan process was not aborted"}
2595            }},
2596            RPCResult{"when action=='status' and a scan is currently in progress", RPCResult::Type::OBJ, "", "", {
2597                    {RPCResult::Type::NUM, "progress", "Approximate percent complete"},
2598                    {RPCResult::Type::NUM, "current_height", "Height of the block currently being scanned"},
2599                },
2600            },
2601            scan_result_abort,
2602        },
2603        RPCExamples{
2604            HelpExampleCli("scanblocks", "start '[\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"]' 300000") +
2605            HelpExampleCli("scanblocks", "start '[\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"]' 100 150 basic") +
2606            HelpExampleCli("scanblocks", "status") +
2607            HelpExampleRpc("scanblocks", "\"start\", [\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"], 300000") +
2608            HelpExampleRpc("scanblocks", "\"start\", [\"addr(bcrt1q4u4nsgk6ug0sqz7r3rj9tykjxrsl0yy4d0wwte)\"], 100, 150, \"basic\"") +
2609            HelpExampleRpc("scanblocks", "\"status\"")
2610        },
2611        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
2612{
2613    UniValue ret(UniValue::VOBJ);
2614    auto action{self.Arg<std::string_view>("action")};
2615    if (action == "status") {
2616        BlockFiltersScanReserver reserver;
2617        if (reserver.reserve()) {
2618            // no scan in progress
2619            return NullUniValue;
2620        }
2621        ret.pushKV("progress", g_scanfilter_progress.load());
2622        ret.pushKV("current_height", g_scanfilter_progress_height.load());
2623        return ret;
2624    } else if (action == "abort") {
2625        BlockFiltersScanReserver reserver;
2626        if (reserver.reserve()) {
2627            // reserve was possible which means no scan was running
2628            return false;
2629        }
2630        // set the abort flag
2631        g_scanfilter_should_abort_scan = true;
2632        return true;
2633    } else if (action == "start") {
2634        BlockFiltersScanReserver reserver;
2635        if (!reserver.reserve()) {
2636            throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan already in progress, use action \"abort\" or \"status\"");
2637        }
2638        const UniValue* scanobjects = self.MaybeArg<UniValue>("scanobjects");
2639        if (!scanobjects) {
2640            throw JSONRPCError(RPC_MISC_ERROR, "scanobjects argument is required for the start action");
2641        }
2642        auto filtertype_name{self.Arg<std::string_view>("filtertype")};
2643
2644        BlockFilterType filtertype;
2645        if (!BlockFilterTypeByName(filtertype_name, filtertype)) {
2646            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Unknown filtertype");
2647        }
2648
2649        UniValue options{request.params[5].isNull() ? UniValue::VOBJ : request.params[5]};
2650        bool filter_false_positives{options.exists("filter_false_positives") ? options["filter_false_positives"].get_bool() : false};
2651
2652        BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
2653        if (!index) {
2654            throw JSONRPCError(RPC_MISC_ERROR, tfm::format("Index is not enabled for filtertype %s", filtertype_name));
2655        }
2656
2657        NodeContext& node = EnsureAnyNodeContext(request.context);
2658        ChainstateManager& chainman = EnsureChainman(node);
2659
2660        // set the start-height
2661        const CBlockIndex* start_index = nullptr;
2662        const CBlockIndex* stop_block = nullptr;
2663        {
2664            LOCK(cs_main);
2665            CChain& active_chain = chainman.ActiveChain();
2666            start_index = active_chain.Genesis();
2667            stop_block = active_chain.Tip(); // If no stop block is provided, stop at the chain tip.
2668            if (!request.params[2].isNull()) {
2669                start_index = active_chain[request.params[2].getInt<int>()];
2670                if (!start_index) {
2671                    throw JSONRPCError(RPC_MISC_ERROR, "Invalid start_height");
2672                }
2673            }
2674            if (!request.params[3].isNull()) {
2675                stop_block = active_chain[request.params[3].getInt<int>()];
2676                if (!stop_block || stop_block->nHeight < start_index->nHeight) {
2677                    throw JSONRPCError(RPC_MISC_ERROR, "Invalid stop_height");
2678                }
2679            }
2680        }
2681        CHECK_NONFATAL(start_index);
2682        CHECK_NONFATAL(stop_block);
2683
2684        // loop through the scan objects, add scripts to the needle_set
2685        GCSFilter::ElementSet needle_set;
2686        for (const UniValue& scanobject : scanobjects->get_array().getValues()) {
2687            FlatSigningProvider provider;
2688            std::vector<CScript> scripts = EvalDescriptorStringOrObject(scanobject, provider);
2689            for (const CScript& script : scripts) {
2690                needle_set.emplace(script.begin(), script.end());
2691            }
2692        }
2693        UniValue blocks(UniValue::VARR);
2694        const int amount_per_chunk = 10000;
2695        std::vector<BlockFilter> filters;
2696        int start_block_height = start_index->nHeight; // for progress reporting
2697        const int total_blocks_to_process = stop_block->nHeight - start_block_height;
2698
2699        g_scanfilter_should_abort_scan = false;
2700        g_scanfilter_progress = 0;
2701        g_scanfilter_progress_height = start_block_height;
2702        bool completed = true;
2703
2704        const CBlockIndex* end_range = nullptr;
2705        do {
2706            node.rpc_interruption_point(); // allow a clean shutdown
2707            if (g_scanfilter_should_abort_scan) {
2708                completed = false;
2709                break;
2710            }
2711
2712            // split the lookup range in chunks if we are deeper than 'amount_per_chunk' blocks from the stopping block
2713            int start_block = !end_range ? start_index->nHeight : start_index->nHeight + 1; // to not include the previous round 'end_range' block
2714            end_range = (start_block + amount_per_chunk < stop_block->nHeight) ?
2715                    WITH_LOCK(::cs_main, return chainman.ActiveChain()[start_block + amount_per_chunk]) :
2716                    stop_block;
2717
2718            if (index->LookupFilterRange(start_block, end_range, filters)) {
2719                for (const BlockFilter& filter : filters) {
2720                    // compare the elements-set with each filter
2721                    if (filter.GetFilter().MatchAny(needle_set)) {
2722                        if (filter_false_positives) {
2723                            // Double check the filter matches by scanning the block
2724                            const CBlockIndex& blockindex = *CHECK_NONFATAL(WITH_LOCK(cs_main, return chainman.m_blockman.LookupBlockIndex(filter.GetBlockHash())));
2725
2726                            if (!CheckBlockFilterMatches(chainman.m_blockman, blockindex, needle_set)) {
2727                                continue;
2728                            }
2729                        }
2730
2731                        blocks.push_back(filter.GetBlockHash().GetHex());
2732                    }
2733                }
2734            }
2735            start_index = end_range;
2736
2737            // update progress
2738            int blocks_processed = end_range->nHeight - start_block_height;
2739            if (total_blocks_to_process > 0) { // avoid division by zero
2740                g_scanfilter_progress = (int)(100.0 / total_blocks_to_process * blocks_processed);
2741            } else {
2742                g_scanfilter_progress = 100;
2743            }
2744            g_scanfilter_progress_height = end_range->nHeight;
2745
2746        // Finish if we reached the stop block
2747        } while (start_index != stop_block);
2748
2749        ret.pushKV("from_height", start_block_height);
2750        ret.pushKV("to_height", start_index->nHeight); // start_index is always the last scanned block here