def block_header_hash(chain, header): #TODO - TB20200609 - Switch to x16r algo, then x16rV2, then KAWPOW import x16r_hash #from binascii import unhexlify, hexlify import ravencoin.core print("header hash x16r: " + ravencoin.core.b2lx(x16r_hash.getPoWHash(header))) return x16r_hash.getPoWHash( header)[::-1] #Reverse is a quirk of Ravencoin
def verify_header(self, header: dict, prev_hash: str, target: int, expected_header_hash: str = None) -> None: height = header.get('block_height') _hash = hash_header(header) if expected_header_hash and expected_header_hash != _hash: raise Exception("hash mismatches with expected: {} vs {}".format( expected_header_hash, _hash)) if prev_hash != header.get('prev_block_hash'): raise Exception("prev hash mismatch: %s vs %s" % (prev_hash, header.get('prev_block_hash'))) # DGWv3 PastBlocksMax = 24 Because checkpoint don't have preblock data. if height % 2016 != 0 and height // 2016 < len( self.checkpoints) or height >= len( self.checkpoints) * 2016 and height <= len( self.checkpoints) * 2016 + DGW_PASTBLOCKS: return if constants.net.TESTNET: return bits = self.convbits(target) if bits != header.get('bits'): raise Exception("bits mismatch: %s vs %s" % (bits, header.get('bits'))) _powhash = rev_hex( bh2u(x16r_hash.getPoWHash(bfh(serialize_header(header))))) if int('0x' + _powhash, 16) > target: raise Exception("insufficient proof of work: %s vs target %s" % (int('0x' + _powhash, 16), target))
def hash_header(header: dict) -> str: if header is None: return '0' * 64 if header.get('prev_block_hash') is None: header['prev_block_hash'] = '00' * 32 result = hash_encode(x16r_hash.getPoWHash(bfh(serialize_header(header)))) return result
def calc_hdr_hash(blk_hdr): #hash1 = hashlib.sha256() #hash1.update(blk_hdr) #hash1_o = hash1.digest() #hash2 = hashlib.sha256() #hash2.update(hash1_o) #hash2_o = hash2.digest() #return hash2_o pow_hash = x16r_hash.getPoWHash(blk_hdr) return pow_hash
def wikihash(s): return x16r_hash.getPoWHash(s)
def hash_raw_header(header: str) -> str: raw_hash = x16r_hash.getPoWHash(bfh(header)[:80]) hash_result = hash_encode(raw_hash) return hash_result
import x16r_hash from binascii import hexlify, unhexlify teststart = '700000005d385ba114d079970b29a9418fd0549e7d68a95c7f168621a314201000000000578586d149fd07b22f3a8a347c516de7052f034d2b76ff68e0d6ecff9b77a45489e3fd511732011df0731000' testbin = unhexlify(teststart) hash_bin = x16r_hash.getPoWHash(testbin) testoutput = b'77a19463753c27887c5697b47118719f4af6fba0647eddde71a938e7b3dd0d48' assert hexlify(hash_bin) == testoutput print('Test succeeded')
def PoWHash(x): return x16r_hash.getPoWHash(to_bytes(x))
def motionhash(s): return x16r_hash.getPoWHash(s)
def genixhash(s): return x16r_hash.getPoWHash(s)
def sdrthash(s): return x16r_hash.getPoWHash(s)
def header_hash(cls, header): '''Given a header return the hash.''' import x16r_hash return x16r_hash.getPoWHash(header)
def allgamescoinhash(s): return x16r_hash.getPoWHash(s)
def calc_hdr_hash(blk_hdr): pow_hash = x16r_hash.getPoWHash(blk_hdr) return pow_hash
def luahash(s): return x16r_hash.getPoWHash(s)
def hash_raw_header(header: str) -> str: return hash_encode(x16r_hash.getPoWHash(bfh(header)))
def X16RHash(msg): return x16r_hash.getPoWHash(msg)
def jotohash(s): return x16r_hash.getPoWHash(s)
def ravendarkhash(s): return x16r_hash.getPoWHash(s)
def submit(self, connection_ref, _id, _params): # TODO: Job ID Check 구현해야함 # TODO: Diff Check 해서 그냥 Share 기록 or Submit 구별 해야함 # TODO: Share Result를 Database에 기록 해야함 - Database 는 Redis가 될듯 session_id = connection_ref.get_session() _worker_name = _params[0] _split_worker_name = _worker_name.strip().split('.') username = _split_worker_name[0] if len(_split_worker_name) == 2: worker = _split_worker_name[1] else: worker = None _job_id = _params[1] _nonce_1 = self.job_manager.get_nonce_from_session_id(session_id) _block_template = self.job_manager.get_block_template(_job_id) if _block_template is None: logger.info('rejected share, worker : %s, reason : job not found' % _worker_name) return {'id': _id, 'result': False, 'error': [21, 'job not found']} if os.getenv("COIN_TYPE") == 'bitcoin': _nonce_2 = _params[2] _time = _params[3] _time_reverse = hash_util.hex_to_reverse_hex(_time) _nonce = _params[4] _nonce_reverse = hash_util.hex_to_reverse_hex(_nonce) if len(_nonce) != 8: logger.info( 'rejected share, worker : %s, reason : incorrect size of nonce' % _worker_name) return { 'id': _id, 'result': False, 'error': [20, 'incorrect size of nonce'] } coinbase = binascii.hexlify(_block_template.coinbase_tx).split( _block_template.extranonce_placeholder) serialized_coinbase = binascii.unhexlify(coinbase[0] + _nonce_1 + _nonce_2.encode() + coinbase[1]) if os.getenv("COIN_ALGORITHM") == 'keccak': coinbase_hash = binascii.hexlify( hash_util.reverse_bytes( hash_util.sha(serialized_coinbase))) else: coinbase_hash = hash_util.bytes_to_reverse_hash( serialized_coinbase) tx_hashes = [coinbase_hash ] + [h['hash'] for h in _block_template.transactions] merkle_root_reverse_hex = hash_util.hex_to_reverse_hex( hash_util.merkle_root(tx_hashes)) # Header POW 종류별 구별 해야댐 header = _block_template.serialize_block_header( _time_reverse, _nonce_reverse, merkle_root_reverse_hex) # 80 bytes block_hex = _block_template.serialize_block( header, None, serialized_coinbase) if os.getenv("COIN_ALGORITHM") == 'lyra2rev2': import lyra2re2_hash header_hash = lyra2re2_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'lyra2rev3': import lyra2re3_hash header_hash = lyra2re3_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'keccak' or os.getenv( "COIN_ALGORITHM") == 'keccakc': import sha3 header_hash = sha3.keccak_256(header).digest() elif os.getenv("COIN_ALGORITHM") == 'x13-bcd': import x13bcd_hash header_hash = x13bcd_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'neoscrypt': import neoscrypt header_hash = neoscrypt.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'yescrypt': import yescrypt_hash header_hash = yescrypt_hash.getHash(header, len(header)) elif os.getenv("COIN_ALGORITHM") == 'xevan': import xevan_hash header_hash = xevan_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'phi2': import phi2_hash header_hash = phi2_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'x16r': import x16r_hash header_hash = x16r_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'x16s': import x16s_hash header_hash = x16s_hash.getPoWHash(header) elif os.getenv("COIN_ALGORITHM") == 'timetravel10': import timetravel10_hash header_hash = timetravel10_hash.getPoWHash(header) else: header_hash = double_sha(header) elif os.getenv("COIN_TYPE") == 'zcash': _time = _params[2] _nonce_2 = _params[3] _soln = _params[4] _nonce = _nonce_1 + _nonce_2.encode() if len(_nonce) != 64: return { 'id': _id, 'result': False, 'error': [20, 'incorrect size of nonce'] } if os.getenv("COIN_ALGORITHM") == 'zhash' and len(_soln) != 202: return { 'id': _id, 'result': False, 'error': [20, 'incorrect size of solution'] } elif os.getenv("COIN_ALGORITHM") != 'zhash' and len(_soln) != 2694: return { 'id': _id, 'result': False, 'error': [20, 'incorrect size of solution'] } n_time_int = int(_time, 16) curtime_int = int(_block_template.curtime, 16) if n_time_int < curtime_int: return { 'id': _id, 'result': False, 'error': [20, 'ntime out of range'] } header = _block_template.serialize_block_header( _time.encode(), _nonce) # 140 bytes header_soln = header + binascii.unhexlify(_soln) header_hash = double_sha(header_soln) block_hex = _block_template.serialize_block( header, binascii.unhexlify(_soln), None) else: raise Exception('invalid coin type') header_bignum = uint256_from_str(header_hash) share_diff = os.getenv("POW_LIMIT") / header_bignum logger.debug('share diff : {0:.8f}'.format(share_diff)) diff = self.user_diffs[connection_ref.username] if share_diff < diff: # logger.debug('low difficulty share of %s' % share_diff) logger.info( 'rejected share, worker : %s, reason : low difficulty share' % _worker_name) self.database_ref.insert_accepted_share( username, worker, False, False, _block_template.block_height, share_diff, _block_template.pool_reward, diff) return { 'id': _id, 'result': None, 'error': [23, 'low difficulty share of %s' % share_diff] } if not self.job_manager.register_submit(_nonce_1, _nonce_2, _nonce, _time): logger.info( 'rejected share, worker : %s, reason : duplicate share' % _worker_name) return { 'id': _id, 'result': None, 'error': [22, 'duplicate share'] } if share_diff >= _block_template.difficulty * 0.99: block_hash = binascii.hexlify( hash_util.reverse_bytes(header_hash)).decode() if os.getenv("COIN") in [ 'monacoin', 'feathercoin', 'phoenixcoin', 'vertcoin', 'shield' ]: temp_hash = double_sha(header) block_hash = binascii.hexlify( hash_util.reverse_bytes(temp_hash)).decode() logger.info('Try new block share, worker : %s, share diff : %s' % (_worker_name, share_diff)) share_result = self.coin_rpc.submit_block( binascii.hexlify(block_hex).decode()) if share_result is None: logger.info('Found Block, result : %s, block hash : %s' % (share_result, block_hash)) result_hash = Interfaces.block_updater.update_block( repeat=False, block_hash=block_hash) if result_hash is not None: block_hash = result_hash self.database_ref.insert_accepted_share( username, worker, True, True, _block_template.block_height, share_diff, _block_template.pool_reward, diff, block_hash) else: logger.error( 'undefined share_result %s, block hash %s, coinbase tx %s' % (share_result, block_hash, binascii.hexlify(_block_template.coinbase_tx))) self.database_ref.insert_accepted_share( username, worker, False, False, _block_template.block_height, share_diff, _block_template.pool_reward, diff) if os.getenv("COIN_TYPE") == 'bitcoin': logger.error('Header : %s' % binascii.hexlify(header).decode()) else: logger.error('Header : %s' % binascii.hexlify(header_soln).decode()) return { 'id': _id, 'result': None, 'error': [20, 'invalid solution'] } else: logger.info('accepted share, worker : %s, share diff : %s' % (_worker_name, '{0:.8f}'.format(share_diff))) self.database_ref.insert_accepted_share( username, worker, True, False, _block_template.block_height, share_diff, _block_template.pool_reward, diff) return {'id': _id, 'result': True, 'error': None}
def wolfhash(s): return x16r_hash.getPoWHash(s)
def velumhash(s): return x16r_hash.getPoWHash(s)
def gennonce(decnonce): hexnonce = str(hex(decnonce)).replace('0x','') while len(hexnonce) < 8: hexnonce = '0' + hexnonce return str(hexnonce) #doesnt matter what this is, as long as nonce changes header = '' while len(header) < 152: header = '00' + header #main target = "000000ffff000000000000000000000000000000000000000000000000000000" targetbin = binascii.unhexlify(target) nonce = 0 while True: complete_header = str(header) + str(gennonce(nonce)) hashbin = x16r_hash.getPoWHash(binascii.unhexlify(complete_header))[::-1] if hashbin < targetbin: print ('block ' + str(binascii.hexlify(hashbin))) print ('nonce was ' + str(nonce)) sys.exit(0) if (nonce % 4096 == 0): print (str(nonce)) nonce += 1
def dcuhash(s): return x16r_hash.getPoWHash(s)
def hiluxhash(s): return x16r_hash.getPoWHash(s)
import x16r_hash __b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' __b58base = len(__b58chars) global PUBKEY_ADDRESS global SCRIPT_ADDRESS PUBKEY_ADDRESS = 0 SCRIPT_ADDRESS = 5 def rev_hex(s): return s.decode('hex')[::-1].encode('hex') # Use Pion's X11 Hash Function HashX16r = lambda x: x16r_hash.getPoWHash(x) Hash = lambda x: hashlib.sha256(hashlib.sha256(x).digest()).digest() hash_encode = lambda x: x[::-1].encode('hex') hash_decode = lambda x: x.decode('hex')[::-1] def header_to_string(res): pbh = res.get('prev_block_hash') if pbh is None: pbh = '0'*64
def sovhash(s): return x16r_hash.getPoWHash(s)
def btcrhash(s): return x16r_hash.getPoWHash(s)