faster-eth-abi 5.2.7__cp38-cp38-win_amd64.whl → 5.2.8__cp38-cp38-win_amd64.whl

faster_eth_abi/_codec.py

@@ -3,7 +3,6 @@ from typing import (
     Any,
     Iterable,
     Tuple,
-    cast,
 )
 
 from eth_typing import (
@@ -79,4 +78,4 @@ def decode_c(
     decoder = self._registry.get_tuple_decoder(*types, strict=strict)
     stream = self.stream_class(data)
 
-    return cast(Tuple[Any, ...], decoder(stream))
+    return decoder(stream)

faster_eth_abi/_decoding.py

@@ -0,0 +1,117 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Optional,
+    Tuple,
+)
+
+from faster_eth_abi.exceptions import (
+    InsufficientDataBytes,
+)
+from faster_eth_abi.io import (
+    BytesIO,
+    ContextFramesBytesIO,
+)
+
+if TYPE_CHECKING:
+    from .decoding import (
+        DynamicArrayDecoder,
+        FixedByteSizeDecoder,
+        HeadTailDecoder,
+        SizedArrayDecoder,
+        TupleDecoder,
+        UnsignedIntegerDecoder,
+    )
+
+
+_UINT256_DECODER: Optional["UnsignedIntegerDecoder"] = None
+
+
+def __set_uint256_decoder() -> "UnsignedIntegerDecoder":
+    # this helper breaks a circular dependency on the non-compiled decoding module
+    from . import (
+        decoding,
+    )
+
+    global _UINT256_DECODER
+    _UINT256_DECODER = decoding.decode_uint_256
+
+    return _UINT256_DECODER
+
+
+def decode_uint_256(stream: ContextFramesBytesIO) -> int:
+    decoder = _UINT256_DECODER
+    if decoder is None:
+        decoder = __set_uint256_decoder()
+    decoded: int = decoder(stream)
+    return decoded
+
+
+# HeadTailDecoder
+def decode_head_tail(self: "HeadTailDecoder", stream: ContextFramesBytesIO) -> Any:
+    # Decode the offset and move the stream cursor forward 32 bytes
+    start_pos = decode_uint_256(stream)
+    # Jump ahead to the start of the value
+    stream.push_frame(start_pos)
+
+    # assertion check for mypy
+    tail_decoder = self.tail_decoder
+    if tail_decoder is None:
+        raise AssertionError("`tail_decoder` is None")
+    # Decode the value
+    value = tail_decoder(stream)
+    # Return the cursor
+    stream.pop_frame()
+
+    return value
+
+
+# TupleDecoder
+def decode_tuple(self: "TupleDecoder", stream: ContextFramesBytesIO) -> Tuple[Any, ...]:
+    self.validate_pointers(stream)
+    return tuple(decoder(stream) for decoder in self.decoders)
+
+
+# SizedArrayDecoder
+def decode_sized_array(
+    self: "SizedArrayDecoder", stream: ContextFramesBytesIO
+) -> Tuple[Any, ...]:
+    item_decoder = self.item_decoder
+    if item_decoder is None:
+        raise AssertionError("`item_decoder` is None")
+
+    array_size = self.array_size
+    self.validate_pointers(stream, array_size)
+    return tuple(item_decoder(stream) for _ in range(array_size))
+
+
+# DynamicArrayDecoder
+def decode_dynamic_array(
+    self: "DynamicArrayDecoder", stream: ContextFramesBytesIO
+) -> Tuple[Any, ...]:
+    array_size = decode_uint_256(stream)
+    stream.push_frame(32)
+    if self.item_decoder is None:
+        raise AssertionError("`item_decoder` is None")
+
+    self.validate_pointers(stream, array_size)
+    item_decoder = self.item_decoder
+    try:
+        return tuple(item_decoder(stream) for _ in range(array_size))
+    finally:
+        stream.pop_frame()
+
+
+# FixedByteSizeDecoder
+def read_fixed_byte_size_data_from_stream(
+    self: "FixedByteSizeDecoder",
+    # NOTE: use BytesIO here so mypyc doesn't type-check
+    # `stream` once we compile ContextFramesBytesIO.
+    stream: BytesIO,
+) -> bytes:
+    data_byte_size = self.data_byte_size
+    if len(data := stream.read(data_byte_size)) == data_byte_size:
+        return data
+    raise InsufficientDataBytes(
+        f"Tried to read {data_byte_size} bytes, only got {len(data)} bytes."
+    )

faster_eth_abi/decoding.py

@@ -2,16 +2,25 @@ import abc
 import decimal
 from typing import (
     Any,
-    Generator,
+    Callable,
+    Final,
+    Optional,
     Tuple,
+    Union,
 )
 
 from faster_eth_utils import (
     big_endian_to_int,
     to_normalized_address,
-    to_tuple,
 )
 
+from faster_eth_abi._decoding import (
+    decode_dynamic_array,
+    decode_head_tail,
+    decode_sized_array,
+    decode_tuple,
+    read_fixed_byte_size_data_from_stream,
+)
 from faster_eth_abi.base import (
     BaseCoder,
 )
@@ -33,6 +42,10 @@ from faster_eth_abi.utils.numeric import (
     ceil32,
 )
 
+DynamicDecoder = Union[
+    "HeadTailDecoder", "SizedArrayDecoder", "DynamicArrayDecoder", "ByteStringDecoder"
+]
+
 
 class BaseDecoder(BaseCoder, metaclass=abc.ABCMeta):
     """
@@ -65,29 +78,18 @@ class HeadTailDecoder(BaseDecoder):
 
     is_dynamic = True
 
-    tail_decoder = None
+    tail_decoder: Optional[DynamicDecoder] = None
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.tail_decoder is None:
             raise ValueError("No `tail_decoder` set")
 
     def decode(self, stream: ContextFramesBytesIO) -> Any:
-        # Decode the offset and move the stream cursor forward 32 bytes
-        start_pos = decode_uint_256(stream)
-        # Jump ahead to the start of the value
-        stream.push_frame(start_pos)
+        return decode_head_tail(self, stream)
 
-        # assertion check for mypy
-        if self.tail_decoder is None:
-            raise AssertionError("`tail_decoder` is None")
-        # Decode the value
-        value = self.tail_decoder(stream)
-        # Return the cursor
-        stream.pop_frame()
-
-        return value
+    __call__ = decode
 
 
 class TupleDecoder(BaseDecoder):
@@ -102,8 +104,11 @@ class TupleDecoder(BaseDecoder):
         )
 
         self.is_dynamic = any(getattr(d, "is_dynamic", False) for d in self.decoders)
+        self.len_of_head = sum(
+            getattr(decoder, "array_size", 1) for decoder in self.decoders
+        )
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.decoders is None:
@@ -114,11 +119,7 @@ class TupleDecoder(BaseDecoder):
         Verify that all pointers point to a valid location in the stream.
         """
         current_location = stream.tell()
-        len_of_head = sum(
-            decoder.array_size if hasattr(decoder, "array_size") else 1
-            for decoder in self.decoders
-        )
-        end_of_offsets = current_location + 32 * len_of_head
+        end_of_offsets = current_location + 32 * self.len_of_head
         total_stream_length = len(stream.getbuffer())
         for decoder in self.decoders:
             if isinstance(decoder, HeadTailDecoder):
@@ -143,11 +144,10 @@ class TupleDecoder(BaseDecoder):
         # return the stream to its original location for actual decoding
         stream.seek(current_location)
 
-    @to_tuple  # type: ignore [misc]
-    def decode(self, stream: ContextFramesBytesIO) -> Generator[Any, None, None]:
-        self.validate_pointers(stream)
-        for decoder in self.decoders:
-            yield decoder(stream)
+    def decode(self, stream: ContextFramesBytesIO) -> Tuple[Any, ...]:
+        return decode_tuple(self, stream)
+
+    __call__ = decode
 
     @parse_tuple_type_str
     def from_type_str(cls, abi_type, registry):
@@ -161,7 +161,7 @@ class TupleDecoder(BaseDecoder):
 class SingleDecoder(BaseDecoder):
     decoder_fn = None
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.decoder_fn is None:
@@ -180,17 +180,19 @@ class SingleDecoder(BaseDecoder):
 
         return value
 
-    def read_data_from_stream(self, stream):
+    __call__ = decode
+
+    def read_data_from_stream(self, stream: ContextFramesBytesIO) -> bytes:
         raise NotImplementedError("Must be implemented by subclasses")
 
-    def split_data_and_padding(self, raw_data):
+    def split_data_and_padding(self, raw_data: bytes) -> Tuple[bytes, bytes]:
         return raw_data, b""
 
 
 class BaseArrayDecoder(BaseDecoder):
     item_decoder = None
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
 
         # Use a head-tail decoder to decode dynamic elements
@@ -199,7 +201,7 @@ class BaseArrayDecoder(BaseDecoder):
                 tail_decoder=self.item_decoder,
             )
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.item_decoder is None:
@@ -246,47 +248,36 @@ class BaseArrayDecoder(BaseDecoder):
 
 
 class SizedArrayDecoder(BaseArrayDecoder):
