bitcore timetravel-10 algo variant

Signed-off-by: Tanguy Pruvot <tanguy.pruvot@gmail.com>

rc.local

@@ -30,6 +30,7 @@ screen -dmS x15 $STRATUM_DIR/run.sh x15
 screen -dmS x17 $STRATUM_DIR/run.sh x17
 screen -dmS xevan $STRATUM_DIR/run.sh xevan
 screen -dmS timetravel $STRATUM_DIR/run.sh timetravel
+screen -dmS bitcore $STRATUM_DIR/run.sh bitcore
 screen -dmS hmq1725 $STRATUM_DIR/run.sh hmq1725
 
 screen -dmS sha $STRATUM_DIR/run.sh sha

stratum/algos/bitcore.c

@@ -0,0 +1,171 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define HASH_FUNC_BASE_TIMESTAMP 1492973331U // BitCore: Genesis Timestamp
+#define HASH_FUNC_COUNT 10
+#define HASH_FUNC_COUNT_PERMUTATIONS 40320
+
+#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>
+
+
+#define _ALIGN(x) __attribute__ ((aligned(x)))
+
+// helpers
+inline void swap(int *a, int *b) {
+	int c = *a;
+	*a = *b;
+	*b = c;
+}
+
+static void reverse(int *pbegin, int *pend) {
+	while ( (pbegin != pend) && (pbegin != --pend) )
+		swap(pbegin++, pend);
+}
+
+static void next_permutation(int *pbegin, int *pend) {
+	if (pbegin == pend)
+		return;
+
+	int *i = pbegin;
+	++i;
+	if (i == pend)
+		return;
+
+	i = pend;
+	--i;
+
+	while (1) {
+		int *j = i;
+		--i;
+
+		if (*i < *j) {
+			int *k = pend;
+
+			while (!(*i < *--k))
+				/* pass */;
+
+			swap(i, k);
+			reverse(j, pend);
+			return; // true
+		}
+
+		if (i == pbegin) {
+			reverse(pbegin, pend);
+			return; // false
+		}
+	}
+}
+// helpers
+
+void timetravel10_hash(const char* input, char* output, uint32_t len)
+{
+	uint32_t _ALIGN(64) hash[16 * HASH_FUNC_COUNT];
+	uint32_t *hashA, *hashB;
+	uint32_t dataLen = 64;
+	uint32_t *work_data = (uint32_t *)input;
+	const uint32_t timestamp = work_data[17];
+
+	sph_blake512_context     ctx_blake;
+	sph_bmw512_context       ctx_bmw;
+	sph_groestl512_context   ctx_groestl;
+	sph_skein512_context     ctx_skein;
+	sph_jh512_context        ctx_jh;
+	sph_keccak512_context    ctx_keccak;
+	sph_luffa512_context     ctx_luffa;
+	sph_cubehash512_context  ctx_cubehash;
+	sph_shavite512_context   ctx_shavite;
+	sph_simd512_context      ctx_simd;
+
+	// We want to permute algorithms. To get started we
+	// initialize an array with a sorted sequence of unique
+	// integers where every integer represents its own algorithm.
+	uint32_t permutation[HASH_FUNC_COUNT];
+	for (uint32_t i = 0; i < HASH_FUNC_COUNT; i++) {
+			permutation[i]=i;
+	}
+
+	// Compute the next permuation
+	uint32_t steps = (timestamp - HASH_FUNC_BASE_TIMESTAMP) % HASH_FUNC_COUNT_PERMUTATIONS;
+	for (uint32_t i = 0; i < steps; i++) {
+		next_permutation(permutation, permutation + HASH_FUNC_COUNT);
+	}
+
+	for (uint32_t i = 0; i < HASH_FUNC_COUNT; i++) {
+		if (i == 0) {
+			dataLen = len;
+			hashA = work_data;
+		} else {
+			dataLen = 64;
+			hashA = &hash[16 * (i - 1)];
+		}
+		hashB = &hash[16 * i];
+
+		switch(permutation[i]) {
+			case 0:
+				sph_blake512_init(&ctx_blake);
+				sph_blake512(&ctx_blake, hashA, dataLen);
+				sph_blake512_close(&ctx_blake, hashB);
+				break;
+			case 1:
+				sph_bmw512_init(&ctx_bmw);
+				sph_bmw512(&ctx_bmw, hashA, dataLen);
+				sph_bmw512_close(&ctx_bmw, hashB);
+				break;
+			case 2:
+				sph_groestl512_init(&ctx_groestl);
+				sph_groestl512(&ctx_groestl, hashA, dataLen);
+				sph_groestl512_close(&ctx_groestl, hashB);
+				break;
+			case 3:
+				sph_skein512_init(&ctx_skein);
+				sph_skein512(&ctx_skein, hashA, dataLen);
+				sph_skein512_close(&ctx_skein, hashB);
+				break;
+			case 4:
+				sph_jh512_init(&ctx_jh);
+				sph_jh512(&ctx_jh, hashA, dataLen);
+				sph_jh512_close(&ctx_jh, hashB);
+				break;
+			case 5:
+				sph_keccak512_init(&ctx_keccak);
+				sph_keccak512(&ctx_keccak, hashA, dataLen);
+				sph_keccak512_close(&ctx_keccak, hashB);
+				break;
+			case 6:
+				sph_luffa512_init(&ctx_luffa);
+				sph_luffa512(&ctx_luffa, hashA, dataLen);
+				sph_luffa512_close(&ctx_luffa, hashB);
+				break;
+			case 7:
+				sph_cubehash512_init(&ctx_cubehash);
+				sph_cubehash512(&ctx_cubehash, hashA, dataLen);
+				sph_cubehash512_close(&ctx_cubehash, hashB);
+				break;
+			case 8:
+				sph_shavite512_init(&ctx_shavite);
+				sph_shavite512(&ctx_shavite, hashA, dataLen);
+				sph_shavite512_close(&ctx_shavite, hashB);
+				break;
+			case 9:
+				sph_simd512_init(&ctx_simd);
+				sph_simd512(&ctx_simd, hashA, dataLen);
+				sph_simd512_close(&ctx_simd, hashB);
+				break;
+			default:
+				break;
+		}
+	}
+
+	memcpy(output, &hash[16 * (HASH_FUNC_COUNT - 1)], 32);
+}
+

