def test_proof_serialize_deserialize(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) keys = { k.encode(): [ rlp_encode([v]), ] for k, v in [('k1', 'v1'), ('k2', 'v2'), ('k35', 'v55'), ('k70', 'v99')] } for k, v in keys.items(): node_trie.update(k, v[0]) for k in keys: keys[k].append(node_trie.generate_state_proof(k, serialize=True)) for k in keys: prf = keys[k][1] assert isinstance(prf, bytes) assert client_trie.verify_spv_proof(node_trie.root_hash, k, keys[k][0], prf, serialized=True)
def test_proof_prefix_only_prefix_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcdefgh' keys_suffices = set() while len(keys_suffices) != 20: keys_suffices.add(randint(25, 25000)) key_vals = {'{}{}'.format(prefix, k): str(randint(3000, 5000)) for k in keys_suffices} for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) proof_nodes, val = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=True) encoded = {k.encode(): rlp_encode([v]) for k, v in key_vals.items()} # Check returned values match the actual values assert encoded == val assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Check without value proof_nodes = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=False) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes)
def test_proof_prefix_only_prefix_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcdefgh' keys_suffices = set() while len(keys_suffices) != 20: keys_suffices.add(randint(25, 25000)) key_vals = { '{}{}'.format(prefix, k): str(randint(3000, 5000)) for k in keys_suffices } for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) proof_nodes, val = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=True) encoded = {k.encode(): rlp_encode([v]) for k, v in key_vals.items()} # Check returned values match the actual values assert encoded == val assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Check without value proof_nodes = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=False) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes)
def test_proof_specific_root(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) kvs = OrderedDict({'k1': 'v1', 'k2': 'v2', 'x3': 'v3', 'x4': 'v5', 'x5': 'v7', 'y99': 'v6'}) size = len(kvs) # Only add some keys old_keys = set() i = 0 for k, v in kvs.items(): node_trie.update(k.encode(), rlp_encode([v])) old_keys.add(k) i += 1 if i >= size // 2: break # Record the root root_hash_0 = node_trie.root_hash root_node_0 = deepcopy(node_trie.root_node) # Add remaining keys new_keys = set() i = 0 for k, v in reversed(kvs.items()): node_trie.update(k.encode(), rlp_encode([v])) new_keys.add(k) i += 1 if i >= size // 2: break # Record new roots root_hash_1 = node_trie.root_hash root_node_1 = deepcopy(node_trie.root_node) # Check each root present for k, v in kvs.items(): assert node_trie.get(k.encode()) == rlp_encode([v]) # Old and new roots should be different assert root_hash_0 != root_hash_1 assert root_node_0 != root_node_1 # Generate and verify proof for both old (if key was present) and new roots for k, v in kvs.items(): k, v = k.encode(), rlp_encode([v]) if k in old_keys: old_root_proof = node_trie.generate_state_proof(k, root=root_node_0) assert client_trie.verify_spv_proof(root_hash_0, k, v, old_root_proof) new_root_proof = node_trie.generate_state_proof(k, root=root_node_1) assert client_trie.verify_spv_proof(root_hash_1, k, v, new_root_proof)
def test_proof_specific_root(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) kvs = OrderedDict({'k1': 'v1', 'k2': 'v2', 'x3': 'v3', 'x4': 'v5', 'x5': 'v7', 'y99': 'v6'}) size = len(kvs) # Only add some keys old_keys = set() i = 0 for k, v in kvs.items(): node_trie.update(k.encode(), rlp_encode([v])) old_keys.add(k) i += 1 if i >= size // 2: break # Record the root root_hash_0 = node_trie.root_hash root_node_0 = deepcopy(node_trie.root_node) # Add remaining keys new_keys = set() i = 0 for k, v in reversed(kvs.items()): node_trie.update(k.encode(), rlp_encode([v])) new_keys.add(k) i += 1 if i >= size // 2: break # Record new roots root_hash_1 = node_trie.root_hash root_node_1 = deepcopy(node_trie.root_node) # Check each root present for k, v in kvs.items(): assert node_trie.get(k.encode()) == rlp_encode([v]) # Old and new roots should be different assert root_hash_0 != root_hash_1 assert root_node_0 != root_node_1 # Generate and verify proof for both old (if key was present) and new roots for k, v in kvs.items(): k, v = k.encode(), rlp_encode([v]) if k in old_keys: old_root_proof = node_trie.generate_state_proof(k, root=root_node_0) assert client_trie.verify_spv_proof(root_hash_0, k, v, old_root_proof) new_root_proof = node_trie.generate_state_proof(k, root=root_node_1) assert client_trie.verify_spv_proof(root_hash_1, k, v, new_root_proof)
def test_get_proof_and_value(): # Non prefix nodes num_keys = 100 test_data = gen_test_data(num_keys) node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) for k, v in test_data.items(): node_trie.update(k, v) for k in test_data: proof, v = node_trie.produce_spv_proof(k, get_value=True) proof.append(deepcopy(node_trie.root_node)) assert v == test_data[k] assert client_trie.verify_spv_proof(node_trie.root_hash, k, v, proof)
def test_get_proof_and_value(): # Non prefix nodes num_keys = 100 test_data = gen_test_data(num_keys) node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) for k, v in test_data.items(): node_trie.update(k, v) for k in test_data: proof, v = node_trie.produce_spv_proof(k, get_value=True) proof.append(deepcopy(node_trie.root_node)) assert v == test_data[k] assert client_trie.verify_spv_proof(node_trie.root_hash, k, v, proof)
def test_proof_serialize_deserialize(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) keys = {k.encode(): [rlp_encode([v]), ] for k, v in [('k1', 'v1'), ('k2', 'v2'), ('k35', 'v55'), ('k70', 'v99')]} for k, v in keys.items(): node_trie.update(k, v[0]) for k in keys: keys[k].append(node_trie.generate_state_proof(k, serialize=True)) for k in keys: prf = keys[k][1] assert isinstance(prf, bytes) assert client_trie.verify_spv_proof(node_trie.root_hash, k, keys[k][0], prf, serialized=True)
def test_verify_proof_random_data(): """ Add some key value pairs in trie. Generate and verify proof for them. :return: """ num_keys = 100 test_data = gen_test_data(num_keys) partitions = 4 partition_size = num_keys // partitions keys = [ list(list(test_data.keys())[i:i + partition_size]) for i in range(0, len(test_data), partition_size) ] node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) root_hashes = [] proofs = [] for i in range(0, partitions): for k in keys[i]: node_trie.update(k, test_data[k]) root_hashes.append(node_trie.root_hash) proofs.append({k: node_trie.generate_state_proof(k) for k in keys[i]}) assert all([ client_trie.verify_spv_proof(root_hashes[i], k, test_data[k], proofs[i][k]) for k in keys[i] ]) # Pick any keys from any partition and verify the already generated proof for _ in range(400): p = randint(0, partitions - 1) key = choice(keys[p]) assert client_trie.verify_spv_proof(root_hashes[p], key, test_data[key], proofs[p][key]) # Pick any key randomly, generate new proof corresponding to current root # and verify proof all_keys = [k for i in keys for k in i] root_hash = node_trie.root_hash for _ in range(400): key = choice(all_keys) proof = node_trie.generate_state_proof(key) assert client_trie.verify_spv_proof(root_hash, key, test_data[key], proof)
def test_proof_prefix_only_prefix_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcdefgh' keys_suffices = set() while len(keys_suffices) != 20: keys_suffices.add(randint(25, 25000)) key_vals = {'{}{}'.format(prefix, k): str(randint(3000, 5000)) for k in keys_suffices} for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) proof_nodes = node_trie.generate_state_proof_for_key_prfx(prefix.encode()) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, {k.encode(): rlp_encode([v]) for k, v in key_vals.items()}, proof_nodes)
def test_verify_proof_random_data(): """ Add some key value pairs in trie. Generate and verify proof for them. :return: """ num_keys = 100 test_data = gen_test_data(num_keys) partitions = 4 partition_size = num_keys // partitions keys = [list(list(test_data.keys())[i:i + partition_size]) for i in range(0, len(test_data), partition_size)] node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) root_hashes = [] proofs = [] for i in range(0, partitions): for k in keys[i]: node_trie.update(k, test_data[k]) root_hashes.append(node_trie.root_hash) proofs.append({k: node_trie.generate_state_proof(k) for k in keys[i]}) assert all([client_trie.verify_spv_proof(root_hashes[i], k, test_data[k], proofs[i][k]) for k in keys[i]]) # Pick any keys from any partition and verify the already generated proof for _ in range(400): p = randint(0, partitions - 1) key = choice(keys[p]) assert client_trie.verify_spv_proof(root_hashes[p], key, test_data[key], proofs[p][key]) # Pick any key randomly, generate new proof corresponding to current root # and verify proof all_keys = [k for i in keys for k in i] root_hash = node_trie.root_hash for _ in range(400): key = choice(all_keys) proof = node_trie.generate_state_proof(key) assert client_trie.verify_spv_proof(root_hash, key, test_data[key], proof)
def test_proof_specific_root(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) node_trie.update('k1'.encode(), rlp_encode(['v1'])) node_trie.update('k2'.encode(), rlp_encode(['v2'])) node_trie.update('x3'.encode(), rlp_encode(['v3'])) root_hash_0 = node_trie.root_hash root_node_0 = node_trie.root_node node_trie.update('x4'.encode(), rlp_encode(['v5'])) node_trie.update('y99'.encode(), rlp_encode(['v6'])) node_trie.update('x5'.encode(), rlp_encode(['v7'])) # root_hash_1 = node_trie.root_hash # root_node_1 = node_trie.root_node k, v = 'k1'.encode(), rlp_encode(['v1']) old_root_proof = node_trie.generate_state_proof(k, root=root_node_0) assert client_trie.verify_spv_proof(root_hash_0, k, v, old_root_proof)
def test_proof_multiple_prefix_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix_1 = 'abcdefgh' prefix_2 = 'abcdefxy' # Prefix overlaps with previous prefix_3 = 'pqrstuvw' prefix_4 = 'mnoptuvw' # Suffix overlaps all_prefixes = (prefix_1, prefix_2, prefix_3, prefix_4) other_nodes_count = 1000 prefix_nodes_count = 100 # Some nodes before prefix nodes for _ in range(other_nodes_count): k, v = randomString(randint(8, 19)).encode(), rlp_encode( [randomString(15)]) node_trie.update(k, v) keys_suffices = set() while len(keys_suffices) != prefix_nodes_count: keys_suffices.add(randint(25, 250000)) key_vals = { '{}{}'.format(prefix, k): str(randint(3000, 5000)) for prefix in all_prefixes for k in keys_suffices } for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) # Some nodes after prefix nodes for _ in range(other_nodes_count): node_trie.update( randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)])) for prefix in all_prefixes: client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) proof_nodes, val = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=True) encoded = { k.encode(): rlp_encode([v]) for k, v in key_vals.items() if k.startswith(prefix) } # Check returned values match the actual values assert encoded == val assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Check without value proof_nodes = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=False) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Verify keys with a different prefix encoded = { k.encode(): rlp_encode([v]) for k, v in key_vals.items() if not k.startswith(prefix) } assert not client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes)
def test_get_prefix_nodes(): trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcd' prefix_nibbles = bin_to_nibbles(to_string(prefix)) key1 = prefix + '1' key2 = prefix + '2' key3 = prefix + '3' trie.update(key1.encode(), rlp_encode(['v1'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles) # The last node should be a leaf since only 1 key assert trie._get_node_type(last_node) == NODE_TYPE_LEAF # The queried key is larger than prefix, results in blank node last_node_ = trie._get_last_node_for_prfx( trie.root_node, bin_to_nibbles(to_string(prefix + '5'))) assert last_node_ == BLANK_NODE trie.update(key2.encode(), rlp_encode(['v2'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles) # The last node should be an extension since more than 1 key assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION trie.update(key3.encode(), rlp_encode(['v3'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles) assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION last_node_key = without_terminator(unpack_to_nibbles(last_node[0])) # Key for the fetched prefix nodes (ignore last nibble) is same as prefix nibbles assert last_node_key[:-1] == prefix_nibbles # The extension node is correctly decoded. decoded_extension = trie._decode_to_node(last_node[1]) assert decoded_extension[1] == [b' ', rlp_encode(['v1'])] assert decoded_extension[2] == [b' ', rlp_encode(['v2'])] assert decoded_extension[3] == [b' ', rlp_encode(['v3'])]
def test_verify_proof(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) node_trie.update('k1'.encode(), rlp_encode(['v1'])) node_trie.update('k2'.encode(), rlp_encode(['v2'])) root_hash_0 = node_trie.root_hash p0 = node_trie.produce_spv_proof('k2'.encode()) p0.append(deepcopy(node_trie.root_node)) p00 = deepcopy(p0) assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0) assert p00 == p0 node_trie.update('k3'.encode(), rlp_encode(['v3'])) node_trie.update('k4'.encode(), rlp_encode(['v4'])) node_trie.update('x1'.encode(), rlp_encode(['y1'])) node_trie.update('x2'.encode(), rlp_encode(['y2'])) root_hash_1 = node_trie.root_hash # Generate 1 proof and then verify that proof p1 = node_trie.produce_spv_proof('k1'.encode()) p1.append(node_trie.root_node) assert client_trie.verify_spv_proof(root_hash_1, 'k1'.encode(), rlp_encode(['v1']), p1) p2 = node_trie.produce_spv_proof('x2'.encode()) p2.append(node_trie.root_node) assert client_trie.verify_spv_proof(root_hash_1, 'x2'.encode(), rlp_encode(['y2']), p2) # Generate more than 1 proof and then verify all proofs p3 = node_trie.produce_spv_proof('k3'.encode()) p3.append(node_trie.root_node) p4 = node_trie.produce_spv_proof('x1'.encode()) p4.append(node_trie.root_node) assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y1']), p4) # Proof is correct but value is different assert not client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y99']), p4) # Verify same proof again assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert p00 == p0 assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0)
def test_verify_proof(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) node_trie.update('k1'.encode(), rlp_encode(['v1'])) node_trie.update('k2'.encode(), rlp_encode(['v2'])) root_hash_0 = node_trie.root_hash p0 = node_trie.produce_spv_proof('k2'.encode()) p0.append(deepcopy(node_trie.root_node)) p00 = deepcopy(p0) assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0) assert p00 == p0 node_trie.update('k3'.encode(), rlp_encode(['v3'])) node_trie.update('k4'.encode(), rlp_encode(['v4'])) node_trie.update('x1'.encode(), rlp_encode(['y1'])) node_trie.update('x2'.encode(), rlp_encode(['y2'])) root_hash_1 = node_trie.root_hash # Generate 1 proof and then verify that proof p1 = node_trie.produce_spv_proof('k1'.encode()) p1.append(node_trie.root_node) assert client_trie.verify_spv_proof(root_hash_1, 'k1'.encode(), rlp_encode(['v1']), p1) p2 = node_trie.produce_spv_proof('x2'.encode()) p2.append(node_trie.root_node) assert client_trie.verify_spv_proof(root_hash_1, 'x2'.encode(), rlp_encode(['y2']), p2) # Generate more than 1 proof and then verify all proofs p3 = node_trie.produce_spv_proof('k3'.encode()) p3.append(node_trie.root_node) p4 = node_trie.produce_spv_proof('x1'.encode()) p4.append(node_trie.root_node) assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y1']), p4) # Proof is correct but value is different assert not client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y99']), p4) # Verify same proof again assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert p00 == p0 assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0)
def test_verify_proof_generated_using_helper(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) node_trie.update('k1'.encode(), rlp_encode(['v1'])) node_trie.update('k2'.encode(), rlp_encode(['v2'])) root_hash_0 = node_trie.root_hash p0 = node_trie.generate_state_proof('k2'.encode()) assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0) node_trie.update('k3'.encode(), rlp_encode(['v3'])) node_trie.update('k4'.encode(), rlp_encode(['v4'])) node_trie.update('x1'.encode(), rlp_encode(['y1'])) node_trie.update('x2'.encode(), rlp_encode(['y2'])) root_hash_1 = node_trie.root_hash # Generate 1 proof and then verify that proof p1 = node_trie.generate_state_proof('k1'.encode()) assert client_trie.verify_spv_proof(root_hash_1, 'k1'.encode(), rlp_encode(['v1']), p1) p2 = node_trie.generate_state_proof('x2'.encode()) assert client_trie.verify_spv_proof(root_hash_1, 'x2'.encode(), rlp_encode(['y2']), p2) # Generate more than 1 proof and then verify all proofs p3 = node_trie.generate_state_proof('k3'.encode()) p4 = node_trie.generate_state_proof('x1'.encode()) assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y1']), p4) # Proof is correct but value is different assert not client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y99']), p4) # Verify same proof again assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0) # Proof generated using non-existent key fails verification p5 = node_trie.generate_state_proof('x909'.encode()) assert not client_trie.verify_spv_proof(root_hash_1, 'x909'.encode(), rlp_encode(['y909']), p5)
def test_verify_proof_generated_using_helper(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) node_trie.update('k1'.encode(), rlp_encode(['v1'])) node_trie.update('k2'.encode(), rlp_encode(['v2'])) root_hash_0 = node_trie.root_hash p0 = node_trie.generate_state_proof('k2'.encode()) assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0) node_trie.update('k3'.encode(), rlp_encode(['v3'])) node_trie.update('k4'.encode(), rlp_encode(['v4'])) node_trie.update('x1'.encode(), rlp_encode(['y1'])) node_trie.update('x2'.encode(), rlp_encode(['y2'])) root_hash_1 = node_trie.root_hash # Generate 1 proof and then verify that proof p1 = node_trie.generate_state_proof('k1'.encode()) assert client_trie.verify_spv_proof(root_hash_1, 'k1'.encode(), rlp_encode(['v1']), p1) p2 = node_trie.generate_state_proof('x2'.encode()) assert client_trie.verify_spv_proof(root_hash_1, 'x2'.encode(), rlp_encode(['y2']), p2) # Generate more than 1 proof and then verify all proofs p3 = node_trie.generate_state_proof('k3'.encode()) p4 = node_trie.generate_state_proof('x1'.encode()) assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y1']), p4) # Proof is correct but value is different assert not client_trie.verify_spv_proof(root_hash_1, 'x1'.encode(), rlp_encode(['y99']), p4) # Verify same proof again assert client_trie.verify_spv_proof(root_hash_1, 'k3'.encode(), rlp_encode(['v3']), p3) assert client_trie.verify_spv_proof(root_hash_0, 'k2'.encode(), rlp_encode(['v2']), p0) # Proof generated using non-existent key fails verification p5 = node_trie.generate_state_proof('x909'.encode()) assert not client_trie.verify_spv_proof(root_hash_1, 'x909'.encode(), rlp_encode(['y909']), p5)
def test_proof_prefix_with_other_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcdefgh' other_nodes_count = 1000 prefix_nodes_count = 100 # Some nodes before prefix node for _ in range(other_nodes_count): node_trie.update( randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)])) keys_suffices = set() while len(keys_suffices) != prefix_nodes_count: keys_suffices.add(randint(25, 250000)) key_vals = { '{}{}'.format(prefix, k): str(randint(3000, 5000)) for k in keys_suffices } for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) # Some nodes after prefix node for _ in range(other_nodes_count): node_trie.update( randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)])) proof_nodes, val = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=True) encoded = {k.encode(): rlp_encode([v]) for k, v in key_vals.items()} # Check returned values match the actual values assert encoded == val assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Check without value proof_nodes = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=False) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Change value of one of any random key encoded_new = deepcopy(encoded) random_key = next(iter(encoded_new.keys())) encoded_new[random_key] = rlp_encode( [rlp_decode(encoded_new[random_key])[0] + b'2212']) assert not client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded_new, proof_nodes)
def test_proof_multiple_prefix_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix_1 = 'abcdefgh' prefix_2 = 'abcdefxy' # Prefix overlaps with previous prefix_3 = 'pqrstuvw' prefix_4 = 'mnoptuvw' # Suffix overlaps all_prefixes = (prefix_1, prefix_2, prefix_3, prefix_4) other_nodes_count = 1000 prefix_nodes_count = 100 # Some nodes before prefix nodes for _ in range(other_nodes_count): k, v = randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)]) node_trie.update(k, v) keys_suffices = set() while len(keys_suffices) != prefix_nodes_count: keys_suffices.add(randint(25, 250000)) key_vals = {'{}{}'.format(prefix, k): str(randint(3000, 5000)) for prefix in all_prefixes for k in keys_suffices} for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) # Some nodes after prefix nodes for _ in range(other_nodes_count): node_trie.update(randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)])) for prefix in all_prefixes: client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) proof_nodes, val = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=True) encoded = {k.encode(): rlp_encode([v]) for k, v in key_vals.items() if k.startswith(prefix)} # Check returned values match the actual values assert encoded == val assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Check without value proof_nodes = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=False) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Verify keys with a different prefix encoded = {k.encode(): rlp_encode([v]) for k, v in key_vals.items() if not k.startswith(prefix)} assert not client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes)
def test_proof_prefix_with_other_nodes(): node_trie = Trie(PersistentDB(KeyValueStorageInMemory())) client_trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcdefgh' other_nodes_count = 1000 prefix_nodes_count = 100 # Some nodes before prefix node for _ in range(other_nodes_count): node_trie.update(randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)])) keys_suffices = set() while len(keys_suffices) != prefix_nodes_count: keys_suffices.add(randint(25, 250000)) key_vals = {'{}{}'.format(prefix, k): str(randint(3000, 5000)) for k in keys_suffices} for k, v in key_vals.items(): node_trie.update(k.encode(), rlp_encode([v])) # Some nodes after prefix node for _ in range(other_nodes_count): node_trie.update(randomString(randint(8, 19)).encode(), rlp_encode([randomString(15)])) proof_nodes, val = node_trie.generate_state_proof_for_keys_with_prefix(prefix.encode(), get_value=True) encoded = {k.encode(): rlp_encode([v]) for k, v in key_vals.items()} # Check returned values match the actual values assert encoded == val assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Check without value proof_nodes = node_trie.generate_state_proof_for_keys_with_prefix( prefix.encode(), get_value=False) assert client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded, proof_nodes) # Change value of one of any random key encoded_new = deepcopy(encoded) random_key = next(iter(encoded_new.keys())) encoded_new[random_key] = rlp_encode([rlp_decode(encoded_new[random_key])[0] + b'2212']) assert not client_trie.verify_spv_proof_multi(node_trie.root_hash, encoded_new, proof_nodes)
def test_get_prefix_nodes(): trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcd' prefix_nibbles = bin_to_nibbles(prefix) key1 = prefix + '1' key2 = prefix + '2' key3 = prefix + '3' trie.update(key1.encode(), rlp_encode(['v1'])) seen_prefix = [] last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles, seen_prfx=seen_prefix) # The last node should be a leaf since only 1 key assert trie._get_node_type(last_node) == NODE_TYPE_LEAF # Seen prefix matches the prefix exactly assert seen_prefix == [] # The queried key is larger than prefix, results in blank node last_node_ = trie._get_last_node_for_prfx(trie.root_node, bin_to_nibbles(prefix + '5'), []) assert last_node_ == BLANK_NODE seen_prefix = [] trie.update(key2.encode(), rlp_encode(['v2'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles, seen_prfx=seen_prefix) # The last node should be an extension since more than 1 key assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION assert seen_prefix == [] seen_prefix = [] trie.update(key3.encode(), rlp_encode(['v3'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles, seen_prfx=seen_prefix) assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION assert seen_prefix == [] last_node_key = without_terminator(unpack_to_nibbles(last_node[0])) # Key for the fetched prefix nodes (ignore last nibble) is same as prefix nibbles assert last_node_key[:-1] == prefix_nibbles # The extension node is correctly decoded. decoded_extension = trie._decode_to_node(last_node[1]) assert decoded_extension[1] == [b' ', rlp_encode(['v1'])] assert decoded_extension[2] == [b' ', rlp_encode(['v2'])] assert decoded_extension[3] == [b' ', rlp_encode(['v3'])] # Add keys with extended prefix extended_prefix = '1' key4 = prefix + extended_prefix + '85' trie.update(key4.encode(), rlp_encode(['v11'])) key5 = prefix + extended_prefix + '96' trie.update(key5.encode(), rlp_encode(['v12'])) seen_prefix = [] new_prefix_nibbs = bin_to_nibbles(prefix + extended_prefix) last_node = trie._get_last_node_for_prfx(trie.root_node, new_prefix_nibbs, seen_prfx=seen_prefix) assert trie._get_node_type(last_node) == NODE_TYPE_BRANCH assert new_prefix_nibbs == seen_prefix assert seen_prefix == bin_to_nibbles(prefix + '1') # traverse to the next node remaining_key4_nibbs = bin_to_nibbles(key4)[len(seen_prefix):] remaining_key5_nibbs = bin_to_nibbles(key5)[len(seen_prefix):] next_nibble = remaining_key4_nibbs[0] if remaining_key4_nibbs[ 0] > remaining_key5_nibbs[0] else remaining_key5_nibbs[0] next_node = trie._decode_to_node(last_node[next_nibble]) assert trie._get_node_type(next_node) == NODE_TYPE_BRANCH # The 8th index should lead to a node with key '5', key4 ended in '85' assert trie._get_node_type(next_node[8]) == NODE_TYPE_LEAF assert without_terminator(unpack_to_nibbles( next_node[8][0])) == bin_to_nibbles('5') # The 9th index should lead to a node with key '6', key5 ended in '96' assert trie._get_node_type(next_node[9]) == NODE_TYPE_LEAF assert without_terminator(unpack_to_nibbles( next_node[9][0])) == bin_to_nibbles('6') prefix_1 = prefix + 'efgh' prefix_1_nibbles = bin_to_nibbles(prefix_1) key1 = prefix_1 + '1' key2 = prefix_1 + '2' key3 = prefix_1 + '3' trie.update(key1.encode(), rlp_encode(['v1'])) trie.update(key2.encode(), rlp_encode(['v1'])) trie.update(key3.encode(), rlp_encode(['v1'])) seen_prefix = [] last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_1_nibbles, seen_prfx=seen_prefix) assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION assert len(seen_prefix) > 0 assert starts_with(prefix_1_nibbles, seen_prefix)
class PruningState(State): """ This class is used to store the committed root hash of the trie in the db. The committed root hash is only updated once a batch gets written to the ledger. It might happen that a few batches are in 3 phase commit and the node crashes. Now when the node restarts, it restores the db from the committed root hash and all entries for uncommitted batches will be ignored """ # SOME KEY THAT DOES NOT COLLIDE WITH ANY STATE VARIABLE'S NAME rootHashKey = b'\x88\xc8\x88 \x9a\xa7\x89\x1b' def __init__(self, keyValueStorage: KeyValueStorage): self._kv = keyValueStorage if self.rootHashKey in self._kv: rootHash = bytes(self._kv.get(self.rootHashKey)) else: rootHash = BLANK_ROOT self._kv.put(self.rootHashKey, BLANK_ROOT) self._trie = Trie(PersistentDB(self._kv), rootHash) @property def head(self): # The current head of the state, if the state is a merkle tree then # head is the root return self._trie.root_node @property def committedHead(self): # The committed head of the state, if the state is a merkle tree then # head is the root return self._hash_to_node(self.committedHeadHash) def get_head_by_hash(self, root_hash): # return node of a merkle tree by given hash return self._hash_to_node(root_hash) def _hash_to_node(self, node_hash): if node_hash == BLANK_ROOT: return BLANK_NODE return self._trie._decode_to_node(node_hash) def set(self, key: bytes, value: bytes): self._trie.update(key, rlp_encode([value])) def get(self, key: bytes, isCommitted: bool = True) -> Optional[bytes]: if not isCommitted: val = self._trie.get(key) else: val = self._trie._get(self.committedHead, bin_to_nibbles(to_string(key))) if val: return self.get_decoded(val) def get_for_root_hash(self, root_hash, key: bytes) -> Optional[bytes]: root = self._hash_to_node(root_hash) val = self._trie._get(root, bin_to_nibbles(to_string(key))) if val: return self.get_decoded(val) def get_all_leaves_for_root_hash(self, root_hash): node = self._hash_to_node(root_hash) leaves = self._trie.to_dict(node) return leaves def remove(self, key: bytes): self._trie.delete(key) def commit(self, rootHash=None, rootNode=None): if rootNode: rootHash = self._trie._encode_node(rootNode) elif rootHash and isHex(rootHash): if isinstance(rootHash, str): rootHash = rootHash.encode() rootHash = unhexlify(rootHash) elif rootHash: rootHash = rootHash else: rootHash = self.headHash self._kv.put(self.rootHashKey, rootHash) def revertToHead(self, headHash=None): head = self._hash_to_node(headHash) self._trie.replace_root_hash(self._trie.root_node, head) # Proofs are always generated over committed state def generate_state_proof(self, key: bytes, root=None, serialize=False, get_value=False): return self._trie.generate_state_proof(key, root, serialize, get_value=get_value) def generate_state_proof_for_keys_with_prefix(self, key_prfx, root=None, serialize=False, get_value=False): return self._trie.generate_state_proof_for_keys_with_prefix( key_prfx, root, serialize, get_value=get_value) @staticmethod def verify_state_proof(root, key, value, proof_nodes, serialized=False): encoded_key, encoded_value = PruningState.encode_kv_for_verification( key, value) return Trie.verify_spv_proof(root, encoded_key, encoded_value, proof_nodes, serialized) @staticmethod def verify_state_proof_multi(root, key_values, proof_nodes, serialized=False): encoded_key_values = dict( PruningState.encode_kv_for_verification(k, v) for k, v in key_values.items()) return Trie.verify_spv_proof_multi(root, encoded_key_values, proof_nodes, serialized) @staticmethod def encode_kv_for_verification(key, value): encoded_key = key.encode() if isinstance(key, str) else key encoded_value = rlp_encode([value]) if value is not None else b'' return encoded_key, encoded_value @property def as_dict(self): d = self._trie.to_dict() return {k: self.get_decoded(v) for k, v in d.items()} @property def headHash(self): """ The hash of the current head of the state, if the state is a merkle tree then hash of the root :return: """ return self._trie.root_hash @property def committedHeadHash(self): return self._kv.get(self.rootHashKey) @property def closed(self): return not self._kv or self._kv.closed @property def isEmpty(self): return self._kv and self.committedHeadHash == BLANK_ROOT def close(self): if self._kv: self._kv.close() self._kv = None @staticmethod def get_decoded(encoded): return rlp_decode(encoded)[0]
class PruningState(State): # This class is used to store the # committed root hash of the trie in the db. # The committed root hash is only updated once a batch gets written to the # ledger. It might happen that a few batches are in 3 phase commit and the # node crashes. Now when the node restarts, it restores the db from the # committed root hash and all entries for uncommitted batches will be # ignored # some key that does not collide with any state variable's name rootHashKey = b'\x88\xc8\x88 \x9a\xa7\x89\x1b' def __init__(self, keyValueStorage: KeyValueStorage): self._kv = keyValueStorage if self.rootHashKey in self._kv: rootHash = bytes(self._kv.get(self.rootHashKey)) else: rootHash = BLANK_ROOT self._kv.put(self.rootHashKey, BLANK_ROOT) self._trie = Trie(PersistentDB(self._kv), rootHash) @property def head(self): # The current head of the state, if the state is a merkle tree then # head is the root return self._trie.root_node @property def committedHead(self): # The committed head of the state, if the state is a merkle tree then # head is the root if self.committedHeadHash == BLANK_ROOT: return BLANK_NODE else: return self._trie._decode_to_node(self.committedHeadHash) def set(self, key: bytes, value: bytes): self._trie.update(key, rlp_encode([value])) def get(self, key: bytes, isCommitted: bool = True): if not isCommitted: val = self._trie.get(key) else: val = self._trie._get(self.committedHead, bin_to_nibbles(to_string(key))) if val: return rlp_decode(val)[0] def remove(self, key: bytes): self._trie.delete(key) def commit(self, rootHash=None, rootNode=None): if rootNode: rootHash = self._trie._encode_node(rootNode) elif rootHash and isHex(rootHash): if isinstance(rootHash, str): rootHash = rootHash.encode() rootHash = unhexlify(rootHash) elif rootHash: rootHash = rootHash else: rootHash = self.headHash self._kv.put(self.rootHashKey, rootHash) def revertToHead(self, headHash=None): if headHash != BLANK_ROOT: head = self._trie._decode_to_node(headHash) else: head = BLANK_NODE self._trie.replace_root_hash(self._trie.root_node, head) @property def as_dict(self): d = self._trie.to_dict() return {k: rlp_decode(v)[0] for k, v in d.items()} @property def headHash(self): """ The hash of the current head of the state, if the state is a merkle tree then hash of the root :return: """ return self._trie.root_hash @property def committedHeadHash(self): return self._kv.get(self.rootHashKey) @property def isEmpty(self): return self.committedHeadHash == BLANK_ROOT def close(self): if self._kv: self._kv.close() self._kv = None
def test_get_values_at_roots_in_memory(): # Update key with different values but preserve root after each update # Check values of keys with different previous roots and check that they # are correct trie = Trie(PersistentDB(KeyValueStorageInMemory())) trie.update('k1'.encode(), rlp_encode(['v1'])) # print state.root_hash.encode('hex') # print state.root_node val = trie.get('k1') print(rlp_decode(val)) oldroot1 = trie.root_node old_root1_hash = trie.root_hash assert trie._decode_to_node(old_root1_hash) == oldroot1 trie.update('k1'.encode(), rlp_encode(['v1a'])) val = trie.get('k1') assert rlp_decode(val) == [b'v1a', ] # Already saved roots help in getting previous values oldval = trie.get_at(oldroot1, 'k1') assert rlp_decode(oldval) == [b'v1', ] oldroot1a = trie.root_node trie.update('k1'.encode(), rlp_encode([b'v1b'])) val = trie.get('k1') assert rlp_decode(val) == [b'v1b'] oldval = trie.get_at(oldroot1a, 'k1') assert rlp_decode(oldval) == [b'v1a', ] oldval = trie.get_at(oldroot1, 'k1') assert rlp_decode(oldval) == [b'v1', ] oldroot1b = trie.root_node trie.update('k1'.encode(), rlp_encode([b'v1c'])) val = trie.get('k1') assert rlp_decode(val) == [b'v1c', ] oldval = trie.get_at(oldroot1b, 'k1') assert rlp_decode(oldval) == [b'v1b', ] oldval = trie.get_at(oldroot1a, 'k1') assert rlp_decode(oldval) == [b'v1a', ] oldval = trie.get_at(oldroot1, 'k1') assert rlp_decode(oldval) == [b'v1', ] oldroot1c = trie.root_node trie.delete('k1'.encode()) assert trie.get('k1') == BLANK_NODE oldval = trie.get_at(oldroot1c, 'k1') assert rlp_decode(oldval) == [b'v1c', ] oldval = trie.get_at(oldroot1b, 'k1') assert rlp_decode(oldval) == [b'v1b', ] oldval = trie.get_at(oldroot1a, 'k1') assert rlp_decode(oldval) == [b'v1a', ] oldval = trie.get_at(oldroot1, 'k1') assert rlp_decode(oldval) == [b'v1', ] trie.root_node = oldroot1c val = trie.get('k1') assert rlp_decode(val) == [b'v1c', ] trie.root_node = oldroot1 val = trie.get('k1') assert rlp_decode(val) == [b'v1', ]
class PruningState(State): """ This class is used to store the committed root hash of the trie in the db. The committed root hash is only updated once a batch gets written to the ledger. It might happen that a few batches are in 3 phase commit and the node crashes. Now when the node restarts, it restores the db from the committed root hash and all entries for uncommitted batches will be ignored """ # SOME KEY THAT DOES NOT COLLIDE WITH ANY STATE VARIABLE'S NAME rootHashKey = b'\x88\xc8\x88 \x9a\xa7\x89\x1b' def __init__(self, keyValueStorage: KeyValueStorage): self._kv = keyValueStorage if self.rootHashKey in self._kv: rootHash = bytes(self._kv.get(self.rootHashKey)) else: rootHash = BLANK_ROOT self._kv.put(self.rootHashKey, BLANK_ROOT) self._trie = Trie( PersistentDB(self._kv), rootHash) @property def head(self): # The current head of the state, if the state is a merkle tree then # head is the root return self._trie.root_node @property def committedHead(self): # The committed head of the state, if the state is a merkle tree then # head is the root return self._hash_to_node(self.committedHeadHash) def get_head_by_hash(self, root_hash): # return node of a merkle tree by given hash return self._hash_to_node(root_hash) def _hash_to_node(self, node_hash): if node_hash == BLANK_ROOT: return BLANK_NODE return self._trie._decode_to_node(node_hash) def set(self, key: bytes, value: bytes): self._trie.update(key, rlp_encode([value])) def get(self, key: bytes, isCommitted: bool = True) -> Optional[bytes]: if not isCommitted: val = self._trie.get(key) else: val = self._trie._get(self.committedHead, bin_to_nibbles(to_string(key))) if val: return self.get_decoded(val) def get_for_root_hash(self, root_hash, key: bytes) -> Optional[bytes]: root = self._hash_to_node(root_hash) val = self._trie._get(root, bin_to_nibbles(to_string(key))) if val: return self.get_decoded(val) def get_all_leaves_for_root_hash(self, root_hash): node = self._hash_to_node(root_hash) leaves = self._trie.to_dict(node) return leaves def remove(self, key: bytes): self._trie.delete(key) def commit(self, rootHash=None, rootNode=None): if rootNode: rootHash = self._trie._encode_node(rootNode) elif rootHash and isHex(rootHash): if isinstance(rootHash, str): rootHash = rootHash.encode() rootHash = unhexlify(rootHash) elif rootHash: rootHash = rootHash else: rootHash = self.headHash self._kv.put(self.rootHashKey, rootHash) def revertToHead(self, headHash=None): head = self._hash_to_node(headHash) self._trie.replace_root_hash(self._trie.root_node, head) # Proofs are always generated over committed state def generate_state_proof(self, key: bytes, root=None, serialize=False, get_value=False): return self._trie.generate_state_proof(key, root, serialize, get_value=get_value) def generate_state_proof_for_keys_with_prefix(self, key_prfx, root=None, serialize=False, get_value=False): return self._trie.generate_state_proof_for_keys_with_prefix(key_prfx, root, serialize, get_value=get_value) @staticmethod def verify_state_proof(root, key, value, proof_nodes, serialized=False): encoded_key, encoded_value = PruningState.encode_kv_for_verification(key, value) return Trie.verify_spv_proof(root, encoded_key, encoded_value, proof_nodes, serialized) @staticmethod def verify_state_proof_multi(root, key_values, proof_nodes, serialized=False): encoded_key_values = dict(PruningState.encode_kv_for_verification(k, v) for k, v in key_values.items()) return Trie.verify_spv_proof_multi(root, encoded_key_values, proof_nodes, serialized) @staticmethod def encode_kv_for_verification(key, value): encoded_key = key.encode() if isinstance(key, str) else key encoded_value = rlp_encode([value]) if value is not None else b'' return encoded_key, encoded_value @property def as_dict(self): d = self._trie.to_dict() return {k: self.get_decoded(v) for k, v in d.items()} @property def headHash(self): """ The hash of the current head of the state, if the state is a merkle tree then hash of the root :return: """ return self._trie.root_hash @property def committedHeadHash(self): return self._kv.get(self.rootHashKey) @property def isEmpty(self): return self.committedHeadHash == BLANK_ROOT def close(self): if self._kv: self._kv.close() self._kv = None @staticmethod def get_decoded(encoded): return rlp_decode(encoded)[0]
def test_get_prefix_nodes(): trie = Trie(PersistentDB(KeyValueStorageInMemory())) prefix = 'abcd' prefix_nibbles = bin_to_nibbles(prefix) key1 = prefix + '1' key2 = prefix + '2' key3 = prefix + '3' trie.update(key1.encode(), rlp_encode(['v1'])) seen_prefix = [] last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles, seen_prfx=seen_prefix) # The last node should be a leaf since only 1 key assert trie._get_node_type(last_node) == NODE_TYPE_LEAF # Seen prefix matches the prefix exactly assert seen_prefix == [] # The queried key is larger than prefix, results in blank node last_node_ = trie._get_last_node_for_prfx(trie.root_node, bin_to_nibbles(prefix + '5'), []) assert last_node_ == BLANK_NODE seen_prefix = [] trie.update(key2.encode(), rlp_encode(['v2'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles, seen_prfx=seen_prefix) # The last node should be an extension since more than 1 key assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION assert seen_prefix == [] seen_prefix = [] trie.update(key3.encode(), rlp_encode(['v3'])) last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_nibbles, seen_prfx=seen_prefix) assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION assert seen_prefix == [] last_node_key = without_terminator(unpack_to_nibbles(last_node[0])) # Key for the fetched prefix nodes (ignore last nibble) is same as prefix nibbles assert last_node_key[:-1] == prefix_nibbles # The extension node is correctly decoded. decoded_extension = trie._decode_to_node(last_node[1]) assert decoded_extension[1] == [b' ', rlp_encode(['v1'])] assert decoded_extension[2] == [b' ', rlp_encode(['v2'])] assert decoded_extension[3] == [b' ', rlp_encode(['v3'])] # Add keys with extended prefix extended_prefix = '1' key4 = prefix + extended_prefix + '85' trie.update(key4.encode(), rlp_encode(['v11'])) key5 = prefix + extended_prefix + '96' trie.update(key5.encode(), rlp_encode(['v12'])) seen_prefix = [] new_prefix_nibbs = bin_to_nibbles(prefix + extended_prefix) last_node = trie._get_last_node_for_prfx(trie.root_node, new_prefix_nibbs, seen_prfx=seen_prefix) assert trie._get_node_type(last_node) == NODE_TYPE_BRANCH assert new_prefix_nibbs == seen_prefix assert seen_prefix == bin_to_nibbles(prefix + '1') # traverse to the next node remaining_key4_nibbs = bin_to_nibbles(key4)[len(seen_prefix):] remaining_key5_nibbs = bin_to_nibbles(key5)[len(seen_prefix):] next_nibble = remaining_key4_nibbs[0] if remaining_key4_nibbs[0] > remaining_key5_nibbs[0] else remaining_key5_nibbs[0] next_node = trie._decode_to_node(last_node[next_nibble]) assert trie._get_node_type(next_node) == NODE_TYPE_BRANCH # The 8th index should lead to a node with key '5', key4 ended in '85' assert trie._get_node_type(next_node[8]) == NODE_TYPE_LEAF assert without_terminator(unpack_to_nibbles(next_node[8][0])) == bin_to_nibbles('5') # The 9th index should lead to a node with key '6', key5 ended in '96' assert trie._get_node_type(next_node[9]) == NODE_TYPE_LEAF assert without_terminator(unpack_to_nibbles(next_node[9][0])) == bin_to_nibbles('6') prefix_1 = prefix + 'efgh' prefix_1_nibbles = bin_to_nibbles(prefix_1) key1 = prefix_1 + '1' key2 = prefix_1 + '2' key3 = prefix_1 + '3' trie.update(key1.encode(), rlp_encode(['v1'])) trie.update(key2.encode(), rlp_encode(['v1'])) trie.update(key3.encode(), rlp_encode(['v1'])) seen_prefix = [] last_node = trie._get_last_node_for_prfx(trie.root_node, prefix_1_nibbles, seen_prfx=seen_prefix) assert trie._get_node_type(last_node) == NODE_TYPE_EXTENSION assert len(seen_prefix) > 0 assert starts_with(prefix_1_nibbles, seen_prefix)