faster-eth-abi 5.2.8__cp310-cp310-musllinux_1_2_x86_64.whl → 5.2.10__cp310-cp310-musllinux_1_2_x86_64.whl

faster_eth_abi/_decoding.py

@@ -1,12 +1,16 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
     Tuple,
 )
 
+from faster_eth_utils import (
+    big_endian_to_int,
+)
+
 from faster_eth_abi.exceptions import (
     InsufficientDataBytes,
+    NonEmptyPaddingBytes,
 )
 from faster_eth_abi.io import (
     BytesIO,
@@ -20,31 +24,25 @@ if TYPE_CHECKING:
         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
+# Helpers
+def decode_uint_256(stream: ContextFramesBytesIO) -> int:
+    """
+    This function is a faster version of decode_uint_256 in decoding.py.
 
-    return _UINT256_DECODER
+    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.")
 
 
-def decode_uint_256(stream: ContextFramesBytesIO) -> int:
-    decoder = _UINT256_DECODER
-    if decoder is None:
-        decoder = __set_uint256_decoder()
-    decoded: int = decoder(stream)
-    return decoded
+def get_value_byte_size(decoder: "FixedByteSizeDecoder") -> int:
+    return decoder.value_bit_size // 8
 
 
 # HeadTailDecoder
@@ -115,3 +113,43 @@ def read_fixed_byte_size_data_from_stream(
     raise InsufficientDataBytes(
         f"Tried to read {data_byte_size} bytes, only got {len(data)} bytes."
     )
+
+
+def split_data_and_padding_fixed_byte_size(
+    self: "FixedByteSizeDecoder",
+    raw_data: bytes,
+) -> Tuple[bytes, bytes]:
+    value_byte_size = get_value_byte_size(self)
+    padding_size = self.data_byte_size - value_byte_size
+
+    if self.is_big_endian:
+        if padding_size == 0:
+            return raw_data, b""
+        padding_bytes = raw_data[:padding_size]
+        data = raw_data[padding_size:]
+    else:
+        data = raw_data[:value_byte_size]
+        padding_bytes = raw_data[value_byte_size:]
+
+    return data, padding_bytes
+
+
+def validate_padding_bytes_fixed_byte_size(
+    self: "FixedByteSizeDecoder",
+    value: Any,
+    padding_bytes: bytes,
+) -> None:
+    value_byte_size = get_value_byte_size(self)
+    padding_size = self.data_byte_size - value_byte_size
+
+    if padding_bytes != b"\x00" * padding_size:
+        raise NonEmptyPaddingBytes(f"Padding bytes were not empty: {padding_bytes!r}")
+
+
+# BooleanDecoder
+def decoder_fn_boolean(data: bytes) -> bool:
+    if data == b"\x00":
+        return False
+    elif data == b"\x01":
+        return True
+    raise NonEmptyPaddingBytes(f"Boolean must be either 0x0 or 0x1.  Got: {data!r}")

faster_eth_abi/_encoding.py

@@ -1,6 +1,3 @@
-from itertools import (
-    accumulate,
-)
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -35,7 +32,12 @@ def encode_tuple(
             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]))
+    tail_offsets = [0]
+    total_offset = 0
+    for item in tail_chunks[:-1]:
+        total_offset += len(item)
+        tail_offsets.append(total_offset)
+
     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)
@@ -77,7 +79,12 @@ def encode_elements(item_encoder: "BaseEncoder", value: Sequence[Any]) -> bytes:
         return b"".join(tail_chunks)
 
     head_length = 32 * len(value)
-    tail_offsets = (0, *accumulate(len(item) for item in tail_chunks[:-1]))
+    tail_offsets = [0]
+    total_offset = 0
+    for item in tail_chunks[:-1]:
+        total_offset += len(item)
+        tail_offsets.append(total_offset)
+
     head_chunks = tuple(
         encode_uint_256(head_length + offset) for offset in tail_offsets
     )

faster_eth_abi/decoding.py

@@ -19,7 +19,11 @@ from faster_eth_abi._decoding import (
     decode_head_tail,
     decode_sized_array,
     decode_tuple,
+    decoder_fn_boolean,
+    get_value_byte_size,
     read_fixed_byte_size_data_from_stream,
+    split_data_and_padding_fixed_byte_size,
+    validate_padding_bytes_fixed_byte_size,
 )
 from faster_eth_abi.base import (
     BaseCoder,
@@ -98,14 +102,14 @@ 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 self.decoders
+            getattr(decoder, "array_size", 1) for decoder in decoders
         )
 
     def validate(self) -> None:
@@ -173,9 +177,10 @@ 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
@@ -190,16 +195,15 @@ class SingleDecoder(BaseDecoder):
 
 
 class BaseArrayDecoder(BaseDecoder):
-    item_decoder = None
+    item_decoder: BaseDecoder = None
 
     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) -> None:
         super().validate()
@@ -280,51 +284,37 @@ class FixedByteSizeDecoder(SingleDecoder):
     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: ContextFramesBytesIO) -> bytes:
         return read_fixed_byte_size_data_from_stream(self, stream)
 
     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
-
-        if self.is_big_endian:
-            padding_bytes = raw_data[:padding_size]
-            data = raw_data[padding_size:]
-        else:
-            data = raw_data[:value_byte_size]
-            padding_bytes = raw_data[value_byte_size:]
-
-        return data, padding_bytes
+        return split_data_and_padding_fixed_byte_size(self, raw_data)
 
     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
-
-        if padding_bytes != b"\x00" * padding_size:
-            raise NonEmptyPaddingBytes(
-                f"Padding bytes were not empty: {padding_bytes!r}"
-            )
+        validate_padding_bytes_fixed_byte_size(self, value, padding_bytes)
 
-    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:
+        # This is unused, but it is kept in to preserve the eth-abi api
+        return get_value_byte_size(self)
 
 
 class Fixed32ByteSizeDecoder(FixedByteSizeDecoder):
@@ -335,16 +325,7 @@ class BooleanDecoder(Fixed32ByteSizeDecoder):
     value_bit_size = 8
     is_big_endian = True
 
-    @staticmethod
-    def decoder_fn(data):
-        if data == b"\x00":
-            return False
-        elif data == b"\x01":
-            return True
-        else:
-            raise NonEmptyPaddingBytes(
-                f"Boolean must be either 0x0 or 0x1.  Got: {data!r}"
-            )
+    decoder_fn = staticmethod(decoder_fn_boolean)
 
     @parse_type_str("bool")
     def from_type_str(cls, abi_type, registry):
@@ -384,13 +365,14 @@ 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: Any, padding_bytes: bytes) -> None:
-        value_byte_size = self._get_value_byte_size()
+        value_byte_size = get_value_byte_size(self)
         padding_size = self.data_byte_size - value_byte_size
 
         if value >= 0:
@@ -424,16 +406,17 @@ class BytesDecoder(Fixed32ByteSizeDecoder):
 
 
 class BaseFixedDecoder(Fixed32ByteSizeDecoder):
-    frac_places = None
+    frac_places: int = None
     is_big_endian = True
 
     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]")
 
 
@@ -456,8 +439,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
 
@@ -467,7 +451,7 @@ class SignedFixedDecoder(BaseFixedDecoder):
         return decimal_value
 
     def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
-        value_byte_size = self._get_value_byte_size()
+        value_byte_size = get_value_byte_size(self)
         padding_size = self.data_byte_size - value_byte_size
 
         if value >= 0:

faster_eth_abi/encoding.py

@@ -668,5 +668,3 @@ class DynamicArrayEncoder(BaseArrayEncoder):
 
     def encode(self, value: Sequence[Any]) -> bytes:
         return encode_elements_dynamic(self.item_encoder, value)
-
-    __call__ = encode

faster_eth_abi/utils/numeric.py

@@ -1,6 +1,7 @@
 import decimal
 from typing import (
     Callable,
+    Dict,
     Final,
     Tuple,
 )
@@ -8,6 +9,7 @@ from typing import (
 ABI_DECIMAL_PREC: Final = 999
 
 abi_decimal_context: Final = decimal.Context(prec=ABI_DECIMAL_PREC)
+decimal_localcontext: Final = decimal.localcontext
 
 ZERO: Final = decimal.Decimal(0)
 TEN: Final = decimal.Decimal(10)
@@ -16,47 +18,76 @@ Decimal: Final = decimal.Decimal
 
 
 def ceil32(x: int) -> int:
-    return x if x % 32 == 0 else x + 32 - (x % 32)
+    remainder = x % 32
+    return x if remainder == 0 else x + 32 - remainder
+
+
+_unsigned_integer_bounds_cache: Final[Dict[int, Tuple[int, int]]] = {}
 
 
 def compute_unsigned_integer_bounds(num_bits: int) -> Tuple[int, int]:
-    return (
-        0,
-        2**num_bits - 1,
-    )
+    bounds = _unsigned_integer_bounds_cache.get(num_bits)
+    if bounds is None:
+        bounds = 0, 2**num_bits - 1
+        _unsigned_integer_bounds_cache[num_bits] = bounds
+    return bounds
+
+
+_signed_integer_bounds_cache: Final[Dict[int, Tuple[int, int]]] = {}
 
 
 def compute_signed_integer_bounds(num_bits: int) -> Tuple[int, int]:
-    return (
-        -1 * 2 ** (num_bits - 1),
-        2 ** (num_bits - 1) - 1,
-    )
+    bounds = _signed_integer_bounds_cache.get(num_bits)
+    if bounds is None:
+        overflow_at = 2 ** (num_bits - 1)
+        min_value = -overflow_at
+        max_value = overflow_at - 1
+        bounds = min_value, max_value
+        _signed_integer_bounds_cache[num_bits] = bounds
+    return bounds
+
+
+_unsigned_fixed_bounds_cache: Final[Dict[Tuple[int, int], decimal.Decimal]] = {}
 
 
 def compute_unsigned_fixed_bounds(
     num_bits: int,
     frac_places: int,
 ) -> Tuple[decimal.Decimal, decimal.Decimal]:
-    int_upper = compute_unsigned_integer_bounds(num_bits)[1]
+    upper = _unsigned_fixed_bounds_cache.get((num_bits, frac_places))
+    if upper is None:
+        int_upper = 2**num_bits - 1
+
+        with decimal_localcontext(abi_decimal_context):
+            upper = Decimal(int_upper) * TEN**-frac_places
 
-    with decimal.localcontext(abi_decimal_context):
-        upper = Decimal(int_upper) * TEN**-frac_places
+        _unsigned_fixed_bounds_cache[(num_bits, frac_places)] = upper
 
     return ZERO, upper
 
 
+_signed_fixed_bounds_cache: Final[
+    Dict[Tuple[int, int], Tuple[decimal.Decimal, decimal.Decimal]]
+] = {}
+
+
 def compute_signed_fixed_bounds(
     num_bits: int,
     frac_places: int,
 ) -> Tuple[decimal.Decimal, decimal.Decimal]:
-    int_lower, int_upper = compute_signed_integer_bounds(num_bits)
+    bounds = _signed_fixed_bounds_cache.get((num_bits, frac_places))
+    if bounds is None:
+        int_lower, int_upper = compute_signed_integer_bounds(num_bits)
+
+        with decimal_localcontext(abi_decimal_context):
+            exp = TEN**-frac_places
+            lower = Decimal(int_lower) * exp
+            upper = Decimal(int_upper) * exp
 
-    with decimal.localcontext(abi_decimal_context):
-        exp = TEN**-frac_places
-        lower = Decimal(int_lower) * exp
-        upper = Decimal(int_upper) * exp
+        bounds = lower, upper
+        _signed_fixed_bounds_cache[(num_bits, frac_places)] = bounds
 
-    return lower, upper
+    return bounds
 
 
 def scale_places(places: int) -> Callable[[decimal.Decimal], decimal.Decimal]:
@@ -70,11 +101,11 @@ def scale_places(places: int) -> Callable[[decimal.Decimal], decimal.Decimal]:
             f"of type {type(places)}.",
         )
 
-    with decimal.localcontext(abi_decimal_context):
+    with decimal_localcontext(abi_decimal_context):
         scaling_factor = TEN**-places
 
     def f(x: decimal.Decimal) -> decimal.Decimal:
-        with decimal.localcontext(abi_decimal_context):
+        with decimal_localcontext(abi_decimal_context):
             return x * scaling_factor
 
     places_repr = f"Eneg{places}" if places > 0 else f"Epos{-places}"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: faster_eth_abi
-Version: 5.2.8
+Version: 5.2.10
 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

{faster_eth_abi-5.2.8.dist-info → faster_eth_abi-5.2.10.dist-info}/RECORD

@@ -1,19 +1,19 @@
-76f9a3652d4d2667c55c__mypyc.cpython-310-x86_64-linux-gnu.so,sha256=4g-xAd1WSPYQfueuZxtBl4bmhuEQaOxarn3aAY8YoAQ,549856
+76f9a3652d4d2667c55c__mypyc.cpython-310-x86_64-linux-gnu.so,sha256=IBP-ko1ltKSYF3KjRvwiQ7ib4_VbIsxth4rlwpeVclw,570872
 faster_eth_abi/__init__.py,sha256=55jGpiVbsTGNu-c_rr-wwyH3eqEv9MELSTWa4AMiKvU,205
 faster_eth_abi/_codec.cpython-310-x86_64-linux-gnu.so,sha256=MqHJOR_RcvI4fyQ2WDOjXWc86JJw4smkZU71GP9gTEk,17624
 faster_eth_abi/_codec.py,sha256=cGnNaQcaSmfywmro7WoxtZaTyUBTeAMB_K9cgoxz9pg,2428
 faster_eth_abi/_decoding.cpython-310-x86_64-linux-gnu.so,sha256=iOdIUZjaW_EJve0SDZVXgiHx-8hBsLtmjYPfemMEW2c,17632
-faster_eth_abi/_decoding.py,sha256=Ce1EQJ9J0fci5Py0c1JPPpafIFFQXIilJM9ilfQjTrA,3147
+faster_eth_abi/_decoding.py,sha256=TjTj4_uzkxN3opJfk4SxHHWn4r9T8ZztpPA-Uzic1Bg,4400
 faster_eth_abi/_encoding.cpython-310-x86_64-linux-gnu.so,sha256=lcIWlh4hyJy60ct82NxsJ9zROBnHhDFNLBVpbkM7xQg,17632
-faster_eth_abi/_encoding.py,sha256=dViSQVK5XvSuLBZADiXImJqXf4dIHkAHYWFzEiJtq-0,3114
+faster_eth_abi/_encoding.py,sha256=nBIqwHbvT7loTmiYlcl7Z8HhnOGEY-jr-cpCZEU-1X8,3230
 faster_eth_abi/abi.cpython-310-x86_64-linux-gnu.so,sha256=ecfFk8oyWudWGZ04LE-pzeU-lJo_wiknq1WI1sqCaGg,17608
 faster_eth_abi/abi.py,sha256=HzkXy0EjHraNbbC5l-EhVqVcx5vy8tcykiKIO4Fp1xw,366
 faster_eth_abi/base.py,sha256=eMpUM78FhJg5wHPj6glvJRpS1AmvQ_1ks9ENwyu68hc,1188
 faster_eth_abi/codec.py,sha256=KMIgLUBeutkDTsRts8Y2Ydt3V0n5bMGLd21CZvwR9ds,4437
 faster_eth_abi/constants.cpython-310-x86_64-linux-gnu.so,sha256=aEe1msVj4qRraAjfcj2PZwwbfZGCrmDyw57Cfx2dO5Y,17632
 faster_eth_abi/constants.py,sha256=uJbuND1rFs_Pexuz58TKd-BJPuoA6hLqFEX6kkDS-dE,107
-faster_eth_abi/decoding.py,sha256=erTreiNiFDgqjXxiW4DeryaoNORdXTjL5eKeglOM65I,16901
-faster_eth_abi/encoding.py,sha256=GLJaKwJsiP07WgiwegdPbV_CxNLzss2Jy7b_4Qifv7g,19032
+faster_eth_abi/decoding.py,sha256=bfMhG-KvKa836JTHyql-HFm5Z37OEd0W8Y0rsaoFn4A,16498
+faster_eth_abi/encoding.py,sha256=lH6t_8rokfmg8M4JBjmIO3a3l9jGu_rbwoskb0PcH7M,19009
 faster_eth_abi/exceptions.py,sha256=Q_b62R-E0OtlxQGLQSyx6BXkBbLf259KQ1pT5Eb1oh8,2952
 faster_eth_abi/from_type_str.cpython-310-x86_64-linux-gnu.so,sha256=RXdacaMJ-MzxzJVCgHIXS00ZGAQv97fw8FDLsikIz8M,17648
 faster_eth_abi/from_type_str.py,sha256=aAZ58YUBZuMF_DovGkthvnacAD6X6VkYFs0Zbv9JxoM,4311
@@ -30,15 +30,15 @@ faster_eth_abi/tools/_strategies.py,sha256=iLIjqRw7FlEEIXtnhSgtrWwbxO74dslT0EQrg
 faster_eth_abi/utils/__init__.cpython-310-x86_64-linux-gnu.so,sha256=GP8ea-5JiarJmWRvwKGh1bWWFhBAqOACNMTlzcpsQ4c,17616
 faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 faster_eth_abi/utils/numeric.cpython-310-x86_64-linux-gnu.so,sha256=oE_NZGDX_e-hQC_S64ronfJViIDpKZ4ItoIVH47Tvdo,17640
-faster_eth_abi/utils/numeric.py,sha256=VU6Z76zvZn7rYaZMyDy1XO9A9ukKTzOrtA80jypp_LQ,2146
+faster_eth_abi/utils/numeric.py,sha256=fkdazLcgd7FN0JGSSyb6Jsx555QdgRf2N0mxrm6rGB4,3278
 faster_eth_abi/utils/padding.cpython-310-x86_64-linux-gnu.so,sha256=UAHhwc1LC-ORT0BiWyv7qmteId9aKrJwRhOVfC5IW8c,17640
 faster_eth_abi/utils/padding.py,sha256=JBuFhdrvKWLrmmJBZ-a6pqbHWydAuiUBt2aBjCwVcVE,493
 faster_eth_abi/utils/string.cpython-310-x86_64-linux-gnu.so,sha256=S_2liZUFaL-iEwLzQg4TmUQdqljRxaurETmrCGVEyj4,17632
 faster_eth_abi/utils/string.py,sha256=fjsAR2C7Xlu5bHomxx5l4rlADFtByzGTQfugMTo8TQk,436
 faster_eth_abi/utils/validation.cpython-310-x86_64-linux-gnu.so,sha256=eRNYiL2ukCCjXzLFLZmi_WLvK4iZZH4xzWJeuUCm10Y,17648
 faster_eth_abi/utils/validation.py,sha256=NA2wRacYEBdkpQnZfmeDvzF-sHyy6NT2QzCFuBnYJVI,521
-faster_eth_abi-5.2.8.dist-info/METADATA,sha256=6r0FX18qHUQ3rJLI7y1iWlpyB8LuyBUHe-5z7D-K0rg,5386
-faster_eth_abi-5.2.8.dist-info/WHEEL,sha256=YJPq7zroHSsdctrb_KymZ4ss41PkmaA9SD9TZzqKSX8,112
-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/licenses/LICENSE,sha256=P_zrhVa0OXK-_XuA0RF3d3gwMLXRSBkn2fWraC4CFLo,1106
+faster_eth_abi-5.2.10.dist-info/METADATA,sha256=BvwIHQ9bGk1_pahVUI1c6lb1mb5GZuIGib2_TPLINF8,5387
+faster_eth_abi-5.2.10.dist-info/WHEEL,sha256=YJPq7zroHSsdctrb_KymZ4ss41PkmaA9SD9TZzqKSX8,112
+faster_eth_abi-5.2.10.dist-info/top_level.txt,sha256=CO2FQwf61aFzjYze7Wywa5KQdJ6bbLkzDoGEjDF2g9o,43
+faster_eth_abi-5.2.10.dist-info/RECORD,,
+faster_eth_abi-5.2.10.dist-info/licenses/LICENSE,sha256=P_zrhVa0OXK-_XuA0RF3d3gwMLXRSBkn2fWraC4CFLo,1106