RanchiMall/stratum-mining
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

riecoin bug fixes

Browse Source
This commit is contained in:
gatra 2014-03-13 23:29:04 -03:00
parent 77e05277e2
commit d6729c10e1
5 changed files with 31 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/block_template.py
View File

@ -68,7 +68,8 @@ class BlockTemplate(halfnode.CBlock):
self.height = data['height'] self.height = data['height']
self.nVersion = data['version'] self.nVersion = data['version']
self.hashPrevBlock = int(data['previousblockhash'], 16) self.hashPrevBlock = int(data['previousblockhash'], 16)
self.nBits = int(data['bits'], 8) self.nBits = int(data['bits'], 16)
self.hashMerkleRoot = 0 self.hashMerkleRoot = 0
self.nTime = 0 self.nTime = 0
self.nNonce = 0 self.nNonce = 0

14
lib/halfnode.py
View File

@ -252,11 +252,12 @@ class CBlock(object):
self.hashMerkleRoot = deser_uint256(f) self.hashMerkleRoot = deser_uint256(f)
if settings.COINDAEMON_ALGO == 'riecoin': if settings.COINDAEMON_ALGO == 'riecoin':
self.nBits = struct.unpack("<I", f.read(4))[0] self.nBits = struct.unpack("<I", f.read(4))[0]
self.nTime = struct.unpack("<I", f.read(4))[0] self.nTime = struct.unpack("<II", f.read(8))[0]
self.nNonce = struct.unpack("<IIIIIIII", f.read(32))[0]
else: else:
self.nTime = struct.unpack("<I", f.read(4))[0] self.nTime = struct.unpack("<I", f.read(4))[0]
self.nBits = struct.unpack("<I", f.read(4))[0] self.nBits = struct.unpack("<I", f.read(4))[0]
self.nNonce = struct.unpack("<I", f.read(4))[0] self.nNonce = struct.unpack("<I", f.read(4))[0]
self.vtx = deser_vector(f, CTransaction) self.vtx = deser_vector(f, CTransaction)
if settings.COINDAEMON_Reward == 'POS': if settings.COINDAEMON_Reward == 'POS':
self.signature = deser_string(f) self.signature = deser_string(f)
@ -269,11 +270,12 @@ class CBlock(object):
r.append(ser_uint256(self.hashMerkleRoot)) r.append(ser_uint256(self.hashMerkleRoot))
if settings.COINDAEMON_ALGO == 'riecoin': if settings.COINDAEMON_ALGO == 'riecoin':
r.append(struct.pack("<I", self.nBits)) r.append(struct.pack("<I", self.nBits))
r.append(struct.pack("<I", self.nTime)) r.append(struct.pack("<II", self.nTime))
r.append(struct.pack("<IIIIIIII", self.nNonce))
else: else:
r.append(struct.pack("<I", self.nTime)) r.append(struct.pack("<I", self.nTime))
r.append(struct.pack("<I", self.nBits)) r.append(struct.pack("<I", self.nBits))
r.append(struct.pack("<I", self.nNonce)) r.append(struct.pack("<I", self.nNonce))
r.append(ser_vector(self.vtx)) r.append(ser_vector(self.vtx))
if settings.COINDAEMON_Reward == 'POS': if settings.COINDAEMON_Reward == 'POS':
r.append(ser_string(self.signature)) r.append(ser_string(self.signature))
@ -313,7 +315,9 @@ class CBlock(object):
r.append(ser_uint256(self.hashMerkleRoot)) r.append(ser_uint256(self.hashMerkleRoot))
r.append(struct.pack("<I", self.nBits)) r.append(struct.pack("<I", self.nBits))
r.append(struct.pack("<II", self.nTime)) r.append(struct.pack("<II", self.nTime))
self.riecoin = util.riecoinPoW( util.doublesha(r), uint256_from_compact(self.nBits), self.nNonce ) hash_bin = util.doublesha(''.join([ r[i*4:i*4+4][::-1] for i in range(0, 20) ]))
self.riecoin = util.riecoinPoW( util.uint256_from_str(hash_bin), uint256_from_compact(self.nBits), self.nNonce )
log.debug("riecoinPoW in Halfnode is %d" % self.riecoin)
return self.riecoin return self.riecoin
else: else:
def calc_sha256(self): def calc_sha256(self):

21
lib/template_registry.py
View File

