Add x16rt algo

stratum/algos/makefile

@@ -13,7 +13,7 @@ SOURCES=lyra2re.c lyra2v2.c lyra2v3.c Lyra2.c lyra2z.c Lyra2-z.c Sponge.c allium
 	x22i.c SWIFFTX/SWIFFTX.c \
 	blake.c blakecoin.c blake2b.c blake2s.c jha.c keccak.c lbry.c tribus.c exosis.c \
 	deep.c fresh.c groestl.c neoscrypt.c nist5.c quark.c qubit.c skein.c skein2.c \
-	bitcore.c timetravel.c x11evo.c x16r.c x16s.c xevan.c bastion.c hmq17.c sonoa.c \
+	bitcore.c timetravel.c x11evo.c x16r.c x16s.c x16rt.c xevan.c bastion.c hmq17.c sonoa.c \
 	bmw.c luffa.c pentablake.c vitalium.c whirlpool.c whirlpoolx.c zr5.c \
 	scrypt.c scryptn.c sha256.c sha256t.c sha256q.c \
 	yescrypt.c yescrypt-opt.c sha256_Y.c \

stratum/algos/x16rt.c

@@ -0,0 +1,206 @@
+/**
+ * sX16RT algorithm (X16 with Randomized chain order based on time)
+ *
+ * tpruvot 2018 - GPL code
+ * blondfrogs 2018 - TimeHash code
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sha3/sph_blake.h>
+#include <sha3/sph_bmw.h>
+#include <sha3/sph_groestl.h>
+#include <sha3/sph_skein.h>
+#include <sha3/sph_jh.h>
+#include <sha3/sph_keccak.h>
+
+#include <sha3/sph_luffa.h>
+#include <sha3/sph_cubehash.h>
+#include <sha3/sph_shavite.h>
+#include <sha3/sph_simd.h>
+#include <sha3/sph_echo.h>
+
+#include <sha3/sph_hamsi.h>
+#include <sha3/sph_fugue.h>
+#include <sha3/sph_shabal.h>
+#include <sha3/sph_whirlpool.h>
+#include <sha3/sph_sha2.h>
+
+#include <sha3/sha2.c>
+
+#include "common.h"
+
+#define TIME_MASK 0xffffff80
+
+enum Algo {
+	BLAKE = 0,
+	BMW,
+	GROESTL,
+	JH,
+	KECCAK,
+	SKEIN,
+	LUFFA,
+	CUBEHASH,
+	SHAVITE,
+	SIMD,
+	ECHO,
+	HAMSI,
+	FUGUE,
+	SHABAL,
+	WHIRLPOOL,
+	SHA512,
+	HASH_FUNC_COUNT
+};
+
+static void getAlgoString(const uint8_t* timeHash, char *output)
+{
+	char *sptr = output;
+
+	for (int j = 0; j < HASH_FUNC_COUNT; j++) {
+		char b = (15 - j) >> 1;
+		uint8_t algoDigit = (j & 1) ? timeHash[b] & 0xF : timeHash[b] >> 4;
+
+		if (algoDigit >= 10)
+			sprintf(sptr, "%c", 'A' + (algoDigit - 10));
+		else
+			sprintf(sptr, "%u", (uint32_t) algoDigit);
+		sptr++;
+	}
+	*sptr = '\0';
+}
+
+static void getTimeHash(const uint32_t timeStamp, void* timeHash)
+{
+    int32_t maskedTime = timeStamp & TIME_MASK;
+    sha256d((unsigned char*)timeHash, (const unsigned char*)&(maskedTime), sizeof(maskedTime));
+}
+
+// X16RT CPU Hash (Validation)
+void x16rt_hash(const char* input, char* output, uint32_t len)
+{
+	uint32_t hash[64/4];
+	char hashOrder[HASH_FUNC_COUNT +1] = { 0 };
+
+	sph_blake512_context ctx_blake;
+	sph_bmw512_context ctx_bmw;
+	sph_groestl512_context ctx_groestl;
+	sph_jh512_context ctx_jh;
+	sph_keccak512_context ctx_keccak;
+	sph_skein512_context ctx_skein;
+	sph_luffa512_context ctx_luffa;
+	sph_cubehash512_context ctx_cubehash;
+	sph_shavite512_context ctx_shavite;
+	sph_simd512_context ctx_simd;
+	sph_echo512_context ctx_echo;
+	sph_hamsi512_context ctx_hamsi;
+	sph_fugue512_context ctx_fugue;
+	sph_shabal512_context ctx_shabal;
+	sph_whirlpool_context ctx_whirlpool;
+	sph_sha512_context ctx_sha512;
+
+	void *in = (void*) input;
+	int size = len;
+
+	//
+
+	uint32_t *in32 = (uint32_t*) input;
+	uint32_t ntime = in32[17];
+	uint8_t timeHash[8]; /* was uint32_t _ALIGN(64) timeHash[8]; */
+	//
+	getTimeHash(ntime, &timeHash);
+	getAlgoString(&timeHash[0], hashOrder);
+
+	for (int i = 0; i < 16; i++)
+	{
+		const char elem = hashOrder[i];
+		const uint8_t algo = elem >= 'A' ? elem - 'A' + 10 : elem - '0';
+
+		switch (algo) {
+		case BLAKE:
+			sph_blake512_init(&ctx_blake);
+			sph_blake512(&ctx_blake, in, size);
+			sph_blake512_close(&ctx_blake, hash);
+			break;
+		case BMW:
+			sph_bmw512_init(&ctx_bmw);
+			sph_bmw512(&ctx_bmw, in, size);
+			sph_bmw512_close(&ctx_bmw, hash);
+			break;
+		case GROESTL:
+			sph_groestl512_init(&ctx_groestl);
+			sph_groestl512(&ctx_groestl, in, size);
+			sph_groestl512_close(&ctx_groestl, hash);
+			break;
+		case SKEIN:
+			sph_skein512_init(&ctx_skein);
+			sph_skein512(&ctx_skein, in, size);
+			sph_skein512_close(&ctx_skein, hash);
+			break;
+		case JH:
+			sph_jh512_init(&ctx_jh);
+			sph_jh512(&ctx_jh, in, size);
+			sph_jh512_close(&ctx_jh, hash);
+			break;
+		case KECCAK:
+			sph_keccak512_init(&ctx_keccak);
+			sph_keccak512(&ctx_keccak, in, size);
+			sph_keccak512_close(&ctx_keccak, hash);
+			break;
+		case LUFFA:
+			sph_luffa512_init(&ctx_luffa);
+			sph_luffa512(&ctx_luffa, in, size);
+			sph_luffa512_close(&ctx_luffa, hash);
+			break;
+		case CUBEHASH:
+			sph_cubehash512_init(&ctx_cubehash);
+			sph_cubehash512(&ctx_cubehash, in, size);
+			sph_cubehash512_close(&ctx_cubehash, hash);
+			break;
+		case SHAVITE:
+			sph_shavite512_init(&ctx_shavite);
+			sph_shavite512(&ctx_shavite, in, size);
+			sph_shavite512_close(&ctx_shavite, hash);
+			break;
+		case SIMD:
+			sph_simd512_init(&ctx_simd);
+			sph_simd512(&ctx_simd, in, size);
+			sph_simd512_close(&ctx_simd, hash);
+			break;
+		case ECHO:
+			sph_echo512_init(&ctx_echo);
+			sph_echo512(&ctx_echo, in, size);
+			sph_echo512_close(&ctx_echo, hash);
+			break;
+		case HAMSI:
+			sph_hamsi512_init(&ctx_hamsi);
+			sph_hamsi512(&ctx_hamsi, in, size);
+			sph_hamsi512_close(&ctx_hamsi, hash);
+			break;
+		case FUGUE:
+			sph_fugue512_init(&ctx_fugue);
+			sph_fugue512(&ctx_fugue, in, size);
+			sph_fugue512_close(&ctx_fugue, hash);
+			break;
+		case SHABAL:
+			sph_shabal512_init(&ctx_shabal);
+			sph_shabal512(&ctx_shabal, in, size);
+			sph_shabal512_close(&ctx_shabal, hash);
+			break;
+		case WHIRLPOOL:
+			sph_whirlpool_init(&ctx_whirlpool);
+			sph_whirlpool(&ctx_whirlpool, in, size);
+			sph_whirlpool_close(&ctx_whirlpool, hash);
+			break;
+		case SHA512:
+			sph_sha512_init(&ctx_sha512);
+			sph_sha512(&ctx_sha512,(const void*) in, size);
+			sph_sha512_close(&ctx_sha512,(void*) hash);
+			break;
+		}
+		in = (void*) hash;
+		size = 64;
+	}
+	memcpy(output, hash, 32);
+}

