Inside Bitcoin

501    }
502}
503
504static bool rest_block_extended(const std::any& context, HTTPRequest* req, const std::string& uri_part)
505{
506    return rest_block(context, req, uri_part, TxVerbosity::SHOW_DETAILS_AND_PREVOUT);
507}
508
509static bool rest_block_notxdetails(const std::any& context, HTTPRequest* req, const std::string& uri_part)
510{
511    return rest_block(context, req, uri_part, TxVerbosity::SHOW_TXID);
512}
513
514static bool rest_block_part(const std::any& context, HTTPRequest* req, const std::string& uri_part)
515{
516    try {
517        if (const auto opt_offset{ToIntegral<size_t>(req->GetQueryParameter("offset").value_or(""))}) {
518            if (const auto opt_size{ToIntegral<size_t>(req->GetQueryParameter("size").value_or(""))}) {
519                return rest_block(context, req, uri_part,
520                                  /*tx_verbosity=*/std::nullopt,
521                                  /*block_part=*/{{*opt_offset, *opt_size}});
522            } else {
523                return RESTERR(req, HTTP_BAD_REQUEST, "Block part size missing or invalid");
524            }
525        } else {
526            return RESTERR(req, HTTP_BAD_REQUEST, "Block part offset missing or invalid");
527        }
528    } catch (const std::runtime_error& e) {
529        return RESTERR(req, HTTP_BAD_REQUEST, e.what());
530    }
531}
532
533static bool rest_filter_header(const std::any& context, HTTPRequest* req, const std::string& uri_part)
534{
535    if (!CheckWarmup(req)) return false;
536
537    std::string param;
538    const RESTResponseFormat rf = ParseDataFormat(param, uri_part);
539
540    std::vector<std::string> uri_parts = SplitString(param, '/');
541    std::string raw_count;
542    std::string raw_blockhash;
543    if (uri_parts.size() == 3) {
544        // deprecated path: /rest/blockfilterheaders/<filtertype>/<count>/<blockhash>
545        raw_blockhash = uri_parts[2];
546        raw_count = uri_parts[1];
547    } else if (uri_parts.size() == 2) {
548        // new path with query parameter: /rest/blockfilterheaders/<filtertype>/<blockhash>?count=<count>
549        raw_blockhash = uri_parts[1];
550        try {
551            raw_count = req->GetQueryParameter("count").value_or("5");
552        } catch (const std::runtime_error& e) {
553            return RESTERR(req, HTTP_BAD_REQUEST, e.what());
554        }
555    } else {
556        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid URI format. Expected /rest/blockfilterheaders/<filtertype>/<blockhash>.<ext>?count=<count>");
557    }
558
559    const auto parsed_count{ToIntegral<size_t>(raw_count)};
560    if (!parsed_count.has_value() || *parsed_count < 1 || *parsed_count > MAX_REST_HEADERS_RESULTS) {
561        return RESTERR(req, HTTP_BAD_REQUEST, strprintf("Header count is invalid or out of acceptable range (1-%u): %s", MAX_REST_HEADERS_RESULTS, raw_count));
562    }
563
564    auto block_hash{uint256::FromHex(raw_blockhash)};
565    if (!block_hash) {
566        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + raw_blockhash);
567    }
568
569    BlockFilterType filtertype;
570    if (!BlockFilterTypeByName(uri_parts[0], filtertype)) {
571        return RESTERR(req, HTTP_BAD_REQUEST, "Unknown filtertype " + uri_parts[0]);
572    }
573
574    BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
575    if (!index) {
576        return RESTERR(req, HTTP_BAD_REQUEST, "Index is not enabled for filtertype " + uri_parts[0]);
577    }
578
579    std::vector<const CBlockIndex*> headers;
580    headers.reserve(*parsed_count);
581    {
582        ChainstateManager* maybe_chainman = GetChainman(context, req);
583        if (!maybe_chainman) return false;
584        ChainstateManager& chainman = *maybe_chainman;
585        LOCK(cs_main);
586        CChain& active_chain = chainman.ActiveChain();
587        const CBlockIndex* pindex{chainman.m_blockman.LookupBlockIndex(*block_hash)};
588        while (pindex != nullptr && active_chain.Contains(*pindex)) {
589            headers.push_back(pindex);
590            if (headers.size() == *parsed_count)
591                break;
592            pindex = active_chain.Next(*pindex);
593        }
594    }
595
596    bool index_ready = index->BlockUntilSyncedToCurrentChain();
597
598    std::vector<uint256> filter_headers;
599    filter_headers.reserve(*parsed_count);
600    for (const CBlockIndex* pindex : headers) {
601        uint256 filter_header;
602        if (!index->LookupFilterHeader(pindex, filter_header)) {
603            std::string errmsg = "Filter not found.";
604
605            if (!index_ready) {
606                errmsg += " Block filters are still in the process of being indexed.";
607            } else {
608                errmsg += " This error is unexpected and indicates index corruption.";
609            }
610
611            return RESTERR(req, HTTP_NOT_FOUND, errmsg);
612        }
613        filter_headers.push_back(filter_header);
614    }
615
616    switch (rf) {
617    case RESTResponseFormat::BINARY: {
618        DataStream ssHeader{};
619        for (const uint256& header : filter_headers) {
620            ssHeader << header;
621        }
622
623        // Do not cache because chain extensions and reorgs can affect the response.
624        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
625        req->WriteHeader("Content-Type", "application/octet-stream");
626        req->WriteReply(HTTP_OK, ssHeader);
627        return true;
628    }
629    case RESTResponseFormat::HEX: {
630        DataStream ssHeader{};
631        for (const uint256& header : filter_headers) {
632            ssHeader << header;
633        }
634
635        std::string strHex = HexStr(ssHeader) + "\n";
636        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
637        req->WriteHeader("Content-Type", "text/plain");
638        req->WriteReply(HTTP_OK, strHex);
639        return true;
640    }
641    case RESTResponseFormat::JSON: {
642        UniValue jsonHeaders(UniValue::VARR);
643        for (const uint256& header : filter_headers) {
644            jsonHeaders.push_back(header.GetHex());
645        }
646
647        std::string strJSON = jsonHeaders.write() + "\n";
648        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
649        req->WriteHeader("Content-Type", "application/json");
650        req->WriteReply(HTTP_OK, strJSON);
651        return true;
652    }
653    default: {
654        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
655    }
656    }
657}
658
659static bool rest_block_filter(const std::any& context, HTTPRequest* req, const std::string& uri_part)
660{
661    if (!CheckWarmup(req)) return false;
662
663    std::string param;
664    const RESTResponseFormat rf = ParseDataFormat(param, uri_part);
665
666    // request is sent over URI scheme /rest/blockfilter/filtertype/blockhash
667    std::vector<std::string> uri_parts = SplitString(param, '/');
668    if (uri_parts.size() != 2) {
669        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid URI format. Expected /rest/blockfilter/<filtertype>/<blockhash>");
670    }
671
672    auto block_hash{uint256::FromHex(uri_parts[1])};
673    if (!block_hash) {
674        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + uri_parts[1]);
675    }
676
677    BlockFilterType filtertype;
678    if (!BlockFilterTypeByName(uri_parts[0], filtertype)) {
679        return RESTERR(req, HTTP_BAD_REQUEST, "Unknown filtertype " + uri_parts[0]);
680    }
681
682    BlockFilterIndex* index = GetBlockFilterIndex(filtertype);
683    if (!index) {
684        return RESTERR(req, HTTP_BAD_REQUEST, "Index is not enabled for filtertype " + uri_parts[0]);
685    }
686
687    const CBlockIndex* block_index;
688    bool block_was_connected;
689    {
690        ChainstateManager* maybe_chainman = GetChainman(context, req);
691        if (!maybe_chainman) return false;
692        ChainstateManager& chainman = *maybe_chainman;
693        LOCK(cs_main);
694        block_index = chainman.m_blockman.LookupBlockIndex(*block_hash);
695        if (!block_index) {
696            return RESTERR(req, HTTP_NOT_FOUND, uri_parts[1] + " not found");
697        }
698        block_was_connected = block_index->IsValid(BLOCK_VALID_SCRIPTS);
699    }
700
701    bool index_ready = index->BlockUntilSyncedToCurrentChain();
702
703    BlockFilter filter;
704    if (!index->LookupFilter(block_index, filter)) {
705        std::string errmsg = "Filter not found.";
706
707        if (!block_was_connected) {
708            errmsg += " Block was not connected to active chain.";
709        } else if (!index_ready) {
710            errmsg += " Block filters are still in the process of being indexed.";
711        } else {
712            errmsg += " This error is unexpected and indicates index corruption.";
713        }
714
715        return RESTERR(req, HTTP_NOT_FOUND, errmsg);
716    }
717
718    switch (rf) {
719    case RESTResponseFormat::BINARY: {
720        DataStream ssResp{};
721        ssResp << filter;
722
723        req->WriteHeader("Cache-Control", REST_CACHE_IMMUTABLE);
724        req->WriteHeader("Content-Type", "application/octet-stream");
725        req->WriteReply(HTTP_OK, ssResp);
726        return true;
727    }
728    case RESTResponseFormat::HEX: {
729        DataStream ssResp{};
730        ssResp << filter;
731
732        std::string strHex = HexStr(ssResp) + "\n";
733        req->WriteHeader("Cache-Control", REST_CACHE_IMMUTABLE);
734        req->WriteHeader("Content-Type", "text/plain");
735        req->WriteReply(HTTP_OK, strHex);
736        return true;
737    }
738    case RESTResponseFormat::JSON: {
739        UniValue ret(UniValue::VOBJ);
740        ret.pushKV("filter", HexStr(filter.GetEncodedFilter()));
741        std::string strJSON = ret.write() + "\n";
742        req->WriteHeader("Cache-Control", REST_CACHE_IMMUTABLE);
743        req->WriteHeader("Content-Type", "application/json");
744        req->WriteReply(HTTP_OK, strJSON);
745        return true;
746    }
747    default: {
748        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
749    }
750    }