Add missing x17 algo

Makefile.am

@@ -33,6 +33,7 @@ cpuminer_SOURCES = \
   sha3/sph_simd.c \
   sha3/sph_echo.c \
   sha3/sph_hamsi.c \
+  sha3/sph_haval.c \
   sha3/sph_fugue.c \
   sha3/sph_ripemd.c \
   sha3/sph_sha2.c \
@@ -94,6 +95,7 @@ cpuminer_SOURCES = \
   algo/x13.c \
   algo/x14.c \
   algo/x15.c \
+  algo/x17.c \
   algo/yescrypt.c \
   algo/zr5.c
 

README.md

@@ -31,6 +31,7 @@ Algorithms
  * ✓ __bmw__ (Midnight [MDT] BMW-256)
  * ✓ __cryptonight__ (Bytecoin [BCN], Monero [XMR])
  * ✓ __cryptonight-light__ (Aeon)
+ * ✓ __decred__ (Blake256-14 [DCR])
  * ✓ __dmd-gr__ (Diamond-Groestl)
  * ✓ __fresh__ (FreshCoin)
  * ✓ __groestl__ (Groestlcoin)
@@ -55,6 +56,7 @@ Algorithms
  * ✓ __x13__ (Sherlockcoin, [ACE], [B2B], [GRC], [XHC], ...)
  * ✓ __x14__ (X14, Webcoin [WEB])
  * ✓ __x15__ (RadianceCoin [RCE])
+ * ✓ __x17__ (Verge [XVG])
  * ✓ __yescrypt__ (GlobalBoostY [BSTY], Unitus [UIS], MyriadCoin [MYR])
  * ✓ __zr5__ (Ziftrcoin [ZRC])
 

algo/x17.c