stratum/algos/x16rt.h

@@ -0,0 +1,18 @@
+#ifndef X16RT_H
+#define X16RT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void x16rt_hash(const char* input, char* output, uint32_t len);
+
+void sha256d(unsigned char *hash, const unsigned char *data, int len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

stratum/client_difficulty.cpp

@@ -77,7 +77,7 @@ int client_send_difficulty(YAAMP_CLIENT *client, double difficulty)
 	if(difficulty >= 1)
 		client_call(client, "mining.set_difficulty", "[%.0f]", difficulty);
 	else
-		client_call(client, "mining.set_difficulty", "[%.3f]", difficulty);
+		client_call(client, "mining.set_difficulty", "[%.8f]", difficulty);
 	return 0;
 }
 

stratum/sha3/makefile

@@ -7,7 +7,7 @@ LDFLAGS=-O2
 SOURCES=sph_jh.c sph_blake.c sph_bmw.c sph_groestl.c sph_skein.c sph_keccak.c sph_luffa.c sph_cubehash.c sph_shavite.c \
 	sph_simd.c sph_echo.c sph_fugue.c sph_hamsi.c sph_shabal.c sph_whirlpool.c \
 	sph_haval.c sph_hefty1.c sph_ripemd.c sph_sha2.c sph_sha2big.c sph_tiger.c \
-	blake2s.c blake2b.c
+	blake2s.c blake2b.c sha2.c
 
 OBJECTS=$(SOURCES:.c=.o)
 OUTPUT=libhash.a