stratum/algos/bitcore.h

@@ -0,0 +1,16 @@
+#ifndef TIMETRAVEL10_H
+#define TIMETRAVEL10_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+void timetravel10_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

stratum/algos/makefile

@@ -11,7 +11,7 @@ LDFLAGS=-O2 -lgmp
 SOURCES=lyra2re.c lyra2v2.c Lyra2.c lyra2z.c Lyra2z.c Sponge.c \
 	blake.c scrypt.c c11.c x11.c x13.c sha256.c sha256t.c keccak.c deep.c \
 	x14.c x15.c x17.c nist5.c fresh.c quark.c neoscrypt.c scryptn.c qubit.c skein.c groestl.c \
-	timetravel.c xevan.c bastion.c hmq17.c \
+	bitcore.c timetravel.c xevan.c bastion.c hmq17.c \
 	skein2.c zr5.c bmw.c luffa.c pentablake.c whirlpool.c whirlpoolx.c blakecoin.c \
 	blake2.c \
 	yescrypt.c yescrypt-opt.c sha256_Y.c lbry.c \

stratum/algos/timetravel.c

@@ -2,6 +2,10 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define HASH_FUNC_BASE_TIMESTAMP 1389040865 // Machinecoin: Genesis Timestamp
+#define HASH_FUNC_COUNT 8                   // Machinecoin: HASH_FUNC_COUNT of 11
+#define HASH_FUNC_COUNT_PERMUTATIONS 40320  // Machinecoin: HASH_FUNC_COUNT!
+
 #include <sha3/sph_blake.h>
 #include <sha3/sph_bmw.h>
 #include <sha3/sph_groestl.h>
@@ -10,13 +14,11 @@
 #include <sha3/sph_skein.h>
 #include <sha3/sph_luffa.h>
 #include <sha3/sph_cubehash.h>
