def test_hash_leaves_false(self):
leaves = [1, 2, 3, 4]
prehashed_leaves = list(map(MerkleTree.hash, leaves))
merk_from_leaves = MerkleTree(leaves=leaves)
merk_from_hashes = MerkleTree(leaves=prehashed_leaves, hash_leaves=False)
for node1, node2 in zip(merk_from_hashes.nodes, merk_from_leaves.nodes):
self.assertEqual(node1, node2)
def test_verify_tree_from_hex_str_invalid(self):
raw_leaves = [secrets.token_bytes(16) for _ in range(16)]
random_hash = MerkleTree.hash(secrets.token_bytes(16))
m = MerkleTree(raw_leaves)
self.assertFalse(MerkleTree.verify_tree_from_hex_str(m.leaves_as_concat_hex_str, random_hash))
def test_from_leaves_hex_str(self):
leaves = [1, 2, 3, 4]
m_from_init = MerkleTree(leaves)
m_from_hex_str = MerkleTree.from_leaves_hex_str(m_from_init.leaves_as_concat_hex_str)
self.assertEqual(m_from_hex_str.root, m_from_init.root)
def enter_any(self, prev_state):
assert self.parent.interpreter.queue_size > 0, "Entered consensus state, but interpreter queue is empty!"
# Merkle-ize transaction queue and create signed merkle hash
all_tx = self.parent.interpreter.queue_binary
self.log.info(
"Delegate got tx from interpreter queue: {}".format(all_tx))
self.merkle = MerkleTree(all_tx)
self.merkle_hash = self.merkle.hash_of_nodes()
self.log.info("Delegate got merkle hash {}".format(self.merkle_hash))
self.signature = ED25519Wallet.sign(self.parent.signing_key,
self.merkle_hash)
# Create merkle signature message and publish it
merkle_sig = MerkleSignature.create(sig_hex=self.signature,
timestamp='now',
sender=self.parent.verifying_key)
self.log.info("Broadcasting signature {}".format(self.signature))
self.parent.composer.send_pub_msg(
filter=Constants.ZmqFilters.DelegateDelegate, message=merkle_sig)
# Now that we've computed/composed the merkle tree hash, validate all our pending signatures
for sig in [
s for s in self.parent.pending_sigs if self.validate_sig(s)
]:
self.signatures.append(sig)
self.check_majority()
def test_leaves_as_hex_str(self):
leaves = [1, 2, 3, 4]
hashed_leaves = [MerkleTree.hash(leaf).hex() for leaf in leaves]
hex_leaves = ''.join(hashed_leaves)
m = MerkleTree(leaves)
self.assertEqual(hex_leaves, m.leaves_as_concat_hex_str)
def test_leaves_as_hex(self):
leaves = [1, 2, 3, 4]
hashed_leaves = [MerkleTree.hash(leaf).hex() for leaf in leaves]
m = MerkleTree(leaves)
for actual, expected in zip(m.leaves_as_hex, hashed_leaves):
self.assertEqual(actual, expected)
def test_verify_tree_from_hex_str(self):
raw_leaves = [secrets.token_bytes(16) for _ in range(16)]
m = MerkleTree(raw_leaves)
self.assertTrue(
MerkleTree.verify_tree_from_hex_str(m.leaves_as_concat_hex_str,
m.root_as_hex))
def test_verify_tree(self):
raw_leaves = [secrets.token_bytes(16) for _ in range(16)]
m = MerkleTree(raw_leaves)
tree_nodes = m.nodes[len(m.nodes) // 2:]
tree_hash = m.hash_of_nodes()
self.assertTrue(MerkleTree.verify_tree(tree_nodes, tree_hash))
def build_test_contender(tree: MerkleTree=None):
"""
Method to build a 'test' block contender. Used exclusively in unit tests.
"""
if not tree:
nodes = [1, 2, 3, 4]
tree = MerkleTree(leaves=nodes)
sigs = [build_test_merkle_sig(msg=tree.root) for _ in range(8)]
return BlockContender.create(signatures=sigs, merkle_leaves=tree.leaves_as_hex)
def test_verify_tree_invalid(self):
raw_leaves = [secrets.token_bytes(16) for _ in range(16)]
m = MerkleTree(raw_leaves)
# Set the last leaf to a random value obviously different then whatever was used to build the tree
# this should cause validation to fail
bad_leaves = m.leaves
bad_leaves[-1] = secrets.token_bytes(16)
self.assertFalse(MerkleTree.verify_tree(bad_leaves, m.root))
def test_make_merkle_works(self):
leaves = [1, 2, 3, 4]
test_merkle = [
None, None, None,
MerkleTree.hash(1),
MerkleTree.hash(2),
MerkleTree.hash(3),
MerkleTree.hash(4)
]
test_merkle[2] = MerkleTree.hash(test_merkle[-2] + test_merkle[-1])
test_merkle[1] = MerkleTree.hash(test_merkle[3] + test_merkle[4])
test_merkle[0] = MerkleTree.hash(test_merkle[1] + test_merkle[2])
m = MerkleTree(leaves)
self.assertEqual(test_merkle, m.nodes)
def test_make_merkle_works(self):
# create a merkle tree that should be
leaves = [1, 2, 3, 4]
test_merkle = [None,
None,
None,
MerkleTree.hash(bytes(1)),
MerkleTree.hash(bytes(2)),
MerkleTree.hash(bytes(3)),
MerkleTree.hash(bytes(4))]
test_merkle[2] = MerkleTree.hash(test_merkle[-2] + test_merkle[-1])
test_merkle[1] = MerkleTree.hash(test_merkle[3] + test_merkle[4])
test_merkle[0] = MerkleTree.hash(test_merkle[1] + test_merkle[2])
m = MerkleTree(leaves)
self.assertEqual(test_merkle, m.nodes)
def test_root_as_hex(self):
leaves = [1, 2, 3, 4]
test_merkle = [
None, None, None,
MerkleTree.hash(1),
MerkleTree.hash(2),
MerkleTree.hash(3),
MerkleTree.hash(4)
]
test_merkle[2] = MerkleTree.hash(test_merkle[-2] + test_merkle[-1])
test_merkle[1] = MerkleTree.hash(test_merkle[3] + test_merkle[4])
test_merkle[0] = MerkleTree.hash(test_merkle[1] + test_merkle[2])
m = MerkleTree(leaves)
self.assertEqual(m.root, test_merkle[0])
self.assertEqual(m.root_as_hex, test_merkle[0].hex())
def build_test_contender(tree: MerkleTree = None, prev_block_hash=''):
"""
Method to build a 'test' block contender. Used exclusively in unit tests.
"""
from cilantro.storage.blocks import BlockStorageDriver
from cilantro.constants.nodes import BLOCK_SIZE
if not tree:
nodes = [str(i).encode() for i in range(BLOCK_SIZE)]
tree = MerkleTree(leaves=nodes)
if not prev_block_hash:
prev_block_hash = BlockStorageDriver.get_latest_block_hash()
sigs = [build_test_merkle_sig(msg=tree.root) for _ in range(8)]
return BlockContender.create(signatures=sigs,
merkle_leaves=tree.leaves_as_hex,
prev_block_hash=prev_block_hash)
def test_find_children(self):
leaves = [1, 2, 3, 4]
test_merkle = [
None, None, None,
MerkleTree.hash(1),
MerkleTree.hash(2),
MerkleTree.hash(3),
MerkleTree.hash(4)
]
test_merkle[2] = MerkleTree.hash(test_merkle[-2] + test_merkle[-1])
test_merkle[1] = MerkleTree.hash(test_merkle[3] + test_merkle[4])
test_merkle[0] = MerkleTree.hash(test_merkle[1] + test_merkle[2])
m = MerkleTree(leaves)
self.assertEqual(m.children(0), [test_merkle[1], test_merkle[2]])
self.assertEqual(m.children(1), [test_merkle[3], test_merkle[4]])
self.assertEqual(m.children(2), [test_merkle[5], test_merkle[6]])
def test_find_root(self):
leaves = [1, 2, 3, 4]
test_merkle = [None,
None,
None,
MerkleTree.hash(bytes(1)),
MerkleTree.hash(bytes(2)),
MerkleTree.hash(bytes(3)),
MerkleTree.hash(bytes(4))]
test_merkle[2] = MerkleTree.hash(test_merkle[-2] + test_merkle[-1])
test_merkle[1] = MerkleTree.hash(test_merkle[3] + test_merkle[4])
test_merkle[0] = MerkleTree.hash(test_merkle[1] + test_merkle[2])
m = MerkleTree(leaves)
self.assertEqual(m.root(2), test_merkle[0])
self.assertEqual(m.root(4), test_merkle[1])
self.assertEqual(m.root(), test_merkle[0])
def test_verify_tree(self):
raw_leaves = [secrets.token_bytes(16) for _ in range(16)]
m = MerkleTree(raw_leaves)
self.assertTrue(MerkleTree.verify_tree(m.leaves, m.root))
def test_construction_1(self):
should_be = [None, None, None, 1, 2, 3, 4]
m = MerkleTree([1, 2, 3, 4])
self.assertEqual(len(should_be), len(m.nodes))
def __init__(self, txs, last_block):
self.merkle_tree = MerkleTree(txs)
self.last_block = last_block
self.hash = self.merkle_tree.parent()