def deserialize(cls: Type[V], stream: BinaryIO, scope: int) -> V:
if scope < 1:
raise Exception("cannot have empty scope for bitlist, need at least a delimiting bit")
if scope > cls.max_byte_length():
raise Exception(f"scope is too large: {scope}, max bitlist byte length is: {cls.max_byte_length()}")
chunks: PyList[Node] = []
bytelen = scope - 1 # excluding the last byte (which contains the delimiting bit)
while scope > 32:
chunks.append(RootNode(Root(stream.read(32))))
scope -= 32
# scope is [1, 32] here
last_chunk_part = stream.read(scope)
last_byte = int(last_chunk_part[scope-1])
if last_byte == 0:
raise Exception("last byte must not be 0: bitlist requires delimiting bit")
last_byte_bitlen = last_byte.bit_length() - 1 # excluding the delimiting bit
bitlen = bytelen * 8 + last_byte_bitlen
if bitlen % 256 != 0:
last_chunk = last_chunk_part[:scope-1] +\
(last_byte ^ (1 << last_byte_bitlen)).to_bytes(length=1, byteorder='little')
last_chunk += b"\x00" * (32 - len(last_chunk))
chunks.append(RootNode(Root(last_chunk)))
if bitlen > cls.limit():
raise Exception(f"bitlist too long: {bitlen}, delimiting bit is over limit ({cls.limit()})")
contents = subtree_fill_to_contents(chunks, cls.contents_depth())
backing = PairNode(contents, uint256(bitlen).get_backing())
return cast(Bitlist, cls.view_from_backing(backing))
def __new__(cls, *args, **kwargs):
vals = list(args)
if len(vals) > 0:
if len(vals) == 1 and isinstance(vals[0], (GeneratorType, list, tuple)):
vals = list(vals[0])
limit = cls.limit()
if len(vals) > limit:
raise Exception(f"too many bitlist inputs: {len(vals)}, limit is: {limit}")
input_bits = list(map(bool, vals))
input_nodes = pack_bits_to_chunks(input_bits)
contents = subtree_fill_to_contents(input_nodes, cls.contents_depth())
kwargs['backing'] = PairNode(contents, uint256(len(input_bits)).get_backing())
return super().__new__(cls, **kwargs)
def __new__(cls,
*args,
backing: Optional[Node] = None,
hook: Optional[ViewHook] = None,
**kwargs):
if backing is not None:
if len(args) != 0:
raise Exception(
"cannot have both a backing and elements to init List")
return super().__new__(cls, backing=backing, hook=hook, **kwargs)
elem_cls = cls.element_cls()
vals = list(args)
if len(vals) == 1:
val = vals[0]
if isinstance(val, (GeneratorType, list, tuple)):
vals = list(val)
if issubclass(elem_cls, uint8):
if isinstance(val, bytes):
vals = list(val)
if isinstance(val, str):
if val[:2] == '0x':
val = val[2:]
vals = list(bytes.fromhex(val))
if len(vals) > 0:
limit = cls.limit()
if len(vals) > limit:
raise Exception(
f"too many list inputs: {len(vals)}, limit is: {limit}")
input_views = []
for el in vals:
if isinstance(el, View):
input_views.append(el)
else:
input_views.append(elem_cls.coerce_view(el))
input_nodes = cls.views_into_chunks(input_views)
contents = subtree_fill_to_contents(input_nodes,
cls.contents_depth())
backing = PairNode(contents,
uint256(len(input_views)).get_backing())
return super().__new__(cls, backing=backing, hook=hook, **kwargs)
def default_node(cls) -> Node:
return PairNode(zero_node(cls.contents_depth()),
zero_node(0)) # mix-in 0 as list length
def get_backing(self) -> Node:
return PairNode(
subtree_fill_to_contents(pack_bytes_to_chunks(self),
self.__class__.contents_depth()),
uint256(len(self)).get_backing())