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 fill_from_rpc(self, data):
'''Convert getblocktemplate result into BlockTemplate instance'''
if 'height' not in data:
log.info("Waiting for new work...")
self.prevhash_hex = self.blank_hash
self.broadcast_args = self.build_fake_broadcast_args()
return
txhashes = [None] + [
util.ser_uint320(int(t['hash'], 16)) for t in data['transactions']
]
mt = merkletree.MerkleTree(txhashes)
self.height = data['height']
self.nVersion = data['version']
self.hashPrevBlock = int(data['previousblockhash'], 16)
self.nBits = int(data['bits'], 16)
self.nBitsHex = data['bits']
self.hashMerkleRoot = 0
self.nTime = 0
self.nNonce = 0
self.cbTxTime = int(self.timestamper.time())
self.nTxTime = self.cbTxTime * 1000
self.nHashCoin = 0
self.sigchecksum = 0
coinbase = CoinbaseTransaction(self.timestamper, self.coinbaser,
data['coinbasevalue'],
data['coinbaseaux']['flags'],
data['height'],
settings.COINBASE_EXTRAS, self.cbTxTime)
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 = int((data['target']), 16)
log.info("Block height: %i network difficulty: %s" %
(self.height, self.diff_to_t(self.target)))
# Reversed prevhash
#self.prevhash_bin = binascii.unhexlify(util.reverse_hash_80(data['previousblockhash']))
self.prevhash_bin = binascii.unhexlify(
util.rev(data['previousblockhash']))
self.prevhash_hex = "%080x" % self.hashPrevBlock
#log.info("%s\n", repr(self))
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_merkleblock(merkleblock):
"""Verifies whether the merkle tree information validates to the merkle root"""
# convert the flags field to a bit field
flag_bits = bloomfilter.bytes_to_bit_field(merkleblock['flags'])
# reverse self.hashes for the merkle root calculation
hashes = [h[::-1] for h in merkleblock['hashes']]
# initialize the merkle tree
merkle_tree = mt.MerkleTree(merkleblock['total'])
# populate the tree with flag bits and hashes
merkle_tree.populate_tree(flag_bits, hashes)
# check if the computed root reversed is the same as the merkle root
return merkle_tree.root()[::-1] == merkleblock['merkle_root']
def makeMRD(mp):
coinbase = bytes.fromhex(mp['coinbasetxn'])
cbtxn = bitcoin.txn.Txn(coinbase)
cbtxn.disassemble()
cbtxn.originalCB = cbtxn.getCoinbase()
txnlist = [
cbtxn,
] + list(map(bitcoin.txn.Txn, map(bytes.fromhex, mp['transactions'])))
merkleTree = merkletree.MerkleTree(txnlist)
merkleRoot = None
prevBlock = bytes.fromhex(mp['previousblockhash'])[::-1]
bits = bytes.fromhex(mp['bits'])[::-1]
rollPrevBlk = False
MRD = (merkleRoot, merkleTree, coinbase, prevBlock, bits, rollPrevBlk, mp)
if 'coinbase/append' in mp.get('mutable', ()):
currentwork[:] = (MRD, time(), 0)
else:
currentwork[2] = 0
return MRD
def get_proof(problem, num_queries, witness):
proof = []
randomness_seed = problem[:]
for i in range(num_queries):
random.seed(str(randomness_seed))
query_idx = random.randint(0, len(problem))
if query_idx < len(problem):
witness[query_idx + 1] = problem[query_idx] + witness[query_idx]
else:
witness[0] = 0
witness[len(witness) - 1] = 0
tree = merkletree.MerkleTree(witness)
query_and_response = [tree.get_root()]
query_and_response += [query_idx]
query_and_response += tree.get_val_and_path(query_idx)
query_and_response += tree.get_val_and_path(
(query_idx + 1) % len(witness))
proof += [query_and_response]
randomness_seed += [query_and_response]
return proof
def __init__(
self,
index=0,
prev_hash='0000000000000000000000000000000000000000000000000000000000000000',
difficulty=3,
max_nodes=256):
'''
Constructor function to generate a block.
Default block is the genesis block.
'''
self.index = index
self.prev_hash = prev_hash
self.merkle_tree = merkletree.MerkleTree(max_nodes)
self.nonce = 1
self.difficulty = difficulty
self.transactions = []
self.next = None
self.time_stamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
self.hash = '0000000000000000000000000000000000000000000000000000000000000000'
self.__addedToChain = False
