66 uint32_t nTxVerDummy = 0;
67 READWRITE(nTxVerDummy, obj.nHeight, obj.out);
87 auto node_context = util::AnyPtr<NodeContext>(context);
91 "Internal bug detected: Node context not found!\n"
92 "You may report this issue here: %s\n",
108 auto node_context = util::AnyPtr<NodeContext>(context);
109 if (!node_context || !node_context->mempool) {
113 return node_context->mempool.get();
125 auto node_context = util::AnyPtr<NodeContext>(context);
126 if (!node_context || !node_context->chainman) {
129 "Internal bug detected: Chainman disabled or instance not found!\n"
130 "You may report this issue here: %s\n",
134 return node_context->chainman.get();
141 param = strReq.substr(0, strReq.rfind(
'?'));
142 const std::string::size_type pos_format{param.rfind(
'.')};
145 if (pos_format == std::string::npos) {
150 const std::string suffix(param, pos_format + 1);
151 for (
const auto& rf_name :
rf_names) {
152 if (suffix == rf_name.name) {
153 param.erase(pos_format);
165 for (
const auto& rf_name :
rf_names) {
166 if (strlen(rf_name.name) > 0) {
168 formats.append(rf_name.name);
169 formats.append(
", ");
173 if (formats.length() > 0)
174 return formats.substr(0, formats.length() - 2);
181 std::string statusmessage;
189 const std::string& strURIPart)
195 std::vector<std::string> path =
SplitString(param,
'/');
197 std::string raw_count;
199 if (path.size() == 2) {
203 }
else if (path.size() == 1) {
208 }
catch (
const std::runtime_error& e) {
212 return RESTERR(req,
HTTP_BAD_REQUEST,
"Invalid URI format. Expected /rest/headers/<hash>.<ext>?count=<count>");
215 const auto parsed_count{ToIntegral<size_t>(raw_count)};
226 std::vector<const CBlockIndex*> headers;
227 headers.reserve(*parsed_count);
230 if (!maybe_chainman)
return false;
234 tip = active_chain.
Tip();
236 while (pindex !=
nullptr && active_chain.
Contains(pindex)) {
237 headers.push_back(pindex);
238 if (headers.size() == *parsed_count) {
241 pindex = active_chain.
Next(pindex);
249 ssHeader << pindex->GetBlockHeader();
252 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
260 ssHeader << pindex->GetBlockHeader();
263 std::string strHex =
HexStr(ssHeader) +
"\n";
273 std::string strJSON = jsonHeaders.
write() +
"\n";
274 req->
WriteHeader(
"Content-Type",
"application/json");
286 const std::string& strURIPart,
303 if (!maybe_chainman)
return false;
312 if (chainman.
m_blockman.IsBlockPruned(*pblockindex)) {
318 std::vector<uint8_t> block_data{};
325 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
331 const std::string strHex{
HexStr(block_data) +
"\n"};
342 std::string strJSON = objBlock.
write() +
"\n";
343 req->
WriteHeader(
"Content-Type",
"application/json");
371 std::vector<std::string> uri_parts =
SplitString(param,
'/');
372 std::string raw_count;
373 std::string raw_blockhash;
374 if (uri_parts.size() == 3) {
376 raw_blockhash = uri_parts[2];
377 raw_count = uri_parts[1];
378 }
else if (uri_parts.size() == 2) {
380 raw_blockhash = uri_parts[1];
383 }
catch (
const std::runtime_error& e) {
387 return RESTERR(req,
HTTP_BAD_REQUEST,
"Invalid URI format. Expected /rest/blockfilterheaders/<filtertype>/<blockhash>.<ext>?count=<count>");
390 const auto parsed_count{ToIntegral<size_t>(raw_count)};
410 std::vector<const CBlockIndex*> headers;
411 headers.reserve(*parsed_count);
414 if (!maybe_chainman)
return false;
419 while (pindex !=
nullptr && active_chain.
Contains(pindex)) {
420 headers.push_back(pindex);
421 if (headers.size() == *parsed_count)
423 pindex = active_chain.
Next(pindex);
427 bool index_ready = index->BlockUntilSyncedToCurrentChain();
429 std::vector<uint256> filter_headers;
430 filter_headers.reserve(*parsed_count);
434 std::string errmsg =
"Filter not found.";
437 errmsg +=
" Block filters are still in the process of being indexed.";
439 errmsg +=
" This error is unexpected and indicates index corruption.";
444 filter_headers.push_back(filter_header);
450 for (
const uint256& header : filter_headers) {
454 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
460 for (
const uint256& header : filter_headers) {
464 std::string strHex =
HexStr(ssHeader) +
"\n";
471 for (
const uint256& header : filter_headers) {
475 std::string strJSON = jsonHeaders.
write() +
"\n";
476 req->
WriteHeader(
"Content-Type",
"application/json");
494 std::vector<std::string> uri_parts =
SplitString(param,
'/');
495 if (uri_parts.size() != 2) {
496 return RESTERR(req,
HTTP_BAD_REQUEST,
"Invalid URI format. Expected /rest/blockfilter/<filtertype>/<blockhash>");
515 bool block_was_connected;
518 if (!maybe_chainman)
return false;
528 bool index_ready = index->BlockUntilSyncedToCurrentChain();
532 std::string errmsg =
"Filter not found.";
534 if (!block_was_connected) {
535 errmsg +=
" Block was not connected to active chain.";
536 }
else if (!index_ready) {
537 errmsg +=
" Block filters are still in the process of being indexed.";
539 errmsg +=
" This error is unexpected and indicates index corruption.";
550 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
558 std::string strHex =
HexStr(ssResp) +
"\n";
566 std::string strJSON =
ret.write() +
"\n";
567 req->
WriteHeader(
"Content-Type",
"application/json");
593 std::string strJSON = chainInfoObject.
write() +
"\n";
594 req->
WriteHeader(
"Content-Type",
"application/json");
611 std::string hash_str;
620 if (!hash_str.empty()) {
627 if (!chainman)
return false;
635 req->
WriteHeader(
"Content-Type",
"application/json");
653 if (param !=
"contents" && param !=
"info") {
658 if (!mempool)
return false;
662 std::string str_json;
663 if (param ==
"contents") {
664 std::string raw_verbose;
667 }
catch (
const std::runtime_error& e) {
670 if (raw_verbose !=
"true" && raw_verbose !=
"false") {
671 return RESTERR(req,
HTTP_BAD_REQUEST,
"The \"verbose\" query parameter must be either \"true\" or \"false\".");
673 std::string raw_mempool_sequence;
675 raw_mempool_sequence = req->
GetQueryParameter(
"mempool_sequence").value_or(
"false");
676 }
catch (
const std::runtime_error& e) {
679 if (raw_mempool_sequence !=
"true" && raw_mempool_sequence !=
"false") {
680 return RESTERR(req,
HTTP_BAD_REQUEST,
"The \"mempool_sequence\" query parameter must be either \"true\" or \"false\".");
682 const bool verbose{raw_verbose ==
"true"};
683 const bool mempool_sequence{raw_mempool_sequence ==
"true"};
684 if (verbose && mempool_sequence) {
685 return RESTERR(req,
HTTP_BAD_REQUEST,
"Verbose results cannot contain mempool sequence values. (hint: set \"verbose=false\")");
692 req->
WriteHeader(
"Content-Type",
"application/json");
715 g_txindex->BlockUntilSyncedToCurrentChain();
719 if (!
node)
return false;
731 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
740 std::string strHex =
HexStr(ssTx) +
"\n";
749 std::string strJSON = objTx.
write() +
"\n";
750 req->
WriteHeader(
"Content-Type",
"application/json");
768 std::vector<std::string> uriParts;
769 if (param.length() > 1)
771 std::string strUriParams = param.substr(1);
776 std::string strRequestMutable = req->
ReadBody();
777 if (strRequestMutable.length() == 0 && uriParts.size() == 0)
780 bool fInputParsed =
false;
781 bool fCheckMemPool =
false;
782 std::vector<COutPoint> vOutPoints;
787 if (uriParts.size() > 0)
790 if (uriParts[0] ==
"checkmempool") fCheckMemPool =
true;
792 for (
size_t i = (fCheckMemPool) ? 1 : 0; i < uriParts.size(); i++)
794 const auto txid_out{util::Split<std::string_view>(uriParts[i],
'-')};
795 if (txid_out.size() != 2) {
799 auto output{ToIntegral<uint32_t>(txid_out.at(1))};
801 if (!txid || !output) {
805 vOutPoints.emplace_back(*txid, *output);
808 if (vOutPoints.size() > 0)
817 std::vector<unsigned char> strRequestV =
ParseHex(strRequestMutable);
818 strRequestMutable.assign(strRequestV.begin(), strRequestV.end());
825 if (strRequestMutable.size() > 0)
831 oss << strRequestMutable;
832 oss >> fCheckMemPool;
835 }
catch (
const std::ios_base::failure&) {
857 std::vector<unsigned char> bitmap;
858 std::vector<CCoin> outs;
859 std::string bitmapStringRepresentation;
860 std::vector<bool> hits;
861 bitmap.resize((vOutPoints.size() + 7) / 8);
863 if (!maybe_chainman)
return false;
869 for (
const COutPoint& vOutPoint : vOutPoints) {
871 bool hit = (!mempool || !mempool->isSpent(vOutPoint)) && view.GetCoin(vOutPoint, coin);
873 if (hit) outs.emplace_back(std::move(coin));
881 if (!mempool)
return false;
886 process_utxos(viewMempool, mempool);
892 for (
size_t i = 0; i < hits.size(); ++i) {
893 const bool hit = hits[i];
894 bitmapStringRepresentation.append(hit ?
"1" :
"0");
895 bitmap[i / 8] |= ((uint8_t)hit) << (i % 8);
904 ssGetUTXOResponse << active_height << active_hash << bitmap << outs;
906 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
913 ssGetUTXOResponse << active_height << active_hash << bitmap << outs;
914 std::string strHex =
HexStr(ssGetUTXOResponse) +
"\n";
926 objGetUTXOResponse.
pushKV(
"chainHeight", active_height);
927 objGetUTXOResponse.
pushKV(
"chaintipHash", active_hash.
GetHex());
928 objGetUTXOResponse.
pushKV(
"bitmap", bitmapStringRepresentation);
931 for (
const CCoin& coin : outs) {
933 utxo.
pushKV(
"height", (int32_t)coin.nHeight);
939 utxo.
pushKV(
"scriptPubKey", std::move(o));
942 objGetUTXOResponse.
pushKV(
"utxos", std::move(utxos));
945 std::string strJSON = objGetUTXOResponse.
write() +
"\n";
946 req->
WriteHeader(
"Content-Type",
"application/json");
957 const std::string& str_uri_part)
960 std::string height_str;
963 int32_t blockheight = -1;
964 if (!
ParseInt32(height_str, &blockheight) || blockheight < 0) {
971 if (!maybe_chainman)
return false;
975 if (blockheight > active_chain.
Height()) {
978 pblockindex = active_chain[blockheight];
984 req->
WriteHeader(
"Content-Type",
"application/octet-stream");
994 req->
WriteHeader(
"Content-Type",
"application/json");
1006 static const struct {
#define PACKAGE_BUGREPORT
UniValue blockheaderToJSON(const CBlockIndex &tip, const CBlockIndex &blockindex)
Block header to JSON.
UniValue blockToJSON(BlockManager &blockman, const CBlock &block, const CBlockIndex &tip, const CBlockIndex &blockindex, TxVerbosity verbosity)
Block description to JSON.
bool BlockFilterTypeByName(const std::string &name, BlockFilterType &filter_type)
Find a filter type by its human-readable name.
BlockFilterIndex * GetBlockFilterIndex(BlockFilterType filter_type)
Get a block filter index by type.
@ BLOCK_VALID_SCRIPTS
Scripts & signatures ok.
Complete block filter struct as defined in BIP 157.
const std::vector< unsigned char > & GetEncodedFilter() const LIFETIMEBOUND
BlockFilterIndex is used to store and retrieve block filters, hashes, and headers for a range of bloc...
bool LookupFilter(const CBlockIndex *block_index, BlockFilter &filter_out) const
Get a single filter by block.
bool LookupFilterHeader(const CBlockIndex *block_index, uint256 &header_out) EXCLUSIVE_LOCKS_REQUIRED(!m_cs_headers_cache)
Get a single filter header by block.
The block chain is a tree shaped structure starting with the genesis block at the root,...
uint256 GetBlockHash() const
bool IsValid(enum BlockStatus nUpTo=BLOCK_VALID_TRANSACTIONS) const EXCLUSIVE_LOCKS_REQUIRED(
Check whether this block index entry is valid up to the passed validity level.
FlatFilePos GetBlockPos() const EXCLUSIVE_LOCKS_REQUIRED(
An in-memory indexed chain of blocks.
CBlockIndex * Next(const CBlockIndex *pindex) const
Find the successor of a block in this chain, or nullptr if the given index is not found or is the tip...
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
int Height() const
Return the maximal height in the chain.
bool Contains(const CBlockIndex *pindex) const
Efficiently check whether a block is present in this chain.
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Abstract view on the open txout dataset.
CCoinsView that brings transactions from a mempool into view.
An outpoint - a combination of a transaction hash and an index n into its vout.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
An output of a transaction.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CChain & ActiveChain() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
RecursiveMutex & GetMutex() const LOCK_RETURNED(
Alias for cs_main.
int ActiveHeight() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Double ended buffer combining vector and stream-like interfaces.
std::optional< std::string > GetQueryParameter(const std::string &key) const
Get the query parameter value from request uri for a specified key, or std::nullopt if the key is not...
void WriteReply(int nStatus, std::string_view reply="")
Write HTTP reply.
void WriteHeader(const std::string &hdr, const std::string &value)
Write output header.
std::string ReadBody()
Read request body.
UniValue HandleRequest(const JSONRPCRequest &request) const
void push_back(UniValue val)
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
void pushKV(std::string key, UniValue val)
std::string GetHex() const
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool ReadRawBlockFromDisk(std::vector< uint8_t > &block, const FlatFilePos &pos) const
static std::optional< transaction_identifier > FromHex(std::string_view hex)
static std::optional< uint256 > FromHex(std::string_view str)
void TxToUniv(const CTransaction &tx, const uint256 &block_hash, UniValue &entry, bool include_hex=true, const CTxUndo *txundo=nullptr, TxVerbosity verbosity=TxVerbosity::SHOW_DETAILS)
TxVerbosity
Verbose level for block's transaction.
@ SHOW_DETAILS_AND_PREVOUT
The same as previous option with information about prevouts if available.
@ SHOW_TXID
Only TXID for each block's transaction.
void ScriptToUniv(const CScript &script, UniValue &out, bool include_hex=true, bool include_address=false, const SigningProvider *provider=nullptr)
UniValue ValueFromAmount(const CAmount amount)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch)
Unregister handler for prefix.
void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler)
Register handler for prefix.
CTransactionRef GetTransaction(const CBlockIndex *const block_index, const CTxMemPool *const mempool, const uint256 &hash, uint256 &hashBlock, const BlockManager &blockman)
Return transaction with a given hash.
std::vector< std::string > SplitString(std::string_view str, char sep)
static constexpr TransactionSerParams TX_WITH_WITNESS
std::shared_ptr< const CTransaction > CTransactionRef
static constexpr unsigned int MAX_REST_HEADERS_RESULTS
static bool rest_blockhash_by_height(const std::any &context, HTTPRequest *req, const std::string &str_uri_part)
static ChainstateManager * GetChainman(const std::any &context, HTTPRequest *req)
Get the node context chainstatemanager.
static bool rest_block_filter(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
static bool rest_getutxos(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
static bool rest_headers(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
static bool rest_tx(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
void StartREST(const std::any &context)
Start HTTP REST subsystem.
static bool rest_block_notxdetails(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
bool(* handler)(const std::any &context, HTTPRequest *req, const std::string &strReq)
static const struct @10 uri_prefixes[]
void StopREST()
Stop HTTP REST subsystem.
RPCHelpMan getdeploymentinfo()
RPCHelpMan getblockchaininfo()
static CTxMemPool * GetMemPool(const std::any &context, HTTPRequest *req)
Get the node context mempool.
static bool rest_chaininfo(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
void InterruptREST()
Interrupt RPC REST subsystem.
static bool rest_deploymentinfo(const std::any &context, HTTPRequest *req, const std::string &str_uri_part)
static bool RESTERR(HTTPRequest *req, enum HTTPStatusCode status, std::string message)
static bool rest_mempool(const std::any &context, HTTPRequest *req, const std::string &str_uri_part)
static const struct @9 rf_names[]
static bool CheckWarmup(HTTPRequest *req)
static bool rest_block_extended(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
static NodeContext * GetNodeContext(const std::any &context, HTTPRequest *req)
Get the node context.
static bool rest_filter_header(const std::any &context, HTTPRequest *req, const std::string &strURIPart)
RESTResponseFormat ParseDataFormat(std::string ¶m, const std::string &strReq)
Parse a URI to get the data format and URI without data format and query string.
static bool rest_block(const std::any &context, HTTPRequest *req, const std::string &strURIPart, TxVerbosity tx_verbosity)
static const size_t MAX_GETUTXOS_OUTPOINTS
static std::string AvailableDataFormatsString()
UniValue MempoolInfoToJSON(const CTxMemPool &pool)
Mempool information to JSON.
UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose, bool include_mempool_sequence)
Mempool to JSON.
HTTPStatusCode
HTTP status codes.
@ HTTP_SERVICE_UNAVAILABLE
@ HTTP_INTERNAL_SERVER_ERROR
bool RPCIsInWarmup(std::string *outStatus)
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
SERIALIZE_METHODS(CCoin, obj)
NodeContext struct containing references to chain state and connection state.
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
std::unique_ptr< TxIndex > g_txindex
The global transaction index, used in GetTransaction. May be null.
bool ParseInt32(std::string_view str, int32_t *out)
Convert string to signed 32-bit integer with strict parse error feedback.
std::string SanitizeString(std::string_view str, int rule)
Remove unsafe chars.