onion-wownero-blockchain-ex.../main.cpp

804 lines
26 KiB
C++
Raw Normal View History

2016-12-19 01:47:19 +00:00
#define CROW_ENABLE_SSL
2016-04-06 06:53:37 +00:00
2016-09-06 10:34:07 +00:00
2017-06-04 01:42:11 +00:00
#include "src/page.h"
#include "ext/crow/crow.h"
2016-04-13 08:46:08 +00:00
#include "src/CmdLineOptions.h"
2016-04-06 06:53:37 +00:00
#include "src/MicroCore.h"
2016-04-08 06:54:04 +00:00
2016-04-07 07:01:49 +00:00
#include <fstream>
#include <regex>
2016-04-06 06:53:37 +00:00
using boost::filesystem::path;
using xmreg::remove_bad_chars;
2016-04-06 06:53:37 +00:00
using namespace std;
2017-05-04 00:43:00 +00:00
namespace myxmr
{
struct jsonresponse: crow::response
{
jsonresponse(const nlohmann::json& _body)
: crow::response {_body.dump()}
2017-05-04 00:43:00 +00:00
{
add_header("Access-Control-Allow-Origin", "*");
add_header("Access-Control-Allow-Headers", "Content-Type");
add_header("Content-Type", "application/json");
}
};
}
int
main(int ac, const char* av[])
2017-05-17 05:30:36 +00:00
{
2016-04-13 08:46:08 +00:00
// get command line options
xmreg::CmdLineOptions opts {ac, av};
auto help_opt = opts.get_option<bool>("help");
2016-04-13 08:46:08 +00:00
// if help was chosen, display help text and finish
if (*help_opt)
{
2016-05-07 10:37:26 +00:00
return EXIT_SUCCESS;
2016-04-13 08:46:08 +00:00
}
auto port_opt = opts.get_option<string>("port");
auto bc_path_opt = opts.get_option<string>("bc-path");
auto deamon_url_opt = opts.get_option<string>("deamon-url");
auto ssl_crt_file_opt = opts.get_option<string>("ssl-crt-file");
auto ssl_key_file_opt = opts.get_option<string>("ssl-key-file");
auto no_blocks_on_index_opt = opts.get_option<string>("no-blocks-on-index");
auto testnet_url = opts.get_option<string>("testnet-url");
auto stagenet_url = opts.get_option<string>("stagenet-url");
auto mainnet_url = opts.get_option<string>("mainnet-url");
auto mempool_info_timeout_opt = opts.get_option<string>("mempool-info-timeout");
2017-06-02 04:32:25 +00:00
auto mempool_refresh_time_opt = opts.get_option<string>("mempool-refresh-time");
auto testnet_opt = opts.get_option<bool>("testnet");
auto stagenet_opt = opts.get_option<bool>("stagenet");
auto enable_key_image_checker_opt = opts.get_option<bool>("enable-key-image-checker");
auto enable_output_key_checker_opt = opts.get_option<bool>("enable-output-key-checker");
auto enable_autorefresh_option_opt = opts.get_option<bool>("enable-autorefresh-option");
auto enable_pusher_opt = opts.get_option<bool>("enable-pusher");
2018-01-12 23:18:44 +00:00
auto enable_js_opt = opts.get_option<bool>("enable-js");
auto enable_mixin_details_opt = opts.get_option<bool>("enable-mixin-details");
auto enable_json_api_opt = opts.get_option<bool>("enable-json-api");
auto enable_tx_cache_opt = opts.get_option<bool>("enable-tx-cache");
auto enable_block_cache_opt = opts.get_option<bool>("enable-block-cache");
auto show_cache_times_opt = opts.get_option<bool>("show-cache-times");
2017-05-17 05:30:36 +00:00
auto enable_emission_monitor_opt = opts.get_option<bool>("enable-emission-monitor");
bool testnet {*testnet_opt};
bool stagenet {*stagenet_opt};
2018-03-27 00:16:02 +00:00
if (testnet && stagenet)
{
cerr << "testnet and stagenet cannot be specified at the same time!" << endl;
return EXIT_FAILURE;
}
2018-03-27 00:16:02 +00:00
const cryptonote::network_type nettype = testnet ?
cryptonote::network_type::TESTNET : stagenet ?
cryptonote::network_type::STAGENET : cryptonote::network_type::MAINNET;
bool enable_pusher {*enable_pusher_opt};
2018-01-12 23:18:44 +00:00
bool enable_js {*enable_js_opt};
bool enable_key_image_checker {*enable_key_image_checker_opt};
bool enable_autorefresh_option {*enable_autorefresh_option_opt};
bool enable_output_key_checker {*enable_output_key_checker_opt};
bool enable_mixin_details {*enable_mixin_details_opt};
bool enable_json_api {*enable_json_api_opt};
bool enable_tx_cache {*enable_tx_cache_opt};
bool enable_block_cache {*enable_block_cache_opt};
2017-05-17 05:30:36 +00:00
bool enable_emission_monitor {*enable_emission_monitor_opt};
bool show_cache_times {*show_cache_times_opt};
2016-09-06 11:19:10 +00:00
2016-04-13 08:46:08 +00:00
// set monero log output level
uint32_t log_level = 0;
mlog_configure("", true);
//cast port number in string to uint
2016-04-13 08:46:08 +00:00
uint16_t app_port = boost::lexical_cast<uint16_t>(*port_opt);
// cast no_blocks_on_index_opt to uint
uint64_t no_blocks_on_index = boost::lexical_cast<uint64_t>(*no_blocks_on_index_opt);
2016-12-19 01:47:19 +00:00
bool use_ssl {false};
string ssl_crt_file;
string ssl_key_file;
// check if ssl enabled and files exist
if (ssl_crt_file_opt and ssl_key_file_opt)
{
if (!boost::filesystem::exists(boost::filesystem::path(*ssl_crt_file_opt)))
{
cerr << "ssl_crt_file path: " << *ssl_crt_file_opt
<< "does not exist!" << endl;
return EXIT_FAILURE;
}
if (!boost::filesystem::exists(boost::filesystem::path(*ssl_key_file_opt)))
{
cerr << "ssl_key_file path: " << *ssl_key_file_opt
<< "does not exist!" << endl;
return EXIT_FAILURE;
}
ssl_crt_file = *ssl_crt_file_opt;
ssl_key_file = *ssl_key_file_opt;
use_ssl = true;
}
2016-04-16 09:58:21 +00:00
// get blockchain path
path blockchain_path;
2016-04-06 06:53:37 +00:00
if (!xmreg::get_blockchain_path(bc_path_opt, blockchain_path, nettype))
2016-04-16 09:58:21 +00:00
{
cerr << "Error getting blockchain path." << endl;
2016-05-07 10:37:26 +00:00
return EXIT_FAILURE;
2016-04-16 09:58:21 +00:00
}
2016-04-06 06:53:37 +00:00
2016-09-06 11:19:10 +00:00
cout << blockchain_path << endl;
2017-05-16 05:29:24 +00:00
2016-04-06 09:15:09 +00:00
// create instance of our MicroCore
2016-04-16 09:58:21 +00:00
// and make pointer to the Blockchain
2016-04-06 09:15:09 +00:00
xmreg::MicroCore mcore;
2016-04-07 05:41:15 +00:00
cryptonote::Blockchain* core_storage;
2016-04-06 09:15:09 +00:00
2016-04-16 09:58:21 +00:00
// initialize mcore and core_storage
2016-04-07 05:41:15 +00:00
if (!xmreg::init_blockchain(blockchain_path.string(),
mcore, core_storage))
2016-04-06 09:15:09 +00:00
{
cerr << "Error accessing blockchain." << endl;
2016-05-07 10:37:26 +00:00
return EXIT_FAILURE;
2016-04-06 09:15:09 +00:00
}
2016-09-06 11:19:10 +00:00
string deamon_url {*deamon_url_opt};
if (testnet && deamon_url == "http:://127.0.0.1:18081")
2016-09-06 11:19:10 +00:00
deamon_url = "http:://127.0.0.1:28081";
if (stagenet && deamon_url == "http:://127.0.0.1:18081")
deamon_url = "http:://127.0.0.1:38081";
2017-05-17 00:20:43 +00:00
uint64_t mempool_info_timeout {5000};
2017-06-02 04:32:25 +00:00
try
{
mempool_info_timeout = boost::lexical_cast<uint64_t>(*mempool_info_timeout_opt);
}
catch (boost::bad_lexical_cast &e)
{
cout << "Cant cast " << (*mempool_info_timeout_opt) <<" into numbers. Using default values."
<< endl;
}
2017-06-02 04:32:25 +00:00
uint64_t mempool_refresh_time {10};
2017-05-17 00:20:43 +00:00
2017-05-17 05:30:36 +00:00
if (enable_emission_monitor == true)
2017-05-17 00:20:43 +00:00
{
2017-05-17 05:30:36 +00:00
// This starts new thread, which aim is
// to calculate, store and monitor
// current total Monero emission amount.
// This thread stores the current emission
// which it has caluclated in
// <blockchain_path>/emission_amount.txt file,
// e.g., ~/.bitmonero/lmdb/emission_amount.txt.
// So instead of calcualting the emission
// from scrach whenever the explorer is started,
// the thread is initalized with the values
// found in emission_amount.txt file.
xmreg::CurrentBlockchainStatus::blockchain_path
= blockchain_path;
xmreg::CurrentBlockchainStatus::nettype
= nettype;
2017-05-17 05:30:36 +00:00
xmreg::CurrentBlockchainStatus::deamon_url
= deamon_url;
xmreg::CurrentBlockchainStatus::set_blockchain_variables(
&mcore, core_storage);
2017-05-17 00:20:43 +00:00
2017-05-17 05:30:36 +00:00
// launch the status monitoring thread so that it keeps track of blockchain
// info, e.g., current height. Information from this thread is used
// by tx searching threads that are launched for each user independently,
// when they log back or create new account.
xmreg::CurrentBlockchainStatus::start_monitor_blockchain_thread();
}
2016-09-06 11:19:10 +00:00
xmreg::MempoolStatus::blockchain_path
= blockchain_path;
xmreg::MempoolStatus::nettype
= nettype;
xmreg::MempoolStatus::deamon_url
= deamon_url;
xmreg::MempoolStatus::set_blockchain_variables(
&mcore, core_storage);
xmreg::MempoolStatus::network_info initial_info;
strcpy(initial_info.block_size_limit_str, "0.0");
strcpy(initial_info.block_size_median_str, "0.0");
xmreg::MempoolStatus::current_network_info = initial_info;
2017-06-02 04:32:25 +00:00
try
{
mempool_refresh_time = boost::lexical_cast<uint64_t>(*mempool_refresh_time_opt);
}
catch (boost::bad_lexical_cast &e)
{
cout << "Cant cast " << (*mempool_refresh_time_opt)
<<" into number. Using default value."
<< endl;
}
// launch the status monitoring thread so that it keeps track of blockchain
// info, e.g., current height. Information from this thread is used
// by tx searching threads that are launched for each user independently,
// when they log back or create new account.
2017-06-02 04:32:25 +00:00
xmreg::MempoolStatus::mempool_refresh_time = mempool_refresh_time;
xmreg::MempoolStatus::start_mempool_status_thread();
2016-04-14 07:58:01 +00:00
// create instance of page class which
2016-04-16 09:58:21 +00:00
// contains logic for the website
xmreg::page xmrblocks(&mcore,
core_storage,
2016-09-06 11:19:10 +00:00
deamon_url,
nettype,
enable_pusher,
2018-01-12 23:18:44 +00:00
enable_js,
enable_key_image_checker,
enable_output_key_checker,
enable_autorefresh_option,
enable_mixin_details,
enable_tx_cache,
enable_block_cache,
show_cache_times,
no_blocks_on_index,
mempool_info_timeout,
*testnet_url,
*stagenet_url,
*mainnet_url);
2016-04-07 06:32:28 +00:00
2016-04-14 07:58:01 +00:00
// crow instance
2016-04-06 06:53:37 +00:00
crow::SimpleApp app;
2017-09-02 00:59:45 +00:00
// get domian url based on the request
auto get_domain = [&use_ssl](crow::request const& req) {
return (use_ssl ? "https://" : "http://")
+ req.get_header_value("Host");
};
2016-04-06 06:53:37 +00:00
CROW_ROUTE(app, "/")
2016-08-20 09:16:18 +00:00
([&](const crow::request& req) {
2016-08-20 10:37:37 +00:00
return crow::response(xmrblocks.index2());
2016-04-12 03:31:26 +00:00
});
2016-04-15 02:59:41 +00:00
CROW_ROUTE(app, "/page/<uint>")
([&](size_t page_no) {
2016-05-01 02:13:44 +00:00
return xmrblocks.index2(page_no);
2016-04-15 02:59:41 +00:00
});
2016-04-15 23:07:47 +00:00
CROW_ROUTE(app, "/block/<uint>")
([&](const crow::request& req, size_t block_height) {
return crow::response(xmrblocks.show_block(block_height));
2016-04-15 23:07:47 +00:00
});
CROW_ROUTE(app, "/block/<string>")
([&](const crow::request& req, string block_hash) {
return crow::response(xmrblocks.show_block(remove_bad_chars(block_hash)));
});
2016-08-20 09:16:18 +00:00
2016-04-18 05:57:38 +00:00
CROW_ROUTE(app, "/tx/<string>")
2016-08-20 09:20:12 +00:00
([&](const crow::request& req, string tx_hash) {
return crow::response(xmrblocks.show_tx(remove_bad_chars(tx_hash)));
2016-04-18 05:57:38 +00:00
});
2016-04-15 23:07:47 +00:00
CROW_ROUTE(app, "/tx/<string>/<uint>")
2017-12-19 22:31:04 +00:00
([&](string tx_hash, uint16_t with_ring_signatures)
{
return xmrblocks.show_tx(remove_bad_chars(tx_hash), with_ring_signatures);
});
CROW_ROUTE(app, "/myoutputs").methods("POST"_method)
2017-12-19 22:31:04 +00:00
([&](const crow::request& req)
{
2016-05-09 05:53:33 +00:00
map<std::string, std::string> post_body
= xmreg::parse_crow_post_data(req.body);
if (post_body.count("xmr_address") == 0
|| post_body.count("viewkey") == 0
|| post_body.count("tx_hash") == 0)
{
2017-01-18 12:15:15 +00:00
return string("xmr address, viewkey or tx hash not provided");
}
string tx_hash = remove_bad_chars(post_body["tx_hash"]);
string xmr_address = remove_bad_chars(post_body["xmr_address"]);
string viewkey = remove_bad_chars(post_body["viewkey"]);
2016-05-09 05:53:33 +00:00
// this will be only not empty when checking raw tx data
// using tx pusher
string raw_tx_data = remove_bad_chars(post_body["raw_tx_data"]);
2017-09-02 00:59:45 +00:00
string domain = get_domain(req);
return xmrblocks.show_my_outputs(tx_hash, xmr_address,
viewkey, raw_tx_data,
domain);
});
CROW_ROUTE(app, "/myoutputs/<string>/<string>/<string>")
([&](const crow::request& req, string tx_hash,
2017-12-19 22:31:04 +00:00
string xmr_address, string viewkey)
{
2017-09-02 00:59:45 +00:00
string domain = get_domain(req);
return xmrblocks.show_my_outputs(remove_bad_chars(tx_hash),
remove_bad_chars(xmr_address),
remove_bad_chars(viewkey),
string {},
2017-09-02 00:59:45 +00:00
domain);
2016-05-09 03:44:36 +00:00
});
2016-04-24 03:42:49 +00:00
CROW_ROUTE(app, "/prove").methods("POST"_method)
([&](const crow::request& req) {
2016-09-18 02:12:40 +00:00
map<std::string, std::string> post_body
= xmreg::parse_crow_post_data(req.body);
2016-09-18 02:12:40 +00:00
2017-01-18 12:15:15 +00:00
if (post_body.count("xmraddress") == 0
|| post_body.count("txprvkey") == 0
2017-01-18 12:15:15 +00:00
|| post_body.count("txhash") == 0)
{
return string("xmr address, tx private key or "
"tx hash not provided");
}
2016-09-18 02:12:40 +00:00
string tx_hash = remove_bad_chars(post_body["txhash"]);
string tx_prv_key = remove_bad_chars(post_body["txprvkey"]);
string xmr_address = remove_bad_chars(post_body["xmraddress"]);
2017-11-20 00:39:08 +00:00
// this will be only not empty when checking raw tx data
// using tx pusher
string raw_tx_data = remove_bad_chars(post_body["raw_tx_data"]);
2017-09-02 00:59:45 +00:00
string domain = get_domain(req);
return xmrblocks.show_prove(tx_hash,
xmr_address,
tx_prv_key,
raw_tx_data,
domain);
2017-09-02 00:59:45 +00:00
});
CROW_ROUTE(app, "/prove/<string>/<string>/<string>")
([&](const crow::request& req, string tx_hash,
string xmr_address, string tx_prv_key) {
string domain = get_domain(req);
return xmrblocks.show_prove(remove_bad_chars(tx_hash),
remove_bad_chars(xmr_address),
remove_bad_chars(tx_prv_key),
string {},
domain);
2016-09-18 02:12:40 +00:00
});
if (enable_pusher)
{
CROW_ROUTE(app, "/rawtx")
([&](const crow::request& req) {
return xmrblocks.show_rawtx();
});
2016-09-27 23:44:39 +00:00
CROW_ROUTE(app, "/checkandpush").methods("POST"_method)
([&](const crow::request& req) {
2016-09-27 23:44:39 +00:00
map<std::string, std::string> post_body
= xmreg::parse_crow_post_data(req.body);
2016-09-27 23:44:39 +00:00
if (post_body.count("rawtxdata") == 0 || post_body.count("action") == 0)
{
return string("Raw tx data or action not provided");
}
2016-09-27 23:44:39 +00:00
string raw_tx_data = remove_bad_chars(post_body["rawtxdata"]);
string action = remove_bad_chars(post_body["action"]);
2016-10-11 04:01:46 +00:00
if (action == "check")
return xmrblocks.show_checkrawtx(raw_tx_data, action);
else if (action == "push")
return xmrblocks.show_pushrawtx(raw_tx_data, action);
return string("Provided action is neither check nor push");
2016-10-11 04:01:46 +00:00
});
}
2016-10-24 04:12:40 +00:00
if (enable_key_image_checker)
{
CROW_ROUTE(app, "/rawkeyimgs")
([&](const crow::request& req) {
return xmrblocks.show_rawkeyimgs();
});
2016-10-24 04:12:40 +00:00
CROW_ROUTE(app, "/checkrawkeyimgs").methods("POST"_method)
([&](const crow::request& req) {
2016-10-24 04:12:40 +00:00
map<std::string, std::string> post_body
= xmreg::parse_crow_post_data(req.body);
2016-10-24 04:12:40 +00:00
if (post_body.count("rawkeyimgsdata") == 0)
{
return string("Raw key images data not given");
}
if (post_body.count("viewkey") == 0)
{
return string("Viewkey not provided. Cant decrypt key image file without it");
}
string raw_data = remove_bad_chars(post_body["rawkeyimgsdata"]);
string viewkey = remove_bad_chars(post_body["viewkey"]);
return xmrblocks.show_checkrawkeyimgs(raw_data, viewkey);
});
}
2016-10-11 04:01:46 +00:00
if (enable_output_key_checker)
{
CROW_ROUTE(app, "/rawoutputkeys")
([&](const crow::request& req) {
return xmrblocks.show_rawoutputkeys();
});
CROW_ROUTE(app, "/checkrawoutputkeys").methods("POST"_method)
([&](const crow::request& req) {
map<std::string, std::string> post_body
= xmreg::parse_crow_post_data(req.body);
if (post_body.count("rawoutputkeysdata") == 0)
{
return string("Raw output keys data not given");
}
if (post_body.count("viewkey") == 0)
{
return string("Viewkey not provided. Cant decrypt "
"key image file without it");
}
string raw_data = remove_bad_chars(post_body["rawoutputkeysdata"]);
string viewkey = remove_bad_chars(post_body["viewkey"]);
return xmrblocks.show_checkcheckrawoutput(raw_data, viewkey);
});
}
2016-04-24 03:42:49 +00:00
CROW_ROUTE(app, "/search").methods("GET"_method)
2016-05-06 01:00:22 +00:00
([&](const crow::request& req) {
return xmrblocks.search(remove_bad_chars(string(req.url_params.get("value"))));
2016-04-24 03:42:49 +00:00
});
2017-01-20 01:36:35 +00:00
CROW_ROUTE(app, "/mempool")
([&](const crow::request& req) {
2017-01-20 01:43:09 +00:00
return xmrblocks.mempool(true);
2017-01-20 01:36:35 +00:00
});
// alias to "/mempool"
CROW_ROUTE(app, "/txpool")
([&](const crow::request& req) {
return xmrblocks.mempool(true);
});
2017-08-20 00:21:38 +00:00
// CROW_ROUTE(app, "/altblocks")
// ([&](const crow::request& req) {
// return xmrblocks.altblocks();
// });
2017-06-22 02:00:38 +00:00
2016-11-23 23:13:34 +00:00
CROW_ROUTE(app, "/robots.txt")
([&]() {
string text = "User-agent: *\n"
"Disallow: ";
return text;
});
2016-08-20 08:59:24 +00:00
2018-01-12 23:18:44 +00:00
if (enable_js)
{
cout << "Enable JavaScript checking of outputs and proving txs\n";
CROW_ROUTE(app, "/js/jquery.min.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("jquery.min.js");
});
CROW_ROUTE(app, "/js/crc32.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("crc32.js");
});
2018-01-14 01:34:35 +00:00
CROW_ROUTE(app, "/js/biginteger.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("biginteger.js");
});
2018-01-12 23:18:44 +00:00
CROW_ROUTE(app, "/js/crypto.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("crypto.js");
});
2018-01-14 01:34:35 +00:00
CROW_ROUTE(app, "/js/config.js")
2018-01-12 23:18:44 +00:00
([&](const crow::request& req) {
2018-01-14 01:34:35 +00:00
return xmrblocks.get_js_file("config.js");
2018-01-12 23:18:44 +00:00
});
2018-01-14 05:38:49 +00:00
CROW_ROUTE(app, "/js/nacl-fast-cn.js")
2018-01-12 23:18:44 +00:00
([&](const crow::request& req) {
return xmrblocks.get_js_file("nacl-fast-cn.js");
});
CROW_ROUTE(app, "/js/base58.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("base58.js");
});
CROW_ROUTE(app, "/js/cn_util.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("cn_util.js");
});
2018-01-14 01:34:35 +00:00
CROW_ROUTE(app, "/js/sha3.js")
([&](const crow::request& req) {
return xmrblocks.get_js_file("sha3.js");
});
CROW_ROUTE(app, "/js/all_in_one.js")
([&](const crow::request& req) {
2018-02-01 03:58:43 +00:00
// /js/all_in_one.js file does not exist. it is generated on the fly
// from the above real files.
return xmrblocks.get_js_file("all_in_one.js");
});
2018-02-01 03:58:43 +00:00
} // if (enable_js)
2018-01-12 23:18:44 +00:00
if (enable_json_api)
{
2018-01-12 23:18:44 +00:00
cout << "Enable JSON API\n";
CROW_ROUTE(app, "/api/transaction/<string>")
([&](const crow::request &req, string tx_hash) {
myxmr::jsonresponse r{xmrblocks.json_transaction(remove_bad_chars(tx_hash))};
return r;
});
2017-05-11 03:38:29 +00:00
CROW_ROUTE(app, "/api/rawtransaction/<string>")
([&](const crow::request &req, string tx_hash) {
myxmr::jsonresponse r{xmrblocks.json_rawtransaction(remove_bad_chars(tx_hash))};
2017-05-11 03:38:29 +00:00
return r;
});
CROW_ROUTE(app, "/api/block/<string>")
([&](const crow::request &req, string block_no_or_hash) {
myxmr::jsonresponse r{xmrblocks.json_block(remove_bad_chars(block_no_or_hash))};
return r;
});
2017-05-11 03:38:29 +00:00
CROW_ROUTE(app, "/api/rawblock/<string>")
([&](const crow::request &req, string block_no_or_hash) {
myxmr::jsonresponse r{xmrblocks.json_rawblock(remove_bad_chars(block_no_or_hash))};
2017-05-11 03:38:29 +00:00
return r;
});
CROW_ROUTE(app, "/api/transactions").methods("GET"_method)
([&](const crow::request &req) {
string page = regex_search(req.raw_url, regex {"page=\\d+"}) ?
req.url_params.get("page") : "0";
string limit = regex_search(req.raw_url, regex {"limit=\\d+"}) ?
req.url_params.get("limit") : "25";
myxmr::jsonresponse r{xmrblocks.json_transactions(
remove_bad_chars(page), remove_bad_chars(limit))};
return r;
});
2017-05-10 00:42:06 +00:00
CROW_ROUTE(app, "/api/mempool").methods("GET"_method)
([&](const crow::request &req) {
2017-05-10 00:42:06 +00:00
string page = regex_search(req.raw_url, regex {"page=\\d+"}) ?
req.url_params.get("page") : "0";
// default value for limit is some large number, so that
// a call to api/mempool without any limit return all
// mempool txs
2017-05-10 00:42:06 +00:00
string limit = regex_search(req.raw_url, regex {"limit=\\d+"}) ?
req.url_params.get("limit") : "100000000";
2017-05-10 00:42:06 +00:00
myxmr::jsonresponse r{xmrblocks.json_mempool(
remove_bad_chars(page), remove_bad_chars(limit))};
return r;
});
CROW_ROUTE(app, "/api/search/<string>")
([&](const crow::request &req, string search_value) {
myxmr::jsonresponse r{xmrblocks.json_search(remove_bad_chars(search_value))};
return r;
});
2017-05-11 04:17:10 +00:00
CROW_ROUTE(app, "/api/networkinfo")
([&](const crow::request &req) {
myxmr::jsonresponse r{xmrblocks.json_networkinfo()};
return r;
});
2017-05-19 09:50:12 +00:00
CROW_ROUTE(app, "/api/emission")
([&](const crow::request &req) {
myxmr::jsonresponse r{xmrblocks.json_emission()};
return r;
});
CROW_ROUTE(app, "/api/outputs").methods("GET"_method)
([&](const crow::request &req) {
string tx_hash = regex_search(req.raw_url, regex {"txhash=\\w+"}) ?
req.url_params.get("txhash") : "";
string address = regex_search(req.raw_url, regex {"address=\\w+"}) ?
req.url_params.get("address") : "";
string viewkey = regex_search(req.raw_url, regex {"viewkey=\\w+"}) ?
req.url_params.get("viewkey") : "";
bool tx_prove{false};
2017-05-04 00:43:00 +00:00
try
{
tx_prove = regex_search(req.raw_url, regex {"txprove=[01]"}) ?
boost::lexical_cast<bool>(req.url_params.get("txprove")) :
false;
}
2017-05-04 00:43:00 +00:00
catch (const boost::bad_lexical_cast &e)
{
cerr << "Cant parse tx_prove as bool. Using default value" << endl;
}
myxmr::jsonresponse r{xmrblocks.json_outputs(
remove_bad_chars(tx_hash),
remove_bad_chars(address),
remove_bad_chars(viewkey),
tx_prove)};
return r;
});
CROW_ROUTE(app, "/api/outputsblocks").methods("GET"_method)
([&](const crow::request &req) {
string limit = regex_search(req.raw_url, regex {"limit=\\d+"}) ?
req.url_params.get("limit") : "3";
string address = regex_search(req.raw_url, regex {"address=\\w+"}) ?
req.url_params.get("address") : "";
string viewkey = regex_search(req.raw_url, regex {"viewkey=\\w+"}) ?
req.url_params.get("viewkey") : "";
bool in_mempool_aswell {false};
try
{
in_mempool_aswell = regex_search(req.raw_url, regex {"mempool=[01]"}) ?
boost::lexical_cast<bool>(req.url_params.get("mempool")) :
false;
}
catch (const boost::bad_lexical_cast &e)
{
cerr << "Cant parse tx_prove as bool. Using default value" << endl;
}
myxmr::jsonresponse r{xmrblocks.json_outputsblocks(
remove_bad_chars(limit),
remove_bad_chars(address),
remove_bad_chars(viewkey),
in_mempool_aswell)};
return r;
});
CROW_ROUTE(app, "/api/version")
([&](const crow::request &req) {
myxmr::jsonresponse r{xmrblocks.json_version()};
return r;
});
2018-02-01 03:58:43 +00:00
} // if (enable_json_api)
if (enable_autorefresh_option)
{
CROW_ROUTE(app, "/autorefresh")
([&]() {
uint64_t page_no {0};
bool refresh_page {true};
return xmrblocks.index2(page_no, refresh_page);
});
}
2016-04-12 03:31:26 +00:00
2016-04-14 07:58:01 +00:00
// run the crow http server
2016-12-19 01:47:19 +00:00
if (use_ssl)
{
cout << "Staring in ssl mode" << endl;
app.port(app_port).ssl_file(ssl_crt_file, ssl_key_file)
.multithreaded().run();
2016-12-19 01:47:19 +00:00
}
else
{
cout << "Staring in non-ssl mode" << endl;
app.port(app_port).multithreaded().run();
}
2016-04-06 06:53:37 +00:00
if (enable_emission_monitor == true)
{
// finish Emission monitoring thread in a cotrolled manner.
2017-06-04 01:42:11 +00:00
cout << "Waiting for emission monitoring thread to finish." << endl;
xmreg::CurrentBlockchainStatus::m_thread.interrupt();
xmreg::CurrentBlockchainStatus::m_thread.join();
2017-06-04 01:42:11 +00:00
cout << "Emission monitoring thread finished." << endl;
}
2017-06-04 01:42:11 +00:00
// finish mempool thread
cout << "Waiting for mempool monitoring thread to finish." << endl;
xmreg::MempoolStatus::m_thread.interrupt();
xmreg::MempoolStatus::m_thread.join();
2017-06-04 01:42:11 +00:00
cout << "Mempool monitoring thread finished." << endl;
2017-06-04 01:42:11 +00:00
cout << "The explorer is terminating." << endl;
2016-05-07 10:37:26 +00:00
return EXIT_SUCCESS;
2016-04-15 03:10:55 +00:00
}