-    array_size = None
+    array_size: int = None
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
         self.is_dynamic = self.item_decoder.is_dynamic
 
-    @to_tuple
     def decode(self, stream):
-        if self.item_decoder is None:
-            raise AssertionError("`item_decoder` is None")
+        return decode_sized_array(self, stream)
 
-        self.validate_pointers(stream, self.array_size)
-        for _ in range(self.array_size):
-            yield self.item_decoder(stream)
+    __call__ = decode
 
 
 class DynamicArrayDecoder(BaseArrayDecoder):
     # Dynamic arrays are always dynamic, regardless of their elements
     is_dynamic = True
 
-    @to_tuple
-    def decode(self, stream):
-        array_size = decode_uint_256(stream)
-        stream.push_frame(32)
-        if self.item_decoder is None:
-            raise AssertionError("`item_decoder` is None")
+    def decode(self, stream: ContextFramesBytesIO) -> Tuple[Any, ...]:
+        return decode_dynamic_array(self, stream)
 
-        self.validate_pointers(stream, array_size)
-        for _ in range(array_size):
-            yield self.item_decoder(stream)
-        stream.pop_frame()
+    __call__ = decode
 
 
 class FixedByteSizeDecoder(SingleDecoder):
-    decoder_fn = None
-    value_bit_size = None
-    data_byte_size = None
-    is_big_endian = None
+    decoder_fn: Callable[[bytes], Any] = None
+    value_bit_size: int = None
+    data_byte_size: int = None
+    is_big_endian: bool = None
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.value_bit_size is None:
@@ -306,18 +297,10 @@ class FixedByteSizeDecoder(SingleDecoder):
         if self.value_bit_size > self.data_byte_size * 8:
             raise ValueError("Value byte size exceeds data size")
 
