Inside Bitcoin

751}
752
753// A bit of a hack - dependency on a function defined in rpc/blockchain.cpp
754RPCMethod getblockchaininfo();
755
756static bool rest_chaininfo(const std::any& context, HTTPRequest* req, const std::string& uri_part)
757{
758    if (!CheckWarmup(req))
759        return false;
760    std::string param;
761    const RESTResponseFormat rf = ParseDataFormat(param, uri_part);
762
763    switch (rf) {
764    case RESTResponseFormat::JSON: {
765        JSONRPCRequest jsonRequest;
766        jsonRequest.context = context;
767        jsonRequest.params = UniValue(UniValue::VARR);
768        UniValue chainInfoObject = getblockchaininfo().HandleRequest(jsonRequest);
769        std::string strJSON = chainInfoObject.write() + "\n";
770        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
771        req->WriteHeader("Content-Type", "application/json");
772        req->WriteReply(HTTP_OK, strJSON);
773        return true;
774    }
775    default: {
776        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: json)");
777    }
778    }
779}
780
781
782RPCMethod getdeploymentinfo();
783
784static bool rest_deploymentinfo(const std::any& context, HTTPRequest* req, const std::string& str_uri_part)
785{
786    if (!CheckWarmup(req)) return false;
787
788    std::string hash_str;
789    const RESTResponseFormat rf = ParseDataFormat(hash_str, str_uri_part);
790    const bool current_tip{hash_str.empty()};
791
792    switch (rf) {
793    case RESTResponseFormat::JSON: {
794        JSONRPCRequest jsonRequest;
795        jsonRequest.context = context;
796        jsonRequest.params = UniValue(UniValue::VARR);
797
798        if (!current_tip) {
799            auto hash{uint256::FromHex(hash_str)};
800            if (!hash) {
801                return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hash_str);
802            }
803
804            const ChainstateManager* chainman = GetChainman(context, req);
805            if (!chainman) return false;
806            if (!WITH_LOCK(::cs_main, return chainman->m_blockman.LookupBlockIndex(*hash))) {
807                return RESTERR(req, HTTP_BAD_REQUEST, "Block not found");
808            }
809
810            jsonRequest.params.push_back(hash_str);
811        }
812
813        req->WriteHeader("Cache-Control", current_tip ? REST_CACHE_NO_STORE : REST_CACHE_IMMUTABLE);
814        req->WriteHeader("Content-Type", "application/json");
815        req->WriteReply(HTTP_OK, getdeploymentinfo().HandleRequest(jsonRequest).write() + "\n");
816        return true;
817    }
818    default: {
819        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: json)");
820    }
821    }
822
823}
824
825static bool rest_mempool(const std::any& context, HTTPRequest* req, const std::string& str_uri_part)
826{
827    if (!CheckWarmup(req))
828        return false;
829
830    std::string param;
831    const RESTResponseFormat rf = ParseDataFormat(param, str_uri_part);
832    if (param != "contents" && param != "info") {
833        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid URI format. Expected /rest/mempool/<info|contents>.json");
834    }
835
836    const CTxMemPool* mempool = GetMemPool(context, req);
837    if (!mempool) return false;
838
839    switch (rf) {
840    case RESTResponseFormat::JSON: {
841        std::string str_json;
842        if (param == "contents") {
843            std::string raw_verbose;
844            try {
845                raw_verbose = req->GetQueryParameter("verbose").value_or("true");
846            } catch (const std::runtime_error& e) {
847                return RESTERR(req, HTTP_BAD_REQUEST, e.what());
848            }
849            if (raw_verbose != "true" && raw_verbose != "false") {
850                return RESTERR(req, HTTP_BAD_REQUEST, "The \"verbose\" query parameter must be either \"true\" or \"false\".");
851            }
852            std::string raw_mempool_sequence;
853            try {
854                raw_mempool_sequence = req->GetQueryParameter("mempool_sequence").value_or("false");
855            } catch (const std::runtime_error& e) {
856                return RESTERR(req, HTTP_BAD_REQUEST, e.what());
857            }
858            if (raw_mempool_sequence != "true" && raw_mempool_sequence != "false") {
859                return RESTERR(req, HTTP_BAD_REQUEST, "The \"mempool_sequence\" query parameter must be either \"true\" or \"false\".");
860            }
861            const bool verbose{raw_verbose == "true"};
862            const bool mempool_sequence{raw_mempool_sequence == "true"};
863            if (verbose && mempool_sequence) {
864                return RESTERR(req, HTTP_BAD_REQUEST, "Verbose results cannot contain mempool sequence values. (hint: set \"verbose=false\")");
865            }
866            str_json = MempoolToJSON(*mempool, verbose, mempool_sequence).write() + "\n";
867        } else {
868            str_json = MempoolInfoToJSON(*mempool).write() + "\n";
869        }
870
871        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
872        req->WriteHeader("Content-Type", "application/json");
873        req->WriteReply(HTTP_OK, str_json);
874        return true;
875    }
876    default: {
877        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: json)");
878    }
879    }
880}
881
882static bool rest_tx(const std::any& context, HTTPRequest* req, const std::string& uri_part)
883{
884    if (!CheckWarmup(req))
885        return false;
886    std::string hashStr;
887    const RESTResponseFormat rf = ParseDataFormat(hashStr, uri_part);
888
889    auto hash{Txid::FromHex(hashStr)};
890    if (!hash) {
891        return RESTERR(req, HTTP_BAD_REQUEST, "Invalid hash: " + hashStr);
892    }
893
894    if (g_txindex) {
895        g_txindex->BlockUntilSyncedToCurrentChain();
896    }
897
898    const NodeContext* const node = GetNodeContext(context, req);
899    if (!node) return false;
900    uint256 hashBlock = uint256();
901    const CTransactionRef tx{GetTransaction(/*block_index=*/nullptr, node->mempool.get(), *hash,  node->chainman->m_blockman, hashBlock)};
902    if (!tx) {
903        return RESTERR(req, HTTP_NOT_FOUND, hashStr + " not found");
904    }
905    switch (rf) {
906    case RESTResponseFormat::BINARY: {
907        DataStream ssTx;
908        ssTx << TX_WITH_WITNESS(tx);
909
910        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
911        req->WriteHeader("Content-Type", "application/octet-stream");
912        req->WriteReply(HTTP_OK, ssTx);
913        return true;
914    }
915
916    case RESTResponseFormat::HEX: {
917        DataStream ssTx;
918        ssTx << TX_WITH_WITNESS(tx);
919
920        std::string strHex = HexStr(ssTx) + "\n";
921        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
922        req->WriteHeader("Content-Type", "text/plain");
923        req->WriteReply(HTTP_OK, strHex);
924        return true;
925    }
926
927    case RESTResponseFormat::JSON: {
928        UniValue objTx(UniValue::VOBJ);
929        TxToUniv(*tx, /*block_hash=*/hashBlock, /*entry=*/ objTx);
930        std::string strJSON = objTx.write() + "\n";
931        req->WriteHeader("Cache-Control", REST_CACHE_NO_STORE);
932        req->WriteHeader("Content-Type", "application/json");
933        req->WriteReply(HTTP_OK, strJSON);
934        return true;
935    }
936
937    default: {
938        return RESTERR(req, HTTP_NOT_FOUND, "output format not found (available: " + AvailableDataFormatsString() + ")");
939    }
940    }
941}
942
943static bool rest_getutxos(const std::any& context, HTTPRequest* req, const std::string& uri_part)
944{
945    if (!CheckWarmup(req))
946        return false;
947    std::string param;
948    const RESTResponseFormat rf = ParseDataFormat(param, uri_part);
949
950    std::vector<std::string> uriParts;
951    if (param.length() > 1)
952    {
953        std::string strUriParams = param.substr(1);
954        uriParts = SplitString(strUriParams, '/');
955    }
956
957    // throw exception in case of an empty request
958    std::string strRequestMutable = req->ReadBody();
959    if (strRequestMutable.length() == 0 && uriParts.size() == 0)
960        return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
961
962    bool fInputParsed = false;
963    bool fCheckMemPool = false;
964    std::vector<COutPoint> vOutPoints;
965
966    // parse/deserialize input
967    // input-format = output-format, rest/getutxos/bin requires binary input, gives binary output, ...
968
969    if (uriParts.size() > 0)
970    {
971        //inputs is sent over URI scheme (/rest/getutxos/checkmempool/txid1-n/txid2-n/...)
972        if (uriParts[0] == "checkmempool") fCheckMemPool = true;
973
974        for (size_t i = (fCheckMemPool) ? 1 : 0; i < uriParts.size(); i++)
975        {
976            const auto txid_out{util::Split<std::string_view>(uriParts[i], '-')};
977            if (txid_out.size() != 2) {
978                return RESTERR(req, HTTP_BAD_REQUEST, "Parse error");
979            }
980            auto txid{Txid::FromHex(txid_out.at(0))};
981            auto output{ToIntegral<uint32_t>(txid_out.at(1))};
982
983            if (!txid || !output) {
984                return RESTERR(req, HTTP_BAD_REQUEST, "Parse error");
985            }
986
987            vOutPoints.emplace_back(*txid, *output);
988        }
989
990        if (vOutPoints.size() > 0)
991            fInputParsed = true;
992        else
993            return RESTERR(req, HTTP_BAD_REQUEST, "Error: empty request");
994    }
995
996    switch (rf) {
997    case RESTResponseFormat::HEX: {
998        // convert hex to bin, continue then with bin part
999        std::vector<unsigned char> strRequestV = ParseHex(strRequestMutable);
1000        strRequestMutable.assign(strRequestV.begin(), strRequestV.end());