def generate_hashes_from_block(data_block, algorithm): sha256_hash = hashlib.sha256( hashlib.sha256(data_block).digest()).digest()[::-1] header_hash = "" if algorithm == 'scrypt': header_hash = scrypt.hash(data_block, data_block, 1024, 1, 1, 32)[::-1] elif algorithm == 'SHA256': header_hash = sha256_hash elif algorithm == 'X11': try: exec('import %s' % "xcoin_hash") except ImportError: sys.exit("Cannot run X11 algorithm: module xcoin_hash not found") header_hash = xcoin_hash.getPoWHash(data_block)[::-1] elif algorithm == 'X13': try: exec('import %s' % "x13_hash") except ImportError: sys.exit("Cannot run X13 algorithm: module x13_hash not found") header_hash = x13_hash.getPoWHash(data_block)[::-1] elif algorithm == 'neoscrypt': try: exec('import %s' % "neoscrypt") except ImportError: sys.exit( "Cannot run neoscrypt algorithm: module neoscrypt not found") header_hash = neoscrypt.getPoWHash(data_block)[::-1] elif algorithm == 'X15': try: exec('import %s' % "x15_hash") except ImportError: sys.exit("Cannot run X15 algorithm: module x15_hash not found") header_hash = x15_hash.getPoWHash(data_block)[::-1] return sha256_hash, header_hash
def Hash_Header(x: bytes, ts=0) -> bytes: x = to_bytes(x, 'utf8') if ts <= 1535760000: out = neoscrypt.getPoWHash(x) else: out = lyra2z.getPoWHash(x) return out
def header_hash(cls, header): ''' Given a header return the hash for sibcoin. Need to download `x11_gost_hash` module Source code: https://github.com/ivansib/x11_gost_hash ''' import neoscrypt return neoscrypt.getPoWHash(header)
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 = neoscrypt.getPoWHash(blk_hdr) return pow_hash
def calc_sha256(self): if self.sha256 is None: r = b"" r += struct.pack("<i", self.nVersion) r += ser_uint256(self.hashPrevBlock) r += ser_uint256(self.hashMerkleRoot) r += struct.pack("<I", self.nTime) r += struct.pack("<I", self.nBits) r += struct.pack("<I", self.nNonce) self.sha256 = uint256_from_str(hash256(r)) self.hash = encode(hash256(r)[::-1], 'hex_codec').decode('ascii') self.neoscrypt = uint256_from_str(neoscrypt.getPoWHash(r))
def pow_hash(data_hex: str, algo: int) -> str: """ Computes the PoW hash for the given algorithm and the serialised header data as hex string. Returns the hash as hex. """ if algo == ALGO_SHA256D: return blockchain.hash_raw_header(data_hex) if algo == ALGO_NEOSCRYPT: data = bfh(data_hex) swapped = bytes() for i in range(0, len(data), 4): swapped += data[i:i + 4][::-1] hashed = neoscrypt.getPoWHash(swapped) return hash_encode(hashed) raise InvalidAlgoError(f"Invalid mining algorithm: {algo}")
def NeoscryptHash(x): return neoscrypt.getPoWHash(x)
def NeoHash(x): return neoscrypt.getPoWHash(to_bytes(x))
def calc_hdr_hash(blk_hdr): hash2_o = neoscrypt.getPoWHash(blk_hdr) return hash2_o
import neoscrypt print neoscrypt.getPoWHash("Hello")
def getNeoPoWHash(header): if loaded: return neoscrypt(header) return getPoWHash(header)
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 PoWNeoScryptHash(x): x = to_bytes(x, 'utf8') return neoscrypt.getPoWHash(x)
def header_hash(cls, header): '''Given a header return the hash.''' import neoscrypt return neoscrypt.getPoWHash(header)
def gobytehash(s): return neoscrypt.getPoWHash(s)
def test_neoscrypt_hash(self): self.pow_hash = hexlify(neoscrypt.getPoWHash(self.block_header))