faster-eth-abi 5.2.4__cp314-cp314t-macosx_11_0_arm64.whl → 5.2.6__cp314-cp314t-macosx_11_0_arm64.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,103 @@
+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: bool = 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/grammar.py

@@ -458,10 +458,11 @@ def normalize(type_str: TypeStr) -> TypeStr:
     :param type_str: The type string to be normalized.
     :returns: The canonical version of the input type string.
     """
-    return TYPE_ALIAS_RE.sub(
-        lambda match: TYPE_ALIASES[match.group(0)],
-        type_str,
-    )
+    return TYPE_ALIAS_RE.sub(__normalize, type_str)
+
+
+def __normalize(match: re.Match[str]) -> str:
+    return TYPE_ALIASES[match.group(0)]
 
 
 parse: Final = visitor.parse

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.6.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: faster_eth_abi
-Version: 5.2.4
-Summary: A fork of eth_abi: Python utilities for working with Ethereum ABI definitions, especially encoding and decoding, implemented in C.
+Version: 5.2.6
+Summary: A aster 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
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/markdown
@@ -36,6 +37,8 @@ Requires-Dist: pre-commit>=3.4.0; extra == "dev"
 Requires-Dist: tox>=4.0.0; extra == "dev"
 Requires-Dist: twine; extra == "dev"
 Requires-Dist: wheel; extra == "dev"
+Requires-Dist: pytest-codspeed; extra == "dev"
+Requires-Dist: pytest-benchmark; extra == "dev"
 Requires-Dist: sphinx>=6.0.0; extra == "dev"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "dev"
@@ -74,6 +77,20 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
+### I forked eth-abi and compiled it to C. It does the same stuff, now faster
+
+[![PyPI](https://img.shields.io/pypi/v/faster-eth-abi.svg?logo=Python&logoColor=white)](https://pypi.org/project/faster-eth-abi/)
+[![Monthly Downloads](https://img.shields.io/pypi/dm/faster-eth-abi)](https://pypistats.org/packages/faster-eth-abi)
+[![Codspeed.io Status](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/BobTheBuidler/faster-eth-abi)
+
+##### This fork will be kept up-to-date with [eth-abi](https://github.com/ethereum/eth-abi). I will pull updates as they are released and push new [faster-eth-abi](https://github.com/BobTheBuidler/faster-eth-abi) releases to [PyPI](https://pypi.org/project/faster-eth-abi/).
+
+##### You can find the compiled C code on faster-eth-abi [master](https://github.com/BobTheBuidler/eth-abi/tree/master) branch.
+
+##### We benchmark `faster-eth-abi` against the original `eth-abi` for your convenience. [See results](https://github.com/BobTheBuidler/faster-eth-abi/tree/master/benchmarks/results).
+
+##### The original eth-abi readme is below:
+
 # Ethereum Contract Interface (ABI) Utility
 
 [![Join the conversation on Discord](https://img.shields.io/discord/809793915578089484?color=blue&label=chat&logo=discord&logoColor=white)](https://discord.gg/GHryRvPB84)

faster_eth_abi-5.2.6.dist-info/RECORD

@@ -0,0 +1,42 @@
+c42f5c78bc058f310136__mypyc.cpython-314t-darwin.so,sha256=eBRjBdOOrOb-CHOmQ_OXVkQqNY62jIdp0zEvTwGJQO4,449072
+faster_eth_abi/_encoding.cpython-314t-darwin.so,sha256=8CJf8JxvrN7y7nTXri-4KfwIGdqHHvUAhNiWlVf6Uys,51040
+faster_eth_abi/_encoding.py,sha256=dViSQVK5XvSuLBZADiXImJqXf4dIHkAHYWFzEiJtq-0,3114
+faster_eth_abi/abi.cpython-314t-darwin.so,sha256=kdfQeepcPB9xGYOYJihM9aVttzcwdcK0QXqvjRcWPcQ,50984
+faster_eth_abi/packed.py,sha256=qDPBjish_0h26O7xGWopnlD4pRkphFuFq4izgIqT600,301
+faster_eth_abi/encoding.py,sha256=yYgXubRd3ZxVP6QPrdHhYnjFGSPtqfyaXh4QBLnURms,18163
+faster_eth_abi/registry.py,sha256=kCcz1mJiENDzl9jKzJ99EiSLSSIFxfi4-96Fe59qrJM,20529
+faster_eth_abi/constants.py,sha256=uJbuND1rFs_Pexuz58TKd-BJPuoA6hLqFEX6kkDS-dE,107
+faster_eth_abi/io.py,sha256=PjOnBChWh_-6ADkpJQONnxHVwsAfC_4bRiT6YQhlP6c,3728
+faster_eth_abi/__init__.py,sha256=55jGpiVbsTGNu-c_rr-wwyH3eqEv9MELSTWa4AMiKvU,205
+faster_eth_abi/decoding.py,sha256=xLon-1I5EZCZBgsTZsvl-ienFY2ZUr5D2FqzsiTdQS0,17347
+faster_eth_abi/packed.cpython-314t-darwin.so,sha256=XPzxGhbWPD2Op6DDG8Tw-qnov3BNfeZLGkHenwfB-4c,51008
+faster_eth_abi/grammar.py,sha256=unpmDhCsUs1PdLW2XbtKF5ij84nJOqVXhuKI8t_-aXk,13369
+faster_eth_abi/from_type_str.cpython-314t-darwin.so,sha256=0jmdkZL_KuCijgAT09Khx-kKlMsfYzk0VMdmjnKyWSA,51080
+faster_eth_abi/from_type_str.py,sha256=aAZ58YUBZuMF_DovGkthvnacAD6X6VkYFs0Zbv9JxoM,4311
+faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/abi.py,sha256=HzkXy0EjHraNbbC5l-EhVqVcx5vy8tcykiKIO4Fp1xw,366
+faster_eth_abi/exceptions.py,sha256=Q_b62R-E0OtlxQGLQSyx6BXkBbLf259KQ1pT5Eb1oh8,2952
+faster_eth_abi/_codec.py,sha256=xVKz8JQW51sCs2eroQBUXEe_SXduT14wRSObzhZuNjo,2461
+faster_eth_abi/codec.py,sha256=KMIgLUBeutkDTsRts8Y2Ydt3V0n5bMGLd21CZvwR9ds,4437
+faster_eth_abi/_codec.cpython-314t-darwin.so,sha256=K70EYWlS6rlI9--coPlHbMU2XktDbLpiCU99gSXNc6Q,51008
+faster_eth_abi/constants.cpython-314t-darwin.so,sha256=jDPHvUF00NLOOyj9ntWWv79SqdqD0qfLUSGi0-tJ650,51040
+faster_eth_abi/base.py,sha256=eMpUM78FhJg5wHPj6glvJRpS1AmvQ_1ks9ENwyu68hc,1188
+faster_eth_abi/tools/_strategies.py,sha256=iLIjqRw7FlEEIXtnhSgtrWwbxO74dslT0EQrgE2o8I8,5960
+faster_eth_abi/tools/_strategies.cpython-314t-darwin.so,sha256=eRwr7M0qGFfaBDqZvfmjd-0INS-g3MdFuIqEbkWxymQ,51072
+faster_eth_abi/tools/__init__.py,sha256=trtATEmgu4ctg04qkejbODDzvDSofgcVJ3rkzMP_hQE,51
+faster_eth_abi/tools/__init__.cpython-314t-darwin.so,sha256=SuDQhh9sDMc7XZxek2ndvjV_DuFOOVg1R7G7OPcgQXk,51008
+faster_eth_abi/utils/numeric.cpython-314t-darwin.so,sha256=UFIqrd-RQhssxofpwJ4jd4OeY0p-ycyAqj2KisR7zJ0,51040
+faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/utils/validation.cpython-314t-darwin.so,sha256=jWjXVTOqsGddGE87CHEJG6oM367YkkfJVI920N-2l_A,51056
+faster_eth_abi/utils/padding.cpython-314t-darwin.so,sha256=8NeZiSvC-K3mfXia6GwWc7BrLmcg2CTDZ8_SkPR6eXU,51040
+faster_eth_abi/utils/__init__.cpython-314t-darwin.so,sha256=Ll7y5xrgG5lQmjhNwh6kdRmjB6rWFOsf2ok1P6KPBxc,51008
+faster_eth_abi/utils/numeric.py,sha256=VU6Z76zvZn7rYaZMyDy1XO9A9ukKTzOrtA80jypp_LQ,2146
+faster_eth_abi/utils/string.py,sha256=fjsAR2C7Xlu5bHomxx5l4rlADFtByzGTQfugMTo8TQk,436
+faster_eth_abi/utils/string.cpython-314t-darwin.so,sha256=sLug1cp9xoVH_DxhmcFCH8LzCjomL3PRCe7UUBZDcs4,51024
+faster_eth_abi/utils/padding.py,sha256=JBuFhdrvKWLrmmJBZ-a6pqbHWydAuiUBt2aBjCwVcVE,493
+faster_eth_abi/utils/validation.py,sha256=NA2wRacYEBdkpQnZfmeDvzF-sHyy6NT2QzCFuBnYJVI,521
+faster_eth_abi-5.2.6.dist-info/RECORD,,
+faster_eth_abi-5.2.6.dist-info/WHEEL,sha256=26nyvDx4qlf6NyRSh1NSNrXJDCQeX0hnJ7EH1bB1egM,137
+faster_eth_abi-5.2.6.dist-info/top_level.txt,sha256=5cP87jVHTOdG5bgQZ3ws5MGsnIwm_yX-WalM08iynHc,51
+faster_eth_abi-5.2.6.dist-info/METADATA,sha256=ASeQJaeQE08DxXJLTBY_zMuODrA67CDt7vUB0wGAM9c,5385
+faster_eth_abi-5.2.6.dist-info/licenses/LICENSE,sha256=P_zrhVa0OXK-_XuA0RF3d3gwMLXRSBkn2fWraC4CFLo,1106

faster_eth_abi-5.2.6.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.cpython-314t-darwin.so,sha256=-OjYHNrJ3FHe6dbOu6J_wyjSwPMcDVL0jKXNWRM5SzY,302288
-faster_eth_abi/abi.cpython-314t-darwin.so,sha256=u9JTCt22hJikAUH1pzEEWXBXqC17SryohV1Z8Sj8uoQ,50728
-faster_eth_abi/packed.py,sha256=qDPBjish_0h26O7xGWopnlD4pRkphFuFq4izgIqT600,301
-faster_eth_abi/encoding.py,sha256=Ht1g6Xa2y-npY5YrI1zjVcerf7YSZX-cYHZ6IJE5G5M,19988
-faster_eth_abi/registry.py,sha256=ja53ifO-YlxZa_k0jtjHYa8nAJ9LJQNc9kVthss_TYo,19667
-faster_eth_abi/constants.py,sha256=uJbuND1rFs_Pexuz58TKd-BJPuoA6hLqFEX6kkDS-dE,107
-faster_eth_abi/io.py,sha256=PjOnBChWh_-6ADkpJQONnxHVwsAfC_4bRiT6YQhlP6c,3728
-faster_eth_abi/__init__.py,sha256=55jGpiVbsTGNu-c_rr-wwyH3eqEv9MELSTWa4AMiKvU,205
-faster_eth_abi/decoding.py,sha256=xLon-1I5EZCZBgsTZsvl-ienFY2ZUr5D2FqzsiTdQS0,17347
-faster_eth_abi/packed.cpython-314t-darwin.so,sha256=efRZ4_l8uSjKvk2fPaobAAozBsqPJiaVrkKBhQioHZM,50736
-faster_eth_abi/grammar.py,sha256=9Q4niyiw8cAKXwVMlpfayPNcWkerZXM6WuWBEjx2TQ8,13335
-faster_eth_abi/from_type_str.cpython-314t-darwin.so,sha256=_tcRAgfq_5H2UU88jLb94bDkTCmpAGaZ1Dw0b36hElQ,50776
-faster_eth_abi/from_type_str.py,sha256=aAZ58YUBZuMF_DovGkthvnacAD6X6VkYFs0Zbv9JxoM,4311
-faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/abi.py,sha256=HzkXy0EjHraNbbC5l-EhVqVcx5vy8tcykiKIO4Fp1xw,366
-faster_eth_abi/exceptions.py,sha256=Q_b62R-E0OtlxQGLQSyx6BXkBbLf259KQ1pT5Eb1oh8,2952
-faster_eth_abi/codec.py,sha256=wjKLVR4Qb4hn2bloeEeZ4lQs7uLKoZq5c6rSTJVlCeo,5174
-faster_eth_abi/constants.cpython-314t-darwin.so,sha256=WkJiq86kqBw08PrGGvhfi9Bqc4VBn3z4gv1hb6vFuOI,50752
-faster_eth_abi/base.py,sha256=eMpUM78FhJg5wHPj6glvJRpS1AmvQ_1ks9ENwyu68hc,1188
-faster_eth_abi/tools/_strategies.py,sha256=iLIjqRw7FlEEIXtnhSgtrWwbxO74dslT0EQrgE2o8I8,5960
-faster_eth_abi/tools/_strategies.cpython-314t-darwin.so,sha256=t4wuixEyeiDud40Geh6kD6uEybth4ynBfqJvnhlhTYw,50784
-faster_eth_abi/tools/__init__.py,sha256=trtATEmgu4ctg04qkejbODDzvDSofgcVJ3rkzMP_hQE,51
-faster_eth_abi/tools/__init__.cpython-314t-darwin.so,sha256=TW6d04ub0J-zEY3aj7vI15L_g1EfDv5DxN3Q1PfB39U,50736
-faster_eth_abi/utils/numeric.cpython-314t-darwin.so,sha256=_DYT_dxZWz4zeTEQbnY2ZN5NQ34ZgFQrDD5_OUMHZ3A,50752
-faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/utils/validation.cpython-314t-darwin.so,sha256=jW9eQzurbfA0z7IEVSZF5V0yeYHr3iDE6Lr_nznxGQE,50768
-faster_eth_abi/utils/padding.cpython-314t-darwin.so,sha256=PsvYsvHzv5LJY810s4Vjk2kWRA6IcmR7j-q7YRmYXqA,50752
-faster_eth_abi/utils/__init__.cpython-314t-darwin.so,sha256=UMqif0i39DZsvlypjMlQySag-qPO9fYwK-kyyxGYUeI,50736
-faster_eth_abi/utils/numeric.py,sha256=VU6Z76zvZn7rYaZMyDy1XO9A9ukKTzOrtA80jypp_LQ,2146
-faster_eth_abi/utils/string.py,sha256=fjsAR2C7Xlu5bHomxx5l4rlADFtByzGTQfugMTo8TQk,436
-faster_eth_abi/utils/string.cpython-314t-darwin.so,sha256=g7bBFuHl3nneBBjTKkhe743xyPeVdx42jefnQhPs3Us,50752
-faster_eth_abi/utils/padding.py,sha256=JBuFhdrvKWLrmmJBZ-a6pqbHWydAuiUBt2aBjCwVcVE,493
-faster_eth_abi/utils/validation.py,sha256=kqDxlcIyb55Y80FdcCYtWP1-8geCePsH3_yPTayxdM8,547
-faster_eth_abi-5.2.4.dist-info/RECORD,,
-faster_eth_abi-5.2.4.dist-info/WHEEL,sha256=26nyvDx4qlf6NyRSh1NSNrXJDCQeX0hnJ7EH1bB1egM,137
-faster_eth_abi-5.2.4.dist-info/top_level.txt,sha256=NbjfpQ9lBrFaSYDeeRrYo2vn3ZGVqu_9MZ0LOqjzQho,51
-faster_eth_abi-5.2.4.dist-info/METADATA,sha256=KuZsNosWAxgduSru00lsek6bd9H2_B4PFGX1cPA-o-A,4129
-faster_eth_abi-5.2.4.dist-info/licenses/LICENSE,sha256=P_zrhVa0OXK-_XuA0RF3d3gwMLXRSBkn2fWraC4CFLo,1106

faster_eth_abi-5.2.4.dist-info/top_level.txt

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