Minor fixes and a last Fork change

Signed-off-by: Pttn <28868425+Pttn@users.noreply.github.com>

Author: Pttn

Client.cpp

@@ -40,24 +40,32 @@ std::array<uint8_t, 32> BlockHeader::powHash(const int32_t powVersion) const {
 
 mpz_class BlockHeader::target(const int32_t powVersion) const {
 	const uint32_t difficultyIntegerPart(decodeBits(bits, powVersion));
+	uint32_t trailingZeros;
+	const std::array<uint8_t, 32> hash(powHash(powVersion));
 	mpz_class target;
-	if (powVersion == -1)
+	if (powVersion == -1) {
+		if (difficultyIntegerPart < 265U) return 0;
 		target = 256;
+		for (uint64_t i(0) ; i < 256 ; i++) {
+			target <<= 1;
+			if ((hash[i/8] >> (i % 8)) & 1)
+				target.get_mpz_t()->_mp_d[0]++;
+		}
+		trailingZeros = difficultyIntegerPart - 265U;
+	}
 	else if (powVersion == 1) {
+		if (difficultyIntegerPart < 264U) return 0;
 		const uint32_t df(bits & 255U);
 		target = 256 + ((10U*df*df*df + 7383U*df*df + 5840720U*df + 3997440U) >> 23U);
+		target <<= 256;
+		mpz_class hashGmp;
+		mpz_import(hashGmp.get_mpz_t(), 32, -1, sizeof(uint8_t), 0, 0, hash.begin());
+		target += hashGmp;
+		trailingZeros = difficultyIntegerPart - 264U;
 	}
 	else
 		return 0;
 
-	const std::array<uint8_t, 32> hash(powHash(powVersion));
-	for (uint64_t i(0) ; i < 256 ; i++) {
-		target <<= 1;
-		if ((hash[i/8] >> (i % 8)) & 1)
-			target.get_mpz_t()->_mp_d[0]++;
-	}
-	if (difficultyIntegerPart < 265U) return 0;
-	const uint32_t trailingZeros(difficultyIntegerPart - 265U);
 	target <<= trailingZeros;
 	return target;
 }
@@ -147,15 +155,15 @@ bool BMClient::getJob(Job& job, const bool dummy) {
 	job.height = _height;
 	job.difficulty = _difficulty;
 	const uint64_t difficultyAsInteger(std::round(65536.*job.difficulty));
-	// Target: (in binary) 1 . Leading Digits L (16 bits) . Height (32 bits) . Requests (32 bits) . (Difficulty - 81) zeros = 2^(Difficulty - 81)(2^80 + 2^64*L + 2^32*Height + Requests)
+	// Target: (in binary) 1 . Leading Digits L (16 bits) . Height (32 bits) . Requests (32 bits) . (Difficulty - 80) zeros = 2^(Difficulty - 80)(2^80 + 2^64*L + 2^32*Height + Requests)
 	job.target = 1;
 	job.target <<= 16;
 	job.target += static_cast<uint16_t>(std::round(std::pow(2., 16. + static_cast<double>(difficultyAsInteger % 65536)/65536.)) - 65536.);
 	job.target <<= 32;
 	job.target += job.height;
 	job.target <<= 32;
 	job.target += _requests;
-	job.target <<= (difficultyAsInteger/65536ULL - 81ULL);
+	job.target <<= (difficultyAsInteger/65536ULL - 80ULL);
 	job.primeCountTarget = _pattern.size();
 	job.primeCountMin = job.primeCountTarget;
 	if (!dummy) _requests++;
@@ -165,7 +173,7 @@ bool BMClient::getJob(Job& job, const bool dummy) {
 bool SearchClient::getJob(Job& job, const bool) {
 	job.height = 1;
 	job.difficulty = _difficulty;
-	// Target: (in binary) 1 . Leading Digits L (16 bits) . 80 Random Bits . (Difficulty - 97) zeros = 2^(Difficulty - 97)*(2^96 + 2^80*L + Random)
+	// Target: (in binary) 1 . Leading Digits L (16 bits) . 80 Random Bits . (Difficulty - 96) zeros = 2^(Difficulty - 96)*(2^96 + 2^80*L + Random)
 	const uint64_t difficultyAsInteger(std::round(65536.*job.difficulty));
 	std::array<uint8_t, 10> random;
 	for (auto &byte : random) byte = rand(0x00, 0xFF);
@@ -176,7 +184,7 @@ bool SearchClient::getJob(Job& job, const bool) {
 		job.target <<= 16;
 		job.target += reinterpret_cast<uint16_t*>(random.data())[4 - i];
 	}
-	job.target <<= (job.difficulty - 97);
+	job.target <<= (job.difficulty - 96);
 	job.primeCountTarget = _pattern.size();
 	job.primeCountMin = job.primeCountTarget;
 	return true;

GBTClient.cpp

@@ -239,8 +239,8 @@ void GBTClient::_submit(const Job& job) {
 	oss << job.transactions << "\"], \"id\": 0}\n";
 	req = oss.str();
 
+	DBG(std::cout << "Sending: " << req;);
 	json_t *jsonSb(_sendRPCCall(req)); // SubmitBlock response
-	DBG(std::cout << "Sent: " << req;);
 	if (jsonSb == nullptr) ERRORMSG("Failure submitting block");
 	else {
 		json_t *jsonSb_Res(json_object_get(jsonSb, "result")),

Miner.cpp

@@ -115,12 +115,12 @@ void Miner::init(const MinerParameters &minerParameters) {
 		primeTableFileBytes = file.tellg();
 		savedPrimes = primeTableFileBytes/sizeof(decltype(_primes)::value_type);
 		if (savedPrimes > 0) {
-			file.seekg(-sizeof(decltype(_primes)::value_type), std::ios::end);
+			file.seekg(-static_cast<int64_t>(sizeof(decltype(_primes)::value_type)), std::ios::end);
 			file.read(reinterpret_cast<char*>(&largestSavedPrime), sizeof(decltype(_primes)::value_type));
 		}
 	}
 	std::chrono::time_point<std::chrono::steady_clock> t0(std::chrono::steady_clock::now());
-	if (savedPrimes > 0 && _parameters.primeTableLimit >= 1048576 && _parameters.primeTableLimit < largestSavedPrime) {
+	if (savedPrimes > 0 && _parameters.primeTableLimit >= 1048576 && _parameters.primeTableLimit <= largestSavedPrime) {
 		std::cout << "Extracting prime numbers from " << primeTableFile << " (" << primeTableFileBytes << " bytes, " << savedPrimes << " primes, largest " << largestSavedPrime << ")..." << std::endl;
 		uint64_t nPrimesUpperBound(std::min(1.085*static_cast<double>(_parameters.primeTableLimit)/std::log(static_cast<double>(_parameters.primeTableLimit)), static_cast<double>(savedPrimes))); // 1.085 = max(π(p)log(p)/p) for p >= 2^20
 		try {

main.cpp

@@ -230,9 +230,7 @@ void Options::loadConf() {
 					std::vector<uint64_t> offsets;
 					uint64_t tmp;
 					while (offsetsSS >> tmp) offsets.push_back(tmp);
-					if (offsets.size() < 2)
-						std::cout << "Too short or invalid tuple offsets, ignoring." << std::endl;
-					else _minerParameters.pattern = offsets;
+					_minerParameters.pattern = offsets;
 				}
 				else if (key == "PrimorialNumber") {
 					try {_minerParameters.primorialNumber = std::stoll(value);}
@@ -276,7 +274,7 @@ void Options::loadConf() {
 			_minerParameters.pattern = {0, 2, 4, 2, 4, 6, 2};
 	}
 	else if (_mode == "Search") {
-		const double base10Exp((_difficulty - 1.)*0.301029996);
+		const double base10Exp(_difficulty*0.301029996);
 		std::cout << "Search Mode at difficulty " << _difficulty << " (numbers around " << std::pow(10., base10Exp - std::floor(base10Exp)) << "*10^" << std::floor(base10Exp) << ") - Good luck!" << std::endl;
 		if (_minerParameters.pattern.size() == 0) // Pick a default pattern if none was chosen
 			_minerParameters.pattern = {0, 2, 4, 2, 4, 6, 2};
@@ -335,10 +333,10 @@ int main(int argc, char** argv) {
 #endif
 
 	std::cout << versionString << ", Riecoin miner by Pttn and contributors" << std::endl;
-	std::cout << "Assembly code by Michael Bell (Rockhawk)" << std::endl;
 	std::cout << "Project page: https://github.com/Pttn/rieMiner" << std::endl;
 	std::cout << "Go to the project page or open README.md for usage information" << std::endl;
 	std::cout << "-----------------------------------------------------------" << std::endl;
+	std::cout << "Assembly code by Michael Bell (Rockhawk)" << std::endl;
 	std::cout << "G++ " << __GNUC__ << "." << __GNUC_MINOR__ << "." << __GNUC_PATCHLEVEL__ << " - https://gcc.gnu.org/" << std::endl;
 	std::cout << "GMP " << __GNU_MP_VERSION << "." << __GNU_MP_VERSION_MINOR << "." << __GNU_MP_VERSION_PATCHLEVEL << " - https://gmplib.org/" << std::endl;
 	std::cout << "Curl " << LIBCURL_VERSION << " - https://curl.haxx.se/" << std::endl;

tools.cpp

@@ -27,7 +27,7 @@ std::vector<uint64_t> generatePrimeTable(const uint64_t limit) {
 	std::vector<uint64_t> compositeTable((limit + 127ULL)/128ULL, 0ULL); // Booleans indicating whether an odd number is composite: 0000100100101100...
 	for (uint64_t f(3ULL) ; f*f <= limit ; f += 2ULL) { // Eliminate f and its multiples m for odd f from 3 to square root of the limit
 		if (compositeTable[f >> 7ULL] & (1ULL << ((f >> 1ULL) & 63ULL))) continue; // Skip if f is composite (f and its multiples were already eliminated)
-		for (uint64_t m((f*f) >> 1ULL) ; m < (limit >> 1ULL) ; m += f) // Start eliminating at f^2 (multiples of f below were already eliminated)
+		for (uint64_t m((f*f) >> 1ULL) ; m <= (limit >> 1ULL) ; m += f) // Start eliminating at f^2 (multiples of f below were already eliminated)
 			compositeTable[m >> 6ULL] |= 1ULL << (m & 63ULL);
 	}
 	std::vector<uint64_t> primeTable(1, 2);