2021-08-22 04:20:59 -06:00
|
|
|
/*
|
|
|
|
* This file is part of the Monero P2Pool <https://github.com/SChernykh/p2pool>
|
2023-01-04 05:07:55 -07:00
|
|
|
* Copyright (c) 2021-2023 SChernykh <https://github.com/SChernykh>
|
2021-08-22 04:20:59 -06:00
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, version 3.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "common.h"
|
|
|
|
#include "zmq_reader.h"
|
|
|
|
#include "json_parsers.h"
|
|
|
|
#include <rapidjson/document.h>
|
|
|
|
|
2023-08-16 05:00:11 -06:00
|
|
|
LOG_CATEGORY(ZMQReader)
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
namespace p2pool {
|
|
|
|
|
2022-08-31 08:37:33 -06:00
|
|
|
ZMQReader::ZMQReader(const std::string& address, uint32_t zmq_port, const std::string& proxy, MinerCallbackHandler* handler)
|
2023-06-16 07:51:33 -06:00
|
|
|
: m_monitor(nullptr)
|
2021-08-22 04:20:59 -06:00
|
|
|
, m_zmqPort(zmq_port)
|
2022-08-31 08:37:33 -06:00
|
|
|
, m_proxy(proxy)
|
2021-08-22 04:20:59 -06:00
|
|
|
, m_handler(handler)
|
|
|
|
, m_tx()
|
|
|
|
, m_minerData()
|
|
|
|
, m_chainmainData()
|
|
|
|
{
|
2022-08-31 08:37:33 -06:00
|
|
|
if (!m_proxy.empty() && is_localhost(address)) {
|
|
|
|
LOGINFO(5, "not using proxy to connect to localhost address " << log::Gray() << address);
|
|
|
|
m_proxy.clear();
|
|
|
|
}
|
|
|
|
|
2023-06-27 06:29:19 -06:00
|
|
|
char addr_buf[log::Stream::BUF_SIZE + 1];
|
|
|
|
addr_buf[0] = '\0';
|
|
|
|
|
2023-05-29 06:37:20 -06:00
|
|
|
std::random_device rd;
|
|
|
|
for (uint32_t port = 49152 + (rd() % 16384), i = 0; i < 100; ++i, port = (port < 65535) ? (port + 1) : 49152) {
|
2021-08-22 04:20:59 -06:00
|
|
|
try {
|
2023-06-27 06:29:19 -06:00
|
|
|
log::Stream s(addr_buf);
|
|
|
|
s << "tcp://127.0.0.1:" << port << '\0';
|
|
|
|
m_publisher.bind(addr_buf);
|
2023-05-29 06:37:20 -06:00
|
|
|
m_publisherPort = static_cast<uint16_t>(port);
|
2021-08-22 04:20:59 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
catch (const std::exception& e) {
|
|
|
|
LOGWARN(1, "failed to to bind port " << i << " for ZMQ publisher, error " << e.what());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!m_publisherPort) {
|
|
|
|
LOGERR(1, "failed to to bind ZMQ publisher port, aborting");
|
2022-05-11 03:44:42 -06:00
|
|
|
throw zmq::error_t(EFSM);
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
|
2023-05-30 04:58:03 -06:00
|
|
|
LOGINFO(5, "listening on tcp://127.0.0.1:" << m_publisherPort << " for internal communications");
|
|
|
|
|
2023-03-10 06:46:53 -07:00
|
|
|
m_subscriber.set(zmq::sockopt::connect_timeout, 1000);
|
|
|
|
|
2023-06-27 06:29:19 -06:00
|
|
|
std::string addr(addr_buf);
|
2023-06-16 07:51:33 -06:00
|
|
|
if (!connect(addr, false)) {
|
|
|
|
throw zmq::error_t(EFSM);
|
|
|
|
}
|
|
|
|
|
2023-03-10 06:46:53 -07:00
|
|
|
if (!m_proxy.empty()) {
|
|
|
|
m_subscriber.set(zmq::sockopt::socks_proxy, zmq::const_buffer(m_proxy.c_str(), m_proxy.length()));
|
|
|
|
}
|
|
|
|
|
2023-06-27 06:29:19 -06:00
|
|
|
log::Stream s(addr_buf);
|
|
|
|
s << "tcp://" << address << ':' << m_zmqPort << '\0';
|
|
|
|
addr.assign(addr_buf);
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
if (!connect(addr, true)) {
|
2023-03-10 06:46:53 -07:00
|
|
|
throw zmq::error_t(EFSM);
|
|
|
|
}
|
2023-06-27 06:29:19 -06:00
|
|
|
m_address = std::move(addr);
|
2023-03-10 06:46:53 -07:00
|
|
|
|
|
|
|
m_subscriber.set(zmq::sockopt::socks_proxy, zmq::const_buffer());
|
|
|
|
|
|
|
|
m_subscriber.set(zmq::sockopt::subscribe, "json-full-chain_main");
|
|
|
|
m_subscriber.set(zmq::sockopt::subscribe, "json-full-miner_data");
|
|
|
|
m_subscriber.set(zmq::sockopt::subscribe, "json-minimal-txpool_add");
|
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
const int err = uv_thread_create(&m_worker, run_wrapper, this);
|
|
|
|
if (err) {
|
2023-06-16 07:51:33 -06:00
|
|
|
LOGERR(1, "failed to start ZMQ worker thread, error " << uv_err_name(err));
|
2023-03-10 06:46:53 -07:00
|
|
|
throw zmq::error_t(EMTHREAD);
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ZMQReader::~ZMQReader()
|
|
|
|
{
|
|
|
|
LOGINFO(1, "stopping");
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
stop();
|
|
|
|
uv_thread_join(&m_worker);
|
|
|
|
|
|
|
|
delete m_monitor;
|
|
|
|
|
|
|
|
LOGINFO(1, "stopped");
|
|
|
|
}
|
|
|
|
|
|
|
|
void ZMQReader::stop()
|
|
|
|
{
|
|
|
|
if (m_stopped.exchange(true)) {
|
|
|
|
return;
|
|
|
|
}
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
try {
|
2023-06-16 07:51:33 -06:00
|
|
|
static constexpr char dummy_msg[] = "json-minimal-txpool_add:[]";
|
|
|
|
m_publisher.send(zmq::const_buffer(dummy_msg, sizeof(dummy_msg) - 1));
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
catch (const std::exception& e) {
|
2022-05-11 03:44:42 -06:00
|
|
|
LOGERR(1, "exception " << e.what());
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
void ZMQReader::monitor_thread(void* arg)
|
|
|
|
{
|
|
|
|
LOGINFO(1, "monitor thread ready");
|
|
|
|
|
|
|
|
ZMQReader* r = reinterpret_cast<ZMQReader*>(arg);
|
|
|
|
|
|
|
|
do {} while (!r->m_stopped && r->m_monitor->m_connected && r->m_monitor->check_event(-1));
|
|
|
|
|
|
|
|
// If not connected anymore, shut down ZMQReader entirely
|
|
|
|
r->stop();
|
|
|
|
|
|
|
|
LOGINFO(1, "monitor thread stopped");
|
|
|
|
}
|
|
|
|
|
2021-10-20 16:22:53 -06:00
|
|
|
void ZMQReader::run_wrapper(void* arg)
|
|
|
|
{
|
|
|
|
reinterpret_cast<ZMQReader*>(arg)->run();
|
|
|
|
LOGINFO(1, "worker thread stopped");
|
|
|
|
}
|
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
void ZMQReader::run()
|
|
|
|
{
|
2023-06-16 07:51:33 -06:00
|
|
|
m_workerThreadRunning = true;
|
|
|
|
ON_SCOPE_LEAVE([this]() { m_workerThreadRunning = false; });
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2023-03-10 06:46:53 -07:00
|
|
|
zmq_msg_t message = {};
|
2021-08-22 04:20:59 -06:00
|
|
|
|
2023-03-10 06:46:53 -07:00
|
|
|
try {
|
2021-08-27 02:32:31 -06:00
|
|
|
int rc = zmq_msg_init(&message);
|
|
|
|
if (rc != 0) {
|
2022-05-11 03:44:42 -06:00
|
|
|
throw zmq::error_t(errno);
|
2021-08-27 02:32:31 -06:00
|
|
|
}
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
const int err = uv_thread_create(&m_monitorThread, monitor_thread, this);
|
|
|
|
if (err) {
|
|
|
|
LOGERR(1, "failed to start ZMQ monitor thread, error " << uv_err_name(err));
|
|
|
|
throw zmq::error_t(EMTHREAD);
|
|
|
|
}
|
2023-06-20 08:53:03 -06:00
|
|
|
|
|
|
|
ON_SCOPE_LEAVE([this]() {
|
|
|
|
m_monitor->abort();
|
|
|
|
uv_thread_join(&m_monitorThread);
|
|
|
|
});
|
2023-06-16 07:51:33 -06:00
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
LOGINFO(1, "worker thread ready");
|
|
|
|
|
|
|
|
do {
|
|
|
|
rc = zmq_msg_recv(&message, m_subscriber, 0);
|
|
|
|
if (rc < 0) {
|
2022-05-11 03:44:42 -06:00
|
|
|
throw zmq::error_t(errno);
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
if (m_stopped) {
|
2021-08-22 04:20:59 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
parse(reinterpret_cast<char*>(zmq_msg_data(&message)), zmq_msg_size(&message));
|
|
|
|
} while (true);
|
|
|
|
}
|
|
|
|
catch (const std::exception& e) {
|
2022-05-11 03:44:42 -06:00
|
|
|
LOGERR(1, "exception " << e.what());
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
2023-03-10 06:46:53 -07:00
|
|
|
|
|
|
|
zmq_msg_close(&message);
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
void ZMQReader::Monitor::on_event_connected(const zmq_event_t&, const char* address)
|
2021-09-27 03:32:49 -06:00
|
|
|
{
|
2023-06-16 07:51:33 -06:00
|
|
|
LOGINFO(1, "connected to " << address);
|
|
|
|
m_connected = true;
|
|
|
|
}
|
2021-09-27 03:32:49 -06:00
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
void ZMQReader::Monitor::on_event_disconnected(const zmq_event_t&, const char* address)
|
|
|
|
{
|
|
|
|
LOGERR(1, "disconnected from " << address);
|
|
|
|
m_connected = false;
|
|
|
|
}
|
2021-09-27 03:32:49 -06:00
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
bool ZMQReader::connect(const std::string& address, bool keep_monitor)
|
|
|
|
{
|
2021-10-28 11:08:42 -06:00
|
|
|
static uint64_t id = 0;
|
|
|
|
|
|
|
|
if (!id) {
|
|
|
|
std::random_device rd;
|
|
|
|
id = (static_cast<uint64_t>(rd()) << 32) | static_cast<uint32_t>(rd());
|
|
|
|
}
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
char buf[64];
|
2021-10-28 11:08:42 -06:00
|
|
|
log::Stream s(buf);
|
|
|
|
s << "inproc://p2pool-connect-mon-" << id << '\0';
|
|
|
|
++id;
|
|
|
|
|
2023-03-10 06:46:53 -07:00
|
|
|
using namespace std::chrono;
|
|
|
|
const auto start_time = steady_clock::now();
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
Monitor* monitor = new Monitor();
|
|
|
|
monitor->init(m_subscriber, buf);
|
2021-09-27 03:32:49 -06:00
|
|
|
m_subscriber.connect(address);
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
while (!monitor->m_connected && monitor->check_event(-1)) {
|
2023-03-10 06:46:53 -07:00
|
|
|
if (duration_cast<milliseconds>(steady_clock::now() - start_time).count() >= 1000) {
|
2021-09-27 03:32:49 -06:00
|
|
|
LOGERR(1, "failed to connect to " << address);
|
2023-06-16 07:51:33 -06:00
|
|
|
delete monitor;
|
2023-03-10 06:46:53 -07:00
|
|
|
return false;
|
2021-09-27 03:32:49 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-16 07:51:33 -06:00
|
|
|
if (keep_monitor) {
|
|
|
|
m_monitor = monitor;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
delete monitor;
|
|
|
|
}
|
|
|
|
|
2021-09-27 03:32:49 -06:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
void ZMQReader::parse(char* data, size_t size)
|
|
|
|
{
|
|
|
|
char* value = data;
|
2023-05-23 12:11:00 -06:00
|
|
|
const char* end = data + size;
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
while ((value < end) && (*value != ':')) {
|
|
|
|
++value;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value >= end) {
|
|
|
|
LOGWARN(1, "ZeroMQ message doesn't have ':' delimiter, skipping it");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*value = '\0';
|
|
|
|
++value;
|
|
|
|
|
|
|
|
using namespace rapidjson;
|
|
|
|
|
|
|
|
Document doc;
|
2023-06-12 07:29:23 -06:00
|
|
|
if (doc.Parse(value, end - value).HasParseError()) {
|
2021-08-29 00:34:26 -06:00
|
|
|
LOGWARN(1, "ZeroMQ message failed to parse, skipping it");
|
|
|
|
return;
|
|
|
|
}
|
2021-08-22 04:20:59 -06:00
|
|
|
|
|
|
|
if (strcmp(data, "json-minimal-txpool_add") == 0) {
|
|
|
|
if (!doc.IsArray()) {
|
|
|
|
LOGWARN(1, "json-minimal-txpool_add is not an array, skipping it");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-03-23 04:30:38 -06:00
|
|
|
m_tx.time_received = seconds_since_epoch();
|
2021-09-14 04:54:42 -06:00
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
for (SizeType i = 0, n = doc.Size(); i < n; ++i) {
|
|
|
|
const auto& v = doc[i];
|
|
|
|
if (PARSE(v, m_tx, id) && PARSE(v, m_tx, blob_size) && PARSE(v, m_tx, weight) && PARSE(v, m_tx, fee)) {
|
|
|
|
m_handler->handle_tx(m_tx);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
LOGWARN(1, "transaction #" << (i + 1) << " in json-minimal-txpool_add failed to parse, skipped it");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-08-26 07:36:40 -06:00
|
|
|
else if (strcmp(data, "json-full-miner_data") == 0) {
|
2021-08-22 04:20:59 -06:00
|
|
|
if (!doc.IsObject()) {
|
2021-08-26 07:36:40 -06:00
|
|
|
LOGWARN(1, "json-full-miner_data is not an object, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!PARSE(doc, m_minerData, major_version) ||
|
|
|
|
!PARSE(doc, m_minerData, height) ||
|
|
|
|
!PARSE(doc, m_minerData, prev_id) ||
|
|
|
|
!PARSE(doc, m_minerData, seed_hash) ||
|
|
|
|
!PARSE(doc, m_minerData, median_weight) ||
|
|
|
|
!PARSE(doc, m_minerData, already_generated_coins) ||
|
|
|
|
!PARSE(doc, m_minerData, difficulty)) {
|
2021-08-26 07:36:40 -06:00
|
|
|
LOGWARN(1, "json-full-miner_data failed to parse, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!doc.HasMember("tx_backlog")) {
|
2021-08-26 07:36:40 -06:00
|
|
|
LOGWARN(1, "json-full-miner_data doesn't have 'tx_backlog', skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto& tx_backlog = doc["tx_backlog"];
|
|
|
|
|
|
|
|
if (!tx_backlog.IsArray()) {
|
2021-08-26 07:36:40 -06:00
|
|
|
LOGWARN(1, "'tx_backlog' in json-full-miner_data is not an array, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_minerData.tx_backlog.clear();
|
|
|
|
|
|
|
|
const SizeType n = tx_backlog.Size();
|
|
|
|
m_minerData.tx_backlog.reserve(n);
|
|
|
|
|
|
|
|
for (SizeType i = 0; i < n; ++i) {
|
|
|
|
const auto& v = tx_backlog[i];
|
|
|
|
if (PARSE(v, m_tx, id) && PARSE(v, m_tx, weight) && PARSE(v, m_tx, fee)) {
|
|
|
|
m_minerData.tx_backlog.push_back(m_tx);
|
|
|
|
}
|
|
|
|
else {
|
2021-08-26 07:36:40 -06:00
|
|
|
LOGWARN(1, "transaction #" << (i + 1) << " in json-full-miner_data `tx_backlog` failed to parse, skipped it");
|
2021-08-22 04:20:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_handler->handle_miner_data(m_minerData);
|
|
|
|
}
|
|
|
|
else if (strcmp(data, "json-full-chain_main") == 0) {
|
|
|
|
if (!doc.IsArray()) {
|
|
|
|
LOGWARN(1, "json-full-chain_main is not an object, skipping it");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto arr = doc.GetArray();
|
|
|
|
for (Value* i = arr.begin(); i != arr.end(); ++i) {
|
|
|
|
if (!PARSE(*i, m_chainmainData, timestamp)) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main timestamp failed to parse, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto it = i->FindMember("miner_tx");
|
|
|
|
if ((it == i->MemberEnd()) || !it->value.IsObject()) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main miner_tx not found, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto extra_it = it->value.FindMember("extra");
|
|
|
|
if ((extra_it == it->value.MemberEnd()) || !extra_it->value.IsString()) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main extra not found, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto inputs_it = it->value.FindMember("inputs");
|
|
|
|
if ((inputs_it == it->value.MemberEnd()) || !inputs_it->value.IsArray()) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main inputs not found, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-09-01 02:43:10 -06:00
|
|
|
// Get block reward from miner_tx outputs
|
|
|
|
m_chainmainData.reward = 0;
|
|
|
|
|
|
|
|
auto outputs_it = it->value.FindMember("outputs");
|
|
|
|
if ((outputs_it != it->value.MemberEnd()) && outputs_it->value.IsArray()) {
|
|
|
|
auto outputs = outputs_it->value.GetArray();
|
|
|
|
for (SizeType j = 0, n = outputs.Size(); j < n; ++j) {
|
|
|
|
if (outputs[j].IsObject()) {
|
|
|
|
auto amount_it = outputs[j].FindMember("amount");
|
|
|
|
if (amount_it != outputs[j].MemberEnd() && amount_it->value.IsUint64()) {
|
|
|
|
m_chainmainData.reward += amount_it->value.GetUint64();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2021-09-18 02:03:06 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main outputs not found");
|
2021-09-01 02:43:10 -06:00
|
|
|
}
|
|
|
|
|
2021-08-22 04:20:59 -06:00
|
|
|
auto inputs = inputs_it->value.GetArray();
|
|
|
|
if ((inputs.Size() == 0) || !inputs[0].IsObject()) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main inputs is not an array, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
it = inputs[0].FindMember("gen");
|
|
|
|
if ((it == inputs[0].MemberEnd()) || !it->value.IsObject()) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main gen not found, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!PARSE(it->value, m_chainmainData, height)) {
|
2021-09-01 02:43:10 -06:00
|
|
|
LOGWARN(1, "json-full-chain_main height not found, skipping it");
|
2021-08-22 04:20:59 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_handler->handle_chain_main(m_chainmainData, extra_it->value.GetString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace p2pool
|