faster-eth-abi 5.2.4__cp311-cp311-win32.whl → 5.2.5__cp311-cp311-win32.whl

faster_eth_abi/_codec.py

@@ -0,0 +1,82 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Iterable,
+    Tuple,
+    cast,
+)
+
+from eth_typing import (
+    Decodable,
+    TypeStr,
+)
+
+from faster_eth_abi.utils.validation import (
+    validate_bytes_param,
+    validate_list_like_param,
+)
+
+if TYPE_CHECKING:
+    from faster_eth_abi.codec import (
+        ABIDecoder,
+        ABIEncoder,
+    )
+
+
+def encode_c(
+    self: "ABIEncoder",
+    types: Iterable[TypeStr],
+    args: Iterable[Any],
+) -> bytes:
+    """
+    Encodes the python values in ``args`` as a sequence of binary values of
+    the ABI types in ``types`` via the head-tail mechanism.
+
+    :param types: A list or tuple of string representations of the ABI types
+        that will be used for encoding e.g.  ``('uint256', 'bytes[]',
+        '(int,int)')``
+    :param args: A list or tuple of python values to be encoded.
+
+    :returns: The head-tail encoded binary representation of the python
+        values in ``args`` as values of the ABI types in ``types``.
+    """
+    # validate encode types and args
+    validate_list_like_param(types, "types")
+    validate_list_like_param(args, "args")
+
+    encoder = self._registry.get_tuple_encoder(*types)
+
+    return encoder(args)
+
+
+def decode_c(
+    self: "ABIDecoder",
+    types: Iterable[TypeStr],
+    data: Decodable,
+    strict: bool = True,
+) -> Tuple[Any, ...]:
+    """
+    Decodes the binary value ``data`` as a sequence of values of the ABI types
+    in ``types`` via the head-tail mechanism into a tuple of equivalent python
+    values.
+
+    :param types: A list or tuple of string representations of the ABI types that
+        will be used for decoding e.g. ``('uint256', 'bytes[]', '(int,int)')``
+    :param data: The binary value to be decoded.
+    :param strict: If ``False``, dynamic-type decoders will ignore validations such
+        as making sure the data is padded to a multiple of 32 bytes or checking that
+        padding bytes are zero / empty. ``False`` is how the Solidity ABI decoder
+        currently works. However, ``True`` is the default for the faster-eth-abi
+        library.
+
+    :returns: A tuple of equivalent python values for the ABI values
+        represented in ``data``.
+    """
+    # validate decode types and data
+    validate_list_like_param(types, "types")
+    validate_bytes_param(data, "data")
+
+    decoder = self._registry.get_tuple_decoder(*types, strict=strict)
+    stream = self.stream_class(data)
+
+    return cast(Tuple[Any, ...], decoder(stream))

faster_eth_abi/_encoding.py