-    def read_data_from_stream(self, stream):
-        data = stream.read(self.data_byte_size)
-
-        if len(data) != self.data_byte_size:
-            raise InsufficientDataBytes(
-                f"Tried to read {self.data_byte_size} bytes, "
-                f"only got {len(data)} bytes."
-            )
+    def read_data_from_stream(self, stream: ContextFramesBytesIO) -> bytes:
+        return read_fixed_byte_size_data_from_stream(self, stream)
 
-        return data
-
-    def split_data_and_padding(self, raw_data):
+    def split_data_and_padding(self, raw_data: bytes) -> Tuple[bytes, bytes]:
         value_byte_size = self._get_value_byte_size()
         padding_size = self.data_byte_size - value_byte_size
 
@@ -330,7 +313,7 @@ class FixedByteSizeDecoder(SingleDecoder):
 
         return data, padding_bytes
 
-    def validate_padding_bytes(self, value, padding_bytes):
+    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
         value_byte_size = self._get_value_byte_size()
         padding_size = self.data_byte_size - value_byte_size
 
@@ -406,7 +389,7 @@ class SignedIntegerDecoder(Fixed32ByteSizeDecoder):
         else:
             return value
 
-    def validate_padding_bytes(self, value, padding_bytes):
+    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
         value_byte_size = self._get_value_byte_size()
         padding_size = self.data_byte_size - value_byte_size
 
@@ -444,7 +427,7 @@ class BaseFixedDecoder(Fixed32ByteSizeDecoder):
     frac_places = None
     is_big_endian = True
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.frac_places is None:
@@ -483,7 +466,7 @@ class SignedFixedDecoder(BaseFixedDecoder):
 
         return decimal_value
 
-    def validate_padding_bytes(self, value, padding_bytes):
+    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
         value_byte_size = self._get_value_byte_size()
         padding_size = self.data_byte_size - value_byte_size
 
@@ -514,7 +497,7 @@ class ByteStringDecoder(SingleDecoder):
     def decoder_fn(data):
         return data
 
-    def read_data_from_stream(self, stream):
+    def read_data_from_stream(self, stream: ContextFramesBytesIO) -> bytes:
         data_length = decode_uint_256(stream)
         padded_length = ceil32(data_length)
 
@@ -534,7 +517,7 @@ class ByteStringDecoder(SingleDecoder):
 
         return data[:data_length]
 
-    def validate_padding_bytes(self, value, padding_bytes):
+    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
         pass
 
     @parse_type_str("bytes")
@@ -543,21 +526,21 @@ class ByteStringDecoder(SingleDecoder):
 
 
 class StringDecoder(ByteStringDecoder):
-    def __init__(self, handle_string_errors="strict"):
-        self.bytes_errors = handle_string_errors
+    def __init__(self, handle_string_errors: str = "strict") -> None:
+        self.bytes_errors: Final = handle_string_errors
         super().__init__()
 
     @parse_type_str("string")
     def from_type_str(cls, abi_type, registry):
         return cls()
 
-    def decode(self, stream):
+    def decode(self, stream: ContextFramesBytesIO) -> str:
         raw_data = self.read_data_from_stream(stream)
         data, padding_bytes = self.split_data_and_padding(raw_data)
-        value = self.decoder_fn(data, self.bytes_errors)
-        self.validate_padding_bytes(value, padding_bytes)
-        return value
+        return self.decoder_fn(data, self.bytes_errors)
+
+    __call__ = decode
 
     @staticmethod
