def test_validate_5_leaves():
mt = MerkleTools()
mt.add_leaf([
'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb',
'3e23e8160039594a33894f6564e1b1348bbd7a0088d42c4acb73eeaed59c009d',
'2e7d2c03a9507ae265ecf5b5356885a53393a2029d241394997265a1a25aefc6',
'18ac3e7343f016890c510e93f935261169d9e3f565436429830faf0934f4f8e4',
'3f79bb7b435b05321651daefd374cdc681dc06faa65e374e38337b88ca046dea'
])
mt.make_tree()
# bad proof
proof = mt.get_proof(3)
is_valid = mt.validate_proof(
proof,
'badc3e7343f016890c510e93f935261169d9e3f565436429830faf0934f4f8e4',
'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba')
assert is_valid == False
# good proof
proof = mt.get_proof(4)
is_valid = mt.validate_proof(
proof,
'3f79bb7b435b05321651daefd374cdc681dc06faa65e374e38337b88ca046dea',
'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba')
assert is_valid == True
proof = mt.get_proof(1)
is_valid = mt.validate_proof(
proof,
'3e23e8160039594a33894f6564e1b1348bbd7a0088d42c4acb73eeaed59c009d',
'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba')
assert is_valid == True
def merkleTree(self):
tree = MerkleTools(hash_type="SHA256")
tree.add_leaf(
[transaction.hash() for transaction in self.transactions], True)
tree.make_tree()
self.merkletree = tree
return tree
class MerkleInputProcessor(BaseInputProcessor):
def __init__(self, *, hash_algo, **kwargs):
super().__init__(hash_algo=hash_algo, **kwargs)
self.mt = MerkleTools(hash_type=hash_algo)
log.info('Tree using {} hashing algorithm', hash_algo)
def add_input(self, inp):
self.mt.add_leaf(inp, do_hash=False)
log.info('leaf added | leaves: {}'.format(len(self.mt.leaves)))
def ready_to_process(self):
return len(self.mt.leaves) > 0
def process(self):
log.info('Make Tree')
self.mt.make_tree()
log.info('Merkle root {}', self.mt.merkle_root.hex())
def reset_inputs(self):
self.mt.reset_tree()
log.info('Resetting Merkle Tree')
@property
def condensed_output(self):
return self.mt.merkle_root
@property
def commitment_data(self):
return msgpack.packb({
'root': self.mt.merkle_root,
'leaves': self.mt.leaves,
'hash_type': self.mt._hash_type
})
def test_build_tree():
mt = MerkleTools()
mt.add_leaf("tierion", do_hash=True)
mt.add_leaves(["bitcoin", "blockchain"], do_hash=True)
mt.make_tree()
assert mt.is_ready == True
mt.merkle_root == bytes.fromhex(
'765f15d171871b00034ee55e48ffdf76afbc44ed0bcff5c82f31351d333c2ed1')
def test_bad_hex():
# try to add bad hex
mt = MerkleTools()
try:
mt.add_leaf('nothexandnothashed')
assert False # should not get here!
except:
pass
def test_build_tree():
mt = MerkleTools()
mt.add_leaf("tierion")
mt.add_leaf(["bitcoin", "blockchain"])
mt.make_tree()
assert mt.is_ready is True
assert mt.get_merkle_root(
) == '765f15d171871b00034ee55e48ffdf76afbc44ed0bcff5c82f31351d333c2ed1'
def calculate_merkle_root(hashes):
mt = MerkleTools(hash_type='sha3_256')
for h in hashes:
mt.add_leaf(h)
mt.make_tree()
return mt.get_merkle_root()
class MerkleTreeGenerator(object):
def __init__(self):
self.tree = MerkleTools(hash_type='sha256')
def populate(self, node_generator):
"""
Populate Merkle Tree with data from node_generator. This requires that node_generator yield byte[] elements.
Hashes, computes hex digest, and adds it to the Merkle Tree
:param node_generator:
:return:
"""
for data in node_generator:
hashed = hash_byte_array(data)
self.tree.add_leaf(hashed)
def get_blockchain_data(self):
"""
Finalize tree and return byte array to issue on blockchain
:return:
"""
self.tree.make_tree()
merkle_root = self.tree.get_merkle_root()
return h2b(ensure_string(merkle_root))
def get_proof_generator(self, tx_id, chain=Chain.bitcoin_mainnet):
"""
Returns a generator (1-time iterator) of proofs in insertion order.
:param tx_id: blockchain transaction id
:return:
"""
root = ensure_string(self.tree.get_merkle_root())
node_count = len(self.tree.leaves)
for index in range(0, node_count):
proof = self.tree.get_proof(index)
proof2 = []
for p in proof:
dict2 = dict()
for key, value in p.items():
dict2[key] = ensure_string(value)
proof2.append(dict2)
target_hash = ensure_string(self.tree.get_leaf(index))
merkle_proof = {
"type": ['MerkleProof2017', 'Extension'],
"merkleRoot":
root,
"targetHash":
target_hash,
"proof":
proof2,
"anchors": [{
"sourceId": to_source_id(tx_id, chain),
"type": chain.blockchain_type.external_display_value,
"chain": chain.external_display_value
}]
}
yield merkle_proof
def test_one_leaf():
# make tree with one leaf
mt = MerkleTools()
mt.add_leaf([
'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb',
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb'
def create_merkle_root(tx_set):
# Merkle root 생성
mt = MerkleTools(hash_type='sha256')
for tx in tx_set:
mt.add_leaf(str(tx), True)
mt.make_tree()
root_value = mt.get_merkle_root()
return root_value
def test_bad_proof():
bLeft = 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb'
bRight = 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c'
mt = MerkleTools()
mt.add_leaf(bLeft)
mt.add_leaf(bRight)
mt.make_tree()
proof = mt.get_proof(1)
is_valid = mt.validate_proof(proof, bRight, bLeft)
assert not is_valid
def test_md5_tree():
bLeftmd5 = '0cc175b9c0f1b6a831c399e269772661'
bRightmd5 = '92eb5ffee6ae2fec3ad71c777531578f'
mRootmd5 = hashlib.md5(
bytearray.fromhex(bLeftmd5) +
bytearray.fromhex(bRightmd5)).hexdigest()
mt = MerkleTools('md5')
mt.add_leaf([bLeftmd5, bRightmd5])
mt.make_tree()
assert mt.get_merkle_root() == mRootmd5
def gen_merkle_tree(tx_list):
mt = MerkleTools(hash_type="sha256")
mt.add_leaf(tx_list, True)
mt.make_tree()
for index in range(0, mt.leaves.__len__()):
logger.info("Transaction" + str(index) + ": " + mt.get_leaf(index))
while not mt.is_ready:
logger.error("mt is not ready!")
return mt.get_merkle_root()
def to_merkle_tree(list_of_transactions):
merkle_tree = MerkleTools()
for tx in list_of_transactions:
print("tx: ", type(tx))
print(tx)
if isinstance(tx, Transaction):
merkle_tree.add_leaf(tx.signature, True)
else:
merkle_tree.add_leaf(tx['signature'], True)
merkle_tree.make_tree()
return merkle_tree.get_merkle_root()
def test_get_proof():
mt = MerkleTools()
mt.add_leaf("tierion")
mt.add_leaf(["bitcoin", "blockchain"])
mt.make_tree()
proof_1 = mt.get_proof(1)
for p in proof_1:
if 'left' in p:
assert p[
'left'] == '2da7240f6c88536be72abe9f04e454c6478ee29709fc3729ddfb942f804fbf08'
else:
assert p[
'right'] == 'ef7797e13d3a75526946a3bcf00daec9fc9c9c4d51ddc7cc5df888f74dd434d1'
def generate_block_candidate(request, miner_address):
# Get unconfirmed transactions
transaction_list = Transaction.objects.filter(
transfer_successful=False).exclude(
from_address=settings.GENESIS_ADDRESS)
last_mined_block = Block.objects.last()
if not last_mined_block:
last_mined_block = GenesisBlock.objects.last()
# add Coinbase transaction
coinbase_transaction = generate_coinbase_transaction(
miner_address, last_mined_block.index + 1)
merkle_tree = MerkleTools()
for transaction in transaction_list:
merkle_tree.add_leaf(transaction.transaction_data_hash)
merkle_tree.add_leaf(coinbase_transaction['transaction_data_hash'])
merkle_tree.make_tree()
if merkle_tree.is_ready:
merkle_root = merkle_tree.get_merkle_root()
else:
return False
block_data_hash = hashlib.sha256(
("1" + str(merkle_root) + str(last_mined_block.difficulty) +
last_mined_block.block_hash + miner_address).encode('utf-8'))
pre_block_header = {
'index': str(last_mined_block.index + 1),
'hash_merkle_root': merkle_root,
'difficulty': settings.DIFFICULTY, # HARDCODED
'hash_prev_block': last_mined_block.block_hash,
'mined_by': miner_address,
'block_data_hash': block_data_hash.hexdigest(),
'nonce': 0,
'time': datetime.today().isoformat(),
}
BlockCandidate.objects.create(
index=last_mined_block.index +
1, # if mined successfully, this will be the index
block_data_hash=block_data_hash.hexdigest(
), # Merkle root included here
prev_block_hash=last_mined_block.block_hash,
difficulty=last_mined_block.difficulty,
transactions=serialize_transactions(transaction_list,
coinbase_transaction))
print("--------------------------------------------------------")
return HttpResponse(json.dumps(pre_block_header))
def test_get_proof():
mt = MerkleTools()
mt.add_leaf("tierion", do_hash=True)
mt.add_leaves(["bitcoin", "blockchain"], do_hash=True)
mt.make_tree()
proof_1 = mt.get_proof(1)
for p in proof_1:
try:
assert p['left'] == bytes.fromhex(
'2da7240f6c88536be72abe9f04e454c6478ee29709fc3729ddfb942f804fbf08'
)
except:
assert p['right'] == bytes.fromhex(
'ef7797e13d3a75526946a3bcf00daec9fc9c9c4d51ddc7cc5df888f74dd434d1'
)
def test_basics():
bLeft = 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb'
bRight = 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c'
mRoot = hashlib.sha256(
bytearray.fromhex(bLeft) + bytearray.fromhex(bRight)).hexdigest()
# tree with no leaves
mt = MerkleTools()
mt.make_tree()
assert mt.get_merkle_root() is None
# tree with hex add_leaf
mt.add_leaf([bLeft, bRight])
mt.make_tree()
assert mt.get_merkle_root() == mRoot
def test_sha256():
mt = MerkleTools(hash_type='sha256')
mt.add_leaf([
'1516f000de6cff5c8c63eef081ebcec2ad2fdcf7034db16045d024a90341e07d',
'e20af19f85f265579ead2578859bf089c92b76a048606983ad83f27ba8f32f1a'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '77c654b3d1605f78ed091cbd420c939c3feff7d57dc30c171fa45a5a3c81fd7d'
assert mt.get_proof(0)[0][
'right'] == 'e20af19f85f265579ead2578859bf089c92b76a048606983ad83f27ba8f32f1a'
is_valid = mt.validate_proof(
mt.get_proof(0),
'1516f000de6cff5c8c63eef081ebcec2ad2fdcf7034db16045d024a90341e07d',
'77c654b3d1605f78ed091cbd420c939c3feff7d57dc30c171fa45a5a3c81fd7d')
assert is_valid == True
def test_sha3_224():
mt = MerkleTools(hash_type='sha3_224')
mt.add_leaf([
'6ed712b9472b671fd70bb950dc4ccfce197c92a7969f6bc2aa6b6d9f',
'08db5633d406804d044a3e67683e179b5ee51249ed2139c239d1e65a'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '674bc9f53d5c666174cdd3ccb9df04768dfb7759655e7d937aef0c3a'
assert mt.get_proof(0)[0][
'right'] == '08db5633d406804d044a3e67683e179b5ee51249ed2139c239d1e65a'
is_valid = mt.validate_proof(
mt.get_proof(0),
'6ed712b9472b671fd70bb950dc4ccfce197c92a7969f6bc2aa6b6d9f',
'674bc9f53d5c666174cdd3ccb9df04768dfb7759655e7d937aef0c3a')
assert is_valid == True
def test_sha224():
mt = MerkleTools(hash_type='sha224')
mt.add_leaf([
'90a3ed9e32b2aaf4c61c410eb925426119e1a9dc53d4286ade99a809',
'35f757ad7f998eb6dd3dd1cd3b5c6de97348b84a951f13de25355177'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'f48bc49bb77d3a3b1c8f8a70db693f41d879189cd1919f8326067ad7'
assert mt.get_proof(0)[0][
'right'] == '35f757ad7f998eb6dd3dd1cd3b5c6de97348b84a951f13de25355177'
is_valid = mt.validate_proof(
mt.get_proof(0),
'90a3ed9e32b2aaf4c61c410eb925426119e1a9dc53d4286ade99a809',
'f48bc49bb77d3a3b1c8f8a70db693f41d879189cd1919f8326067ad7')
assert is_valid == True
def test_sha3_256():
mt = MerkleTools(hash_type='sha3_256')
mt.add_leaf([
'1d7d4ea1cc029ca460e486642830c284657ea0921235c46298b51f0ed1bb7bf7',
'89b9e14eae37e999b096a6f604adefe7feea4dc240ccecb5e4e92785cffc7070'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '6edf674f5ce762e096c3081aee2a0a977732e07f4d704baf34f5e3804db03343'
assert mt.get_proof(0)[0][
'right'] == '89b9e14eae37e999b096a6f604adefe7feea4dc240ccecb5e4e92785cffc7070'
is_valid = mt.validate_proof(
mt.get_proof(0),
'1d7d4ea1cc029ca460e486642830c284657ea0921235c46298b51f0ed1bb7bf7',
'6edf674f5ce762e096c3081aee2a0a977732e07f4d704baf34f5e3804db03343')
assert is_valid == True
def test_proof_nodes():
bLeft = 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb'
bRight = 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c'
mRoot = hashlib.sha256(
bytearray.fromhex(bLeft) + bytearray.fromhex(bRight)).hexdigest()
mt = MerkleTools()
mt.add_leaf(bLeft)
mt.add_leaf(bRight)
mt.make_tree()
proof = mt.get_proof(0)
assert proof[0][
'right'] == 'cb4990b9a8936bbc137ddeb6dcab4620897b099a450ecdc5f3e86ef4b3a7135c'
proof = mt.get_proof(1)
assert proof[0][
'left'] == 'a292780cc748697cb499fdcc8cb89d835609f11e502281dfe3f6690b1cc23dcb'
def test_sha512():
mt = MerkleTools(hash_type='sha512')
mt.add_leaf([
'c0a8907588c1da716ce31cbef05da1a65986ec23afb75cd42327634dd53d754be6c00a22d6862a42be5f51187a8dff695c530a797f7704e4eb4b473a14ab416e',
'df1e07eccb2a2d4e1b30d11e646ba13ddc426c1aefbefcff3639405762f216fdcc40a684f3d1855e6d465f99fd9547e53fa8a485f18649fedec5448b45963976'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'd9d27704a3a785d204257bfa2b217a1890e55453b6686f091fa1be8aa2b265bc06c285a909459996e093546677c3f392458d7b1fc34a994a86689ed4100e8337'
assert mt.get_proof(0)[0][
'right'] == 'df1e07eccb2a2d4e1b30d11e646ba13ddc426c1aefbefcff3639405762f216fdcc40a684f3d1855e6d465f99fd9547e53fa8a485f18649fedec5448b45963976'
is_valid = mt.validate_proof(
mt.get_proof(0),
'c0a8907588c1da716ce31cbef05da1a65986ec23afb75cd42327634dd53d754be6c00a22d6862a42be5f51187a8dff695c530a797f7704e4eb4b473a14ab416e',
'd9d27704a3a785d204257bfa2b217a1890e55453b6686f091fa1be8aa2b265bc06c285a909459996e093546677c3f392458d7b1fc34a994a86689ed4100e8337'
)
assert is_valid == True
def test_sha384():
mt = MerkleTools(hash_type='sha384')
mt.add_leaf([
'84ae8c6367d64899aef44a951edfa4833378b9e213f916c5eb8492cc37cb951c726e334dace7dbe4bb1dc80c1efe33d0',
'368c89a00446010def75ad7b179cea9a3d24f8cbb7e2755a28638d194809e7b614eb45453665032860b6c1a135fb6e8b'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'c363aa3b824e3f3b927034fab826eff61a9bfa2030ae9fc4598992edf9f3e42f8b497d6742946caf7a771429eb1745cf'
assert mt.get_proof(0)[0][
'right'] == '368c89a00446010def75ad7b179cea9a3d24f8cbb7e2755a28638d194809e7b614eb45453665032860b6c1a135fb6e8b'
is_valid = mt.validate_proof(
mt.get_proof(0),
'84ae8c6367d64899aef44a951edfa4833378b9e213f916c5eb8492cc37cb951c726e334dace7dbe4bb1dc80c1efe33d0',
'c363aa3b824e3f3b927034fab826eff61a9bfa2030ae9fc4598992edf9f3e42f8b497d6742946caf7a771429eb1745cf'
)
assert is_valid == True
def test_sha3_384():
mt = MerkleTools(hash_type='sha3_384')
mt.add_leaf([
'e222605f939aa69b964a0a03d7075676bb3dbb40c3bd10b22f0adcb149434e7c1085c206f0e3371470a49817aa6d5b16',
'ae331b6f8643ed7e404471c81be9a74f73fc84ffd5140a0ec9aa8596fa0d0a2ded5f7b780bb2fbfc4e2226ee2a04a2fa'
])
mt.make_tree()
assert mt.get_merkle_root(
) == 'bd54df0015fa0d4fee713fbf5c8ae232c93239c75fb9d41c7dd7a9278711764a6ee83c81766b3945ed94030254537b57'
assert mt.get_proof(0)[0][
'right'] == 'ae331b6f8643ed7e404471c81be9a74f73fc84ffd5140a0ec9aa8596fa0d0a2ded5f7b780bb2fbfc4e2226ee2a04a2fa'
is_valid = mt.validate_proof(
mt.get_proof(0),
'e222605f939aa69b964a0a03d7075676bb3dbb40c3bd10b22f0adcb149434e7c1085c206f0e3371470a49817aa6d5b16',
'bd54df0015fa0d4fee713fbf5c8ae232c93239c75fb9d41c7dd7a9278711764a6ee83c81766b3945ed94030254537b57'
)
assert is_valid == True
def test_sha3_512():
mt = MerkleTools(hash_type='sha3_512')
mt.add_leaf([
'004a237ea808cd9375ee9db9f85625948a890c54e2c30f736f54c969074eb56f0ff3d43dafb4b40d5d974acc1c2a68c046fa4d7c2c20cab6df956514040d0b8b',
'0b43a85d08c05252d0e23c96bc6b1bda11dfa787049ff452b3c86f4c6135e870c058c05131f199ef8619cfac937a736bbc936a667e4d96a5bf68e4056ce5fdce'
])
mt.make_tree()
assert mt.get_merkle_root(
) == '3dff3f19b67628591d294cba2c07ed20d20d83e1624af8c1dca8fcf096127b9f86435e2d6a84ca4cee526525cacd1c628bf06ee938983413afafbb4598c5862a'
assert mt.get_proof(0)[0][
'right'] == '0b43a85d08c05252d0e23c96bc6b1bda11dfa787049ff452b3c86f4c6135e870c058c05131f199ef8619cfac937a736bbc936a667e4d96a5bf68e4056ce5fdce'
is_valid = mt.validate_proof(
mt.get_proof(0),
'004a237ea808cd9375ee9db9f85625948a890c54e2c30f736f54c969074eb56f0ff3d43dafb4b40d5d974acc1c2a68c046fa4d7c2c20cab6df956514040d0b8b',
'3dff3f19b67628591d294cba2c07ed20d20d83e1624af8c1dca8fcf096127b9f86435e2d6a84ca4cee526525cacd1c628bf06ee938983413afafbb4598c5862a'
)
assert is_valid == True
def create_merkle_tree(matches, date):
"""
Here the merkle tree is created based on the given list with matches.
The package MerkleTools is being used to generate the Merkle Tree
The matches will first be "flattened" into a string and receive the date to make
these unique, so no the same hash will be generated, in for example: a rematch fight
"""
# get date and format the data
merkle_datalist = []
for match in matches:
merkle_datalist.append(f"{date}{str(match)}")
# make the tree
try:
mt = MerkleTools()
mt.add_leaf(merkle_datalist, True)
mt.make_tree()
return mt.get_merkle_root()
except Exception:
return None
class Block:
def __init__(self,
hash_str,
previous,
nonce,
height,
merkle_root=None,
transactions=None):
self.hash_str = hash_str
self.previous = previous
self.nonce = nonce
self.height = height
self.transactions = [] if transactions is None else transactions
self.merkle_root = merkle_root
self._mt = MerkleTools()
def add_transaction(self, transaction):
self.transactions.append(transaction)
self._mt.add_leaf(str(transaction.serialize()), True)
self._mt.make_tree()
self.merkle_root = self._mt.get_merkle_root()
def serialize(self):
return {
'hash': self.hash_str,
'previous': self.previous.hash_str if self.previous else None,
'nonce': self.nonce,
'height': self.height,
'merkle_root': self.merkle_root,
'transactions': [t.serialize() for t in self.transactions]
}
@classmethod
def deserialize(cls, serialized_block, previous):
return cls(serialized_block['hash'], previous,
serialized_block['nonce'], serialized_block['height'],
serialized_block['merkle_root'], [
Transaction.deserialize(t)
for t in serialized_block['transactions']
])
def test_unhashed_leaves():
mt = MerkleTools()
mt.add_leaf('a', True)
mt.add_leaf('b', True)
mt.add_leaf('c', True)
mt.add_leaf('d', True)
mt.add_leaf('e', True)
mt.make_tree()
assert mt.get_merkle_root(
) == 'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba'
mt.reset_tree()
mt.add_leaf(['a', 'b', 'c', 'd', 'e'], True)
mt.make_tree()
assert mt.get_merkle_root(
) == 'd71f8983ad4ee170f8129f1ebcdd7440be7798d8e1c80420bf11f1eced610dba'