@ -150,12 +150,14 @@ class TemplateRegistry(object):
def diff_to_target(self, difficulty): def diff_to_target(self, difficulty):
'''Converts difficulty to target''' '''Converts difficulty to target'''
if settings.COINDAEMON_ALGO == 'scrypt' or 'scrypt-jane': if settings.COINDAEMON_ALGO == 'scrypt':
diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000
elif settings.COINDAEMON_ALGO == 'scrypt-jane':
diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000 diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000
elif settings.COINDAEMON_ALGO == 'quark': elif settings.COINDAEMON_ALGO == 'quark':
diff1 = 0x000000ffff000000000000000000000000000000000000000000000000000000 diff1 = 0x000000ffff000000000000000000000000000000000000000000000000000000
elif settings.COINDAEMON_ALGO == 'riecoin': elif settings.COINDAEMON_ALGO == 'riecoin':
return difficulty; return difficulty
else: else:
diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000 diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000
@ -235,6 +237,9 @@ class TemplateRegistry(object):
extranonce2_bin = binascii.unhexlify(extranonce2) extranonce2_bin = binascii.unhexlify(extranonce2)
ntime_bin = binascii.unhexlify(ntime) ntime_bin = binascii.unhexlify(ntime)
nonce_bin = binascii.unhexlify(nonce) nonce_bin = binascii.unhexlify(nonce)
if settings.COINDAEMON_ALGO == 'riecoin':
ntime_bin = (''.join([ ntime_bin[(1-i)*4:(1-i)*4+4] for i in range(0, 2) ]))
nonce_bin = (''.join([ nonce_bin[(7-i)*4:(7-i)*4+4] for i in range(0, 8) ]))
# 1. Build coinbase # 1. Build coinbase
coinbase_bin = job.serialize_coinbase(extranonce1_bin, extranonce2_bin) coinbase_bin = job.serialize_coinbase(extranonce1_bin, extranonce2_bin)
@ -259,14 +264,13 @@ class TemplateRegistry(object):
else: else:
hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ])) hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
if settings.COINDAEMON_ALGO == 'riecoin': hash_int = util.uint256_from_str(hash_bin)
# hash_bin already has doublesha
# this is kind of an ugly hack: we use hash_int to store the number of primes
hash_int = util.riecoinPoW( hash_bin, job.target, int(nonce, 16) )
else:
hash_int = util.uint256_from_str(hash_bin)
scrypt_hash_hex = "%064x" % hash_int scrypt_hash_hex = "%064x" % hash_int
if settings.COINDAEMON_ALGO == 'riecoin':
# this is kind of an ugly hack: we use hash_int to store the number of primes
hash_int = util.riecoinPoW( hash_int, job.target, int(nonce, 16) )
header_hex = binascii.hexlify(header_bin) header_hex = binascii.hexlify(header_bin)
if settings.COINDAEMON_ALGO == 'scrypt' or settings.COINDAEMON_ALGO == 'scrypt-jane': if settings.COINDAEMON_ALGO == 'scrypt' or settings.COINDAEMON_ALGO == 'scrypt-jane':
header_hex = header_hex+"000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000" header_hex = header_hex+"000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000"
@ -276,7 +280,6 @@ class TemplateRegistry(object):
header_hex = header_hex+"00000080000000000000000080030000" header_hex = header_hex+"00000080000000000000000080030000"
else: pass else: pass
target_user = self.diff_to_target(difficulty) target_user = self.diff_to_target(difficulty)
if settings.COINDAEMON_ALGO == 'riecoin': if settings.COINDAEMON_ALGO == 'riecoin':
if hash_int < target_user: if hash_int < target_user:

11
lib/util.py
View File

@ -56,7 +56,10 @@ def uint256_from_str_be(s):
def uint256_from_compact(c): def uint256_from_compact(c):
nbytes = (c >> 24) & 0xFF nbytes = (c >> 24) & 0xFF
v = (c & 0xFFFFFFL) << (8 * (nbytes - 3)) if nbytes <= 3:
v = (c & 0xFFFFFFL) >> (8 * (3 - nbytes))
else:
v = (c & 0xFFFFFFL) << (8 * (nbytes - 3))
return v return v
def deser_vector(f, c): def deser_vector(f, c):
@ -217,12 +220,12 @@ def isPrime( n ):
return True return True
return False return False
def riecoinPoW( hash_bin, diff, nNonce ): def riecoinPoW( hash_int, diff, nNonce ):
base = 1 << 8 base = 1 << 8
for i in range(256): for i in range(256):
base = base << 1 base = base << 1
base = base | (hash_bin & 1) base = base | (hash_int & 1)
hash_bin = hash_bin >> 1 hash_int = hash_int >> 1
trailingZeros = diff - 1 - 8 - 256 trailingZeros = diff - 1 - 8 - 256
if trailingZeros < 16 or trailingZeros > 20000: if trailingZeros < 16 or trailingZeros > 20000:
return 0 return 0

2
mining/service.py
View File

@ -87,7 +87,7 @@ class MiningService(GenericService):
else: else:
session['difficulty'] = settings.POOL_TARGET session['difficulty'] = settings.POOL_TARGET
# worker_log = (valid, invalid, is_banned, diff, is_ext_diff, timestamp) # worker_log = (valid, invalid, is_banned, diff, is_ext_diff, timestamp)
Interfaces.worker_manager.worker_log['authorized'][worker_name] = (0, 0, False, session['difficulty'], is_ext_diff, Interfaces.timestamper.time()) Interfaces.worker_manager.worker_log['authorized'][worker_name] = (0, 0, False, session['difficulty'], is_ext_diff, Interfaces.timestamper.time())
return True return True
else: else:
ip = self.connection_ref()._get_ip() ip = self.connection_ref()._get_ip()