def run(self): try: template = self.registry.get_last_template() if template: current_prevhash = "%064x" % template.hashPrevBlock else: current_prevhash = None # Get prevhash if config.BITCOIN_VERSION_0_9_PLUS: prevhash = yield self.bitcoin_rpc.get_best_block_hash() else: prevhash = util.reverse_hash((yield self.bitcoin_rpc.prevhash())) if prevhash and prevhash != current_prevhash: log.info("New block! Prevhash: %s" % prevhash) self.registry.update_blank_block(prevhash) elif posix_time() - self.registry.last_update >= config.MERKLE_REFRESH_INTERVAL: log.info("Merkle update! Prevhash: %s" % prevhash) self.registry.update_block() except Exception: log.exception("UpdateWatchdog.run failed") finally: self.schedule()
def fill_from_rpc(self, data): '''Convert getblocktemplate result into BlockTemplate instance''' #txhashes = [None] + [ binascii.unhexlify(t['hash']) for t in data['transactions'] ] txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = self.coinbase_transaction_class(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], settings.COINBASE_EXTRAS) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.vtx = [ coinbase, ] for tx in data['transactions']: t = halfnode.CTransaction() t.deserialize(StringIO.StringIO(binascii.unhexlify(tx['data']))) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) # Reversed prevhash self.prevhash_bin = binascii.unhexlify(util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def fill_from_another(self, block, prevhash): self.height = block.height + 1 self.nVersion = block.nVersion self.hashPrevBlock = int(prevhash, 16) self.nBits = block.nBits self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.merkletree = merkletree.MerkleTree([None]) self.coinbase_flags = block.coinbase_flags # TODO: replace by some more complete solution coinbasevalue = 50*10**8 if self.height < 210000 else 25*10**8 coinbase = self.coinbase_transaction_class(self.job_id, self.timestamper, self.coinbaser, coinbasevalue, self.coinbase_flags, self.height, config.COINBASE_EXTRAS) #@UndefinedVariable self.vtx = [ coinbase, ] self.curtime = int(self.timestamper.time()) + block.timedelta self.timedelta = block.timedelta self.target = block.target # Reversed prevhash self.prevhash_bin = binascii.unhexlify(util.reverse_hash(prevhash)) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def run(self): update = False try: if self.registry.last_block: current_prevhash = "%064x" % self.registry.last_block.hashPrevBlock else: current_prevhash = None prevhash = util.reverse_hash(self.bitcoin_rpc.prevhash()) if prevhash and prevhash != current_prevhash: logger.log('debug', "New block! Prevhash: %s" % prevhash) update = True elif time.time() - self.registry.last_update >= settings.MERKLE_REFRESH_INTERVAL: logger.log('debug', "Merkle update! Prevhash: %s" % prevhash) update = True else: logger.log('debug', 'Nothing updated') if update: self.registry.update_block() except Exception, e: logger.log('error', "UpdateWatchdog.run failed %s" % e)
def run(self): update = False try: if self.registry.last_block: current_prevhash = "%064x" % self.registry.last_block.hashPrevBlock else: current_prevhash = None prevhash = util.reverse_hash((yield self.bitcoin_rpc.prevhash())) if prevhash and prevhash != current_prevhash: log.info("New block! Prevhash: %s" % prevhash) update = True elif Interfaces.timestamper.time() - self.registry.last_update >= settings.MERKLE_REFRESH_INTERVAL: log.info("Merkle update! Prevhash: %s" % prevhash) update = True if update: self.registry.update_block() except Exception: log.exception("UpdateWatchdog.run failed") finally: self.schedule()
def run(self): update = False try: if self.registry.last_block: current_prevhash = "%064x" % self.registry.last_block.hashPrevBlock else: current_prevhash = None log.info("Checking for new block.") prevhash = util.reverse_hash((yield self.bitcoin_rpc.prevhash())) if prevhash and prevhash != current_prevhash: log.info("New block! Prevhash: %s" % prevhash) update = True elif Interfaces.timestamper.time( ) - self.registry.last_update >= settings.MERKLE_REFRESH_INTERVAL: log.info("Merkle update! Prevhash: %s" % prevhash) update = True if update: self.registry.update_block() except Exception: log.exception("UpdateWatchdog.run failed") finally: self.schedule()
def fill_from_rpc(self, data): '''Convert getblocktemplate result into BlockTemplate instance''' commitment = None nTime = data['curtime'] if data.has_key('curtime') else None if settings.COINDAEMON_HAS_SEGWIT: txids = [] hashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] try: txids = [None] + [ util.ser_uint256(int(t['txid'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txids) except KeyError: mt = merkletree.MerkleTree(hashes) wmt = merkletree.MerkleTree(hashes).withFirst(binascii.unhexlify('0000000000000000000000000000000000000000000000000000000000000000')) self.witness = SHA256.new(SHA256.new(wmt + witness_nonce).digest()).digest() commitment = b'\x6a' + struct.pack(">b", len(self.witness) + len(witness_magic)) + witness_magic + self.witness try: default_witness = data['default_witness_commitment'] commitment_check = binascii.unhexlify(default_witness) if(commitment != commitment_check): print("calculated witness does not match supplied one! This block probably will not be accepted!") commitment = commitment_check except KeyError: pass self.witness = commitment[6:] else: txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = CoinbaseTransaction(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], commitment, settings.COINBASE_EXTRAS, nTime) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.vtx = [ coinbase, ] for tx in data['transactions']: t = TxBlob() t.deserialize(binascii.unhexlify(tx['data'])) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) # Reversed prevhash self.prevhash_bin = binascii.unhexlify(util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def prevhash(self): # resp = (yield self._call('getwork', [])) resp = (yield self._call('getblocktemplate', [{}])) try: defer.returnValue(util.reverse_hash(json.loads(resp)['result']['previousblockhash'])) except Exception as e: log.exception("Cannot decode prevhash %s" % str(e)) raise
def prevhash(self): # resp = (yield self._call('getwork', [])) resp = (yield self._call('getblocktemplate', [{}])) try: defer.returnValue( util.reverse_hash( json.loads(resp)['result']['previousblockhash'])) except Exception as e: log.exception("Cannot decode prevhash %s" % str(e)) raise
def fill_from_rpc(self, data): '''Convert getblocktemplate result into BlockTemplate instance''' payee = None if (data['payee'] != ''): payee = util.script_to_address(data['payee']) payee_amount = data.get('payee_amount', data['coinbasevalue'] / 5) #default to 20% #txhashes = [None] + [ binascii.unhexlify(t['hash']) for t in data['transactions'] ] txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = CoinbaseTransactionPOW(self.timestamper, self.coinbaser, payee, payee_amount, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], settings.COINBASE_EXTRAS) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.masternode_payments = data['masternode_payments'] self.vtx = [ coinbase, ] for vote in data['votes']: v = halfnode.CMasterNodeVote() v.deserialize(StringIO.StringIO(binascii.unhexlify(vote))) self.vmn.append(v) for tx in data['transactions']: t = halfnode.CTransaction() t.deserialize(StringIO.StringIO(binascii.unhexlify(tx['data']))) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) # Reversed prevhash self.prevhash_bin = binascii.unhexlify( util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def fill_from_rpc(self, data, aux_data): '''Convert getblocktemplate result into BlockTemplate instance''' self.auxs = aux_data self.tree, self.merkle_size = util.make_auxpow_tree(aux_data) self.aux_targets = [None for i in self.auxs] merkle_leaves = [ ('0' * 64) for x in range(self.merkle_size) ] for chain in range(len(self.auxs)): merkle_index = self.tree[self.auxs[chain]['chainid']] merkle_leaves[merkle_index] = self.auxs[chain]['hash'] target = self.auxs[chain]['target'].decode('hex')[::-1].encode('hex') self.aux_targets[chain] = int(target, 16) log.info("Merged Chain: %i network difficulty: %s" % (self.auxs[chain]['chainid'], float(util.diff_to_target(self.aux_targets[chain])))) self.merkle_hashes = [ int(t, 16) for t in merkle_leaves ] self.mm_data = '\xfa\xbemm' + util.aux_pow_coinbase_type.pack(dict( merkle_root = util.merkle_hash(self.merkle_hashes), size = self.merkle_size, nonce = 0, )) txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = CoinbaseTransaction(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], settings.COINBASE_EXTRAS + self.mm_data, data['curtime']) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.vtx = [ coinbase, ] for tx in data['transactions']: t = halfnode.CTransaction() t.deserialize(StringIO.StringIO(binascii.unhexlify(tx['data']))) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) log.info("MainNet Block Height: %i network difficulty: %s" % (self.height, float(util.diff_to_target(self.target)))) # Reversed prevhash self.prevhash_bin = binascii.unhexlify(util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def prevhash(self): try: resp = (yield self._call('getbestblockhash', [])) defer.returnValue(json.loads(resp)['result']) # if internal server error try getblocktemplate without empty {} # ppcoin except Exception as e: if (str(e) == "500 Internal Server Error"): resp = (yield self._call('getwork', [])) defer.returnValue(util.reverse_hash(json.loads(resp)['result']['data'][8:72])) else: log.exception("Cannot decode prevhash %s" % str(e)) raise
def prevhash(self): try: resp = (yield self._call('getbestblockhash', [])) defer.returnValue(json.loads(resp)['result']) except Exception as e: if str(e) == "500 Internal Server Error": resp = (yield self._call('getwork', [])) defer.returnValue( util.reverse_hash( json.loads(resp)['result']['data'][8:72])) else: log.exception("Cannot decode prevhash %s" % str(e)) raise
def fill_from_rpc(self, data): """Convert getblocktemplate result into BlockTemplate instance""" # txhashes = [None] + [ binascii.unhexlify(t['hash']) for t in data['transactions'] ] txhashes = [None] + [util.ser_uint256(int(t["hash"], 16)) for t in data["transactions"]] mt = merkletree.MerkleTree(txhashes) if settings.MAIN_COIN_TYPE == "proof-of-work": coinbase = self.coinbase_transaction_class( self.timestamper, self.coinbaser, data["coinbasevalue"], data["coinbaseaux"]["flags"], data["height"], settings.COINBASE_EXTRAS, ) else: coinbase = self.coinbase_transaction_class( self.timestamper, self.coinbaser, data["coinbasevalue"], data["coinbaseaux"]["flags"], data["height"], settings.COINBASE_EXTRAS, data["curtime"], ) self.height = data["height"] self.nVersion = data["version"] self.hashPrevBlock = int(data["previousblockhash"], 16) self.nBits = int(data["bits"], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.vtx = [coinbase] for tx in data["transactions"]: t = halfnode.CTransaction() t.deserialize(StringIO.StringIO(binascii.unhexlify(tx["data"]))) self.vtx.append(t) self.curtime = data["curtime"] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) # Reversed prevhash self.prevhash_bin = binascii.unhexlify(util.reverse_hash(data["previousblockhash"])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def run(self): log.info("Polling for new block information.") update = False prevhash = None try: # Get the current prevhash from the pool registry if one exists if self.registry.last_template: log.debug("Loading Prevhash from pool registry.") current_prevhash = "%064x" % self.registry.last_template.block.hashPrevBlock else: log.debug("No Prevhash in pool registry.") current_prevhash = None # Get the current prevhash from the coin deamon log.info("Loading Prevhash from network.") prevhash = util.reverse_hash((yield self.bitcoin_rpc.prevhash())) log.debug("Got Prevhash: %s" % prevhash) # We must have a prevhash if prevhash is None: log.error("Prevhash is NULL, is coin deamon ready/responding?") raise # Detects new a block by comparing the new prevhash with the current prevhash # If a new block is detected, run an update imidietly. # If no new block is detected, update only if it's time to refresh the transactions (merkele refresh) if prevhash and prevhash != current_prevhash: log.info("New block detected on network! Prevhash: %s" % prevhash) update = True elif Interfaces.timestamper.time( ) - self.registry.last_block_update_start_time >= settings.MERKLE_REFRESH_INTERVAL: log.info("Performing Merkle tree update. Prevhash: %s" % prevhash) update = True # Runs a Block/Getwork forced update if needed if update: self.registry.update_block(True) except Exception as e: log.warning("Block update failed: %s" % (str(e))) finally: # Schedule the next update self.schedule()
def fill_from_rpc(self, data): '''Convert getblocktemplate result into BlockTemplate instance''' payee = None if(data['payee'] != ''): payee = util.script_to_address(data['payee']) payee_amount = data.get('payee_amount', data['coinbasevalue']/5) #default to 20% #txhashes = [None] + [ binascii.unhexlify(t['hash']) for t in data['transactions'] ] txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = CoinbaseTransactionPOW(self.timestamper, self.coinbaser, payee, payee_amount, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], settings.COINBASE_EXTRAS) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.masternode_payments = data['masternode_payments'] self.vtx = [ coinbase, ] for vote in data['votes']: v = halfnode.CMasterNodeVote() v.deserialize(StringIO.StringIO(binascii.unhexlify(vote))) self.vmn.append(v) for tx in data['transactions']: t = halfnode.CTransaction() t.deserialize(StringIO.StringIO(binascii.unhexlify(tx['data']))) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) # Reversed prevhash self.prevhash_bin = binascii.unhexlify(util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def run(self): log.info("Polling for new block information.") update = False prevhash = None try: # Get the current prevhash from the pool registry if one exists if self.registry.last_template: log.debug("Loading Prevhash from pool registry.") current_prevhash = "%064x" % self.registry.last_template.block.hashPrevBlock else: log.debug("No Prevhash in pool registry.") current_prevhash = None # Get the current prevhash from the coin deamon log.info("Loading Prevhash from network.") prevhash = util.reverse_hash((yield self.bitcoin_rpc.prevhash())) log.debug("Got Prevhash: %s" % prevhash) # We must have a prevhash if prevhash is None: log.error("Prevhash is NULL, is coin deamon ready/responding?") raise # Detects new a block by comparing the new prevhash with the current prevhash # If a new block is detected, run an update imidietly. # If no new block is detected, update only if it's time to refresh the transactions (merkele refresh) if prevhash and prevhash != current_prevhash: log.info("New block detected on network! Prevhash: %s" % prevhash) update = True elif Interfaces.timestamper.time() - self.registry.last_block_update_start_time >= settings.MERKLE_REFRESH_INTERVAL: log.info("Performing Merkle tree update. Prevhash: %s" % prevhash) update = True # Runs a Block/Getwork forced update if needed if update: self.registry.update_block(True) except Exception as e: log.warning("Block update failed: %s" % (str(e))) finally: # Schedule the next update self.schedule()
def fill_from_rpc(self, data, aux_data): '''Convert getblocktemplate result into BlockTemplate instance''' self.auxs = aux_data self.tree, self.merkle_size = util.make_auxpow_tree(aux_data) self.aux_targets = [None for i in self.auxs] merkle_leaves = [('0' * 64) for x in range(self.merkle_size)] for chain in range(len(self.auxs)): merkle_index = self.tree[self.auxs[chain]['chainid']] merkle_leaves[merkle_index] = self.auxs[chain]['hash'] target = self.auxs[chain]['target'].decode('hex')[::-1].encode( 'hex') self.aux_targets[chain] = int(target, 16) log.info("Merged Chain: %i network difficulty: %s" % (self.auxs[chain]['chainid'], float(util.diff_to_target(self.aux_targets[chain])))) self.merkle_hashes = [int(t, 16) for t in merkle_leaves] self.mm_data = '\xfa\xbemm' + util.aux_pow_coinbase_type.pack( dict( merkle_root=util.merkle_hash(self.merkle_hashes), size=self.merkle_size, nonce=0, )) txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = CoinbaseTransaction(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], settings.COINBASE_EXTRAS + self.mm_data, data['curtime']) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.vtx = [ coinbase, ] for tx in data['transactions']: t = halfnode.CTransaction() t.deserialize(StringIO.StringIO(binascii.unhexlify(tx['data']))) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) log.info("MainNet Block Height: %i network difficulty: %s" % (self.height, float(util.diff_to_target(self.target)))) # Reversed prevhash self.prevhash_bin = binascii.unhexlify( util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()
def fill_from_rpc(self, data): '''Convert getblocktemplate result into BlockTemplate instance''' commitment = None nTime = data['curtime'] if data.has_key('curtime') else None if settings.COINDAEMON_HAS_SEGWIT: txids = [] hashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] try: txids = [None] + [ util.ser_uint256(int(t['txid'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txids) except KeyError: mt = merkletree.MerkleTree(hashes) wmt = merkletree.MerkleTree(hashes).withFirst( binascii.unhexlify( '0000000000000000000000000000000000000000000000000000000000000000' )) self.witness = SHA256.new( SHA256.new(wmt + witness_nonce).digest()).digest() commitment = b'\x6a' + struct.pack( ">b", len(self.witness) + len(witness_magic)) + witness_magic + self.witness try: default_witness = data['default_witness_commitment'] commitment_check = binascii.unhexlify(default_witness) if (commitment != commitment_check): print( "calculated witness does not match supplied one! This block probably will not be accepted!" ) commitment = commitment_check except KeyError: pass self.witness = commitment[6:] else: txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ] mt = merkletree.MerkleTree(txhashes) coinbase = CoinbaseTransaction(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'], commitment, settings.COINBASE_EXTRAS, nTime) self.height = data['height'] self.nVersion = data['version'] self.hashPrevBlock = int(data['previousblockhash'], 16) self.nBits = int(data['bits'], 16) self.hashMerkleRoot = 0 self.nTime = 0 self.nNonce = 0 self.vtx = [ coinbase, ] for tx in data['transactions']: t = TxBlob() t.deserialize(binascii.unhexlify(tx['data'])) self.vtx.append(t) self.curtime = data['curtime'] self.timedelta = self.curtime - int(self.timestamper.time()) self.merkletree = mt self.target = util.uint256_from_compact(self.nBits) # Reversed prevhash self.prevhash_bin = binascii.unhexlify( util.reverse_hash(data['previousblockhash'])) self.prevhash_hex = "%064x" % self.hashPrevBlock self.broadcast_args = self.build_broadcast_args()