+#if HASH_FUNC_COUNT > 8
 #include <sha3/sph_shavite.h>
 #include <sha3/sph_simd.h>
 #include <sha3/sph_echo.h>
-
-#define HASH_FUNC_BASE_TIMESTAMP 1389040865 // Machinecoin: Genesis Timestamp
-#define HASH_FUNC_COUNT 8                   // Machinecoin: HASH_FUNC_COUNT of 11
-#define HASH_FUNC_COUNT_PERMUTATIONS 40320  // Machinecoin: HASH_FUNC_COUNT!
+#endif
 
 #define _ALIGN(x) __attribute__ ((aligned(x)))
 
@@ -69,7 +71,7 @@ static void next_permutation(int *pbegin, int *pend) {
 
 void timetravel_hash(const char* input, char* output, uint32_t len)
 {
-	uint32_t _ALIGN(64) hash[128]; // 16 bytes * HASH_FUNC_COUNT
+	uint32_t _ALIGN(64) hash[16 * HASH_FUNC_COUNT];
 	uint32_t *hashA, *hashB;
 	uint32_t dataLen = 64;
 	uint32_t *work_data = (uint32_t *)input;
@@ -84,10 +86,11 @@ void timetravel_hash(const char* input, char* output, uint32_t len)
 	sph_keccak512_context    ctx_keccak;
 	sph_luffa512_context     ctx_luffa;
 	sph_cubehash512_context  ctx_cubehash;
+#if HASH_FUNC_COUNT > 8
 	sph_shavite512_context   ctx_shavite;
 	sph_simd512_context      ctx_simd;
 	sph_echo512_context      ctx_echo;
-
+#endif
 	// We want to permute algorithms. To get started we
 	// initialize an array with a sorted sequence of unique
 	// integers where every integer represents its own algorithm.
@@ -153,6 +156,7 @@ void timetravel_hash(const char* input, char* output, uint32_t len)
 				sph_cubehash512 (&ctx_cubehash, hashA, dataLen);
 				sph_cubehash512_close(&ctx_cubehash, hashB);
 				break;
+#if HASH_FUNC_COUNT > 8
 			case 8:
 				sph_shavite512_init(&ctx_shavite);
 				sph_shavite512(&ctx_shavite, hashA, dataLen);
@@ -168,6 +172,7 @@ void timetravel_hash(const char* input, char* output, uint32_t len)
 				sph_echo512 (&ctx_echo, hashA, dataLen);
 				sph_echo512_close(&ctx_echo, hashB);
 				break;
+#endif
 			default:
 				break;
 		}

stratum/client_submit.cpp

@@ -399,8 +399,8 @@ bool client_submit(YAAMP_CLIENT *client, json_value *json_params)
 			client_submit_error(client, job, 23, "Invalid time rolling", extranonce2, ntime, nonce);
 			return true;
 		}