-    def decoder_fn(data, handle_string_errors="strict"):
+    def decoder_fn(data: bytes, handle_string_errors: str = "strict") -> str:
         return data.decode("utf-8", errors=handle_string_errors)

faster_eth_abi/encoding.py

@@ -3,6 +3,8 @@ import codecs
 import decimal
 from typing import (
     Any,
+    Callable,
+    ClassVar,
     NoReturn,
     Optional,
     Sequence,
@@ -20,6 +22,9 @@ from faster_eth_utils import (
     is_text,
     to_canonical_address,
 )
+from typing_extensions import (
+    Self,
+)
 
 from faster_eth_abi._encoding import (
     encode_elements,
@@ -108,37 +113,40 @@ class TupleEncoder(BaseEncoder):
 
         self.is_dynamic = any(getattr(e, "is_dynamic", False) for e in self.encoders)
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.encoders is None:
             raise ValueError("`encoders` may not be none")
 
-    def validate_value(self, value):
+    def validate_value(self, value: Sequence[Any]) -> None:
         if not is_list_like(value):
             self.invalidate_value(
                 value,
                 msg="must be list-like object such as array or tuple",
             )
 
-        if len(value) != len(self.encoders):
+        encoders = self.encoders
+        if len(value) != len(encoders):
             self.invalidate_value(
                 value,
                 exc=ValueOutOfBounds,
-                msg=f"value has {len(value)} items when {len(self.encoders)} "
+                msg=f"value has {len(value)} items when {len(encoders)} "
                 "were expected",
             )
 
-        for item, encoder in zip(value, self.encoders):
+        for item, encoder in zip(value, encoders):
             try:
                 encoder.validate_value(item)
             except AttributeError:
                 encoder(item)
 
-    def encode(self, values):
+    def encode(self, values: Sequence[Any]) -> bytes:
         self.validate_value(values)
         return encode_tuple(values, self.encoders)
 
+    __call__: Callable[[Self, Sequence[Any]], bytes] = encode
+
     @parse_tuple_type_str
     def from_type_str(cls, abi_type, registry):
         encoders = tuple(
@@ -155,25 +163,26 @@ class FixedSizeEncoder(BaseEncoder):
     type_check_fn = None
     is_big_endian = None
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
-        if self.value_bit_size is None:
+        value_bit_size = self.value_bit_size
+        if value_bit_size is None:
             raise ValueError("`value_bit_size` may not be none")
-        if self.data_byte_size is None:
+        data_byte_size = self.data_byte_size
+        if data_byte_size is None:
             raise ValueError("`data_byte_size` may not be none")
         if self.encode_fn is None:
             raise ValueError("`encode_fn` may not be none")
         if self.is_big_endian is None:
             raise ValueError("`is_big_endian` may not be none")
 
-        if self.value_bit_size % 8 != 0:
+        if value_bit_size % 8 != 0:
             raise ValueError(
-                f"Invalid value bit size: {self.value_bit_size}. "
-                "Must be a multiple of 8"
+                f"Invalid value bit size: {value_bit_size}. Must be a multiple of 8"
             )
 
-        if self.value_bit_size > self.data_byte_size * 8:
+        if value_bit_size > data_byte_size * 8:
             raise ValueError("Value byte size exceeds data size")
 
     def validate_value(self, value):
@@ -181,11 +190,12 @@ class FixedSizeEncoder(BaseEncoder):
 
     def encode(self, value: Any) -> bytes:
         self.validate_value(value)
-        if self.encode_fn is None:
+        encode_fn = self.encode_fn
+        if encode_fn is None:
             raise AssertionError("`encode_fn` is None")
-        return encode_fixed(
-            value, self.encode_fn, self.is_big_endian, self.data_byte_size
-        )
+        return encode_fixed(value, encode_fn, self.is_big_endian, self.data_byte_size)
+
+    __call__ = encode
 
 
 class Fixed32ByteSizeEncoder(FixedSizeEncoder):
@@ -202,7 +212,7 @@ class BooleanEncoder(Fixed32ByteSizeEncoder):
             cls.invalidate_value(value)
 
     @classmethod
-    def encode_fn(cls, value):
+    def encode_fn(cls, value: bool) -> bytes:
         if value is True:
             return b"\x01"
         elif value is False:
@@ -225,7 +235,7 @@ class NumberEncoder(Fixed32ByteSizeEncoder):
     illegal_value_fn = None
     type_check_fn = None
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.bounds_fn is None:
@@ -234,14 +244,14 @@ class NumberEncoder(Fixed32ByteSizeEncoder):
             raise ValueError("`type_check_fn` cannot be null")
 
     def validate_value(self, value):
-        if self.type_check_fn is None:
+        type_check_fn = self.type_check_fn
+        if type_check_fn is None:
             raise AssertionError("`type_check_fn` is None")
-        if not self.type_check_fn(value):
+        if not type_check_fn(value):
             self.invalidate_value(value)
 
-        illegal_value = self.illegal_value_fn is not None and self.illegal_value_fn(
-            value
-        )
+        illegal_value_fn = self.illegal_value_fn
+        illegal_value = illegal_value_fn is not None and illegal_value_fn(value)
         if illegal_value:
             self.invalidate_value(value, exc=IllegalValue)
 
@@ -284,10 +294,12 @@ class SignedIntegerEncoder(NumberEncoder):
     def encode_fn(self, value: int) -> bytes:
         return int_to_big_endian(value % (2**self.value_bit_size))
 
-    def encode(self, value):
+    def encode(self, value: int) -> bytes:
         self.validate_value(value)
         return encode_signed(value, self.encode_fn, self.data_byte_size)
 
+    __call__ = encode
+
     @parse_type_str("int")
     def from_type_str(cls, abi_type, registry):
         return cls(value_bit_size=abi_type.sub)
@@ -330,13 +342,14 @@ class BaseFixedEncoder(NumberEncoder):
                 f"{self.frac_places}",
             )
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
-        if self.frac_places is None:
+        frac_places = self.frac_places
+        if frac_places is None:
             raise ValueError("must specify `frac_places`")
 
-        if self.frac_places <= 0 or self.frac_places > 80:
+        if frac_places <= 0 or frac_places > 80:
             raise ValueError("`frac_places` must be in range (0, 80]")
 
 
@@ -390,6 +403,8 @@ class SignedFixedEncoder(BaseFixedEncoder):
         self.validate_value(value)
         return encode_signed(value, self.encode_fn, self.data_byte_size)
 
+    __call__ = encode
+
     @parse_type_str("fixed")
     def from_type_str(cls, abi_type, registry):
         value_bit_size, frac_places = abi_type.sub
@@ -422,7 +437,7 @@ class AddressEncoder(Fixed32ByteSizeEncoder):
         if not is_address(value):
             cls.invalidate_value(value)
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.value_bit_size != 20 * 8:
@@ -479,7 +494,7 @@ class ByteStringEncoder(BaseEncoder):
             cls.invalidate_value(value)
 
     @classmethod
-    def encode(cls, value):
+    def encode(cls, value: bytes) -> bytes:
         cls.validate_value(value)
         value_length = len(value)
 
@@ -488,9 +503,11 @@ class ByteStringEncoder(BaseEncoder):
 
         return encoded_size + padded_value
 
+    __call__: ClassVar[Callable[[Type[Self], bytes], bytes]] = encode
+
     @parse_type_str("bytes")
     def from_type_str(cls, abi_type, registry):
-        return cls()
+        return cls()  # type: ignore [misc]
 
 
 class PackedByteStringEncoder(ByteStringEncoder):
@@ -501,6 +518,8 @@ class PackedByteStringEncoder(ByteStringEncoder):
         cls.validate_value(value)
         return value
 
+    __call__ = encode
+
 
 class TextStringEncoder(BaseEncoder):
     is_dynamic = True
@@ -511,7 +530,7 @@ class TextStringEncoder(BaseEncoder):
             cls.invalidate_value(value)
 
     @classmethod
-    def encode(cls, value):
+    def encode(cls, value: str) -> bytes:
         cls.validate_value(value)
 
         value_as_bytes = codecs.encode(value, "utf8")
@@ -522,24 +541,28 @@ class TextStringEncoder(BaseEncoder):
 
         return encoded_size + padded_value
 
+    __call__: ClassVar[Callable[[Type[Self], str], bytes]] = encode
+
     @parse_type_str("string")
     def from_type_str(cls, abi_type, registry):
-        return cls()
+        return cls()  # type: ignore [misc]
 
 
 class PackedTextStringEncoder(TextStringEncoder):
     is_dynamic = False
 
     @classmethod
-    def encode(cls, value):
+    def encode(cls, value: str) -> bytes:
         cls.validate_value(value)
         return codecs.encode(value, "utf8")
 
+    __call__ = encode
+
 
 class BaseArrayEncoder(BaseEncoder):
-    item_encoder = None
+    item_encoder: BaseEncoder = None
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.item_encoder is None:
@@ -552,8 +575,9 @@ class BaseArrayEncoder(BaseEncoder):
                 msg="must be list-like such as array or tuple",
             )
 
+        item_encoder = self.item_encoder
         for item in value:
-            self.item_encoder.validate_value(item)
+            item_encoder.validate_value(item)
 
     def encode_elements(self, value: Sequence[Any]) -> bytes:
         self.validate_value(value)
@@ -581,17 +605,19 @@ class PackedArrayEncoder(BaseArrayEncoder):
     def validate_value(self, value: Any) -> None:
         super().validate_value(value)
 
-        if self.array_size is not None and len(value) != self.array_size:
+        array_size = self.array_size
+        if array_size is not None and len(value) != array_size:
             self.invalidate_value(
                 value,
                 exc=ValueOutOfBounds,
-                msg=f"value has {len(value)} items when {self.array_size} were "
-                "expected",
+                msg=f"value has {len(value)} items when {array_size} were expected",
             )
 
     def encode(self, value: Sequence[Any]) -> bytes:
         return encode_elements(self.item_encoder, value)
 
+    __call__ = encode
+
     @parse_type_str(with_arrlist=True)
     def from_type_str(cls, abi_type, registry):
         item_encoder = registry.get_encoder(abi_type.item_type.to_type_str())
@@ -614,7 +640,7 @@ class SizedArrayEncoder(BaseArrayEncoder):
 
         self.is_dynamic = self.item_encoder.is_dynamic
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.array_size is None:
@@ -634,9 +660,13 @@ class SizedArrayEncoder(BaseArrayEncoder):
     def encode(self, value: Sequence[Any]) -> bytes:
         return encode_elements(self.item_encoder, value)
 
+    __call__ = encode
+
 
 class DynamicArrayEncoder(BaseArrayEncoder):
     is_dynamic = True
 
     def encode(self, value: Sequence[Any]) -> bytes:
         return encode_elements_dynamic(self.item_encoder, value)
+
+    __call__ = encode

{faster_eth_abi-5.2.7.dist-info → faster_eth_abi-5.2.8.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: faster_eth_abi
-Version: 5.2.7
-Summary: A aster fork of eth_abi: Python utilities for working with Ethereum ABI definitions, especially encoding and decoding. Implemented in C.
+Version: 5.2.8
+Summary: A faster fork of eth_abi: Python utilities for working with Ethereum ABI definitions, especially encoding and decoding. Implemented in C.
 Home-page: https://github.com/BobTheBuidler/faster-eth-abi
 Author: The Ethereum Foundation
 Author-email: snakecharmers@ethereum.org

faster_eth_abi-5.2.8.dist-info/RECORD

@@ -0,0 +1,44 @@
+76f9a3652d4d2667c55c__mypyc.cp38-win_amd64.pyd,sha256=q4OWcbGDcAvt6tEq6H4JmF2sD2wZGQQDmb8Z08zyoBo,150528
+faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
+faster_eth_abi/_codec.cp38-win_amd64.pyd,sha256=ov2tFCp3g4DpZMjiTNVKE4KG6D_kLHVoQCqDKd-m3fs,10752
+faster_eth_abi/_codec.py,sha256=fLRvqvrD8F38U4m1wZztvx-7JJbZaPikwXS5u9BzY14,2509
+faster_eth_abi/_decoding.cp38-win_amd64.pyd,sha256=e1D0PXNjPWPArQCTTGz8S4L-JNnbxtFRTMerZn7Hvd0,10752
+faster_eth_abi/_decoding.py,sha256=uhteNEJzs873MqIOxc68XuFnKOhsUH0CJcQFLbL0Q18,3264
+faster_eth_abi/_encoding.cp38-win_amd64.pyd,sha256=eB1NvWF884YxLwfAaFpO-peOjdwXavNR8D7sSU6N_Q0,10752
+faster_eth_abi/_encoding.py,sha256=157A_MltVLCEwBmD7SB8UaKXkAOtIKC5MVupk6dk_yA,3217
+faster_eth_abi/abi.cp38-win_amd64.pyd,sha256=g_ZjR_KtG0AdhsXupKMyB3cI1a7IcmHoM1yum_yvAvc,10752
+faster_eth_abi/abi.py,sha256=-t9OVBSCxy6SuWpCu3cxHrCqkx8_svPIRb0MSFXEl5Q,383
+faster_eth_abi/base.py,sha256=y4IXpQJWGfUISl3xjCO420Grxido3tE2ebPV2rK-DvM,1229
+faster_eth_abi/codec.py,sha256=e1uO8BJrXRn0Ih70eUa5qipD2wcg2aZSR4fyVuGpFoY,4580
+faster_eth_abi/constants.cp38-win_amd64.pyd,sha256=hDd5QdYIRSHnIsFYvOTs6HS5sNpCkbPcqF0wvUZs1ZA,10752
+faster_eth_abi/constants.py,sha256=q3FGynS-Eb78cnrL6mBoAvTDz16PF3tW2OylTMd6ajs,114
+faster_eth_abi/decoding.py,sha256=-2P8kAaHM1HFYS5b8QKstStO6PkWlugEaDUoujX1Uf0,17447
+faster_eth_abi/encoding.py,sha256=bKw8wCqpfv8U83I2xsmiI37wn2lQUIhn4bn1xS_l1Zc,19704
+faster_eth_abi/exceptions.py,sha256=KzNYRc9t0CvlkveozWvLeo1WC_GarcBkwzV67aY_5yI,3067
+faster_eth_abi/from_type_str.cp38-win_amd64.pyd,sha256=arpdYW6yEWJV-thinlDbcau9zVXLE1vQbHE1N-_t9Sc,10752
+faster_eth_abi/from_type_str.py,sha256=WLRP3OIyrJORgloX-7V0x2KdrZj0kLay-J9I8f-H36s,4446
+faster_eth_abi/grammar.py,sha256=lhEmp3ZwMTzm1-jJiMUVD4zrBgU4MEZCRiND4WxfOes,13839
+faster_eth_abi/io.py,sha256=E_QX7aYAjGYnkNAZmJMmSmx1lqvl_FDNmMFruTi9UX4,3831
+faster_eth_abi/packed.cp38-win_amd64.pyd,sha256=S4BxBMQ5iKxx-EuX9NLs01BtDJ_ZTMr7t5XTshs9CYA,10752
+faster_eth_abi/packed.py,sha256=RZ2chvsx9_AL9OxY1ixHTsaUJHaR_tmrNdViOIp-xSg,316
+faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/registry.py,sha256=gU5-k_1eYUjs7-NAKoH9nncCJ36tZZHM5ZXvwmXt0cw,21192
+faster_eth_abi/tools/__init__.cp38-win_amd64.pyd,sha256=y9qVkZkQBq4cHlak6AxTd8vgyZjqgzO5Gi0hdHYfMgU,10752
+faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
+faster_eth_abi/tools/_strategies.cp38-win_amd64.pyd,sha256=hqimZqHOpkEx4y9wwzxUb1aiTq3ba6JKf77ciDr1uOg,10752
+faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
+faster_eth_abi/utils/__init__.cp38-win_amd64.pyd,sha256=mNvFnTB_cDtCph7BYWTyqYBdZWYigaX5A0tsigibdQA,10752
+faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/utils/numeric.cp38-win_amd64.pyd,sha256=7tKEMfWQe04RNnhtGrVt1hPgHdNIc99PmHbTSd69ERI,10752
+faster_eth_abi/utils/numeric.py,sha256=hNGble1NA99_5hrAOnH0ZakCuHc6PFMC1p0olmpo_vM,2232
+faster_eth_abi/utils/padding.cp38-win_amd64.pyd,sha256=hGtYY27LEgjZRn8ILVr96XPiL_zr7ccMt10YcBJhF6A,10752
+faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
+faster_eth_abi/utils/string.cp38-win_amd64.pyd,sha256=CsEnZWyDRCU_8DR6WGoVvETY5ufvEdNkvBmcLatJky8,10752
+faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
+faster_eth_abi/utils/validation.cp38-win_amd64.pyd,sha256=uK55JUrpdE2odEoakg24S_gi_XGubIbg3BltGoiEss4,10752
+faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
+faster_eth_abi-5.2.8.dist-info/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
+faster_eth_abi-5.2.8.dist-info/METADATA,sha256=yOnTAF2c2n9t-pBL2rjLtx82TLs9NscD8mV7UV2ZEnw,5207
+faster_eth_abi-5.2.8.dist-info/WHEEL,sha256=2M046GvC9RLU1f1TWyM-2sB7cRKLhAC7ucAFK8l8f24,99
+faster_eth_abi-5.2.8.dist-info/top_level.txt,sha256=CO2FQwf61aFzjYze7Wywa5KQdJ6bbLkzDoGEjDF2g9o,43
+faster_eth_abi-5.2.8.dist-info/RECORD,,

faster_eth_abi-5.2.8.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+76f9a3652d4d2667c55c__mypyc
+faster_eth_abi

faster_eth_abi-5.2.7.dist-info/RECORD

@@ -1,42 +0,0 @@
-c42f5c78bc058f310136__mypyc.cp38-win_amd64.pyd,sha256=R7Ly2lhWHIOJR2kyUFv3I4zPgmJRzMsk5EAyYG6elaM,141824
-faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
-faster_eth_abi/_codec.cp38-win_amd64.pyd,sha256=oPffSO17VA43_MQO3h9ThqPtFZ423hhRZnafTDXyh8s,10752
-faster_eth_abi/_codec.py,sha256=mEjPRDPbpT67gc3HlzM8xAQ7uDOLwVRqQq5-dbwXZ1g,2543
-faster_eth_abi/_encoding.cp38-win_amd64.pyd,sha256=cbAFl0WY9r1KVIQ56R0IbGrcFXcBbJSua16VOzStoTs,10752
-faster_eth_abi/_encoding.py,sha256=157A_MltVLCEwBmD7SB8UaKXkAOtIKC5MVupk6dk_yA,3217
-faster_eth_abi/abi.cp38-win_amd64.pyd,sha256=VW5W6HoorMQtlCkSBusYQu6W35knXvJvqB5s8Mp-L0g,10752
-faster_eth_abi/abi.py,sha256=-t9OVBSCxy6SuWpCu3cxHrCqkx8_svPIRb0MSFXEl5Q,383
-faster_eth_abi/base.py,sha256=y4IXpQJWGfUISl3xjCO420Grxido3tE2ebPV2rK-DvM,1229
-faster_eth_abi/codec.py,sha256=e1uO8BJrXRn0Ih70eUa5qipD2wcg2aZSR4fyVuGpFoY,4580
-faster_eth_abi/constants.cp38-win_amd64.pyd,sha256=HCruOVtC5tKpp7tNM4hYIjnWacofEbT4ViGVpPRhfc0,10752
-faster_eth_abi/constants.py,sha256=q3FGynS-Eb78cnrL6mBoAvTDz16PF3tW2OylTMd6ajs,114
-faster_eth_abi/decoding.py,sha256=w98AsF5cq5DXE9OVflfkVLpMeCRbxzZuIj0hFPJcJNc,17910
-faster_eth_abi/encoding.py,sha256=vlFlvohYCUCGtvxhIih3apDuCA5FPu-D_qH7UiaiFTQ,18805
-faster_eth_abi/exceptions.py,sha256=KzNYRc9t0CvlkveozWvLeo1WC_GarcBkwzV67aY_5yI,3067
-faster_eth_abi/from_type_str.cp38-win_amd64.pyd,sha256=Wm5jsFmqZqYG0vojORMVUgChjMmZuI6jE1kC1Dh6bEo,10752
-faster_eth_abi/from_type_str.py,sha256=WLRP3OIyrJORgloX-7V0x2KdrZj0kLay-J9I8f-H36s,4446
-faster_eth_abi/grammar.py,sha256=lhEmp3ZwMTzm1-jJiMUVD4zrBgU4MEZCRiND4WxfOes,13839
-faster_eth_abi/io.py,sha256=E_QX7aYAjGYnkNAZmJMmSmx1lqvl_FDNmMFruTi9UX4,3831
-faster_eth_abi/packed.cp38-win_amd64.pyd,sha256=UtGWVJE1fntLKvPNG0mASXmIP0vc2HlxoMsHgfK_3Lc,10752
-faster_eth_abi/packed.py,sha256=RZ2chvsx9_AL9OxY1ixHTsaUJHaR_tmrNdViOIp-xSg,316
-faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/registry.py,sha256=gU5-k_1eYUjs7-NAKoH9nncCJ36tZZHM5ZXvwmXt0cw,21192
-faster_eth_abi/tools/__init__.cp38-win_amd64.pyd,sha256=eEZWZEsTiNiNrOui9MU952CSxzZ-THwIv170mFCleFQ,10752
-faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
-faster_eth_abi/tools/_strategies.cp38-win_amd64.pyd,sha256=ZY3F44p_mji7aQPrZtqpqZBARBJlM00bAa1hsHmU_y0,10752
-faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
-faster_eth_abi/utils/__init__.cp38-win_amd64.pyd,sha256=GYusZ5fV9qana6ismMUcBgzOl54YXCT-CWcDi9opjjE,10752
-faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/utils/numeric.cp38-win_amd64.pyd,sha256=5vy5SpnVlbmr8ZnzRed8uBPH3JvrI9BLBPO5ftYeNks,10752
-faster_eth_abi/utils/numeric.py,sha256=hNGble1NA99_5hrAOnH0ZakCuHc6PFMC1p0olmpo_vM,2232
-faster_eth_abi/utils/padding.cp38-win_amd64.pyd,sha256=8XE4-hP6RrUqX2ERs7rwGU5bU5bc5xGKO2bUdyDomKQ,10752
-faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
-faster_eth_abi/utils/string.cp38-win_amd64.pyd,sha256=BrAFt8HqTChSMh8M7Ds0kf387sQZNfAVz8RRgelsa2c,10752
-faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
-faster_eth_abi/utils/validation.cp38-win_amd64.pyd,sha256=KeA99IaYPqEXXXanh5I7Zu2pdqq80rLkjHcQbNwRlbU,10752
-faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
-faster_eth_abi-5.2.7.dist-info/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
-faster_eth_abi-5.2.7.dist-info/METADATA,sha256=kQzDvvRInVqFBhsPk0aeqgABHsOt6zucNW1MqXA0Ggc,5206
-faster_eth_abi-5.2.7.dist-info/WHEEL,sha256=2M046GvC9RLU1f1TWyM-2sB7cRKLhAC7ucAFK8l8f24,99
-faster_eth_abi-5.2.7.dist-info/top_level.txt,sha256=5cP87jVHTOdG5bgQZ3ws5MGsnIwm_yX-WalM08iynHc,51
-faster_eth_abi-5.2.7.dist-info/RECORD,,

faster_eth_abi-5.2.7.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-c42f5c78bc058f310136__mypyc
-eth_abi
-faster_eth_abi