faster-eth-abi 5.2.7__cp314-cp314-win32.whl → 5.2.9__cp314-cp314-win32.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,109 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Tuple,
+)
+
+from faster_eth_utils import (
+    big_endian_to_int,
+)
+
+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,
+    )
+
+
+def decode_uint_256(stream: ContextFramesBytesIO) -> int:
+    """
+    This function is a faster version of decode_uint_256 in decoding.py.
+
+    It recreates the logic from the UnsignedIntegerDecoder, but we can
+    skip a lot because we know the value of many vars.
+    """
+    # read data from stream
+    if len(data := stream.read(32)) == 32:
+        return big_endian_to_int(data)  # type: ignore [no-any-return]
+    raise InsufficientDataBytes(f"Tried to read 32 bytes, only got {len(data)} bytes.")
+
+
+# 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)
-
-        # 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 decode_head_tail(self, stream)
 
-        return value
+    __call__ = decode
 
 
 class TupleDecoder(BaseDecoder):
@@ -96,14 +98,17 @@ class TupleDecoder(BaseDecoder):
     def __init__(self, decoders: Tuple[BaseDecoder, ...], **kwargs: Any) -> None:
         super().__init__(**kwargs)
 
-        self.decoders = tuple(
+        self.decoders = decoders = tuple(
             HeadTailDecoder(tail_decoder=d) if getattr(d, "is_dynamic", False) else d
             for d in decoders
         )
 
-        self.is_dynamic = any(getattr(d, "is_dynamic", False) for d in self.decoders)
+        self.is_dynamic = any(getattr(d, "is_dynamic", False) for d in decoders)
+        self.len_of_head = sum(
+            getattr(decoder, "array_size", 1) for decoder in 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:
@@ -173,33 +173,35 @@ class SingleDecoder(BaseDecoder):
     def decode(self, stream):
         raw_data = self.read_data_from_stream(stream)
         data, padding_bytes = self.split_data_and_padding(raw_data)
-        if self.decoder_fn is None:
+        decoder_fn = self.decoder_fn
+        if decoder_fn is None:
             raise AssertionError("`decoder_fn` is None")
-        value = self.decoder_fn(data)
+        value = decoder_fn(data)
         self.validate_padding_bytes(value, padding_bytes)
 
         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
+    item_decoder: BaseDecoder = None
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
 
         # Use a head-tail decoder to decode dynamic elements
-        if self.item_decoder.is_dynamic:
-            self.item_decoder = HeadTailDecoder(
-                tail_decoder=self.item_decoder,
-            )
+        item_decoder = self.item_decoder
+        if item_decoder.is_dynamic:
+            self.item_decoder = HeadTailDecoder(tail_decoder=item_decoder)
 
-    def validate(self):
+    def validate(self) -> None:
         super().validate()
 
         if self.item_decoder is None:
@@ -246,78 +248,61 @@ 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:
+        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.decoder_fn is None:
             raise ValueError("`decoder_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(
-                "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 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."
-            )
-
-        return data
+    def read_data_from_stream(self, stream: ContextFramesBytesIO) -> bytes:
+        return read_fixed_byte_size_data_from_stream(self, stream)
 
-    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 +315,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
 
@@ -339,9 +324,8 @@ class FixedByteSizeDecoder(SingleDecoder):
                 f"Padding bytes were not empty: {padding_bytes!r}"
             )
 
-    def _get_value_byte_size(self):
-        value_byte_size = self.value_bit_size // 8
-        return value_byte_size
+    def _get_value_byte_size(self) -> int:
+        return self.value_bit_size // 8
 
 
 class Fixed32ByteSizeDecoder(FixedByteSizeDecoder):
@@ -353,7 +337,7 @@ class BooleanDecoder(Fixed32ByteSizeDecoder):
     is_big_endian = True
 
     @staticmethod
-    def decoder_fn(data):
+    def decoder_fn(data: bytes) -> bool:
         if data == b"\x00":
             return False
         elif data == b"\x01":
@@ -401,12 +385,13 @@ class SignedIntegerDecoder(Fixed32ByteSizeDecoder):
 
     def decoder_fn(self, data):
         value = big_endian_to_int(data)
-        if value >= 2 ** (self.value_bit_size - 1):
-            return value - 2**self.value_bit_size
+        value_bit_size = self.value_bit_size
+        if value >= 2 ** (value_bit_size - 1):
+            return value - 2**value_bit_size
         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
 
@@ -441,16 +426,17 @@ class BytesDecoder(Fixed32ByteSizeDecoder):
 
 
 class BaseFixedDecoder(Fixed32ByteSizeDecoder):
-    frac_places = None
+    frac_places: int = None
     is_big_endian = True
 
-    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]")
 
 
@@ -473,8 +459,9 @@ class UnsignedFixedDecoder(BaseFixedDecoder):
 class SignedFixedDecoder(BaseFixedDecoder):
     def decoder_fn(self, data):
         value = big_endian_to_int(data)
