164 lines
5.0 KiB
Python
164 lines
5.0 KiB
Python
from ..merkle_minimal import merkleize_chunks, hash
|
|
from eth2spec.utils.ssz.ssz_typing import (
|
|
is_uint_type, is_bool_type, is_container_type,
|
|
is_list_kind, is_vector_kind,
|
|
read_vector_elem_type, read_elem_type,
|
|
uint_byte_size,
|
|
infer_input_type,
|
|
get_zero_value,
|
|
)
|
|
|
|
# SSZ Serialization
|
|
# -----------------------------
|
|
|
|
BYTES_PER_LENGTH_OFFSET = 4
|
|
|
|
|
|
def is_basic_type(typ):
|
|
return is_uint_type(typ) or is_bool_type(typ)
|
|
|
|
|
|
def serialize_basic(value, typ):
|
|
if is_uint_type(typ):
|
|
return value.to_bytes(uint_byte_size(typ), 'little')
|
|
elif is_bool_type(typ):
|
|
if value:
|
|
return b'\x01'
|
|
else:
|
|
return b'\x00'
|
|
else:
|
|
raise Exception("Type not supported: {}".format(typ))
|
|
|
|
|
|
def deserialize_basic(value, typ):
|
|
if is_uint_type(typ):
|
|
return typ(int.from_bytes(value, 'little'))
|
|
elif is_bool_type(typ):
|
|
assert value in (b'\x00', b'\x01')
|
|
return True if value == b'\x01' else False
|
|
else:
|
|
raise Exception("Type not supported: {}".format(typ))
|
|
|
|
|
|
def is_fixed_size(typ):
|
|
if is_basic_type(typ):
|
|
return True
|
|
elif is_list_kind(typ):
|
|
return False
|
|
elif is_vector_kind(typ):
|
|
return is_fixed_size(read_vector_elem_type(typ))
|
|
elif is_container_type(typ):
|
|
return all(is_fixed_size(t) for t in typ.get_field_types())
|
|
else:
|
|
raise Exception("Type not supported: {}".format(typ))
|
|
|
|
|
|
def is_empty(obj):
|
|
return get_zero_value(type(obj)) == obj
|
|
|
|
|
|
@infer_input_type
|
|
def serialize(obj, typ=None):
|
|
if is_basic_type(typ):
|
|
return serialize_basic(obj, typ)
|
|
elif is_list_kind(typ) or is_vector_kind(typ):
|
|
return encode_series(obj, [read_elem_type(typ)] * len(obj))
|
|
elif is_container_type(typ):
|
|
return encode_series(obj.get_field_values(), typ.get_field_types())
|
|
else:
|
|
raise Exception("Type not supported: {}".format(typ))
|
|
|
|
|
|
def encode_series(values, types):
|
|
# bytes and bytesN are already in the right format.
|
|
if isinstance(values, bytes):
|
|
return values
|
|
|
|
# Recursively serialize
|
|
parts = [(is_fixed_size(types[i]), serialize(values[i], typ=types[i])) for i in range(len(values))]
|
|
|
|
# Compute and check lengths
|
|
fixed_lengths = [len(serialized) if constant_size else BYTES_PER_LENGTH_OFFSET
|
|
for (constant_size, serialized) in parts]
|
|
variable_lengths = [len(serialized) if not constant_size else 0
|
|
for (constant_size, serialized) in parts]
|
|
|
|
# Check if integer is not out of bounds (Python)
|
|
assert sum(fixed_lengths + variable_lengths) < 2 ** (BYTES_PER_LENGTH_OFFSET * 8)
|
|
|
|
# Interleave offsets of variable-size parts with fixed-size parts.
|
|
# Avoid quadratic complexity in calculation of offsets.
|
|
offset = sum(fixed_lengths)
|
|
variable_parts = []
|
|
fixed_parts = []
|
|
for (constant_size, serialized) in parts:
|
|
if constant_size:
|
|
fixed_parts.append(serialized)
|
|
else:
|
|
fixed_parts.append(offset.to_bytes(BYTES_PER_LENGTH_OFFSET, 'little'))
|
|
variable_parts.append(serialized)
|
|
offset += len(serialized)
|
|
|
|
# Return the concatenation of the fixed-size parts (offsets interleaved) with the variable-size parts
|
|
return b''.join(fixed_parts + variable_parts)
|
|
|
|
|
|
# SSZ Hash-tree-root
|
|
# -----------------------------
|
|
|
|
|
|
def pack(values, subtype):
|
|
if isinstance(values, bytes):
|
|
return values
|
|
return b''.join([serialize_basic(value, subtype) for value in values])
|
|
|
|
|
|
def chunkify(bytez):
|
|
# pad `bytez` to nearest 32-byte multiple
|
|
bytez += b'\x00' * (-len(bytez) % 32)
|
|
return [bytez[i:i + 32] for i in range(0, len(bytez), 32)]
|
|
|
|
|
|
def mix_in_length(root, length):
|
|
return hash(root + length.to_bytes(32, 'little'))
|
|
|
|
|
|
def is_bottom_layer_kind(typ):
|
|
return (
|
|
is_basic_type(typ) or
|
|
(is_list_kind(typ) or is_vector_kind(typ)) and is_basic_type(read_elem_type(typ))
|
|
)
|
|
|
|
|
|
@infer_input_type
|
|
def get_typed_values(obj, typ=None):
|
|
if is_container_type(typ):
|
|
return obj.get_typed_values()
|
|
elif is_list_kind(typ) or is_vector_kind(typ):
|
|
elem_type = read_elem_type(typ)
|
|
return list(zip(obj, [elem_type] * len(obj)))
|
|
else:
|
|
raise Exception("Invalid type")
|
|
|
|
|
|
@infer_input_type
|
|
def hash_tree_root(obj, typ=None):
|
|
if is_bottom_layer_kind(typ):
|
|
data = serialize_basic(obj, typ) if is_basic_type(typ) else pack(obj, read_elem_type(typ))
|
|
leaves = chunkify(data)
|
|
else:
|
|
fields = get_typed_values(obj, typ=typ)
|
|
leaves = [hash_tree_root(field_value, typ=field_typ) for field_value, field_typ in fields]
|
|
if is_list_kind(typ):
|
|
return mix_in_length(merkleize_chunks(leaves), len(obj))
|
|
else:
|
|
return merkleize_chunks(leaves)
|
|
|
|
|
|
@infer_input_type
|
|
def signing_root(obj, typ):
|
|
assert is_container_type(typ)
|
|
# ignore last field
|
|
leaves = [hash_tree_root(field_value, typ=field_typ) for field_value, field_typ in obj.get_typed_values()[:-1]]
|
|
return merkleize_chunks(chunkify(b''.join(leaves)))
|