def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin):
'''Serialize header for calculating block hash'''
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
return r
def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin):
'''Serialize header for calculating block hash'''
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
return r
def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin):
"""Serialize header for calculating block hash"""
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
if settings.COINDAEMON_ALGO == 'riecoin':
r += struct.pack(">I", self.nBits)
r += ntime_bin
else:
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
return r
def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin,
version_rolling):
'''Serialize header for calculating block hash'''
version = self.nVersion
if version_rolling and len(version_rolling) == 8:
version |= int(version_rolling, 16)
r = struct.pack(">i", version)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
return r
def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin):
'''Serialize header for calculating block hash'''
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
if settings.COINDAEMON_ALGO == 'riecoin':
r += struct.pack(">I", self.nBits)
r += ntime_bin
else:
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
return r
def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin):
'''Serialize header for calculating block hash'''
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
r += self.hashstateroot_bin
r += self.hashutxoroot_bin
r += binascii.unhexlify(
"0000000000000000000000000000000000000000000000000000000000000000ffffffff00"
)
return r
def verify(self, extranonce2, ntime, nonce):
return
coinbase = self.coinb1 + self.extranonce1 + extranonce2 + self.coinb2
coinbase_hash_bin = doublesha(binascii.unhexlify(coinbase))
merkle_root = build_merkle_root(self.merkle_branch, coinbase_hash_bin)
merkle_root = ser_uint256_be(uint256_from_str(merkle_root))
preheader = self.version + self.prevhash + merkle_root.encode("hex") + ntime + self.nbits
preheader_bin = preheader.decode("hex")
preheader_bin = ''.join([preheader_bin[i*4:i*4+4][::-1] for i in range(0,19)])
hash_bin = doublesha(preheader_bin + nonce.decode("hex")[::-1])
print hash_bin.encode("hex")
val = struct.unpack("<I", hash_bin[-4:])[0]
assert val < THRESH, (val, THRESH)
def verify(self, extranonce2, ntime, nonce):
return
coinbase = self.coinb1 + self.extranonce1 + extranonce2 + self.coinb2
coinbase_hash_bin = doublesha(binascii.unhexlify(coinbase))
merkle_root = build_merkle_root(self.merkle_branch, coinbase_hash_bin)
merkle_root = ser_uint256_be(uint256_from_str(merkle_root))
preheader = self.version + self.prevhash + merkle_root.encode(
"hex") + ntime + self.nbits
preheader_bin = preheader.decode("hex")
preheader_bin = ''.join(
[preheader_bin[i * 4:i * 4 + 4][::-1] for i in range(0, 19)])
hash_bin = doublesha(preheader_bin + nonce.decode("hex")[::-1])
print hash_bin.encode("hex")
val = struct.unpack("<I", hash_bin[-4:])[0]
assert val < THRESH, (val, THRESH)
def serialize_header(self, merkle_root_int, ntime_bin, nonce_bin):
'''Serialize header for calculating block hash'''
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
if settings.COINDAEMON_ALGO == 'riecoin':
r += struct.pack(">I", self.nBits)
r += ntime_bin
else:
r += ntime_bin
r += struct.pack(">I", self.nBits)
r += nonce_bin
if settings.COINDAEMON_ALGO == 'jackpotcoin':
r += struct.pack(">i",
self.nSuperBlock) # serialize with BE for JACKPOT
r += struct.pack(">i",
self.nRoundMask) # serialize with BE for JACKPT
return r
def serialize_header(self, merkle_root_int, ntime, nnonce):
'''Serialize header for calculating block hash'''
if settings.COINDAEMON_ALGO == 'heavy':
r = struct.pack("<i", self.nVersion)
r += ''.join([
self.prevhash_bin[i * 4:i * 4 + 4][::-1] for i in range(0, 64)
])
r += util.ser_uint256_le(merkle_root_int)
r += struct.pack("<I", ntime)
r += struct.pack("<I", self.nBits)
r += struct.pack("<I", nnonce)
else:
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
r += struct.pack(">I", nntime)
r += struct.pack(">I", self.nBits)
r += struct.pack(">I", nnonce)
return r
def serialize_header(self, merkle_root_int, ntime, nnonce, nvote = None):
'''Serialize header for calculating block hash'''
if settings.COINDAEMON_ALGO == 'heavy':
r = struct.pack("<i", self.nVersion)
r += ''.join([ self.prevhash_bin[i*4:i*4+4][::-1] for i in range(0, 64) ])
r += util.ser_uint256_le(merkle_root_int)
r += struct.pack("<I", ntime)
r += struct.pack("<I", self.nBits)
r += struct.pack("<I", nnonce)
r += struct.pack("<H", nvote)
r += struct.pack("<H", self.nReward)
else:
r = struct.pack(">i", self.nVersion)
r += self.prevhash_bin
r += util.ser_uint256_be(merkle_root_int)
r += struct.pack(">I", nntime)
r += struct.pack(">I", self.nBits)
r += struct.pack(">I", nnonce)
return r
def run(self):
difficulty = 1
while True:
s = self.f.readline()
if not s:
break
if TEST:
s = """{"params": ["bf", "4d16b6f85af6e2198f44ae2a6de67f78487ae5611b77c6c0440b921e00000000",
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff20020862062f503253482f04b8864e5008",
"072f736c7573682f000000000100f2052a010000001976a914d23fcdf86f7e756a64a7a9688ef9903327048ed988ac00000000", [],
"00000002", "1c2ac4af", "504e86b9", false], "id": null, "method": "mining.notify"}"""
extranonce1 = "08000002"
s = s.strip()
assert s
d = simplejson.loads(s)
# if d.get('method', None) == "mining.notify" and self.done:
# continue
print d
if d.get('error', None):
raise Exception()
if d['id'] == 1 and 'method' not in d:
subscription, extranonce1, extranonce2_size = d['result']
elif d.get('method', None) == "mining.set_difficulty":
difficulty = d['params'][0]
elif d.get('method', None) == "mining.notify":
print "stopping worker"
self.w.stop()
print "stopped"
params, clean_jobs = d['params'][:-1], d['params'][:-1]
j = JobInfo(extranonce1, *params)
self.jobs[j.id] = j
extranonce2 = (
(int(time.time()) << 16) + os.getpid()) & 0xffffffff
extranonce2 = struct.pack(">I", extranonce2).encode("hex")
if TEST:
extranonce2 = "00000001"
print "extranonce2 = %s" % extranonce2
coinbase = j.coinb1 + extranonce1 + extranonce2 + j.coinb2
coinbase_hash_bin = doublesha(binascii.unhexlify(coinbase))
merkle_root = build_merkle_root(j.merkle_branch,
coinbase_hash_bin)
merkle_root = ser_uint256_be(uint256_from_str(merkle_root))
# ntime = "504e86ed"
ntime = j.ntime
if TEST:
ntime = "504e86ed"
preheader = j.version + j.prevhash + merkle_root.encode(
"hex") + ntime + j.nbits
preheader_bin = preheader.decode("hex")
preheader_bin = ''.join([
preheader_bin[i * 4:i * 4 + 4][::-1] for i in range(0, 19)
])
self.w.start(difficulty, j.id, extranonce2, ntime,
preheader_bin)
else:
assert d['id'] < self.mid
def run(self):
difficulty = 1
while True:
s = self.f.readline()
if not s:
break
if TEST:
s = """{"params": ["bf", "4d16b6f85af6e2198f44ae2a6de67f78487ae5611b77c6c0440b921e00000000",
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff20020862062f503253482f04b8864e5008",
"072f736c7573682f000000000100f2052a010000001976a914d23fcdf86f7e756a64a7a9688ef9903327048ed988ac00000000", [],
"00000002", "1c2ac4af", "504e86b9", false], "id": null, "method": "mining.notify"}"""
extranonce1 = "08000002"
s = s.strip()
assert s
d = simplejson.loads(s)
# if d.get('method', None) == "mining.notify" and self.done:
# continue
print d
if d.get('error', None):
raise Exception()
if d['id'] == 1 and 'method' not in d:
subscription, extranonce1, extranonce2_size = d['result']
elif d.get('method', None) == "mining.set_difficulty":
difficulty = d['params'][0]
elif d.get('method', None) == "mining.notify":
print "stopping worker"
self.w.stop()
print "stopped"
params, clean_jobs = d['params'][:-1], d['params'][:-1]
j = JobInfo(extranonce1, *params)
self.jobs[j.id] = j
extranonce2 = ((int(time.time()) << 16) + os.getpid()) & 0xffffffff
extranonce2 = struct.pack(">I", extranonce2).encode("hex")
if TEST:
extranonce2 = "00000001"
print "extranonce2 = %s" % extranonce2
coinbase = j.coinb1 + extranonce1 + extranonce2 + j.coinb2
coinbase_hash_bin = doublesha(binascii.unhexlify(coinbase))
merkle_root = build_merkle_root(j.merkle_branch, coinbase_hash_bin)
merkle_root = ser_uint256_be(uint256_from_str(merkle_root))
# ntime = "504e86ed"
ntime = j.ntime
if TEST:
ntime = "504e86ed"
preheader = j.version + j.prevhash + merkle_root.encode("hex") + ntime + j.nbits
preheader_bin = preheader.decode("hex")
preheader_bin = ''.join([preheader_bin[i*4:i*4+4][::-1] for i in range(0,19)])
self.w.start(difficulty, j.id, extranonce2, ntime, preheader_bin)
else:
assert d['id'] < self.mid
