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