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 is_valid(self): if settings.COINDAEMON_ALGO == 'scrypt': self.calc_scrypt() else: self.calc_sha256() target = util.uint256_from_compact(self.nBits) if settings.COINDAEMON_ALGO == 'scrypt' and self.scrypt > self.target: return False elif self.sha256 > self.target: return False hashes = [] hashes.append(b'\0' * 0x20) for tx in self.vtx[1:]: hashes.append( SHA256.new(SHA256.new(tx.serialize()).digest()).digest()) while len(hashes) > 1: newhashes = [] for i in xrange(0, len(hashes), 2): i2 = min(i + 1, len(hashes) - 1) newhashes.append( SHA256.new(SHA256.new(hashes[i] + hashes[i2]).digest()).digest()) hashes = newhashes calcwitness = SHA256.new( SHA256.new(hashes[0] + witness_nonce).digest()).digest() if calcwitness != self.witness: return False return True
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 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''' 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): """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 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 is_valid(self): self.calc_hash() target = util.uint256_from_compact(self.nBits) if self.sha256 > self.target: return False hashes = [] hashes.append(b'\0' * 0x20) for tx in self.vtx[1:]: hashes.append(SHA256.new(SHA256.new(tx.serialize()).digest()).digest()) while len(hashes) > 1: newhashes = [] for i in xrange(0, len(hashes), 2): i2 = min(i+1, len(hashes)-1) newhashes.append(SHA256.new(SHA256.new(hashes[i] + hashes[i2]).digest()).digest()) hashes = newhashes calcwitness = SHA256.new(SHA256.new(hashes[0] + witness_nonce).digest()).digest() if calcwitness != self.witness: return False return True
def is_valid(self): self.calc_hash() target = util.uint256_from_compact(self.nBits) if self.sha256 > self.target: return False hashes = [] hashes.append(b'\0' * 0x20) for tx in self.vtx[1:]: hashes.append(SHA256(SHA256(tx.serialize()).digest()).digest()) while len(hashes) > 1: newhashes = [] for i in xrange(0, len(hashes), 2): i2 = min(i + 1, len(hashes) - 1) newhashes.append( SHA256(SHA256(hashes[i] + hashes[i2]).digest()).digest()) hashes = newhashes calcwitness = SHA256(SHA256(hashes[0] + witness_nonce).digest()).digest() if calcwitness != self.witness: return False return True
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()
def bits_to_diff(self, nbits): diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000 return diff1 / util.uint256_from_compact(nbits)