Support for Difficulty Offsets to beat Records while Mining, Bump to 2507.

Signed-off-by: Pttn <[email protected]>

Author: Pttn

Client.cpp

@@ -22,14 +22,17 @@ std::vector<uint8_t> BlockHeader::toV8() const {
 	return v8;
 }
 
-mpz_class BlockHeader::target(const int32_t powVersion) const {
-	const uint32_t difficultyIntegerPart(decodeBits(bits, powVersion));
+mpz_class BlockHeader::target(const int32_t powVersion, const uint16_t difficultyOffset) const {
+	uint64_t bits64(bits);
+	bits64 += uint64_t{difficultyOffset} << 13ULL;
+	if (bits64 > 4294967295ULL) bits64 = 4294967295ULL;
+	const uint32_t difficultyIntegerPart(decodeBits(bits64, powVersion));
 	uint32_t trailingZeros;
 	const std::array<uint8_t, 32> hash(sha256sha256(toV8().data(), 80));
 	mpz_class target;
 	if (powVersion == 1) {
 		if (difficultyIntegerPart < 264U) return 0;
-		const uint32_t df(bits & 255U);
+		const uint32_t df(bits64 & 255U);
 		target = 256 + ((10U*df*df*df + 7383U*df*df + 5840720U*df + 3997440U) >> 23U);
 		target <<= 256;
 		mpz_class hashGmp;
@@ -43,11 +46,11 @@ mpz_class BlockHeader::target(const int32_t powVersion) const {
 	return target;
 }
 
-std::array<uint8_t, 32> encodedOffset(const Stella::Result &result) {
+std::array<uint8_t, 32> encodedOffset(const Stella::Result &result, const uint16_t difficultyOffset) {
 	std::array<uint8_t, 32> nOffset;
 	for (auto &byte : nOffset) byte = 0;
 	// [31-30 Primorial Number|29-14 Primorial Factor|13-2 Primorial Offset|1-0 Reserved/Version]
-	*reinterpret_cast<uint16_t*>(&nOffset.data()[ 0]) = 2;
+	*reinterpret_cast<uint16_t*>(&nOffset.data()[ 0]) = 2U + (difficultyOffset << 5U);
 	*reinterpret_cast<uint64_t*>(&nOffset.data()[ 2]) = result.primorialOffset; // Only 64 bits used out of 96
 	*reinterpret_cast<uint64_t*>(&nOffset.data()[14]) = result.primorialFactor; // Only 64 bits used out of 128
 	*reinterpret_cast<uint16_t*>(&nOffset.data()[30]) = result.primorialNumber;

Client.hpp

@@ -15,7 +15,7 @@
 // Decodes the nBits field from a Block Header
 double decodeBits(const uint32_t, const int32_t);
 
-std::array<uint8_t, 32> encodedOffset(const Stella::Result&);
+std::array<uint8_t, 32> encodedOffset(const Stella::Result&, const uint16_t);
 
 // Riecoin Block Header structure, total 896 bits/112 bytes (224 hex chars)
 struct BlockHeader { // The fields are named according to the GetBlockTemplate labels
@@ -28,8 +28,7 @@ struct BlockHeader { // The fields are named according to the GetBlockTemplate l
 
 	BlockHeader() : version(0), previousblockhash{0}, merkleRoot{0}, curtime(0), bits(0), nOffset{0} {}
 	std::vector<uint8_t> toV8() const;
-	mpz_class target(const int32_t) const;
-	mpz_class targetOffsetMax(const int32_t) const;
+	mpz_class target(const int32_t, const uint16_t) const;
 };
 
 // Client or Network Parameters/Context
@@ -74,6 +73,7 @@ class GBTClient : public NetworkedClient {
 	const std::vector<std::string> _rules;
 	const std::string _host, _url, _proxy, _cookie;
 	std::string _credentials;
+	const uint16_t _difficultyOffset;
 	const std::vector<uint8_t> _scriptPubKey;
 	// Client State Variables
 	CURL *_curl;
@@ -107,6 +107,7 @@ class GBTClient : public NetworkedClient {
 		_proxy(options.proxy),
 		_cookie(options.cookie),
 		_credentials(options.username + ":" + options.password),
+		_difficultyOffset(options.difficultyOffset),
 		_scriptPubKey(bech32ToScriptPubKey(options.payoutAddress)),
 		_curl(curl_easy_init()) {}
 	void connect();
@@ -123,7 +124,7 @@ class GBTClient : public NetworkedClient {
 class StratumClient : public NetworkedClient {
 	// Options
 	const std::string _username, _password, _host, _proxy;
-	const uint16_t _port;
+	const uint16_t _port, _difficultyOffset;
 	// Client State Variables
 	CURL *_curl;
 	std::mutex _submitMutex;
@@ -153,7 +154,7 @@ class StratumClient : public NetworkedClient {
 
 	void _processMessage(const std::string&); // Processes a message received from the pool
 public:
-	StratumClient(const Options &options) : _username(options.username), _password(options.password), _host(options.host), _proxy(options.proxy), _port(options.port), _curl(curl_easy_init()) {}
+	StratumClient(const Options &options) : _username(options.username), _password(options.password), _host(options.host), _proxy(options.proxy), _port(options.port), _difficultyOffset(options.difficultyOffset), _curl(curl_easy_init()) {}
 	void connect(); // Also sends mining.subscribe
 	void process(); // Get messages from the server and calls _processMessage to handle them
 	std::optional<ClientInfo> info() const;

GBTClient.cpp

@@ -4,7 +4,7 @@
 #include "Stella.hpp"
 #include "main.hpp"
 
-const std::string cbMsg("/rM51/");
+const std::string cbMsg("/rM57/");
 static std::vector<uint8_t> coinbaseGen(const std::vector<uint8_t> &scriptPubKey, const uint32_t height, const uint64_t coinbasevalue, const std::vector<uint8_t> &dwc) {
 	std::vector<uint8_t> coinbase;
 	// Version (01000000)
@@ -238,7 +238,7 @@ void GBTClient::process() {
 				if (job.id == block.jobId) { // Sends a pending result via submitblock
 					logger.log("Submitting block with "s + std::to_string(job.txCount) + " transaction(s) (including coinbase)...\n"s, MessageType::BOLD);
 					BlockHeader bh(job.bh);
-					bh.nOffset = encodedOffset(block);
+					bh.nOffset = encodedOffset(block, _difficultyOffset);
 					std::ostringstream oss;
 					oss << v8ToHexStr(bh.toV8());
 					// Variable Length Integer Format
@@ -298,7 +298,7 @@ std::optional<Stella::Job> GBTClient::getJob() {
 	else
 		_currentJobs.push_back(job);
 	stellaJob.id = _currentJobId;
-	stellaJob.target = job.bh.target(_currentJobTemplate.clientInfo->powVersion);
+	stellaJob.target = job.bh.target(_currentJobTemplate.clientInfo->powVersion, _difficultyOffset);
 	_currentJobId++;
 	return stellaJob;
 }

Makefile

@@ -1,4 +1,4 @@
-VER    = 2501
+VER    = 2507
 CXX    = g++
 M4     = m4
 AS     = as

README.md

@@ -218,6 +218,7 @@ rieMiner proposes the following Modes depending on what you want to do. Use the
 * `SieveBits`: the size of the primorial factors table for the sieve is 2^SieveBits bits. 25 seems to be an optimal value, or 24 if there are many SieveWorkers. Though, if you have less than 8 MiB of L3 cache, you can try to decrement this value. Default: 25 if SieveWorkers <= 4, 24 otherwise;
 * `SieveIterations`: how many times the primorial factors table is reused for sieving. Increasing will decrease the frequency of new jobs, so less time would be "lost" in sieving, but this will also increase the memory usage. It is not clear however how this actually plays performance wise, 16 seems to be a good value. Default: 16;
 * `SieveWorkers`: the number of threads to use for sieving. Increasing it may solve some CPU underuse problems, but will use more memory. 0 for choosing automatically. Default: 0;
+* `DifficultyOffset`: while Mining, the raw Difficulty Offset as per the Improved PoW Version 1 Implementation (integer between 0 and 2047). Useful for record attempts while mining rather than via the Search Mode. Default: 0;
 * `RestartDifficultyFactor`: if the Difficulty changes by the given factor, the miner will restart. Useful to let it retune some parameters once a while to optimize for lower or higher Difficulties as it varies. This value must be at least 1 and the closer it is to 1 and the more often there will be restarts. Default: 1.03;
 * `ConstellationPattern`: which sort of constellations to look for, as offsets separated by commas. Note that they are not cumulative, so '0, 2, 4, 2, 4, 6, 2' corresponds to n + (0, 2, 6, 8, 12, 18, 20). If empty (or not accepted by the server), a valid pattern will be chosen (0, 2, 4, 2, 4, 6, 2 in Search and Benchmark Modes). Default: empty;
 * `PrimorialOffsets`: list of offsets from a primorial multiple to use for the sieve process, separated by commas. If empty, a default one will be chosen if possible (see main.hpp source file), otherwise rieMiner will not start (if the chosen constellation pattern is not in main.hpp). Default: empty;

StratumClient.cpp

@@ -5,7 +5,7 @@
 #include "Client.hpp"
 #include "Stella.hpp"
 
-constexpr const char* userAgent("rieMiner/2501");
+constexpr const char* userAgent("rieMiner/2507");
 
 static std::array<uint8_t, 32> calculateMerkleRootStratum(const std::vector<std::array<uint8_t, 32>> &merkleBranches) {
 	std::array<uint8_t, 32> merkleRoot{};
@@ -312,7 +312,7 @@ void StratumClient::process() {
 						<< job.jobId << "\", \""
 						<< v8ToHexStr(job.extraNonce2) << "\", \""
 						<< std::setfill('0') << std::setw(16) << std::hex << job.bh.curtime << "\", \""
-						<< v8ToHexStr(reverse(a8ToV8(encodedOffset(share)))) << "\"]}\n";
+						<< v8ToHexStr(reverse(a8ToV8(encodedOffset(share, _difficultyOffset)))) << "\"]}\n";
 					logger.logDebug("Sending: "s + oss.str());
 					size_t bytesSent(0);
 					CURLcode cc(curl_easy_send(_curl, oss.str().c_str(), oss.str().size(), &bytesSent));
@@ -393,7 +393,7 @@ std::optional<Stella::Job> StratumClient::getJob() {
 	else
 		_currentJobs.push_back(job);
 	stellaJob.id = _currentJobId;
-	stellaJob.target = job.bh.target(_currentJobTemplate.clientInfo->powVersion);
+	stellaJob.target = job.bh.target(_currentJobTemplate.clientInfo->powVersion, _difficultyOffset);
 	_currentJobId++;
 	return stellaJob;
 }

main.cpp

@@ -134,6 +134,11 @@ bool Configuration::parse(const int argc, char** argv, std::string &parsingMessa
 			try {_options.stellaConfig.sieveIterations = std::stoi(value);}
 			catch (...) {_options.stellaConfig.sieveIterations = 0;}
 		}
+		else if (key == "DifficultyOffset") {
+			try {_options.difficultyOffset = std::stoi(value);}
+			catch (...) {_options.difficultyOffset = 0U;}
+			if (_options.difficultyOffset > 2047U) _options.difficultyOffset = 2047U;
+		}
 		else if (key == "RestartDifficultyFactor") {
 			try {_options.restartDifficultyFactor = std::stod(value);}
 			catch (...) {_options.restartDifficultyFactor = 1.03;}
@@ -365,6 +370,8 @@ int main(int argc, char** argv) {
 			if (configuration.options().rules.size() > 0)
 				logger.log("Consensus Rules: "s + Stella::formatContainer(configuration.options().rules) + "\n"s);
 		}
+		if (configuration.options().difficultyOffset != 0)
+			std::cout << "Difficulty Offset " << configuration.options().difficultyOffset << " (+ " << 32*configuration.options().difficultyOffset << ")" << std::endl;
 		logger.log("Auto retune when the Difficulty varies by a factor "s + Stella::doubleToString(configuration.options().restartDifficultyFactor) + "\n"s);
 	}
 	if (configuration.options().refreshInterval > 0.)
@@ -448,7 +455,7 @@ int main(int argc, char** argv) {
 				stellaInstance->addJob(job.value());
 				stellaInstance->startThreads();
 				logger.hr();
-				logger.log(Stella::formattedClockTimeNow() + " Started mining at block "s + std::to_string(clientInfo->height) + ", difficulty "s + Stella::doubleToString(clientInfo->difficulty, 3U)  + "\n"s, MessageType::BOLD);
+				logger.log(Stella::formattedClockTimeNow() + " Started mining at block "s + std::to_string(clientInfo->height) + ", difficulty "s + Stella::doubleToString(clientInfo->difficulty + 32U*configuration.options().difficultyOffset, 3U)  + (32U*configuration.options().difficultyOffset > 0U ? " (offset +"s + std::to_string(32U*configuration.options().difficultyOffset) + ")"s : ""s)+ "\n"s, MessageType::BOLD);
 				timer = std::chrono::steady_clock::now();
 				continue;
 			}
@@ -465,7 +472,7 @@ int main(int argc, char** argv) {
 				tupleCountsRecent[countsRecentEntryPos] = std::make_pair(std::chrono::steady_clock::now(), stellaInstance->getTupleCounts());
 				// Notify the event
 				logger.log(Stella::formattedClockTimeNow());
-				logger.log(" Block "s + std::to_string(currentHeight) + ", average "s + Stella::doubleToString(averageBlockTime, 1) + " s, difficulty "s + Stella::doubleToString(clientInfo->difficulty, 3) + "\n"s);
+				logger.log(" Block "s + std::to_string(currentHeight) + ", average "s + Stella::doubleToString(averageBlockTime, 1) + " s, difficulty "s + Stella::doubleToString(clientInfo->difficulty + 32U*configuration.options().difficultyOffset, 3U)  + (32U*configuration.options().difficultyOffset > 0U ? " (offset +"s + std::to_string(32U*configuration.options().difficultyOffset) + ")"s : ""s)+ "\n"s);
 
 				// Restart if needed to retune parameters.
 				if (!stellaInstance->hasAcceptedPatterns(clientInfo->acceptedPatterns)) { // Pattern changed and no longer compatible with the current one.

main.hpp

@@ -43,6 +43,7 @@ struct Options {
 	uint16_t port{28332U};
 	double refreshInterval{30.}, difficulty{1024.}, benchmarkBlockInterval{150.}, benchmarkTimeLimit{960.};
 	uint64_t benchmarkPrimeCountLimit{10000000};
+	uint16_t difficultyOffset{0U};
 	double restartDifficultyFactor{1.03};
 	std::vector<std::string> rules{};
 	uint16_t apiPort{0U};