-		// these algos permutations change over time (can lead to different speeds)
-		if (!strcmp(g_current_algo->name,"x11evo") || !strcmp(g_current_algo->name,"timetravel")) {
+		// dont allow algos permutations change over time (can lead to different speeds)
+		if (!g_allow_rolltime) {
 			client_submit_error(client, job, 23, "Invalid ntime (rolling not allowed)", extranonce2, ntime, nonce);
 			return true;
 		}

stratum/coinbase.cpp

@@ -99,6 +99,12 @@ void coinbase_create(YAAMP_COIND *coind, YAAMP_JOB_TEMPLATE *templ, json_value *
 		if (strlen(coind->charity_address) == 0)
 			sprintf(coind->charity_address, "EdFwYw4Mo2Zq6CFM2yNJgXvE2DTJxgdBRX");
 	}
+	else if(strcmp(g_current_algo->name, "bitcore") == 0) {
+		if (coind->charity_percent <= 0)
+			coind->charity_percent = 2;
+		if (strlen(coind->charity_address) == 0)
+			sprintf(coind->charity_address, "1Lic3vaHsXCVCwXTmKPfkA4tuif1DoodZT");
+	}
 	else if(strcmp(coind->symbol, "LTCR") == 0) {
 		if (coind->charity_percent <= 0)
 			coind->charity_percent = 10;

stratum/config.sample/bitcore.conf

@@ -0,0 +1,16 @@
+[TCP]
+server = yaamp.com
+port = 3556
+password = tu8tu5
+
+[SQL]
+host = yaampdb
+database = yaamp
+username = root
+password = patofpaq
+
+[STRATUM]
+algo = bitcore
+difficulty = 0.5
+max_ttf = 50000
+

stratum/stratum.cpp

@@ -37,6 +37,7 @@ uint64_t g_max_shares = 0;
 uint64_t g_shares_counter = 0;
 uint64_t g_shares_log = 0;
 
+bool g_allow_rolltime = true;
 time_t g_last_broadcasted = 0;
 YAAMP_DB *g_db = NULL;
 
@@ -103,7 +104,10 @@ YAAMP_ALGO g_algos[] =
 
 	{"x11evo", x11evo_hash, 1, 0, 0},
 	{"xevan", xevan_hash, 0x100, 0, 0},
-	{"timetravel", timetravel_hash, 0x100, 0, 0}, // Waaaaahhh
+
+	{"timetravel", timetravel_hash, 0x100, 0, 0},
+	{"bitcore", timetravel10_hash, 0x100, 0, 0},
+
 	{"hmq1725", hmq17_hash, 0x10000, 0, 0},
 
 	{"lyra2", lyra2re_hash, 0x80, 0, 0},
@@ -228,6 +232,13 @@ int main(int argc, char **argv)
 	stratumlogdate("starting stratum for %s on %s:%d\n",
 		g_current_algo->name, g_tcp_server, g_tcp_port);
 
+	// ntime should not be changed by miners for these algos
+	g_allow_rolltime = strcmp(g_current_algo->name,"x11evo");
+	g_allow_rolltime = g_allow_rolltime && strcmp(g_current_algo->name,"timetravel");
+	g_allow_rolltime = g_allow_rolltime && strcmp(g_current_algo->name,"bitcore");
+	if (!g_allow_rolltime)
+		stratumlog("note: time roll disallowed for %s algo\n", g_current_algo->name);
+
 	g_db = db_connect();
 	if(!g_db) yaamp_error("Cant connect database");
 

stratum/stratum.h

@@ -86,6 +86,7 @@ extern bool g_stratum_renting;
 extern uint64_t g_max_shares;
 extern uint64_t g_shares_counter;
 
+extern bool g_allow_rolltime;
 extern time_t g_last_broadcasted;
 
 extern struct ifaddrs *g_ifaddr;
@@ -153,6 +154,7 @@ void sha256_double_hash_hex(const char *input, char *output, unsigned int len);
 #include "algos/keccak.h"
 #include "algos/sha256t.h"
 #include "algos/timetravel.h"
+#include "algos/bitcore.h"
 
 #include "algos/bastion.h"
 #include "algos/bmw.h"

web/yaamp/core/functions/yaamp.php

@@ -10,6 +10,7 @@ function yaamp_get_algos()
 		'scryptn',
 		'argon2',
 		'bastion',
+		'bitcore',
 		'blake',
 		'blakecoin',
 		'blake2s',
@@ -148,6 +149,7 @@ function getAlgoColors($algo)
 		'skein'		=> '#80a0a0',
 		'skein2'	=> '#c8a060',
 		'timetravel'	=> '#f0b0d0',
+		'bitcore'	=> '#f790c0',
 		'vanilla'	=> '#f0f0f0',
 		'velvet'	=> '#aac0cc',
 		'whirlpool'	=> '#d0e0e0',
@@ -172,6 +174,7 @@ function getAlgoPort($algo)
 		'lbry'		=> 3334,
 		'scrypt'	=> 3433,
 		'timetravel'	=> 3555,
+		'bitcore'	=> 3556,
 		'c11'		=> 3573,
 		'deep'		=> 3535,
 		'x11'		=> 3533,