Add hex algo... (#285)

made by XDNA Core developers

stratum/algos/hex.c

@@ -0,0 +1,180 @@
+// Copyright (c) 2018 The XDNA Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <stdint.h>
+#include <stdio.h>
+#include <memory.h>
+
+#include "hex.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"
+
+enum Algo {
+    BLAKE = 0,
+    BMW,
+    GROESTL,
+    JH,
+    KECCAK,
+    SKEIN,
+    LUFFA,
+    CUBEHASH,
+    SHAVITE,
+    SIMD,
+    ECHO,
+    HAMSI,
+    FUGUE,
+    SHABAL,
+    WHIRLPOOL,
+    SHA512,
+    HASH_FUNC_COUNT
+};
+
+static const int TOTAL_CYCLES = 16;
+
+static uint8_t get_first_algo(const uint32_t* prevblock) {
+    uint8_t* data = (uint8_t*)prevblock;
+    return data[7] >> 4;
+}
+
+void hex_hash(const char* input, char* output, uint32_t len)
+{
+    unsigned char hash[128];
+    uint8_t curr_algo;
+
+    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;
+
+    const void *in = input;
+    int size = len;
+
+    uint32_t *in32 = (uint32_t*) input;
+
+    // initial algo = first digit of prev block hashorder (cheers, x16r)
+    curr_algo = get_first_algo(&in32[1]);
+
+    for (int i = 0; i < TOTAL_CYCLES; i++)
+    {
+        // Only 4 test algos yet
+        switch (curr_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 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 SKEIN:
+                sph_skein512_init(&ctx_skein);
+                sph_skein512(&ctx_skein, in, size);
+                sph_skein512_close(&ctx_skein, 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;
+        }
+        // next algos = first digit on prev hash
+        curr_algo = (uint8_t)hash[0] % HASH_FUNC_COUNT;
+        in = (void*)hash;
+        size = 64;
+    }
+
+    memcpy(output, hash, 32);
+}

stratum/algos/hex.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2018 The XDNA Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef HEXHASH_H
+#define HEXHASH_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void hex_hash(const char* input, char* output, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // HEXHASH_H

stratum/algos/makefile

@@ -18,7 +18,7 @@ SOURCES=lyra2re.c lyra2v2.c Lyra2.c lyra2z.c Lyra2-z.c Sponge.c allium.c \
 	yescrypt.c yescrypt-opt.c sha256_Y.c \
 	a5a.c a5amath.c m7m.c magimath.cpp velvet.c \
 	argon2a.c ar2/blake2b.c ar2/argon2.c ar2/ref.c ar2/cores.c ar2/ar2-scrypt-jane.c \
-	hive.c pomelo.c \
+	hive.c pomelo.c hex.c \
 	phi.c phi2.c polytimos.c skunk.c sib.c veltor.c gost.c aergo.c
 
 OBJECTS=$(SOURCES:%.c=%.o) $(SOURCES:%.cpp=%.o)

stratum/stratum.cpp

@@ -158,6 +158,8 @@ YAAMP_ALGO g_algos[] =
 	{"tribus", tribus_hash, 1, 0, 0},
 	{"keccak", keccak256_hash, 0x80, 0, sha256_hash_hex },
 	{"keccakc", keccak256_hash, 0x100, 0, 0},
+	{"hex", hex_hash, 0x100, 0, sha256_hash_hex },
+	
 	{"phi", phi_hash, 1, 0, 0},
 	{"phi2", phi2_hash, 0x100, 0, 0},
 

stratum/stratum.h

@@ -205,4 +205,5 @@ void sha256_double_hash_hex(const char *input, char *output, unsigned int len);
 #include "algos/argon2a.h"
 #include "algos/vitalium.h"
 #include "algos/aergo.h"
+#include "algos/hex.h"
 

web/yaamp/core/functions/yaamp.php

@@ -22,6 +22,7 @@ function yaamp_get_algos()
 		'keccak',
 		'keccakc',
 		'jha',
+		'hex',
 		'hsr',
 		'lbry',
 		'luffa',
@@ -83,6 +84,7 @@ function yaamp_algo_mBTC_factor($algo)
 	case 'decred':
 	case 'keccak':
 	case 'keccakc':
+	case 'hex':
 	case 'lbry':
 	case 'vanilla':
 		return 1000;
@@ -165,6 +167,7 @@ function getAlgoColors($algo)
 		'hsr'		=> '#aa70ff',
 		'keccak'	=> '#c0f0c0',
 		'keccakc'	=> '#c0f0c0',
+		'hex'	=> '#c0f0c0',
 		'lbry'		=> '#b0d0e0',
 		'luffa'		=> '#a0c0c0',
 		'm7m'		=> '#d0a0a0',
@@ -245,6 +248,7 @@ function getAlgoPort($algo)
 		'sib'		=> 5033,
 		'keccak'	=> 5133,
 		'keccakc'	=> 5134,
+		'hex'		=> 5135,
 		'skein2'	=> 5233,
 		//'groestl'	=> 5333,
 		'dmd-gr'	=> 5333,