def test_merkleize_edge_case(limit, success): chunks = (A_CHUNK, ) if success: merkleize(chunks, limit=limit) else: with pytest.raises(ValueError): merkleize(chunks, limit=limit)
def hash_tree_root(self, value: Sequence[TSerializableElement]) -> bytes: if isinstance(self.element_sedes, BasicSedes): serialized_elements = tuple( self.element_sedes.serialize(element) for element in value) return merkleize(pack(serialized_elements)) else: element_tree_hashes = tuple( self.element_sedes.hash_tree_root(element) for element in value) return merkleize(element_tree_hashes)
def get_hash_tree_root(self, value: Sequence[Any]) -> bytes: if isinstance(value, BaseHashableStructure) and value.sedes == self: return value.hash_tree_root if isinstance(self.element_sedes, BasicSedes): serialized_elements = tuple( self.element_sedes.serialize(element) for element in value) return merkleize(pack(serialized_elements)) else: element_tree_hashes = tuple( self.element_sedes.get_hash_tree_root(element) for element in value) return merkleize(element_tree_hashes)
def get_hash_tree_root(self, value: Tuple[Any, ...]) -> bytes: if isinstance(value, BaseHashableStructure) and value.sedes == self: return value.hash_tree_root merkle_leaves = tuple( sedes.get_hash_tree_root(element) for element, sedes in zip(value, self.field_sedes)) return merkleize(merkle_leaves)
def hash_tree_root(self, value: Iterable[TSerializable]) -> bytes: if isinstance(self.element_sedes, BasicSedes): serialized_items = tuple( self.element_sedes.serialize(element) for element in value) length = len(serialized_items) merkle_leaves = pack(serialized_items) else: merkle_leaves = tuple( self.element_sedes.hash_tree_root(element) for element in value) length = len(merkle_leaves) return mix_in_length(merkleize(merkle_leaves), length)
def get_hash_tree_root(self, value: Iterable[TSerializable]) -> bytes: if isinstance(value, BaseHashableStructure) and value.sedes == self: return value.hash_tree_root if isinstance(self.element_sedes, BasicSedes): serialized_items = tuple( self.element_sedes.serialize(element) for element in value) merkle_leaves = pack(serialized_items) else: merkle_leaves = tuple( self.element_sedes.get_hash_tree_root(element) for element in value) return mix_in_length(merkleize(merkle_leaves, limit=self.chunk_count), len(value))
def get_hash_tree_root_and_leaves( self, value: Tuple[Any, ...], cache: CacheObj) -> Tuple[Hash32, CacheObj]: merkle_leaves = () for element, sedes in zip(value, self.field_sedes): key = sedes.get_key(element) if key not in cache: if hasattr(sedes, "get_hash_tree_root_and_leaves"): root, cache = sedes.get_hash_tree_root_and_leaves( element, cache) cache[key] = root else: cache[key] = sedes.get_hash_tree_root(element) merkle_leaves += (cache[key], ) return merkleize(merkle_leaves), cache
BaseSedes, BasicSedes, CompositeSedes, ) from ssz.utils import ( merkleize, mix_in_length, pack, read_exact, s_decode_offset, ) TSerializable = TypeVar("TSerializable") TDeserialized = TypeVar("TDeserialized") EMPTY_LIST_HASH_TREE_ROOT = mix_in_length(merkleize(pack([])), 0) class EmptyList(BaseCompositeSedes[Sequence[TSerializable], Tuple[TSerializable, ...]]): is_fixed_sized = False def get_fixed_size(self): raise NotImplementedError("Empty list does not implement `get_fixed_size`") def serialize(self, value: Sequence[TSerializable]): if len(value): raise SerializationError("Cannot serialize non-empty sequence using `EmptyList` sedes") return b'' def deserialize(self, data: bytes) -> Tuple[TDeserialized, ...]: if data:
def get_hash_tree_root(self, value: TSerializable) -> Hash32: serialized_value = self.serialize(value) return merkleize(pack((serialized_value, ))) # type: ignore
def get_hash_tree_root(self, value: Sequence[bool]) -> bytes: return mix_in_length( merkleize(pack_bits(value), limit=self.chunk_count), len(value))
def hash_tree_root(self, value: TSerializable) -> bytes: serialized_value = self.serialize(value) return merkleize(pack((serialized_value, )))
def hash_tree_root(self, value: Tuple[Any, ...]) -> bytes: merkle_leaves = tuple( sedes.hash_tree_root(element) for element, sedes in zip(value, self.field_sedes) ) return merkleize(merkle_leaves)
def test_merkleize(chunks, root): assert merkleize(chunks) == root
def test_compute(chunks_and_chunk_count): root = merkleize(*chunks_and_chunk_count) hash_tree = HashTree.compute(*chunks_and_chunk_count) assert hash_tree.chunks == chunks_and_chunk_count[0] assert hash_tree.root == root assert hash_tree.chunk_count == chunks_and_chunk_count[1]
def hash_tree_root(self, value: TAnyTypedDict) -> bytes: merkle_leaves = tuple( field_sedes.hash_tree_root(value[field_name]) for field_name, field_sedes in self.fields) return merkleize(merkle_leaves)
def hash_tree_root(self, value: bytes) -> bytes: serialized_value = self.serialize(value) return merkleize(pack_bytes(serialized_value))
def hash_tree_root(self, value: bytes) -> bytes: merkle_leaves = pack_bytes(value) merkleized = merkleize(merkle_leaves) return mix_in_length(merkleized, len(value))