@@ -0,0 +1,156 @@
+#include <miner.h>
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <sha3/sph_blake.h>
+#include <sha3/sph_bmw.h>
+#include <sha3/sph_groestl.h>
+#include <sha3/sph_jh.h>
+#include <sha3/sph_keccak.h>
+#include <sha3/sph_skein.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/sph_haval.h>
+
+//#define DEBUG_ALGO
+
+void x17hash(void *output, const void *input)
+{
+	unsigned char _ALIGN(64) hash[64];
+
+	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;
+	sph_haval256_5_context   ctx_haval;
+
+	sph_blake512_init(&ctx_blake);
+	sph_blake512(&ctx_blake, input, 80);
+	sph_blake512_close(&ctx_blake, hash);
+
+	sph_bmw512_init(&ctx_bmw);
+	sph_bmw512(&ctx_bmw, hash, 64);
+	sph_bmw512_close(&ctx_bmw, hash);
+
+	sph_groestl512_init(&ctx_groestl);
+	sph_groestl512(&ctx_groestl, hash, 64);
+	sph_groestl512_close(&ctx_groestl, hash);
+
+	sph_skein512_init(&ctx_skein);
+	sph_skein512(&ctx_skein, hash, 64);
+	sph_skein512_close(&ctx_skein, hash);
+
+	sph_jh512_init(&ctx_jh);
+	sph_jh512(&ctx_jh, hash, 64);
+	sph_jh512_close(&ctx_jh, hash);
+
+	sph_keccak512_init(&ctx_keccak);
+	sph_keccak512(&ctx_keccak, hash, 64);
+	sph_keccak512_close(&ctx_keccak, hash);
+
+	sph_luffa512_init(&ctx_luffa);
+	sph_luffa512(&ctx_luffa, hash, 64);
+	sph_luffa512_close(&ctx_luffa, hash);
+
+	sph_cubehash512_init(&ctx_cubehash);
+	sph_cubehash512(&ctx_cubehash, hash, 64);
+	sph_cubehash512_close(&ctx_cubehash, hash);
+
+	sph_shavite512_init(&ctx_shavite);
+	sph_shavite512(&ctx_shavite, hash, 64);
+	sph_shavite512_close(&ctx_shavite, hash);
+
+	sph_simd512_init(&ctx_simd);
+	sph_simd512(&ctx_simd, hash, 64);
+	sph_simd512_close(&ctx_simd, hash);
+
+	sph_echo512_init(&ctx_echo);
+	sph_echo512(&ctx_echo, hash, 64);
+	sph_echo512_close(&ctx_echo, hash);
+
+	sph_hamsi512_init(&ctx_hamsi);
+	sph_hamsi512(&ctx_hamsi, hash, 64);
+	sph_hamsi512_close(&ctx_hamsi, hash);
+
+	sph_fugue512_init(&ctx_fugue);
+	sph_fugue512(&ctx_fugue, hash, 64);
+	sph_fugue512_close(&ctx_fugue, hash);
+
+	sph_shabal512_init(&ctx_shabal);
+	sph_shabal512(&ctx_shabal, hash, 64);
+	sph_shabal512_close(&ctx_shabal, hash);
+
+	sph_whirlpool_init(&ctx_whirlpool);
+	sph_whirlpool(&ctx_whirlpool, hash, 64);
+	sph_whirlpool_close(&ctx_whirlpool, hash);
+
+	sph_sha512_init(&ctx_sha512);
+	sph_sha512(&ctx_sha512,(const void*) hash, 64);
+	sph_sha512_close(&ctx_sha512,(void*) hash);
+
+	sph_haval256_5_init(&ctx_haval);
+	sph_haval256_5(&ctx_haval,(const void*) hash, 64);
+	sph_haval256_5_close(&ctx_haval, hash);
+
+	memcpy(output, hash, 32);
+}
+
+int scanhash_x17(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
+{
+	uint32_t _ALIGN(64) hash[8];
+	uint32_t _ALIGN(64) endiandata[20];
+	uint32_t *pdata = work->data;
+	uint32_t *ptarget = work->target;
+
+	const uint32_t Htarg = ptarget[7];
+	const uint32_t first_nonce = pdata[19];
+	uint32_t nonce = first_nonce;
+	volatile uint8_t *restart = &(work_restart[thr_id].restart);
+
+	if (opt_benchmark)
+		ptarget[7] = 0x0cff;
+
+	for (int k=0; k < 19; k++)
+		be32enc(&endiandata[k], pdata[k]);
+
+	do {
+		be32enc(&endiandata[19], nonce);
+		x17hash(hash, endiandata);
+
+		if (hash[7] <= Htarg && fulltest(hash, ptarget)) {
+			work_set_target_ratio(work, hash);
+			pdata[19] = nonce;
+			*hashes_done = pdata[19] - first_nonce;
+			return 1;
+		}
+		nonce++;
+
+	} while (nonce < max_nonce && !(*restart));
+
+	pdata[19] = nonce;
+	*hashes_done = pdata[19] - first_nonce + 1;
+	return 0;
+}

cpu-miner.c

@@ -119,7 +119,8 @@ enum algos {
 	ALGO_X11,         /* X11 */
 	ALGO_X13,         /* X13 */
 	ALGO_X14,         /* X14 */
-	ALGO_X15,         /* X15 Whirlpool */
+	ALGO_X15,         /* X15 */
+	ALGO_X17,         /* X17 */
 	ALGO_YESCRYPT,
 	ALGO_ZR5,
 	ALGO_COUNT
@@ -169,6 +170,7 @@ static const char *algo_names[] = {
 	"x13",
 	"x14",
 	"x15",
+	"x17",
 	"yescrypt",
 	"zr5",
 	"\0"
@@ -316,6 +318,7 @@ Options:\n\
                           x13          X13\n\
                           x14          X14\n\
                           x15          X15\n\
+                          x17          X17\n\
                           yescrypt     Yescrypt\n\
                           zr5          ZR5\n\
   -o, --url=URL         URL of mining server\n\
@@ -2114,6 +2117,7 @@ static void *miner_thread(void *userdata)
 				break;
 			case ALGO_LBRY:
 			case ALGO_X15:
+			case ALGO_X17:
 			case ALGO_ZR5:
 				max64 = 0x1ffff;
 				break;
@@ -2279,6 +2283,9 @@ static void *miner_thread(void *userdata)
 		case ALGO_X15:
 			rc = scanhash_x15(thr_id, &work, max_nonce, &hashes_done);
 			break;
+		case ALGO_X17:
+			rc = scanhash_x17(thr_id, &work, max_nonce, &hashes_done);
+			break;
 		case ALGO_YESCRYPT:
 			rc = scanhash_yescrypt(thr_id, &work, max_nonce, &hashes_done);
 			break;

cpuminer.vcxproj

@@ -243,6 +243,7 @@
     <ClCompile Include="algo\x13.c" />
     <ClCompile Include="algo\x14.c" />
     <ClCompile Include="algo\x15.c" />
+    <ClCompile Include="algo\x17.c" />
     <ClCompile Include="algo\yescrypt.c" />
     <ClCompile Include="algo\zr5.c" />
     <ClCompile Include="yescrypt\yescrypt-best.c" />

cpuminer.vcxproj.filters

@@ -270,6 +270,9 @@
     <ClCompile Include="algo\x15.c">
       <Filter>algo</Filter>
     </ClCompile>
+    <ClCompile Include="algo\x17.c">
+      <Filter>algo</Filter>
+    </ClCompile>
     <ClCompile Include="algo\pluck.c">
       <Filter>algo</Filter>
     </ClCompile>

miner.h

@@ -243,6 +243,7 @@ int scanhash_x11(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *ha
 int scanhash_x13(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done);
 int scanhash_x14(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done);
 int scanhash_x15(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done);
+int scanhash_x17(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done);
 int scanhash_yescrypt(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done);
 int scanhash_zr5(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done);
 
@@ -522,6 +523,7 @@ void x11hash(void *output, const void *input);
 void x13hash(void *output, const void *input);
 void x14hash(void *output, const void *input);
 void x15hash(void *output, const void *input);
+void x17hash(void *output, const void *input);
 void zr5hash(void *output, const void *input);
 void yescrypthash(void *output, const void *input);
 void zr5hash_pok(void *output, uint32_t *pdata);

util.c

@@ -2440,6 +2440,9 @@ void print_hash_tests(void)
 	x15hash(&hash[0], &buf[0]);
 	printpfx("x15", hash);
 
+	x17hash(&hash[0], &buf[0]);
+	printpfx("x17", hash);
+
 	yescrypthash(&hash[0], &buf[0]);
 	printpfx("yescrypt", hash);