-        if value >= 2 ** (self.value_bit_size - 1):
-            signed_value = value - 2**self.value_bit_size
+        value_bit_size = self.value_bit_size
+        if value >= 2 ** (value_bit_size - 1):
+            signed_value = value - 2**value_bit_size
         else:
             signed_value = value
 
@@ -483,7 +470,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 +501,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 +521,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 +530,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,6 +660,8 @@ 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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 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.9
+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.9.dist-info/RECORD

@@ -0,0 +1,44 @@
+76f9a3652d4d2667c55c__mypyc.cp314-win32.pyd,sha256=0qPsleQujc4Prlr6YdwPjSkYCS_TmzvZEweGoJuPJ8k,138240
+faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
+faster_eth_abi/_codec.cp314-win32.pyd,sha256=TzqeT156gb9NOUYMTbPJIpOgWHH87OZBoh4uf55mqUI,9216
+faster_eth_abi/_codec.py,sha256=fLRvqvrD8F38U4m1wZztvx-7JJbZaPikwXS5u9BzY14,2509
+faster_eth_abi/_decoding.cp314-win32.pyd,sha256=i3fBU4w-BTcjUlV8-S3VOuD8J_v4jaOh1__rbTZIKYM,9216
+faster_eth_abi/_decoding.py,sha256=GeXe2OaAmojlnGbw3CmSzKK9k5g0QLLn_Qesz7y98X0,3208
+faster_eth_abi/_encoding.cp314-win32.pyd,sha256=IPiX1s0Yt6-C6_thN0bc5_41_uR2LHsGSTJmeSCB4nw,9216
+faster_eth_abi/_encoding.py,sha256=157A_MltVLCEwBmD7SB8UaKXkAOtIKC5MVupk6dk_yA,3217
+faster_eth_abi/abi.cp314-win32.pyd,sha256=lsPT4CgXlcYmBdfpK4HVRXnev2nUUVfQSjdqr6n55fg,9216
+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.cp314-win32.pyd,sha256=dTIbg1TxLzK1KYEaKs5hEhHDbaqWu-fpVLbxsQ9Q5bk,9216
+faster_eth_abi/constants.py,sha256=q3FGynS-Eb78cnrL6mBoAvTDz16PF3tW2OylTMd6ajs,114
+faster_eth_abi/decoding.py,sha256=LUyG3EO6K4O6u1020FVMNEB80TwW2aHy6gInHoW5qy8,17632
+faster_eth_abi/encoding.py,sha256=P1svhYylcZa55cQ9LPj6jV8iJVLSL_c5SIZT1Umol58,19679
+faster_eth_abi/exceptions.py,sha256=KzNYRc9t0CvlkveozWvLeo1WC_GarcBkwzV67aY_5yI,3067
+faster_eth_abi/from_type_str.cp314-win32.pyd,sha256=aoyT4srt-ZDUYSXXil8bo7RetY_nOMuPLYrucElURow,9216
+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.cp314-win32.pyd,sha256=xes76a-pSPSIqaoib6a-PtC0VEfrghXh1dWBmO-VAII,9216
+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__.cp314-win32.pyd,sha256=roRJOos6LPFV0oklRO5lnLcL7toUnB7jiVIg7QpjhfQ,9216
+faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
+faster_eth_abi/tools/_strategies.cp314-win32.pyd,sha256=rM5mLhIE7wsL72OYHdYm7HdNRJlr7l8P88otbWrNSGw,9216
+faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
+faster_eth_abi/utils/__init__.cp314-win32.pyd,sha256=qBWDKpqUuHUGmDzDgvMnFJI61BKyJK9Z5PFyo4iWoF4,9216
+faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/utils/numeric.cp314-win32.pyd,sha256=vI7AyNmpSnvVRtwcvy0KXQ4ZY91koRdNfw4vOrzNnDY,9216
+faster_eth_abi/utils/numeric.py,sha256=hNGble1NA99_5hrAOnH0ZakCuHc6PFMC1p0olmpo_vM,2232
+faster_eth_abi/utils/padding.cp314-win32.pyd,sha256=0iTTXC8bGaY4JLEzMAxMc8NLr6Jv1EdY3e3st9xKnx4,9216
+faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
+faster_eth_abi/utils/string.cp314-win32.pyd,sha256=d6My9x_k0SL7VJMt0YqGR3WOJVqozKPc6sdkN_P6DNs,9216
+faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
+faster_eth_abi/utils/validation.cp314-win32.pyd,sha256=bXUcqPgX8XgecFII3Wo9iOBRjJr_vN-oYdnwshVmqVg,9216
+faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
+faster_eth_abi-5.2.9.dist-info/licenses/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
+faster_eth_abi-5.2.9.dist-info/METADATA,sha256=KDOT00QI4vuhhmIEyht-d1iYsmyvKLtq9xwMBQqxhzg,5498
+faster_eth_abi-5.2.9.dist-info/WHEEL,sha256=avp3B09fSRXVHn4cshTNKc58MtFVN-cVe0NyrqeYT2s,97
+faster_eth_abi-5.2.9.dist-info/top_level.txt,sha256=CO2FQwf61aFzjYze7Wywa5KQdJ6bbLkzDoGEjDF2g9o,43
+faster_eth_abi-5.2.9.dist-info/RECORD,,

