void scrypt_process_cpu(minerScryptBlock_t* block)
{
scrypt_testStuff();
uint32 outputHash[32/4];
char scratchpad[SCRYPT_SCRATCHPAD_SIZE];
uint32 shareCompare = *(uint32*)(block->targetShare+32-4);
uint32 nonce = 0;
for(uint32 t=0; t<32768; t++)
{
for(uint32 x=0; x<4096; x++)
{
block->nonce = nonce;
nonce++;
scrypt_1024_1_1_256_sp((const char*)block, (char*)outputHash, scratchpad);
if( outputHash[7] < shareCompare )
{
totalShareCount++;
xptMiner_submitShare(block);
}
//__debugbreak();
totalCollisionCount++;
}
//if( block->height != monitorCurrentBlockHeight )
//{
// printf("cancled\n");
// break;
//}
}
//printf("next\n");
}
void metiscoin_process(minerMetiscoinBlock_t* block)
{
sph_keccak512_context ctx_keccak;
sph_shavite512_context ctx_shavite;
sph_metis512_context ctx_metis;
static unsigned char pblank[1];
block->nonce = 0;
uint32 target = *(uint32*)(block->targetShare+28);
uint64 hash0[8];
uint64 hash1[8];
uint64 hash2[8];
for(uint32 n=0; n<0x1000; n++)
{
if( block->height != monitorCurrentBlockHeight )
break;
for(uint32 f=0; f<0x8000; f++)
{
sph_keccak512_init(&ctx_keccak);
sph_shavite512_init(&ctx_shavite);
sph_metis512_init(&ctx_metis);
sph_keccak512(&ctx_keccak, &block->version, 80);
sph_keccak512_close(&ctx_keccak, hash0);
sph_shavite512(&ctx_shavite, hash0, 64);
sph_shavite512_close(&ctx_shavite, hash1);
sph_metis512(&ctx_metis, hash1, 64);
sph_metis512_close(&ctx_metis, hash2);
if( *(uint32*)((uint8*)hash2+28) <= target )
{
totalShareCount++;
xptMiner_submitShare(block);
}
block->nonce++;
}
totalCollisionCount += 0x8000;
}
}
bool protoshares_revalidateCollision(minerProtosharesBlock_t* block, uint8* midHash, uint32 indexA, uint32 indexB)
{
uint8 tempHash[32 + 4];
uint64 resultHash[8];
memcpy(tempHash + 4, midHash, 32);
// get birthday A
*(uint32*)tempHash = indexA & ~7; // indexA & ~7 == indexA - (indexA % BIRTHDAYS_PER_HASH)
sha512_ctx c512;
sha512_init(&c512);
sha512_update(&c512, tempHash, 32 + 4);
sha512_final(&c512, (unsigned char*)resultHash);
uint64 birthdayA = resultHash[indexA & 7] >> (64ULL - SEARCH_SPACE_BITS);
// get birthday B
*(uint32*)tempHash = indexB & ~7;
sha512_init(&c512);
sha512_update(&c512, tempHash, 32 + 4);
sha512_final(&c512, (unsigned char*)resultHash);
uint64 birthdayB = resultHash[indexB & 7] >> (64ULL - SEARCH_SPACE_BITS);
#ifdef VERIFY_RESULTS
printf("Nonce Pair:\n");
printf(" Nonce A = %#010x; Hash A = %#018llx\n", indexA, birthdayA);
printf(" Nonce B = %#010x; Hash B = %#018llx\n", indexB, birthdayB);
printf("\n");
#endif
if ( birthdayA != birthdayB ) {
return false; // invalid collision
}
// birthday collision found
totalCollisionCount += 2; // we can use every collision twice -> A B and B A
//printf("Collision found %8d = %8d | num: %d\n", indexA, indexB, totalCollisionCount);
// get full block hash (for A B)
block->birthdayA = indexA;
block->birthdayB = indexB;
uint8 proofOfWorkHash[32];
sha256_ctx c256;
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)block, 80 + 8);
sha256_final(&c256, proofOfWorkHash);
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)proofOfWorkHash, 32);
sha256_final(&c256, proofOfWorkHash);
bool hashMeetsTarget = true;
uint32* generatedHash32 = (uint32*)proofOfWorkHash;
uint32* targetHash32 = (uint32*)block->targetShare;
for (sint32 hc = 7; hc >= 0; hc--) {
if ( generatedHash32[hc] < targetHash32[hc] ) {
hashMeetsTarget = true;
break;
} else if ( generatedHash32[hc] > targetHash32[hc] ) {
hashMeetsTarget = false;
break;
}
}
if ( hashMeetsTarget ) {
totalShareCount++;
curShareCount++;
#ifndef NOSUBMIT
xptMiner_submitShare(block);
#endif
}
// get full block hash (for B A)
block->birthdayA = indexB;
block->birthdayB = indexA;
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)block, 80 + 8);
sha256_final(&c256, proofOfWorkHash);
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)proofOfWorkHash, 32);
sha256_final(&c256, proofOfWorkHash);
hashMeetsTarget = true;
generatedHash32 = (uint32*)proofOfWorkHash;
targetHash32 = (uint32*)block->targetShare;
for (sint32 hc = 7; hc >= 0; hc--) {
if ( generatedHash32[hc] < targetHash32[hc] ) {
hashMeetsTarget = true;
break;
} else if ( generatedHash32[hc] > targetHash32[hc] ) {
hashMeetsTarget = false;
break;
}
}
if ( hashMeetsTarget ) {
totalShareCount++;
curShareCount++;
#ifndef NOSUBMIT
xptMiner_submitShare(block);
#endif
}
return true;
}
void riecoin_process(minerRiecoinBlock_t* block)
{
uint32 searchBits = block->targetCompact;
if( riecoin_sieve )
memset(riecoin_sieve, 0x00, riecoin_sieveSize/8);
else
{
riecoin_sieve = (uint8*)malloc(riecoin_sieveSize/8);
memset(riecoin_sieve, 0x00, riecoin_sieveSize/8);
}
uint8* sieve = riecoin_sieve;
// test data
// getblock 16ee31c116b75d0299dc03cab2b6cbcb885aa29adf292b2697625bc9d28b2b64
//debug_parseHexStringLE("c59ba5357285de73b878fed43039a37f85887c8960e66bcb6e86bdad565924bd", 64, block->merkleRoot);
//block->version = 2;
//debug_parseHexStringLE("c64673c670fb327c2e009b3b626d2def01d51ad4131a7a1040e9cef7bfa34838", 64, block->prevBlockHash);
//block->nTime = 1392151955;
//block->nBits = 0x02013000;
//debug_parseHexStringLE("0000000000000000000000000000000000000000000000000000000070b67515", 64, block->nOffset);
// generate PoW hash (version to nBits)
uint8 powHash[32];
sha256_ctx ctx;
sha256_init(&ctx);
sha256_update(&ctx, (uint8*)block, 80);
sha256_final(&ctx, powHash);
sha256_init(&ctx);
sha256_update(&ctx, powHash, 32);
sha256_final(&ctx, powHash);
// generatePrimeBase
uint32* powHashU32 = (uint32*)powHash;
mpz_t z_target;
mpz_t z_temp;
mpz_init(z_temp);
mpz_init_set_ui(z_target, 1);
mpz_mul_2exp(z_target, z_target, zeroesBeforeHashInPrime);
for(uint32 i=0; i<256; i++)
{
mpz_mul_2exp(z_target, z_target, 1);
if( (powHashU32[i/32]>>(i))&1 )
z_target->_mp_d[0]++;
}
unsigned int trailingZeros = searchBits - 1 - zeroesBeforeHashInPrime - 256;
mpz_mul_2exp(z_target, z_target, trailingZeros);
// find first offset where x%2310 = 97
uint64 remainder2310 = mpz_tdiv_ui(z_target, 2310);
remainder2310 = (2310-remainder2310)%2310;
remainder2310 += 97;
mpz_add_ui(z_temp, z_target, remainder2310);
mpz_t z_temp2;
mpz_init(z_temp2);
mpz_t z_ft_r;
mpz_init(z_ft_r);
mpz_t z_ft_b;
mpz_init_set_ui(z_ft_b, 2);
mpz_t z_ft_n;
mpz_init(z_ft_n);
static uint32 primeTupleBias[6] = {0,4,6,10,12,16};
for(uint32 i=5; i<riecoin_primeTestSize; i++)
{
for(uint32 f=0; f<6; f++)
{
uint32 p = riecoin_primeTestTable[i];
uint32 remainder = mpz_tdiv_ui(z_temp, p);//;
remainder += primeTupleBias[f];
remainder %= p;
uint32 index;
// a+b*x=0 (mod p) => b*x=p-a => x = (p-a)*modinv(b)
sint32 pa = (p<remainder)?(p-remainder+p):(p-remainder);
sint32 b = 2310;
index = (pa%p)*int_invert(b, p);
index %= p;
while(index < riecoin_sieveSize)
{
sieve[(index)>>3] |= (1<<((index)&7));
index += p;
}
}
}
uint32 countCandidates = 0;
uint32 countPrimes = 0;
uint32 countPrimes2 = 0;
// scan for candidates
for(uint32 i=1; i<riecoin_sieveSize; i++)
{
if( sieve[(i)>>3] & (1<<((i)&7)) )
continue;
countCandidates++;
// test the first 4 numbers for being prime (5th and 6th is checked server side)
// we use fermat test as it is slightly faster for virtually the same accuracy
// p1
mpz_add_ui(z_temp, z_target, (uint64)remainder2310 + 2310ULL*(uint64)i);
mpz_sub_ui(z_ft_n, z_temp, 1);
mpz_powm(z_ft_r, z_ft_b, z_ft_n, z_temp);
if (mpz_cmp_ui(z_ft_r, 1) != 0)
continue;
else
countPrimes++;
// p2
mpz_add_ui(z_temp, z_temp, 4);
mpz_sub_ui(z_ft_n, z_temp, 1);
mpz_powm(z_ft_r, z_ft_b, z_ft_n, z_temp);
if (mpz_cmp_ui(z_ft_r, 1) != 0)
continue;
else
countPrimes2++;
total2ChainCount++;
// p3
mpz_add_ui(z_temp, z_temp, 2);
if( mpz_probab_prime_p(z_temp, 1) == 0 )
continue;
total3ChainCount++;
// p4
mpz_add_ui(z_temp, z_temp, 4);
if( mpz_probab_prime_p(z_temp, 1) == 0 )
continue;
total4ChainCount++;
// calculate offset
mpz_add_ui(z_temp, z_target, (uint64)remainder2310 + 2310ULL*(uint64)i);
mpz_sub(z_temp2, z_temp, z_target);
// submit share
uint8 nOffset[32];
memset(nOffset, 0x00, 32);
#ifdef _WIN64
for(uint32 d=0; d<min(32/8, z_temp2->_mp_size); d++)
{
*(uint64*)(nOffset+d*8) = z_temp2->_mp_d[d];
}
#else
for(uint32 d=0; d<min(32/4, z_temp2->_mp_size); d++)
{
*(uint32*)(nOffset+d*4) = z_temp2->_mp_d[d];
}
#endif
totalShareCount++;
xptMiner_submitShare(block, nOffset);
}
}
bool protoshares_revalidateCollision(minerProtosharesBlock_t* block, uint8* midHash, uint32 indexA, uint32 indexB)
{
uint8 tempHash[32+4];
uint64 resultHash[8];
memcpy(tempHash+4, midHash, 32);
// get birthday A
*(uint32*)tempHash = indexA&~7;
sha512_ctx c512;
sha512_init(&c512);
sha512_update(&c512, tempHash, 32+4);
sha512_final(&c512, (unsigned char*)resultHash);
uint64 birthdayA = resultHash[indexA&7] >> (64ULL-SEARCH_SPACE_BITS);
// get birthday B
*(uint32*)tempHash = indexB&~7;
sha512_init(&c512);
sha512_update(&c512, tempHash, 32+4);
sha512_final(&c512, (unsigned char*)resultHash);
uint64 birthdayB = resultHash[indexB&7] >> (64ULL-SEARCH_SPACE_BITS);
if( birthdayA != birthdayB )
{
return false; // invalid collision
}
// birthday collision found
totalCollisionCount += 2; // we can use every collision twice -> A B and B A
//printf("Collision found %8d = %8d | num: %d\n", indexA, indexB, totalCollisionCount);
// get full block hash (for A B)
block->birthdayA = indexA;
block->birthdayB = indexB;
uint8 proofOfWorkHash[32];
sha256_ctx c256;
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)block, 80+8);
sha256_final(&c256, proofOfWorkHash);
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)proofOfWorkHash, 32);
sha256_final(&c256, proofOfWorkHash);
bool hashMeetsTarget = true;
uint32* generatedHash32 = (uint32*)proofOfWorkHash;
uint32* targetHash32 = (uint32*)block->targetShare;
for(sint32 hc=7; hc>=0; hc--)
{
if( generatedHash32[hc] < targetHash32[hc] )
{
hashMeetsTarget = true;
break;
}
else if( generatedHash32[hc] > targetHash32[hc] )
{
hashMeetsTarget = false;
break;
}
}
if( hashMeetsTarget )
{
//printf("[DEBUG] Submit Protoshares share\n");
totalShareCount++;
xptMiner_submitShare(block);
}
// get full block hash (for B A)
block->birthdayA = indexB;
block->birthdayB = indexA;
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)block, 80+8);
sha256_final(&c256, proofOfWorkHash);
sha256_init(&c256);
sha256_update(&c256, (unsigned char*)proofOfWorkHash, 32);
sha256_final(&c256, proofOfWorkHash);
hashMeetsTarget = true;
generatedHash32 = (uint32*)proofOfWorkHash;
targetHash32 = (uint32*)block->targetShare;
for(sint32 hc=7; hc>=0; hc--)
{
if( generatedHash32[hc] < targetHash32[hc] )
{
hashMeetsTarget = true;
break;
}
else if( generatedHash32[hc] > targetHash32[hc] )
{
hashMeetsTarget = false;
break;
}
}
if( hashMeetsTarget )
{
// printf("[DEBUG] Submit Protoshares share\n");
totalShareCount++;
xptMiner_submitShare(block);
}
return true;
}
