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 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 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'])
# 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()
