855 lines
29 KiB
C++
855 lines
29 KiB
C++
/* XMRig - Hush/DragonX HAC Support
|
|
* Copyright (c) 2024 XMRig <https://github.com/xmrig>
|
|
*
|
|
* 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, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*/
|
|
|
|
#include "base/net/stratum/HushClient.h"
|
|
#include "3rdparty/rapidjson/document.h"
|
|
#include "3rdparty/rapidjson/error/en.h"
|
|
#include "base/io/json/Json.h"
|
|
#include "base/io/json/JsonRequest.h"
|
|
#include "base/io/log/Log.h"
|
|
#include "base/kernel/interfaces/IClientListener.h"
|
|
#include "base/net/http/Fetch.h"
|
|
#include "base/net/http/HttpData.h"
|
|
#include "base/net/http/HttpListener.h"
|
|
#include "base/tools/Chrono.h"
|
|
#include "base/tools/Cvt.h"
|
|
#include "base/tools/Timer.h"
|
|
#include "net/JobResult.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
#include <openssl/sha.h>
|
|
|
|
namespace xmrig {
|
|
|
|
static const char *kJsonRPC = "/";
|
|
|
|
// Simple Base64 encoder for HTTP Basic Auth
|
|
static std::string toBase64(const std::string &input)
|
|
{
|
|
static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
std::string encoded;
|
|
encoded.reserve(((input.size() + 2) / 3) * 4);
|
|
|
|
unsigned int val = 0;
|
|
int bits = -6;
|
|
for (unsigned char c : input) {
|
|
val = (val << 8) + c;
|
|
bits += 8;
|
|
while (bits >= 0) {
|
|
encoded.push_back(table[(val >> bits) & 0x3F]);
|
|
bits -= 6;
|
|
}
|
|
}
|
|
if (bits > -6) {
|
|
encoded.push_back(table[((val << 8) >> (bits + 8)) & 0x3F]);
|
|
}
|
|
while (encoded.size() % 4) {
|
|
encoded.push_back('=');
|
|
}
|
|
return encoded;
|
|
}
|
|
|
|
// Create JSON-RPC 1.0 request (HAC daemons use 1.0, not 2.0)
|
|
static void createRpc10(rapidjson::Document &doc, int64_t id, const char *method, rapidjson::Value ¶ms)
|
|
{
|
|
using namespace rapidjson;
|
|
auto &allocator = doc.GetAllocator();
|
|
|
|
doc.AddMember("jsonrpc", "1.0", allocator);
|
|
doc.AddMember("id", id, allocator);
|
|
doc.AddMember("method", StringRef(method), allocator);
|
|
doc.AddMember("params", params, allocator);
|
|
}
|
|
|
|
HushClient::HushClient(int id, IClientListener *listener) :
|
|
BaseClient(id, listener)
|
|
{
|
|
m_httpListener = std::make_shared<HttpListener>(this);
|
|
m_timer = new Timer(this);
|
|
}
|
|
|
|
HushClient::~HushClient()
|
|
{
|
|
delete m_timer;
|
|
}
|
|
|
|
void HushClient::deleteLater()
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
bool HushClient::disconnect()
|
|
{
|
|
if (m_state != UnconnectedState) {
|
|
setState(UnconnectedState);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HushClient::isTLS() const
|
|
{
|
|
#ifdef XMRIG_FEATURE_TLS
|
|
return m_pool.isTLS();
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void HushClient::connect()
|
|
{
|
|
if (m_pool.algorithm().family() != Algorithm::RANDOM_X) {
|
|
LOG_ERR("%s " RED("HAC coins require RandomX algorithm"), tag());
|
|
return;
|
|
}
|
|
|
|
setState(ConnectingState);
|
|
getBlockTemplate();
|
|
}
|
|
|
|
void HushClient::connect(const Pool &pool)
|
|
{
|
|
setPool(pool);
|
|
connect();
|
|
}
|
|
|
|
void HushClient::setPool(const Pool &pool)
|
|
{
|
|
BaseClient::setPool(pool);
|
|
|
|
// Default to RandomX if not specified
|
|
if (!m_pool.algorithm().isValid()) {
|
|
m_pool.setAlgo(Algorithm::RX_0);
|
|
}
|
|
}
|
|
|
|
int64_t HushClient::submit(const JobResult &result)
|
|
{
|
|
if (result.jobId != m_currentJobId) {
|
|
LOG_DEBUG("%s " RED("job ID mismatch"), tag());
|
|
return -1;
|
|
}
|
|
|
|
// HAC PoW: RandomX hash becomes nSolution, then SHA256D(header) must be < target
|
|
// Check if SHA256D(header + solution) meets network target before submitting
|
|
if (!checkPow(result.nonce, result.result())) {
|
|
// Hash doesn't meet network target, don't submit
|
|
return -1;
|
|
}
|
|
|
|
// Log submission details
|
|
const String solutionHex = Cvt::toHex(result.result(), 32);
|
|
LOG_INFO("%s " CYAN_BOLD("submitting block") " nonce=0x%08x", tag(), result.nonce);
|
|
|
|
// Build the full block with header + solution + transactions
|
|
const std::string blockHex = serializeBlockHex(result.nonce, result.result());
|
|
|
|
return submitBlock(blockHex);
|
|
}
|
|
|
|
void HushClient::onTimer(const Timer *)
|
|
{
|
|
if (m_state == ConnectingState) {
|
|
connect();
|
|
}
|
|
else if (m_state == ConnectedState) {
|
|
// Poll for new block template
|
|
getBlockTemplate();
|
|
}
|
|
}
|
|
|
|
void HushClient::onHttpData(const HttpData &data)
|
|
{
|
|
if (data.status != 200) {
|
|
LOG_ERR("%s " RED("HTTP error %d"), tag(), data.status);
|
|
return retry();
|
|
}
|
|
|
|
m_ip = data.ip().c_str();
|
|
|
|
#ifdef XMRIG_FEATURE_TLS
|
|
if (data.tlsVersion()) {
|
|
strncpy(m_tlsVersion, data.tlsVersion(), sizeof(m_tlsVersion) - 1);
|
|
}
|
|
if (data.tlsFingerprint()) {
|
|
strncpy(m_tlsFingerprint, data.tlsFingerprint(), sizeof(m_tlsFingerprint) - 1);
|
|
}
|
|
#endif
|
|
|
|
rapidjson::Document doc;
|
|
if (doc.Parse(data.body.c_str()).HasParseError()) {
|
|
LOG_ERR("%s " RED("JSON parse error: %s"), tag(), rapidjson::GetParseError_En(doc.GetParseError()));
|
|
return retry();
|
|
}
|
|
|
|
// Debug: log the raw response for troubleshooting
|
|
LOG_DEBUG("%s RPC response: %.200s", tag(), data.body.c_str());
|
|
|
|
const int64_t id = Json::getInt64(doc, "id", -1);
|
|
|
|
// Handle "result" field which can be object, string, or null depending on RPC method
|
|
const rapidjson::Value *resultPtr = nullptr;
|
|
if (doc.HasMember("result")) {
|
|
resultPtr = &doc["result"];
|
|
}
|
|
static const rapidjson::Value nullValue;
|
|
const auto &result = resultPtr ? *resultPtr : nullValue;
|
|
const auto &error = Json::getObject(doc, "error");
|
|
|
|
if (!parseResponse(id, result, error)) {
|
|
retry();
|
|
}
|
|
}
|
|
|
|
int64_t HushClient::getBlockTemplate()
|
|
{
|
|
using namespace rapidjson;
|
|
Document doc(kObjectType);
|
|
auto &allocator = doc.GetAllocator();
|
|
|
|
// JSON-RPC 1.0 style: params is an array with optional object
|
|
Value params(kArrayType);
|
|
// Empty params array for basic getblocktemplate
|
|
// HAC will return coinbasetxn by default
|
|
|
|
createRpc10(doc, m_sequence, "getblocktemplate", params);
|
|
m_pendingRequest = REQ_TEMPLATE;
|
|
|
|
return rpcSend(doc);
|
|
}
|
|
|
|
int64_t HushClient::getBlockHash(uint64_t height)
|
|
{
|
|
using namespace rapidjson;
|
|
Document doc(kObjectType);
|
|
auto &allocator = doc.GetAllocator();
|
|
|
|
Value params(kArrayType);
|
|
params.PushBack(Value(height), allocator);
|
|
|
|
createRpc10(doc, m_sequence, "getblockhash", params);
|
|
m_pendingRequest = REQ_KEYHASH;
|
|
m_pendingKeyHeight = height;
|
|
|
|
return rpcSend(doc);
|
|
}
|
|
|
|
int64_t HushClient::submitBlock(const std::string &blockHex)
|
|
{
|
|
using namespace rapidjson;
|
|
Document doc(kObjectType);
|
|
auto &allocator = doc.GetAllocator();
|
|
|
|
Value params(kArrayType);
|
|
params.PushBack(Value(blockHex.c_str(), allocator), allocator);
|
|
|
|
createRpc10(doc, m_sequence, "submitblock", params);
|
|
m_pendingRequest = REQ_SUBMIT;
|
|
|
|
LOG_INFO("%s " MAGENTA_BOLD("submitting block at height %u"), tag(), m_height);
|
|
|
|
return rpcSend(doc);
|
|
}
|
|
|
|
int64_t HushClient::rpcSend(const rapidjson::Document &doc)
|
|
{
|
|
FetchRequest req(HTTP_POST, m_pool.host(), m_pool.port(), kJsonRPC, doc, m_pool.isTLS(), isQuiet());
|
|
|
|
// HAC daemons require text/plain content-type (override application/json)
|
|
req.headers.erase("Content-Type");
|
|
req.headers.insert({"Content-Type", "text/plain"});
|
|
|
|
// Add RPC authentication if configured
|
|
if (!m_pool.user().isEmpty()) {
|
|
std::string auth = m_pool.user().data();
|
|
if (!m_pool.password().isEmpty()) {
|
|
auth += ":";
|
|
auth += m_pool.password().data();
|
|
}
|
|
const std::string encoded = toBase64(auth);
|
|
req.headers.insert({"Authorization", "Basic " + encoded});
|
|
}
|
|
|
|
fetch(tag(), std::move(req), m_httpListener);
|
|
|
|
return m_sequence++;
|
|
}
|
|
|
|
bool HushClient::parseBlockTemplate(const rapidjson::Value &result)
|
|
{
|
|
if (!result.IsObject()) {
|
|
LOG_ERR("%s " RED("invalid block template response"), tag());
|
|
return false;
|
|
}
|
|
|
|
// Check if this is the same job (same previous block hash)
|
|
const char *prevHash = Json::getString(result, "previousblockhash");
|
|
if (prevHash && m_prevJobHash == prevHash && m_state == ConnectedState) {
|
|
// Same block, skip duplicate job
|
|
return true;
|
|
}
|
|
|
|
// Parse BIP22 block template fields
|
|
m_height = Json::getUint64(result, "height");
|
|
m_curtime = Json::getUint64(result, "curtime");
|
|
m_version = Json::getInt(result, "version", 4);
|
|
m_prevHash = Json::getString(result, "previousblockhash");
|
|
m_saplingRoot = Json::getString(result, "finalsaplingroothash");
|
|
m_target = Json::getString(result, "target");
|
|
m_bits = Json::getString(result, "bits");
|
|
|
|
// Parse target into bytes for PoW comparison (32 bytes, big-endian from hex)
|
|
m_targetBytes.resize(32);
|
|
if (m_target.size() == 64) {
|
|
Cvt::fromHex(m_targetBytes.data(), 32, m_target.data(), 64);
|
|
}
|
|
|
|
// Coinbase transaction
|
|
const auto &coinbase = result["coinbasetxn"];
|
|
if (!coinbase.IsObject()) {
|
|
LOG_ERR("%s " RED("missing coinbasetxn in template"), tag());
|
|
return false;
|
|
}
|
|
m_coinbaseTx = Json::getString(coinbase, "data");
|
|
m_merkleRoot = Json::getString(coinbase, "hash");
|
|
|
|
LOG_DEBUG("%s template: height=%lu bits=%s target=%s", tag(), m_height, m_bits.data(), m_target.data());
|
|
LOG_DEBUG("%s prevHash=%s", tag(), m_prevHash.data());
|
|
LOG_DEBUG("%s merkleRoot=%s", tag(), m_merkleRoot.data());
|
|
|
|
// Other transactions (may be empty for low traffic chains)
|
|
m_transactions.clear();
|
|
const auto &txs = result["transactions"];
|
|
if (txs.IsArray()) {
|
|
for (const auto &tx : txs.GetArray()) {
|
|
if (tx.IsObject()) {
|
|
m_transactions.push_back(Json::getString(tx, "data"));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validate required fields
|
|
if (m_height == 0 || m_prevHash.isEmpty() || m_coinbaseTx.isEmpty()) {
|
|
LOG_ERR("%s " RED("incomplete block template"), tag());
|
|
return false;
|
|
}
|
|
|
|
// Check if we need to fetch new RandomX key
|
|
const uint64_t keyHeight = getKeyHeight(m_height);
|
|
if (keyHeight != m_keyHeight || m_keyBlockHash.isEmpty()) {
|
|
if (keyHeight == 0) {
|
|
// Use genesis key - chain-specific initial seed
|
|
// For HACs this is typically: hash(magic + symbol + rpcport)
|
|
m_keyBlockHash = "0000000000000000000000000000000000000000000000000000000000000000";
|
|
m_keyHeight = 0;
|
|
LOG_INFO("%s " CYAN("using genesis RandomX key for height %u"), tag(), m_height);
|
|
} else {
|
|
LOG_INFO("%s " CYAN("fetching RandomX key block hash at height %u"), tag(), keyHeight);
|
|
getBlockHash(keyHeight);
|
|
return true; // Will continue after receiving key hash
|
|
}
|
|
}
|
|
|
|
// Create the mining job
|
|
Job job(false, m_pool.algorithm(), String());
|
|
job.setHeight(m_height);
|
|
|
|
// Set diff=1 so ALL RandomX results get submitted to us for PoW checking
|
|
// We filter in submit() by checking SHA256D(header+solution) < target
|
|
job.setDiff(1);
|
|
|
|
if (!job.setSeedHash(m_keyBlockHash.data())) {
|
|
LOG_ERR("%s " RED("failed to set seed hash: %s (len=%zu)"), tag(), m_keyBlockHash.data(), m_keyBlockHash.size());
|
|
return false;
|
|
}
|
|
|
|
// Build full block blob for RandomX hashing:
|
|
// HAC computes RandomX(full_serialized_block) where block = header + nSolution(empty) + txcount + txs
|
|
// Header: version(4) + prevHash(32) + merkleRoot(32) + saplingRoot(32) + time(4) + bits(4) + nonce(32) + nSolution(varint_len + data)
|
|
m_headerBlob.clear();
|
|
m_headerBlob.reserve(1024); // Will grow if many transactions
|
|
|
|
// nVersion (4 bytes, little-endian)
|
|
const uint32_t ver = static_cast<uint32_t>(m_version);
|
|
m_headerBlob.insert(m_headerBlob.end(), reinterpret_cast<const uint8_t*>(&ver),
|
|
reinterpret_cast<const uint8_t*>(&ver) + 4);
|
|
|
|
// hashPrevBlock (32 bytes, internal byte order)
|
|
std::vector<uint8_t> prevHashBytes(32);
|
|
Cvt::fromHex(prevHashBytes.data(), 32, m_prevHash.data(), 64);
|
|
std::reverse(prevHashBytes.begin(), prevHashBytes.end());
|
|
m_headerBlob.insert(m_headerBlob.end(), prevHashBytes.begin(), prevHashBytes.end());
|
|
|
|
// hashMerkleRoot (32 bytes)
|
|
std::vector<uint8_t> merkleRoot(32);
|
|
Cvt::fromHex(merkleRoot.data(), 32, m_merkleRoot.data(), 64);
|
|
std::reverse(merkleRoot.begin(), merkleRoot.end());
|
|
m_headerBlob.insert(m_headerBlob.end(), merkleRoot.begin(), merkleRoot.end());
|
|
|
|
// hashFinalSaplingRoot (32 bytes)
|
|
std::vector<uint8_t> saplingRoot(32);
|
|
Cvt::fromHex(saplingRoot.data(), 32, m_saplingRoot.data(), 64);
|
|
std::reverse(saplingRoot.begin(), saplingRoot.end());
|
|
m_headerBlob.insert(m_headerBlob.end(), saplingRoot.begin(), saplingRoot.end());
|
|
|
|
// nTime (4 bytes)
|
|
const uint32_t time32 = static_cast<uint32_t>(m_curtime);
|
|
m_headerBlob.insert(m_headerBlob.end(), reinterpret_cast<const uint8_t*>(&time32),
|
|
reinterpret_cast<const uint8_t*>(&time32) + 4);
|
|
|
|
// nBits (4 bytes)
|
|
uint32_t bits = 0;
|
|
for (int i = 0; i < 8 && i < static_cast<int>(m_bits.size()); i += 2) {
|
|
uint8_t byte;
|
|
Cvt::fromHex(&byte, 1, m_bits.data() + i, 2);
|
|
bits = (bits << 8) | byte;
|
|
}
|
|
m_headerBlob.insert(m_headerBlob.end(), reinterpret_cast<const uint8_t*>(&bits),
|
|
reinterpret_cast<const uint8_t*>(&bits) + 4);
|
|
|
|
// nNonce placeholder (32 bytes of zeros - miner fills first 4 bytes)
|
|
// Remember position for later extraction
|
|
m_nonceOffset = m_headerBlob.size();
|
|
m_headerBlob.insert(m_headerBlob.end(), 32, 0);
|
|
|
|
// nSolution - empty vector serialized as compact size 0
|
|
// For CBlock serialization, nSolution is std::vector<unsigned char>
|
|
// Empty vector = compactsize(0) = 0x00
|
|
m_headerBlob.push_back(0x00);
|
|
|
|
// Transactions: compactsize(count) + coinbase + other txs
|
|
const size_t txCount = 1 + m_transactions.size(); // coinbase + others
|
|
|
|
// Write compact size for transaction count
|
|
if (txCount < 0xFD) {
|
|
m_headerBlob.push_back(static_cast<uint8_t>(txCount));
|
|
} else if (txCount <= 0xFFFF) {
|
|
m_headerBlob.push_back(0xFD);
|
|
const uint16_t cnt16 = static_cast<uint16_t>(txCount);
|
|
m_headerBlob.insert(m_headerBlob.end(), reinterpret_cast<const uint8_t*>(&cnt16),
|
|
reinterpret_cast<const uint8_t*>(&cnt16) + 2);
|
|
} else {
|
|
m_headerBlob.push_back(0xFE);
|
|
const uint32_t cnt32 = static_cast<uint32_t>(txCount);
|
|
m_headerBlob.insert(m_headerBlob.end(), reinterpret_cast<const uint8_t*>(&cnt32),
|
|
reinterpret_cast<const uint8_t*>(&cnt32) + 4);
|
|
}
|
|
|
|
// Append coinbase transaction
|
|
std::vector<uint8_t> cbTx(m_coinbaseTx.size() / 2);
|
|
Cvt::fromHex(cbTx.data(), cbTx.size(), m_coinbaseTx.data(), m_coinbaseTx.size());
|
|
m_headerBlob.insert(m_headerBlob.end(), cbTx.begin(), cbTx.end());
|
|
|
|
// Append other transactions
|
|
for (const auto &txHex : m_transactions) {
|
|
std::vector<uint8_t> tx(txHex.size() / 2);
|
|
Cvt::fromHex(tx.data(), tx.size(), txHex.data(), txHex.size());
|
|
m_headerBlob.insert(m_headerBlob.end(), tx.begin(), tx.end());
|
|
}
|
|
|
|
// Set the full block blob for mining
|
|
LOG_DEBUG("%s block blob size=%zu (header=141 + %zu txs), seed=%s",
|
|
tag(), m_headerBlob.size(), txCount, m_keyBlockHash.data());
|
|
{
|
|
const String hdrHex = Cvt::toHex(m_headerBlob.data(), std::min(m_headerBlob.size(), size_t(200)));
|
|
LOG_DEBUG("%s block: %s...", tag(), hdrHex.data());
|
|
}
|
|
if (!job.setBlob(Cvt::toHex(m_headerBlob.data(), m_headerBlob.size()))) {
|
|
LOG_ERR("%s " RED("failed to set job blob (size=%zu)"), tag(), m_headerBlob.size());
|
|
return false;
|
|
}
|
|
|
|
m_currentJobId = Cvt::toHex(Cvt::randomBytes(4));
|
|
job.setId(m_currentJobId);
|
|
|
|
m_job = std::move(job);
|
|
m_prevJobHash = m_prevHash;
|
|
m_jobSteadyMs = Chrono::steadyMSecs();
|
|
|
|
if (m_state == ConnectingState) {
|
|
LOG_INFO("%s " GREEN("connected to %s:%d"), tag(), m_pool.host().data(), m_pool.port());
|
|
setState(ConnectedState);
|
|
}
|
|
|
|
LOG_INFO("%s " MAGENTA_BOLD("new job") " height: " CYAN_BOLD("%u") " diff: " CYAN_BOLD("%u"),
|
|
tag(), m_height, job.diff());
|
|
|
|
m_listener->onJobReceived(this, m_job, rapidjson::Value());
|
|
return true;
|
|
}
|
|
|
|
bool HushClient::parseResponse(int64_t id, const rapidjson::Value &result, const rapidjson::Value &error)
|
|
{
|
|
// Handle RPC errors
|
|
if (error.IsObject()) {
|
|
const char *message = Json::getString(error, "message", "unknown error");
|
|
const int code = Json::getInt(error, "code", -1);
|
|
LOG_ERR("%s " RED("RPC error %d: \"%s\""), tag(), code, message);
|
|
return false;
|
|
}
|
|
|
|
switch (m_pendingRequest) {
|
|
case REQ_TEMPLATE:
|
|
if (parseBlockTemplate(result)) {
|
|
m_timer->start(m_pool.pollInterval(), m_pool.pollInterval());
|
|
return true;
|
|
}
|
|
return m_pendingRequest == REQ_KEYHASH; // Waiting for key is ok
|
|
|
|
case REQ_KEYHASH:
|
|
if (result.IsString()) {
|
|
m_keyBlockHash = result.GetString();
|
|
m_keyHeight = m_pendingKeyHeight;
|
|
LOG_INFO("%s " GREEN("RandomX key block %u: %.16s..."),
|
|
tag(), m_keyHeight, m_keyBlockHash.data());
|
|
// Now get the block template again with the key
|
|
m_pendingRequest = REQ_NONE;
|
|
getBlockTemplate();
|
|
return true;
|
|
}
|
|
LOG_ERR("%s " RED("invalid getblockhash response - expected string, got type %d"),
|
|
tag(), result.GetType());
|
|
return false;
|
|
|
|
case REQ_SUBMIT:
|
|
// submitblock returns null on success
|
|
if (result.IsNull()) {
|
|
LOG_INFO("%s " GREEN_BOLD("BLOCK ACCEPTED!"), tag());
|
|
if (m_results.count(id)) {
|
|
m_listener->onResultAccepted(this, m_results[id], nullptr);
|
|
m_results.erase(id);
|
|
}
|
|
} else if (result.IsString()) {
|
|
const char *msg = result.GetString();
|
|
if (strlen(msg) > 0) {
|
|
LOG_ERR("%s " RED("block rejected: %s"), tag(), msg);
|
|
} else {
|
|
LOG_INFO("%s " GREEN_BOLD("BLOCK ACCEPTED!"), tag());
|
|
}
|
|
}
|
|
// Get new work after submit
|
|
getBlockTemplate();
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void HushClient::retry()
|
|
{
|
|
m_failures++;
|
|
m_listener->onClose(this, static_cast<int>(m_failures));
|
|
|
|
if (m_state == ConnectedState) {
|
|
setState(ConnectingState);
|
|
}
|
|
|
|
m_timer->stop();
|
|
m_timer->start(m_retryPause, 0);
|
|
}
|
|
|
|
void HushClient::setState(SocketState state)
|
|
{
|
|
if (m_state == state) {
|
|
return;
|
|
}
|
|
|
|
m_state = state;
|
|
|
|
switch (state) {
|
|
case ConnectedState:
|
|
m_failures = 0;
|
|
m_listener->onLoginSuccess(this);
|
|
break;
|
|
|
|
case UnconnectedState:
|
|
m_timer->stop();
|
|
m_failures = -1;
|
|
m_listener->onClose(this, -1);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint64_t HushClient::getKeyHeight(uint64_t height) const
|
|
{
|
|
// RandomX key changes every RANDOMX_INTERVAL blocks with RANDOMX_LAG delay
|
|
if (height < static_cast<uint64_t>(RANDOMX_INTERVAL + RANDOMX_LAG)) {
|
|
return 0; // Use genesis key
|
|
}
|
|
return ((height - RANDOMX_LAG) / RANDOMX_INTERVAL) * RANDOMX_INTERVAL;
|
|
}
|
|
|
|
std::vector<uint8_t> HushClient::serializeBlock(uint32_t nonce, uint64_t extraNonce) const
|
|
{
|
|
std::vector<uint8_t> blob;
|
|
blob.reserve(1024);
|
|
|
|
// nVersion (4 bytes, little-endian)
|
|
const uint32_t ver = static_cast<uint32_t>(m_version);
|
|
blob.insert(blob.end(), reinterpret_cast<const uint8_t*>(&ver),
|
|
reinterpret_cast<const uint8_t*>(&ver) + 4);
|
|
|
|
// hashPrevBlock (32 bytes, reversed from hex display)
|
|
std::vector<uint8_t> prevHash(32);
|
|
Cvt::fromHex(prevHash.data(), 32, m_prevHash.data(), 64);
|
|
std::reverse(prevHash.begin(), prevHash.end());
|
|
blob.insert(blob.end(), prevHash.begin(), prevHash.end());
|
|
|
|
// hashMerkleRoot (32 bytes, reversed)
|
|
std::vector<uint8_t> merkleRoot(32);
|
|
Cvt::fromHex(merkleRoot.data(), 32, m_merkleRoot.data(), 64);
|
|
std::reverse(merkleRoot.begin(), merkleRoot.end());
|
|
blob.insert(blob.end(), merkleRoot.begin(), merkleRoot.end());
|
|
|
|
// hashFinalSaplingRoot (32 bytes, reversed)
|
|
std::vector<uint8_t> saplingRoot(32);
|
|
Cvt::fromHex(saplingRoot.data(), 32, m_saplingRoot.data(), 64);
|
|
std::reverse(saplingRoot.begin(), saplingRoot.end());
|
|
blob.insert(blob.end(), saplingRoot.begin(), saplingRoot.end());
|
|
|
|
// nTime (4 bytes, little-endian)
|
|
const uint32_t time32 = static_cast<uint32_t>(m_curtime);
|
|
blob.insert(blob.end(), reinterpret_cast<const uint8_t*>(&time32),
|
|
reinterpret_cast<const uint8_t*>(&time32) + 4);
|
|
|
|
// nBits (4 bytes) - convert from big-endian hex to little-endian binary
|
|
uint32_t bits = 0;
|
|
for (int i = 0; i < 8 && i < static_cast<int>(m_bits.size()); i += 2) {
|
|
uint8_t byte;
|
|
Cvt::fromHex(&byte, 1, m_bits.data() + i, 2);
|
|
bits = (bits << 8) | byte;
|
|
}
|
|
blob.insert(blob.end(), reinterpret_cast<const uint8_t*>(&bits),
|
|
reinterpret_cast<const uint8_t*>(&bits) + 4);
|
|
|
|
// nNonce (32 bytes for Zcash/Hush - uint256)
|
|
std::vector<uint8_t> nonce256(32, 0);
|
|
memcpy(nonce256.data(), &nonce, 4);
|
|
memcpy(nonce256.data() + 4, &extraNonce, sizeof(extraNonce));
|
|
blob.insert(blob.end(), nonce256.begin(), nonce256.end());
|
|
|
|
// nSolution placeholder (CompactSize + 32 zeros)
|
|
blob.push_back(32); // CompactSize for 32 bytes
|
|
blob.insert(blob.end(), 32, 0);
|
|
|
|
// Transaction count (CompactSize)
|
|
const size_t txCount = 1 + m_transactions.size();
|
|
if (txCount < 0xFD) {
|
|
blob.push_back(static_cast<uint8_t>(txCount));
|
|
} else {
|
|
blob.push_back(0xFD);
|
|
blob.push_back(txCount & 0xFF);
|
|
blob.push_back((txCount >> 8) & 0xFF);
|
|
}
|
|
|
|
// Coinbase transaction
|
|
std::vector<uint8_t> coinbase(m_coinbaseTx.size() / 2);
|
|
Cvt::fromHex(coinbase.data(), coinbase.size(), m_coinbaseTx.data(), m_coinbaseTx.size());
|
|
blob.insert(blob.end(), coinbase.begin(), coinbase.end());
|
|
|
|
// Other transactions
|
|
for (const auto &txHex : m_transactions) {
|
|
std::vector<uint8_t> tx(txHex.size() / 2);
|
|
Cvt::fromHex(tx.data(), tx.size(), txHex.data(), txHex.size());
|
|
blob.insert(blob.end(), tx.begin(), tx.end());
|
|
}
|
|
|
|
return blob;
|
|
}
|
|
|
|
std::string HushClient::serializeBlockHex(uint32_t nonce, const uint8_t* solution) const
|
|
{
|
|
std::vector<uint8_t> blob;
|
|
blob.reserve(1024);
|
|
|
|
// Header (same as serializeBlock but with actual nonce and solution)
|
|
const uint32_t ver = static_cast<uint32_t>(m_version);
|
|
blob.insert(blob.end(), reinterpret_cast<const uint8_t*>(&ver),
|
|
reinterpret_cast<const uint8_t*>(&ver) + 4);
|
|
|
|
std::vector<uint8_t> prevHash(32);
|
|
Cvt::fromHex(prevHash.data(), 32, m_prevHash.data(), 64);
|
|
std::reverse(prevHash.begin(), prevHash.end());
|
|
blob.insert(blob.end(), prevHash.begin(), prevHash.end());
|
|
|
|
std::vector<uint8_t> merkleRoot(32);
|
|
Cvt::fromHex(merkleRoot.data(), 32, m_merkleRoot.data(), 64);
|
|
std::reverse(merkleRoot.begin(), merkleRoot.end());
|
|
blob.insert(blob.end(), merkleRoot.begin(), merkleRoot.end());
|
|
|
|
std::vector<uint8_t> saplingRoot(32);
|
|
Cvt::fromHex(saplingRoot.data(), 32, m_saplingRoot.data(), 64);
|
|
std::reverse(saplingRoot.begin(), saplingRoot.end());
|
|
blob.insert(blob.end(), saplingRoot.begin(), saplingRoot.end());
|
|
|
|
const uint32_t time32 = static_cast<uint32_t>(m_curtime);
|
|
blob.insert(blob.end(), reinterpret_cast<const uint8_t*>(&time32),
|
|
reinterpret_cast<const uint8_t*>(&time32) + 4);
|
|
|
|
uint32_t bits = 0;
|
|
for (int i = 0; i < 8 && i < static_cast<int>(m_bits.size()); i += 2) {
|
|
uint8_t byte;
|
|
Cvt::fromHex(&byte, 1, m_bits.data() + i, 2);
|
|
bits = (bits << 8) | byte;
|
|
}
|
|
blob.insert(blob.end(), reinterpret_cast<const uint8_t*>(&bits),
|
|
reinterpret_cast<const uint8_t*>(&bits) + 4);
|
|
|
|
// Nonce (32 bytes with found nonce value)
|
|
std::vector<uint8_t> nonce256(32, 0);
|
|
memcpy(nonce256.data(), &nonce, 4);
|
|
blob.insert(blob.end(), nonce256.begin(), nonce256.end());
|
|
|
|
// Solution (the RandomX hash - 32 bytes)
|
|
blob.push_back(32); // CompactSize
|
|
blob.insert(blob.end(), solution, solution + 32);
|
|
|
|
// Transactions
|
|
const size_t txCount = 1 + m_transactions.size();
|
|
if (txCount < 0xFD) {
|
|
blob.push_back(static_cast<uint8_t>(txCount));
|
|
} else {
|
|
blob.push_back(0xFD);
|
|
blob.push_back(txCount & 0xFF);
|
|
blob.push_back((txCount >> 8) & 0xFF);
|
|
}
|
|
|
|
std::vector<uint8_t> coinbase(m_coinbaseTx.size() / 2);
|
|
Cvt::fromHex(coinbase.data(), coinbase.size(), m_coinbaseTx.data(), m_coinbaseTx.size());
|
|
blob.insert(blob.end(), coinbase.begin(), coinbase.end());
|
|
|
|
for (const auto &txHex : m_transactions) {
|
|
std::vector<uint8_t> tx(txHex.size() / 2);
|
|
Cvt::fromHex(tx.data(), tx.size(), txHex.data(), txHex.size());
|
|
blob.insert(blob.end(), tx.begin(), tx.end());
|
|
}
|
|
|
|
const String hex = Cvt::toHex(blob.data(), blob.size());
|
|
return std::string(hex.data(), hex.size());
|
|
}
|
|
|
|
void HushClient::sha256d(const uint8_t* data, size_t len, uint8_t* out)
|
|
{
|
|
uint8_t hash1[32];
|
|
SHA256(data, len, hash1);
|
|
SHA256(hash1, 32, out);
|
|
}
|
|
|
|
std::vector<uint8_t> HushClient::serializeHeader(uint32_t nonce, const uint8_t* solution) const
|
|
{
|
|
std::vector<uint8_t> header;
|
|
header.reserve(140 + 1 + 32); // header + compactsize + solution
|
|
|
|
// nVersion (4 bytes, little-endian)
|
|
const uint32_t ver = static_cast<uint32_t>(m_version);
|
|
header.insert(header.end(), reinterpret_cast<const uint8_t*>(&ver),
|
|
reinterpret_cast<const uint8_t*>(&ver) + 4);
|
|
|
|
// hashPrevBlock (32 bytes, internal byte order)
|
|
std::vector<uint8_t> prevHashBytes(32);
|
|
Cvt::fromHex(prevHashBytes.data(), 32, m_prevHash.data(), 64);
|
|
std::reverse(prevHashBytes.begin(), prevHashBytes.end());
|
|
header.insert(header.end(), prevHashBytes.begin(), prevHashBytes.end());
|
|
|
|
// hashMerkleRoot (32 bytes)
|
|
std::vector<uint8_t> merkleRoot(32);
|
|
Cvt::fromHex(merkleRoot.data(), 32, m_merkleRoot.data(), 64);
|
|
std::reverse(merkleRoot.begin(), merkleRoot.end());
|
|
header.insert(header.end(), merkleRoot.begin(), merkleRoot.end());
|
|
|
|
// hashFinalSaplingRoot (32 bytes)
|
|
std::vector<uint8_t> saplingRoot(32);
|
|
Cvt::fromHex(saplingRoot.data(), 32, m_saplingRoot.data(), 64);
|
|
std::reverse(saplingRoot.begin(), saplingRoot.end());
|
|
header.insert(header.end(), saplingRoot.begin(), saplingRoot.end());
|
|
|
|
// nTime (4 bytes)
|
|
const uint32_t time32 = static_cast<uint32_t>(m_curtime);
|
|
header.insert(header.end(), reinterpret_cast<const uint8_t*>(&time32),
|
|
reinterpret_cast<const uint8_t*>(&time32) + 4);
|
|
|
|
// nBits (4 bytes)
|
|
uint32_t bits = 0;
|
|
for (int i = 0; i < 8 && i < static_cast<int>(m_bits.size()); i += 2) {
|
|
uint8_t byte;
|
|
Cvt::fromHex(&byte, 1, m_bits.data() + i, 2);
|
|
bits = (bits << 8) | byte;
|
|
}
|
|
header.insert(header.end(), reinterpret_cast<const uint8_t*>(&bits),
|
|
reinterpret_cast<const uint8_t*>(&bits) + 4);
|
|
|
|
// nNonce (32 bytes with found nonce value in first 4 bytes)
|
|
std::vector<uint8_t> nonce256(32, 0);
|
|
memcpy(nonce256.data(), &nonce, 4);
|
|
header.insert(header.end(), nonce256.begin(), nonce256.end());
|
|
|
|
// nSolution (compactsize + 32 bytes)
|
|
header.push_back(32); // CompactSize for 32 bytes
|
|
header.insert(header.end(), solution, solution + 32);
|
|
|
|
return header;
|
|
}
|
|
|
|
bool HushClient::checkPow(uint32_t nonce, const uint8_t* solution) const
|
|
{
|
|
// Build header with solution
|
|
const std::vector<uint8_t> header = serializeHeader(nonce, solution);
|
|
|
|
// Compute SHA256D(header)
|
|
uint8_t blockHash[32];
|
|
sha256d(header.data(), header.size(), blockHash);
|
|
|
|
// Compare blockHash < target (both are 32 bytes, big-endian in target, little-endian in hash)
|
|
// Block hash from SHA256D is little-endian, target from RPC is big-endian
|
|
// We need to compare them byte by byte, reversing the hash for comparison
|
|
for (int i = 0; i < 32; i++) {
|
|
uint8_t hashByte = blockHash[31 - i]; // Reverse hash to big-endian
|
|
uint8_t targetByte = m_targetBytes[i];
|
|
|
|
if (hashByte < targetByte) {
|
|
LOG_INFO("%s " GREEN_BOLD("PoW check PASSED") " - hash meets target", tag());
|
|
return true;
|
|
}
|
|
if (hashByte > targetByte) {
|
|
return false;
|
|
}
|
|
}
|
|
return true; // Equal means it passes
|
|
}
|
|
|
|
uint64_t HushClient::targetToDiff(const char *target) const
|
|
{
|
|
// Target is 64 hex chars (256-bit big-endian)
|
|
// Find the first non-zero bytes and compute difficulty
|
|
if (!target || strlen(target) < 16) {
|
|
return 1;
|
|
}
|
|
|
|
// Parse first 8 bytes as big-endian uint64 for approximation
|
|
uint64_t t = 0;
|
|
for (int i = 0; i < 16; i += 2) {
|
|
uint8_t byte;
|
|
Cvt::fromHex(&byte, 1, target + i, 2);
|
|
t = (t << 8) | byte;
|
|
}
|
|
|
|
if (t == 0) {
|
|
return 0xFFFFFFFFFFFFFFFFULL;
|
|
}
|
|
|
|
// Rough difficulty approximation
|
|
return 0xFFFFFFFFFFFFFFFFULL / t;
|
|
}
|
|
|
|
} // namespace xmrig
|