def get_hash_tree_root_and_leaves(
self, value: Sequence[bool],
cache: CacheObj) -> Tuple[Hash32, CacheObj]:
root, cache = merkleize_with_cache(pack_bits(value),
cache=cache,
limit=self.chunk_count)
return mix_in_length(root, len(value)), cache
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: TSerializable,
cache: CacheObj) -> Tuple[Hash32, CacheObj]:
merkle_leaves = ()
if isinstance(self.element_sedes, BasicSedes):
serialized_items = tuple(
self.element_sedes.serialize(element) for element in value)
merkle_leaves = pack(serialized_items)
else:
has_get_hash_tree_root_and_leaves = hasattr(
self.element_sedes, "get_hash_tree_root_and_leaves")
if has_get_hash_tree_root_and_leaves:
merkle_leaves = get_merkle_leaves_with_cache(
value, self.element_sedes, cache)
else:
merkle_leaves = get_merkle_leaves_without_cache(
value, self.element_sedes)
merkleize_result, cache = merkleize_with_cache(merkle_leaves,
cache=cache,
limit=self.chunk_count)
return mix_in_length(merkleize_result, len(value)), 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: Sequence[bool]) -> bytes:
return mix_in_length(
merkleize(pack_bits(value), limit=self.chunk_count), len(value))
def hash_tree_root(self) -> Hash32:
return mix_in_length(self.raw_root, len(self))
def test_mix_in_length(root, length, result):
assert mix_in_length(root, length) == result
def hash_tree_root(self, value: bytes) -> bytes:
merkle_leaves = pack_bytes(value)
merkleized = merkleize(merkle_leaves)
return mix_in_length(merkleized, len(value))
