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))