faster_eth_abi-5.2.9.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.cp314-win32.pyd,sha256=6XMnpBuqLdwGUcJTwyR7nq9DE1dNzn2tgeODugcdr2g,129024
-faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
-faster_eth_abi/_codec.cp314-win32.pyd,sha256=0oOFwWEYGz4W3Dmijtrdsz2w6hR4oJNh4OYr3uxrkUw,9216
-faster_eth_abi/_codec.py,sha256=mEjPRDPbpT67gc3HlzM8xAQ7uDOLwVRqQq5-dbwXZ1g,2543
-faster_eth_abi/_encoding.cp314-win32.pyd,sha256=MPrCH0-WWk8z2Z3SIsHliyXPkJiYs9ggH2cy5frEfz4,9216
-faster_eth_abi/_encoding.py,sha256=157A_MltVLCEwBmD7SB8UaKXkAOtIKC5MVupk6dk_yA,3217
-faster_eth_abi/abi.cp314-win32.pyd,sha256=U51VC1Tj48TN1DBQPHkocBE7klQEE8P1YluSAaUKeVg,9216
-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.cp314-win32.pyd,sha256=OnMdrlBu-AOWwtwhaoQRyDGxuhiNWvuwDJxoNo6bx94,9216
-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.cp314-win32.pyd,sha256=bL48hPOjgqciIiJpguacZ7etLsCxWXwG_rW76BollpI,9216
-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.cp314-win32.pyd,sha256=DoOaBWlHeqsK9mi9kSJW6bFT835IG-i5s0uKUICR0uE,9216
-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__.cp314-win32.pyd,sha256=g-igD5c0HjaRHHnxM5dm7jpVOeayOr6a7fT9gBBzJ9o,9216
-faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
-faster_eth_abi/tools/_strategies.cp314-win32.pyd,sha256=8-VTqEpmG4EtFQtfvqFqJz5MmzatxK4IvEuZFs-jCrQ,9216
-faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
-faster_eth_abi/utils/__init__.cp314-win32.pyd,sha256=tZMVMD0WPC46fBI0oD6gsMPqcBDy19-r-_zjAYYVlwA,9216
-faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/utils/numeric.cp314-win32.pyd,sha256=VJLEaZgmb7hA9r-lC0dXmlzuZaBc9ns5clV9zRNCxos,9216
-faster_eth_abi/utils/numeric.py,sha256=hNGble1NA99_5hrAOnH0ZakCuHc6PFMC1p0olmpo_vM,2232
-faster_eth_abi/utils/padding.cp314-win32.pyd,sha256=Uw6Nl8H3xYfPj4hdFlB6l4f6yKg7zin5bTFMQNA8rlU,9216
-faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
-faster_eth_abi/utils/string.cp314-win32.pyd,sha256=UEYZq9DbyTdYlYFf_HoUJCOEMCScOV6-bJ6fijw5dIk,9216
-faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
-faster_eth_abi/utils/validation.cp314-win32.pyd,sha256=uZhfJKrlt2khHBltXxgIBOxU_XHw5oBi0qLfNmrc8fQ,9216
-faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
-faster_eth_abi-5.2.7.dist-info/licenses/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
-faster_eth_abi-5.2.7.dist-info/METADATA,sha256=96YSgdtfqL_8HbaSyInDgKBRk6QC18eraaRYG-u-v6g,5497
-faster_eth_abi-5.2.7.dist-info/WHEEL,sha256=avp3B09fSRXVHn4cshTNKc58MtFVN-cVe0NyrqeYT2s,97
-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