@@ -0,0 +1,102 @@
+from itertools import (
+    accumulate,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    List,
+    Optional,
+    Sequence,
+    TypeVar,
+)
+
+if TYPE_CHECKING:
+    from faster_eth_abi.encoding import (
+        BaseEncoder,
+    )
+
+
+T = TypeVar("T")
+
+
+def encode_tuple(
+    values: Sequence[Any],
+    encoders: Sequence["BaseEncoder"],
+) -> bytes:
+    raw_head_chunks: List[Optional[bytes]] = []
+    tail_chunks: List[bytes] = []
+    for value, encoder in zip(values, encoders):
+        if getattr(encoder, "is_dynamic", False):
+            raw_head_chunks.append(None)
+            tail_chunks.append(encoder(value))
+        else:
+            raw_head_chunks.append(encoder(value))
+            tail_chunks.append(b"")
+
+    head_length = sum(32 if item is None else len(item) for item in raw_head_chunks)
+    tail_offsets = (0, *accumulate(len(item) for item in tail_chunks[:-1]))
+    head_chunks = tuple(
+        encode_uint_256(head_length + offset) if chunk is None else chunk
+        for chunk, offset in zip(raw_head_chunks, tail_offsets)
+    )
+
+    return b"".join(head_chunks) + b"".join(tail_chunks)
+
+
+def encode_fixed(
+    value: Any,
+    encode_fn: Callable[[Any], bytes],
+    is_big_endian: bool,
+    data_byte_size: int,
+) -> bytes:
+    base_encoded_value = encode_fn(value)
+    if is_big_endian:
+        return base_encoded_value.rjust(data_byte_size, b"\x00")
+    else:
+        return base_encoded_value.ljust(data_byte_size, b"\x00")
+
+
+def encode_signed(
+    value: T,
+    encode_fn: Callable[[T], bytes],
+    data_byte_size: int,
+) -> bytes:
+    base_encoded_value = encode_fn(value)
+    if value >= 0:
+        return base_encoded_value.rjust(data_byte_size, b"\x00")
+    else:
+        return base_encoded_value.rjust(data_byte_size, b"\xff")
+
+
+def encode_elements(item_encoder: "BaseEncoder", value: Sequence[Any]) -> bytes:
+    tail_chunks = tuple(item_encoder(i) for i in value)
+
+    items_are_dynamic = getattr(item_encoder, "is_dynamic", False)
+    if not items_are_dynamic or len(value) == 0:
+        return b"".join(tail_chunks)
+
+    head_length = 32 * len(value)
+    tail_offsets = (0, *accumulate(len(item) for item in tail_chunks[:-1]))
+    head_chunks = tuple(
+        encode_uint_256(head_length + offset) for offset in tail_offsets
+    )
+    return b"".join(head_chunks) + b"".join(tail_chunks)
+
+
+def encode_elements_dynamic(item_encoder: "BaseEncoder", value: Sequence[Any]) -> bytes:
+    encoded_size = encode_uint_256(len(value))
+    encoded_elements = encode_elements(item_encoder, value)
+    return encoded_size + encoded_elements
+
+
+def encode_uint_256(i: int) -> bytes:
+    # An optimized version of the `encode_uint_256` in `encoding.py` which does not perform any validation.
+    # We should not have any issues here unless you're encoding really really massive iterables.
+    big_endian = int_to_big_endian(i)
+    return big_endian.rjust(32, b"\x00")
+
+
+def int_to_big_endian(value: int) -> bytes:
+    # vendored from eth-utils so it can compile nicely into faster-eth-abi's binary
+    return value.to_bytes((value.bit_length() + 7) // 8 or 1, "big")

faster_eth_abi/codec.py

@@ -2,7 +2,6 @@ from typing import (
     Any,
     Iterable,
     Tuple,
-    cast,
 )
 
 from eth_typing.abi import (
@@ -10,12 +9,12 @@ from eth_typing.abi import (
     TypeStr,
 )
 
+from faster_eth_abi._codec import (
+    decode_c,
+    encode_c,
+)
 from faster_eth_abi.decoding import (
     ContextFramesBytesIO,
-    TupleDecoder,
-)
-from faster_eth_abi.encoding import (
-    TupleEncoder,
 )
 from faster_eth_abi.exceptions import (
     EncodingError,
@@ -23,10 +22,6 @@ from faster_eth_abi.exceptions import (
 from faster_eth_abi.registry import (
     ABIRegistry,
 )
-from faster_eth_abi.utils.validation import (
-    validate_bytes_param,
-    validate_list_like_param,
-)
 
 
 class BaseABICoder:
@@ -64,15 +59,7 @@ class ABIEncoder(BaseABICoder):
         :returns: The head-tail encoded binary representation of the python
             values in ``args`` as values of the ABI types in ``types``.
         """
-        # validate encode types and args
-        validate_list_like_param(types, "types")
-        validate_list_like_param(args, "args")
-
-        encoders = tuple(self._registry.get_encoder(type_str) for type_str in types)
-
-        encoder = TupleEncoder(encoders=encoders)
-
-        return encoder(args)
+        return encode_c(self, types, args)
 
     def is_encodable(self, typ: TypeStr, arg: Any) -> bool:
         """
@@ -149,18 +136,7 @@ class ABIDecoder(BaseABICoder):
         :returns: A tuple of equivalent python values for the ABI values
             represented in ``data``.
         """
-        # validate decode types and data
-        validate_list_like_param(types, "types")
-        validate_bytes_param(data, "data")
-
-        decoders = tuple(
-            self._registry.get_decoder(type_str, strict=strict) for type_str in types
-        )
-
-        decoder = TupleDecoder(decoders=decoders)
-        stream = self.stream_class(data)
-
-        return cast(Tuple[Any, ...], decoder(stream))
+        return decode_c(self, types, data, strict)
 
 
 class ABICodec(ABIEncoder, ABIDecoder):

faster_eth_abi/encoding.py

@@ -1,18 +1,16 @@
 import abc
 import codecs
 import decimal
-from itertools import (
-    accumulate,
-)
 from typing import (
     Any,
+    NoReturn,
     Optional,
+    Sequence,
     Tuple,
     Type,
 )
 
 from faster_eth_utils import (
-    int_to_big_endian,
     is_address,
     is_boolean,
     is_bytes,
@@ -23,6 +21,14 @@ from faster_eth_utils import (
     to_canonical_address,
 )
 
+from faster_eth_abi._encoding import (
+    encode_elements,
+    encode_elements_dynamic,
+    encode_fixed,
+    encode_signed,
+    encode_tuple,
+    int_to_big_endian,
+)
 from faster_eth_abi.base import (
     BaseCoder,
 )
@@ -45,8 +51,6 @@ from faster_eth_abi.utils.numeric import (
     compute_unsigned_integer_bounds,
 )
 from faster_eth_abi.utils.padding import (
-    fpad,
-    zpad,
     zpad_right,
 )
 from faster_eth_abi.utils.string import (
@@ -82,7 +86,7 @@ class BaseEncoder(BaseCoder, metaclass=abc.ABCMeta):
         value: Any,
         exc: Type[Exception] = EncodingTypeError,
         msg: Optional[str] = None,
-    ) -> None:
+    ) -> NoReturn:
         """
         Throws a standard exception for when a value is not encodable by an
         encoder.
@@ -133,26 +137,7 @@ class TupleEncoder(BaseEncoder):
 
     def encode(self, values):
         self.validate_value(values)
-
-        raw_head_chunks = []
-        tail_chunks = []
-        for value, encoder in zip(values, self.encoders):
-            if getattr(encoder, "is_dynamic", False):
-                raw_head_chunks.append(None)
-                tail_chunks.append(encoder(value))
-            else:
-                raw_head_chunks.append(encoder(value))
-                tail_chunks.append(b"")
-
-        head_length = sum(32 if item is None else len(item) for item in raw_head_chunks)
-        tail_offsets = (0,) + tuple(accumulate(map(len, tail_chunks[:-1])))
-        head_chunks = tuple(
-            encode_uint_256(head_length + offset) if chunk is None else chunk
-            for chunk, offset in zip(raw_head_chunks, tail_offsets)
-        )
-
-        encoded_value = b"".join(head_chunks + tuple(tail_chunks))
-        return encoded_value
+        return encode_tuple(values, self.encoders)
 
     @parse_tuple_type_str
     def from_type_str(cls, abi_type, registry):
@@ -194,18 +179,13 @@ class FixedSizeEncoder(BaseEncoder):
     def validate_value(self, value):
         raise NotImplementedError("Must be implemented by subclasses")
 
-    def encode(self, value):
+    def encode(self, value: Any) -> bytes:
         self.validate_value(value)
         if self.encode_fn is None:
             raise AssertionError("`encode_fn` is None")
-        base_encoded_value = self.encode_fn(value)
-
-        if self.is_big_endian:
-            padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
-        else:
-            padded_encoded_value = zpad_right(base_encoded_value, self.data_byte_size)
-
-        return padded_encoded_value
+        return encode_fixed(
+            value, self.encode_fn, self.is_big_endian, self.data_byte_size
+        )
 
 
 class Fixed32ByteSizeEncoder(FixedSizeEncoder):
@@ -217,7 +197,7 @@ class BooleanEncoder(Fixed32ByteSizeEncoder):
     is_big_endian = True
 
     @classmethod
-    def validate_value(cls, value):
+    def validate_value(cls, value: Any) -> None:
         if not is_boolean(value):
             cls.invalidate_value(value)
 
@@ -301,19 +281,12 @@ class SignedIntegerEncoder(NumberEncoder):
     bounds_fn = staticmethod(compute_signed_integer_bounds)
     type_check_fn = staticmethod(is_integer)
 
-    def encode_fn(self, value):
+    def encode_fn(self, value: int) -> bytes:
         return int_to_big_endian(value % (2**self.value_bit_size))
 
     def encode(self, value):
         self.validate_value(value)
-        base_encoded_value = self.encode_fn(value)
-
-        if value >= 0:
-            padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
-        else:
-            padded_encoded_value = fpad(base_encoded_value, self.data_byte_size)
-
-        return padded_encoded_value
+        return encode_signed(value, self.encode_fn, self.data_byte_size)
 
     @parse_type_str("int")
     def from_type_str(cls, abi_type, registry):
@@ -353,7 +326,7 @@ class BaseFixedEncoder(NumberEncoder):
             self.invalidate_value(
                 value,
                 exc=IllegalValue,
-                msg=f"residue {repr(residue)} outside allowed fractional precision of "
+                msg=f"residue {residue!r} outside allowed fractional precision of "
                 f"{self.frac_places}",
             )
 
@@ -415,14 +388,7 @@ class SignedFixedEncoder(BaseFixedEncoder):
 
     def encode(self, value):
         self.validate_value(value)
-        base_encoded_value = self.encode_fn(value)
-
-        if value >= 0:
-            padded_encoded_value = zpad(base_encoded_value, self.data_byte_size)
-        else:
-            padded_encoded_value = fpad(base_encoded_value, self.data_byte_size)
-
-        return padded_encoded_value
+        return encode_signed(value, self.encode_fn, self.data_byte_size)
 
     @parse_type_str("fixed")
     def from_type_str(cls, abi_type, registry):
@@ -452,7 +418,7 @@ class AddressEncoder(Fixed32ByteSizeEncoder):
     is_big_endian = True
 
     @classmethod
-    def validate_value(cls, value):
+    def validate_value(cls, value: Any) -> None:
         if not is_address(value):
             cls.invalidate_value(value)
 
@@ -474,7 +440,7 @@ class PackedAddressEncoder(AddressEncoder):
 class BytesEncoder(Fixed32ByteSizeEncoder):
     is_big_endian = False
 
-    def validate_value(self, value):
+    def validate_value(self, value: Any) -> None:
         if not is_bytes(value):
             self.invalidate_value(value)
 
@@ -508,7 +474,7 @@ class ByteStringEncoder(BaseEncoder):
     is_dynamic = True
 
     @classmethod
-    def validate_value(cls, value):
+    def validate_value(cls, value: Any) -> None:
         if not is_bytes(value):
             cls.invalidate_value(value)
 
@@ -540,7 +506,7 @@ class TextStringEncoder(BaseEncoder):
     is_dynamic = True
 
     @classmethod
-    def validate_value(cls, value):
+    def validate_value(cls, value: Any) -> None:
         if not is_text(value):
             cls.invalidate_value(value)
 
@@ -579,7 +545,7 @@ class BaseArrayEncoder(BaseEncoder):
         if self.item_encoder is None:
             raise ValueError("`item_encoder` may not be none")
 
-    def validate_value(self, value):
+    def validate_value(self, value: Any) -> None:
         if not is_list_like(value):
             self.invalidate_value(
                 value,
@@ -589,24 +555,9 @@ class BaseArrayEncoder(BaseEncoder):
         for item in value:
             self.item_encoder.validate_value(item)
 
-    def encode_elements(self, value):
+    def encode_elements(self, value: Sequence[Any]) -> bytes:
         self.validate_value(value)
-
-        item_encoder = self.item_encoder
-        if item_encoder is None:
-            raise AssertionError("`item_encoder` is None")
-        tail_chunks = tuple(item_encoder(i) for i in value)
-
-        items_are_dynamic = getattr(item_encoder, "is_dynamic", False)
-        if not items_are_dynamic or len(value) == 0:
-            return b"".join(tail_chunks)
-
-        head_length = 32 * len(value)
-        tail_offsets = (0,) + tuple(accumulate(map(len, tail_chunks[:-1])))
-        head_chunks = tuple(
-            encode_uint_256(head_length + offset) for offset in tail_offsets
-        )
-        return b"".join(head_chunks + tail_chunks)
+        return encode_elements(self.item_encoder, value)
 
     @parse_type_str(with_arrlist=True)
     def from_type_str(cls, abi_type, registry):
@@ -627,7 +578,7 @@ class BaseArrayEncoder(BaseEncoder):
 class PackedArrayEncoder(BaseArrayEncoder):
     array_size = None
 
-    def validate_value(self, value):
+    def validate_value(self, value: Any) -> None:
         super().validate_value(value)
 
         if self.array_size is not None and len(value) != self.array_size:
@@ -638,10 +589,8 @@ class PackedArrayEncoder(BaseArrayEncoder):
                 "expected",
             )
 
-    def encode(self, value):
-        encoded_elements = self.encode_elements(value)
-
-        return encoded_elements
+    def encode(self, value: Sequence[Any]) -> bytes:
+        return encode_elements(self.item_encoder, value)
 
     @parse_type_str(with_arrlist=True)
     def from_type_str(cls, abi_type, registry):
@@ -671,7 +620,7 @@ class SizedArrayEncoder(BaseArrayEncoder):
         if self.array_size is None:
             raise ValueError("`array_size` may not be none")
 
-    def validate_value(self, value):
+    def validate_value(self, value: Any) -> None:
         super().validate_value(value)
 
         if len(value) != self.array_size:
@@ -682,18 +631,12 @@ class SizedArrayEncoder(BaseArrayEncoder):
                 "expected",
             )
 
-    def encode(self, value):
-        encoded_elements = self.encode_elements(value)
-
-        return encoded_elements
+    def encode(self, value: Sequence[Any]) -> bytes:
+        return encode_elements(self.item_encoder, value)
 
 
 class DynamicArrayEncoder(BaseArrayEncoder):
     is_dynamic = True
 
-    def encode(self, value):
-        encoded_size = encode_uint_256(len(value))
-        encoded_elements = self.encode_elements(value)
-        encoded_value = encoded_size + encoded_elements
-
-        return encoded_value
+    def encode(self, value: Sequence[Any]) -> bytes:
+        return encode_elements_dynamic(self.item_encoder, value)

faster_eth_abi/registry.py

@@ -347,6 +347,12 @@ class ABIRegistry(Copyable, BaseRegistry):
         self._decoders = PredicateMapping("decoder registry")
         self.get_encoder = functools.lru_cache(maxsize=None)(self._get_encoder_uncached)
         self.get_decoder = functools.lru_cache(maxsize=None)(self._get_decoder_uncached)
+        self.get_tuple_encoder = functools.lru_cache(maxsize=None)(
+            self._get_tuple_encoder_uncached
+        )
+        self.get_tuple_decoder = functools.lru_cache(maxsize=None)(
+            self._get_tuple_decoder_uncached
+        )
 
     def _get_registration(self, mapping, type_str):
         coder = super()._get_registration(mapping, type_str)
@@ -454,9 +460,17 @@ class ABIRegistry(Copyable, BaseRegistry):
         self.unregister_encoder(label)
         self.unregister_decoder(label)
 
-    def _get_encoder_uncached(self, type_str):
+    def _get_encoder_uncached(self, type_str: TypeStr):  # type: ignore [no-untyped-def]
         return self._get_registration(self._encoders, type_str)
 
+    def _get_tuple_encoder_uncached(
+        self, 
+        *type_strs: TypeStr,
+    ) -> encoding.TupleEncoder:
+        return encoding.TupleEncoder(
+            encoders=tuple(self.get_encoder(type_str) for type_str in type_strs)
+        )
+
     def has_encoder(self, type_str: TypeStr) -> bool:
         """
         Returns ``True`` if an encoder is found for the given type string
@@ -473,7 +487,7 @@ class ABIRegistry(Copyable, BaseRegistry):
 
         return True
 
-    def _get_decoder_uncached(self, type_str, strict=True):
+    def _get_decoder_uncached(self, type_str: TypeStr, strict: bool = True):  # type: ignore [no-untyped-def]
         decoder = self._get_registration(self._decoders, type_str)
 
         if hasattr(decoder, "is_dynamic") and decoder.is_dynamic:
@@ -484,6 +498,15 @@ class ABIRegistry(Copyable, BaseRegistry):
 
         return decoder
 
+    def _get_tuple_decoder_uncached(
+        self, 
+        *type_strs: TypeStr, 
+        strict: bool = True,
+    ) -> decoding.TupleDecoder:
+        return decoding.TupleDecoder(
+            decoders=tuple(self.get_decoder(type_str, strict) for type_str in type_strs)
+        )
+
     def copy(self):
         """
         Copies a registry such that new registrations can be made or existing

faster_eth_abi/utils/validation.py

@@ -2,13 +2,9 @@ from typing import (
     Any,
 )
 
-from faster_eth_utils import (
-    is_bytes,
-)
-
 
 def validate_bytes_param(param: Any, param_name: str) -> None:
-    if not is_bytes(param):
+    if not isinstance(param, (bytes, bytearray)):
         raise TypeError(
             f"The `{param_name}` value must be of bytes type. Got {type(param)}"
         )

{faster_eth_abi-5.2.4.dist-info → faster_eth_abi-5.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: faster_eth_abi
-Version: 5.2.4
+Version: 5.2.5
 Summary: A 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

faster_eth_abi-5.2.5.dist-info/RECORD

@@ -0,0 +1,42 @@
+c42f5c78bc058f310136__mypyc.cp311-win32.pyd,sha256=aSWZWYr9mokC4Zig1subPc2ysik7zCY0p6n0u7cqAc0,123392
+faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
+faster_eth_abi/_codec.cp311-win32.pyd,sha256=hMD1tHjfAZPbGGkTz8pgJtJlSQuASdOb6PqiYGsWTto,9216
+faster_eth_abi/_codec.py,sha256=mEjPRDPbpT67gc3HlzM8xAQ7uDOLwVRqQq5-dbwXZ1g,2543
+faster_eth_abi/_encoding.cp311-win32.pyd,sha256=9sORx3nV-1qpSXHjsYnloVaOLVYsx_LAkpJ4pud1sac,9216
+faster_eth_abi/_encoding.py,sha256=YwtCHxSIVXHBiqQxz78kPIjCSf352if38mVeFstE-04,3204
+faster_eth_abi/abi.cp311-win32.pyd,sha256=zM7Cqmb38diBGg-VT49DcsGZOGutsq5XtdEw5l8i170,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.cp311-win32.pyd,sha256=jc70SYQmRsjmzbPJ1wXNxyT7CuGfy4KiaWuU4mqCL_8,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.cp311-win32.pyd,sha256=SI2YI8j_lGQ7nXDD1fxl9S-B-86VUBUyDFtm3XzPV6k,9216
+faster_eth_abi/from_type_str.py,sha256=WLRP3OIyrJORgloX-7V0x2KdrZj0kLay-J9I8f-H36s,4446
+faster_eth_abi/grammar.py,sha256=mB68n7WuFvQB8lh5zPZEO36fOXGfj3gEnNP6yWFHvQo,13802
+faster_eth_abi/io.py,sha256=E_QX7aYAjGYnkNAZmJMmSmx1lqvl_FDNmMFruTi9UX4,3831
+faster_eth_abi/packed.cp311-win32.pyd,sha256=m4m6k8lqO4Wa8bT1VpynaVcYYtMkae3gOIBbuRyzN0A,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__.cp311-win32.pyd,sha256=gsHhIv9PBbDGr88VznI-5ew5glBwWVf1LFlnf_J1D28,9216
+faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
+faster_eth_abi/tools/_strategies.cp311-win32.pyd,sha256=hvYcGKPoEp4ZJJLGppjfZgpI5SafVH9P_FXc1Ga7C6E,9216
+faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
+faster_eth_abi/utils/__init__.cp311-win32.pyd,sha256=8KTFukR5g2t2q5ohsSfo_xXqEbt8euq_TOBWZLbFTfw,9216
+faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/utils/numeric.cp311-win32.pyd,sha256=gBNPHv0x8AYRVsVRWoY2JLdVJOp65C4aBjYbj5ktnfk,9216
+faster_eth_abi/utils/numeric.py,sha256=hNGble1NA99_5hrAOnH0ZakCuHc6PFMC1p0olmpo_vM,2232
+faster_eth_abi/utils/padding.cp311-win32.pyd,sha256=QpJWQZOGjfx8JFd1Ys8daLqOUpe0nYcX_dN-sUJEYhk,9216
+faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
+faster_eth_abi/utils/string.cp311-win32.pyd,sha256=XgN0k85nstaeXIwF_AM4bJPf27kkoYMQdrSKiUOSfkM,9216
+faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
+faster_eth_abi/utils/validation.cp311-win32.pyd,sha256=0A3eUTe4E92KctAn83yL4QHsX9--tn1yNmtIXhN_Spo,9216
+faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
+faster_eth_abi-5.2.5.dist-info/licenses/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
+faster_eth_abi-5.2.5.dist-info/METADATA,sha256=BibGaKKtyttJ3DAAaHTi-BSrtUZs1VrWHe1TXtDL79k,4224
+faster_eth_abi-5.2.5.dist-info/WHEEL,sha256=Ri8zddKrjGdgjlj1OpSsvpDnvHfnQhMQWi3E_v2pqng,97
+faster_eth_abi-5.2.5.dist-info/top_level.txt,sha256=5cP87jVHTOdG5bgQZ3ws5MGsnIwm_yX-WalM08iynHc,51
+faster_eth_abi-5.2.5.dist-info/RECORD,,

faster_eth_abi-5.2.5.dist-info/top_level.txt

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

faster_eth_abi-5.2.4.dist-info/RECORD

@@ -1,38 +0,0 @@
-a1f8aa123fabc88e2b56__mypyc.cp311-win32.pyd,sha256=DFVAJsvyrIhHk_8qW1e_efHigUGLYhmdcEGu-nAp8O4,107008
-faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
-faster_eth_abi/abi.cp311-win32.pyd,sha256=GfsP9qLKO-XqAdDNwB4bYT5ECuk_HznOcx9do66WMoM,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=5wbB8yznz6v4-W6W_q-gfeHh247S5UmUubo6_r379fk,5341
-faster_eth_abi/constants.cp311-win32.pyd,sha256=l7CPURadgt3Esk7hNgo7beZJ8WwuSRpqDsyIK_g4Q2E,9216
-faster_eth_abi/constants.py,sha256=q3FGynS-Eb78cnrL6mBoAvTDz16PF3tW2OylTMd6ajs,114
-faster_eth_abi/decoding.py,sha256=w98AsF5cq5DXE9OVflfkVLpMeCRbxzZuIj0hFPJcJNc,17910
-faster_eth_abi/encoding.py,sha256=CLeUpoWZhwIOOGMAMY8NwYdBdDd1j6AXcKqVkoevuKk,20687
-faster_eth_abi/exceptions.py,sha256=KzNYRc9t0CvlkveozWvLeo1WC_GarcBkwzV67aY_5yI,3067
-faster_eth_abi/from_type_str.cp311-win32.pyd,sha256=VUUIYp1MiEO6qke_4erZO4f--pQePZP5QO60rWxxTOo,9216
-faster_eth_abi/from_type_str.py,sha256=WLRP3OIyrJORgloX-7V0x2KdrZj0kLay-J9I8f-H36s,4446
-faster_eth_abi/grammar.py,sha256=mB68n7WuFvQB8lh5zPZEO36fOXGfj3gEnNP6yWFHvQo,13802
-faster_eth_abi/io.py,sha256=E_QX7aYAjGYnkNAZmJMmSmx1lqvl_FDNmMFruTi9UX4,3831
-faster_eth_abi/packed.cp311-win32.pyd,sha256=dp7vzQbMWACls9hnC0PT8B5vBbfotnZULxpfByBbj2M,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=md0L1XgJ-Wb7mlpLm2Di-5S5Mr53jxHHgjUhI9vDK-0,20307
-faster_eth_abi/tools/__init__.cp311-win32.pyd,sha256=hKboTv0wwC_xPmt-uhpV51KHxbUz-KKTFip0psI5Jvc,9216
-faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
-faster_eth_abi/tools/_strategies.cp311-win32.pyd,sha256=M1QlUWUIALJIqS9Ji3w_DeMV3GudfHqWR-7bcehyPKk,9216
-faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
-faster_eth_abi/utils/__init__.cp311-win32.pyd,sha256=18yQ07LdV-ZqkCnQKgk63wmPxUspLEH6capuTMAjynA,9216
-faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/utils/numeric.cp311-win32.pyd,sha256=0caHHaa5C6VjrP3G8pQF6WAJ_F3Bi-GduuK2GJD0YoA,9216
-faster_eth_abi/utils/numeric.py,sha256=hNGble1NA99_5hrAOnH0ZakCuHc6PFMC1p0olmpo_vM,2232
-faster_eth_abi/utils/padding.cp311-win32.pyd,sha256=k3xeL_sKrNeVnjhLjG4dwSsktcs4eIYw8lGO4iu0utA,9216
-faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
-faster_eth_abi/utils/string.cp311-win32.pyd,sha256=5YGZtf0ytrPWHmd9GRD8GD2xnnus7d2sVhLVhE_D9OQ,9216
-faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
-faster_eth_abi/utils/validation.cp311-win32.pyd,sha256=r4zM5hvnkc1D8jgE9DnBjQMvM_3KhtocG_yFY6-GQZg,9216
-faster_eth_abi/utils/validation.py,sha256=3JTxhDbhkfkNeKKQm2TjiCgmDN9vdlX8_pmWeZuWCBg,569
-faster_eth_abi-5.2.4.dist-info/licenses/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
-faster_eth_abi-5.2.4.dist-info/METADATA,sha256=03oBUuwxfTvXEx4rroDxeVnbk6d_AfdxcbmBcVgK6jE,4224
-faster_eth_abi-5.2.4.dist-info/WHEEL,sha256=Ri8zddKrjGdgjlj1OpSsvpDnvHfnQhMQWi3E_v2pqng,97
-faster_eth_abi-5.2.4.dist-info/top_level.txt,sha256=NbjfpQ9lBrFaSYDeeRrYo2vn3ZGVqu_9MZ0LOqjzQho,51
-faster_eth_abi-5.2.4.dist-info/RECORD,,

faster_eth_abi-5.2.4.dist-info/top_level.txt

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