faster-eth-abi 5.2.10__cp310-cp310-win_amd64.whl → 5.2.12__cp310-cp310-win_amd64.whl

faster_eth_abi/_codec.py

@@ -39,8 +39,6 @@ def encode_c(
     :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)
@@ -71,8 +69,6 @@ def decode_c(
     :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)

faster_eth_abi/_grammar.py

@@ -0,0 +1,349 @@
+import re
+from typing import (
+    Any,
+    Final,
+    NewType,
+    NoReturn,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    final,
+)
+
+from eth_typing.abi import (
+    TypeStr,
+)
+from mypy_extensions import (
+    mypyc_attr,
+)
+from parsimonious.nodes import (
+    Node,
+)
+from typing_extensions import (
+    Self,
+)
+
+from faster_eth_abi.exceptions import (
+    ABITypeError,
+)
+
+
+TYPE_ALIASES: Final = {
+    "int": "int256",
+    "uint": "uint256",
+    "fixed": "fixed128x18",
+    "ufixed": "ufixed128x18",
+    "function": "bytes24",
+    "byte": "bytes1",
+}
+
+TYPE_ALIAS_RE: Final = re.compile(
+    rf"\b({'|'.join(map(re.escape, TYPE_ALIASES.keys()))})\b"
+)
+
+
+IntSubtype = NewType("IntSubtype", int)
+FixedSubtype = NewType("FixedSubtype", Tuple[int, int])
+Subtype = Union[IntSubtype, FixedSubtype]
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class ABIType:
+    """
+    Base class for results of type string parsing operations.
+    """
+
+    __slots__ = ("arrlist", "node")
+
+    def __init__(
+        self, arrlist: Optional[Sequence[str]] = None, node: Optional[Node] = None
+    ) -> None:
+        self.arrlist: Final = arrlist
+        """
+        The list of array dimensions for a parsed type.  Equal to ``None`` if
+        type string has no array dimensions.
+        """
+
+        self.node: Final = node
+        """
+        The parsimonious ``Node`` instance associated with this parsed type.
+        Used to generate error messages for invalid types.
+        """
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"<{type(self).__qualname__} {self.to_type_str()!r}>"
+
+    def __eq__(self, other: Any) -> bool:
+        # Two ABI types are equal if their string representations are equal
+        return type(self) is type(other) and self.to_type_str() == other.to_type_str()
+
+    def to_type_str(self) -> TypeStr:  # pragma: no cover
+        """
+        Returns the string representation of an ABI type.  This will be equal to
+        the type string from which it was created.
+        """
+        raise NotImplementedError("Must implement `to_type_str`")
+
+    @property
+    def item_type(self) -> Self:
+        """
+        If this type is an array type, equal to an appropriate
+        :class:`~faster_eth_abi.grammar.ABIType` instance for the array's items.
+        """
+        raise NotImplementedError("Must implement `item_type`")
+
+    def validate(self) -> None:  # pragma: no cover
+        """
+        Validates the properties of an ABI type against the solidity ABI spec:
+
+        https://solidity.readthedocs.io/en/develop/abi-spec.html
+
+        Raises :class:`~faster_eth_abi.exceptions.ABITypeError` if validation fails.
+        """
+        raise NotImplementedError("Must implement `validate`")
+
+    @final
+    def invalidate(self, error_msg: str) -> NoReturn:
+        # Invalidates an ABI type with the given error message.  Expects that a
+        # parsimonious node was provided from the original parsing operation
+        # that yielded this type.
+        node = self.node
+
+        raise ABITypeError(
+            f"For '{node.text}' type at column {node.start + 1} "
+            f"in '{node.full_text}': {error_msg}"
+        )
+
+    @final
+    @property
+    def is_array(self) -> bool:
+        """
+        Equal to ``True`` if a type is an array type (i.e. if it has an array
+        dimension list).  Otherwise, equal to ``False``.
+        """
+        return self.arrlist is not None
+
+    @property
+    def is_dynamic(self) -> bool:
+        """
+        Equal to ``True`` if a type has a dynamically sized encoding.
+        Otherwise, equal to ``False``.
+        """
+        raise NotImplementedError("Must implement `is_dynamic`")
+
+    @final
+    @property
+    def _has_dynamic_arrlist(self) -> bool:
+        return self.is_array and any(len(dim) == 0 for dim in self.arrlist)
+
+
+TComp = TypeVar("TComp", bound=ABIType)
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class TupleType(ABIType):
+    """
+    Represents the result of parsing a tuple type string e.g. "(int,bool)".
+    """
+
+    __slots__ = ("components",)
+
+    def __init__(
+        self,
+        components: Tuple[TComp, ...],
+        arrlist: Optional[Sequence[str]] = None,
+        *,
+        node: Optional[Node] = None,
+    ) -> None:
+        super().__init__(arrlist, node)
+
+        self.components: Final = components
+        """
+        A tuple of :class:`~faster_eth_abi.grammar.ABIType` instances for each of the
+        tuple type's components.
+        """
+
+    def to_type_str(self) -> TypeStr:
+        arrlist = self.arrlist
+
+        if isinstance(arrlist, tuple):
+            arrlist = "".join(map(repr, map(list, arrlist)))
+        else:
+            arrlist = ""
+
+        return f"({','.join(c.to_type_str() for c in self.components)}){arrlist}"
+
+    @property
+    def item_type(self) -> Self:
+        if not self.is_array:
+            raise ValueError(
+                f"Cannot determine item type for non-array type '{self.to_type_str()}'"
+            )
+
+        arrlist = self.arrlist[:-1] or None  # type: ignore [index]
+        cls = type(self)
+        if cls is TupleType:
+            return TupleType(self.components, arrlist, node=self.node)  # type: ignore [return-value]
+        else:
+            return cls(self.components, arrlist, node=self.node)
+
+    def validate(self) -> None:
+        for c in self.components:
+            c.validate()
+
+    @property
+    def is_dynamic(self) -> bool:
+        if self._has_dynamic_arrlist:
+            return True
+
+        return any(c.is_dynamic for c in self.components)
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class BasicType(ABIType):
+    """
+    Represents the result of parsing a basic type string e.g. "uint", "address",
+    "ufixed128x19[][2]".
+    """
+
+    __slots__ = ("base", "sub")
+
+    def __init__(
+        self,
+        base: str,
+        sub: Optional[Subtype] = None,
+        arrlist: Optional[Sequence] = None,
+        *,
+        node: Optional[Node] = None,
+    ) -> None:
+        super().__init__(arrlist, node)
+
+        self.base: Final = base
+        """The base of a basic type e.g. "uint" for "uint256" etc."""
+
+        self.sub: Final = sub
+        """
+        The sub type of a basic type e.g. ``256`` for "uint256" or ``(128, 18)``
+        for "ufixed128x18" etc.  Equal to ``None`` if type string has no sub
+        type.
+        """
+
+    def to_type_str(self) -> TypeStr:
+        sub, arrlist = self.sub, self.arrlist
+
+        if isinstance(sub, int):
+            substr = str(sub)
+        elif isinstance(sub, tuple):
+            substr = "x".join(map(str, sub))
+        else:
+            substr = ""
+
+        if isinstance(arrlist, tuple):
+            return self.base + substr + "".join(map(repr, map(list, arrlist)))
+        else:
+            return self.base + substr
+
+    @property
+    def item_type(self) -> Self:
+        if not self.is_array:
+            raise ValueError(
+                f"Cannot determine item type for non-array type '{self.to_type_str()}'"
+            )
+
+        cls = type(self)
+        arrlist = self.arrlist[:-1] or None  # type: ignore [index]
+        if cls is BasicType:
+            return BasicType(self.base, self.sub, arrlist, node=self.node)  # type: ignore [return-value]
+        else:
+            return cls(self.base, self.sub, arrlist, node=self.node)
+
+    @property
+    def is_dynamic(self) -> bool:
+        if self._has_dynamic_arrlist:
+            return True
+
+        base = self.base
+        if base == "string":
+            return True
+
+        if base == "bytes" and self.sub is None:
+            return True
+
+        return False
+
+    def validate(self) -> None:
+        base, sub = self.base, self.sub
+
+        # Check validity of string type
+        if base == "string":
+            if sub is not None:
+                self.invalidate("string type cannot have suffix")
+
+        # Check validity of bytes type
+        elif base == "bytes":
+            if not (sub is None or isinstance(sub, int)):
+                self.invalidate(
+                    "bytes type must have either no suffix or a numerical suffix"
+                )
+
+            if isinstance(sub, int) and sub > 32:
+                self.invalidate("maximum 32 bytes for fixed-length bytes")
+
+        # Check validity of integer type
+        elif base in ("int", "uint"):
+            if not isinstance(sub, int):
+                self.invalidate("integer type must have numerical suffix")
+
+            if sub < 8 or sub > 256:
+                self.invalidate("integer size out of bounds (max 256 bits)")
+
+            if sub % 8 != 0:
+                self.invalidate("integer size must be multiple of 8")
+
+        # Check validity of fixed type
+        elif base in ("fixed", "ufixed"):
+            if not isinstance(sub, tuple):
+                self.invalidate(
+                    "fixed type must have suffix of form <bits>x<exponent>, "
+                    "e.g. 128x19",
+                )
+
+            bits, minus_e = sub
+
+            if bits < 8 or bits > 256:
+                self.invalidate("fixed size out of bounds (max 256 bits)")
+
+            if bits % 8 != 0:
+                self.invalidate("fixed size must be multiple of 8")
+
+            if minus_e < 1 or minus_e > 80:
+                self.invalidate(
+                    f"fixed exponent size out of bounds, {minus_e} must be in 1-80"
+                )
+
+        # Check validity of hash type
+        elif base == "hash":
+            if not isinstance(sub, int):
+                self.invalidate("hash type must have numerical suffix")
+
+        # Check validity of address type
+        elif base == "address":
+            if sub is not None:
+                self.invalidate("address cannot have suffix")
+
+
+def normalize(type_str: TypeStr) -> TypeStr:
+    """
+    Normalizes a type string into its canonical version e.g. the type string
+    'int' becomes 'int256', etc.
+
+    :param type_str: The type string to be normalized.
+    :returns: The canonical version of the input type string.
+    """
+    return TYPE_ALIAS_RE.sub(__normalize, type_str)
+
+
+def __normalize(match: "re.Match[str]") -> str:
+    return TYPE_ALIASES[match.group(0)]

faster_eth_abi/codec.py

@@ -18,6 +18,7 @@ from faster_eth_abi.decoding import (
 )
 from faster_eth_abi.exceptions import (
     EncodingError,
+    MultipleEntriesFound,
 )
 from faster_eth_abi.registry import (
     ABIRegistry,
@@ -74,20 +75,18 @@ class ABIEncoder(BaseABICoder):
         :returns: ``True`` if ``arg`` is encodable as a value of the ABI type
             ``typ``.  Otherwise, ``False``.
         """
-        if not self.is_encodable_type(typ):
+        try:
+            encoder = self._registry.get_encoder(typ)
+        except MultipleEntriesFound:
+            raise
+        except:
             return False
 
-        encoder = self._registry.get_encoder(typ)
-
+        validate = getattr(encoder, "validate_value", encoder)
         try:
-            encoder.validate_value(arg)
+            validate(arg)
         except EncodingError:
             return False
-        except AttributeError:
-            try:
-                encoder(arg)
-            except EncodingError:
-                return False
 
         return True
 

faster_eth_abi/exceptions.py

@@ -1,20 +1,29 @@
+# mypy: disable-error-code="misc"
+# cannot subclass `Any`
+
+"""
+faster-eth-abi exceptions always inherit from eth-abi exceptions, so porting to faster-eth-abi
+does not require any change to your existing exception handlers. They will continue to work.
+"""
+
+import eth_abi.exceptions
 import parsimonious
 
 
-class EncodingError(Exception):
+class EncodingError(eth_abi.exceptions.EncodingError):
     """
     Base exception for any error that occurs during encoding.
     """
 
 
-class EncodingTypeError(EncodingError):
+class EncodingTypeError(EncodingError, eth_abi.exceptions.EncodingTypeError):
     """
     Raised when trying to encode a python value whose type is not supported for
     the output ABI type.
     """
 
 
-class IllegalValue(EncodingError):
+class IllegalValue(EncodingError, eth_abi.exceptions.IllegalValue):
     """
     Raised when trying to encode a python value with the correct type but with
     a value that is not considered legal for the output ABI type.
@@ -26,7 +35,7 @@ class IllegalValue(EncodingError):
     """
 
 
-class ValueOutOfBounds(IllegalValue):
+class ValueOutOfBounds(IllegalValue, eth_abi.exceptions.ValueOutOfBounds):
     """
     Raised when trying to encode a python value with the correct type but with
     a value that appears outside the range of valid values for the output ABI
@@ -39,31 +48,31 @@ class ValueOutOfBounds(IllegalValue):
     """
 
 
-class DecodingError(Exception):
+class DecodingError(eth_abi.exceptions.DecodingError):
     """
     Base exception for any error that occurs during decoding.
     """
 
 
-class InsufficientDataBytes(DecodingError):
+class InsufficientDataBytes(DecodingError, eth_abi.exceptions.InsufficientDataBytes):
     """
     Raised when there are insufficient data to decode a value for a given ABI type.
     """
 
 
-class NonEmptyPaddingBytes(DecodingError):
+class NonEmptyPaddingBytes(DecodingError, eth_abi.exceptions.NonEmptyPaddingBytes):
     """
     Raised when the padding bytes of an ABI value are malformed.
     """
 
 
-class InvalidPointer(DecodingError):
+class InvalidPointer(DecodingError, eth_abi.exceptions.InvalidPointer):
     """
     Raised when the pointer to a value in the ABI encoding is invalid.
     """
 
 
-class ParseError(parsimonious.ParseError):  # type: ignore[misc] # subclasses Any
+class ParseError(eth_abi.exceptions.ParseError):
     """
     Raised when an ABI type string cannot be parsed.
     """
@@ -75,7 +84,7 @@ class ParseError(parsimonious.ParseError):  # type: ignore[misc] # subclasses An
         )
 
 
-class ABITypeError(ValueError):
+class ABITypeError(eth_abi.exceptions.ABITypeError):
     """
     Raised when a parsed ABI type has inconsistent properties; for example,
     when trying to parse the type string ``'uint7'`` (which has a bit-width
@@ -83,13 +92,13 @@ class ABITypeError(ValueError):
     """
 
 
-class PredicateMappingError(Exception):
+class PredicateMappingError(eth_abi.exceptions.PredicateMappingError):
     """
     Raised when an error occurs in a registry's internal mapping.
     """
 
 
-class NoEntriesFound(ValueError, PredicateMappingError):
+class NoEntriesFound(PredicateMappingError, eth_abi.exceptions.NoEntriesFound):
     """
     Raised when no registration is found for a type string in a registry's
     internal mapping.
@@ -101,7 +110,7 @@ class NoEntriesFound(ValueError, PredicateMappingError):
     """
 
 
-class MultipleEntriesFound(ValueError, PredicateMappingError):
+class MultipleEntriesFound(PredicateMappingError, eth_abi.exceptions.MultipleEntriesFound):
     """
     Raised when multiple registrations are found for a type string in a
     registry's internal mapping.  This error is non-recoverable and indicates

faster_eth_abi/from_type_str.py

@@ -12,11 +12,13 @@ from eth_typing import (
     TypeStr,
 )
 
-from .grammar import (
+from ._grammar import (
     ABIType,
     BasicType,
     TupleType,
     normalize,
+)
+from .grammar import (
     parse,
 )
 

faster_eth_abi/grammar.py

@@ -25,6 +25,14 @@ from typing_extensions import (
     Self,
 )
 
+from faster_eth_abi._grammar import (
+    TYPE_ALIASES,
+    TYPE_ALIAS_RE,
+    ABIType,
+    BasicType,
+    TupleType,
+    normalize,
+)
 from faster_eth_abi.exceptions import (
     ABITypeError,
     ParseError,
@@ -156,313 +164,7 @@ class NodeVisitor(parsimonious.NodeVisitor):  # type: ignore [misc]
 
 visitor: Final = NodeVisitor()
 
-
-class ABIType:
-    """
-    Base class for results of type string parsing operations.
-    """
-
-    __slots__ = ("arrlist", "node")
-
-    def __init__(
-        self, arrlist: Optional[Sequence] = None, node: Optional[Node] = None
-    ) -> None:
-        self.arrlist: Final = arrlist
-        """
-        The list of array dimensions for a parsed type.  Equal to ``None`` if
-        type string has no array dimensions.
-        """
-
-        self.node: Final = node
-        """
-        The parsimonious ``Node`` instance associated with this parsed type.
-        Used to generate error messages for invalid types.
-        """
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"<{type(self).__qualname__} {self.to_type_str()!r}>"
-
-    def __eq__(self, other: Any) -> bool:
-        # Two ABI types are equal if their string representations are equal
-        return type(self) is type(other) and self.to_type_str() == other.to_type_str()
-
-    def to_type_str(self) -> TypeStr:  # pragma: no cover
-        """
-        Returns the string representation of an ABI type.  This will be equal to
-        the type string from which it was created.
-        """
-        raise NotImplementedError("Must implement `to_type_str`")
-
-    @property
-    def item_type(self) -> Self:
-        """
-        If this type is an array type, equal to an appropriate
-        :class:`~faster_eth_abi.grammar.ABIType` instance for the array's items.
-        """
-        raise NotImplementedError("Must implement `item_type`")
-
-    def validate(self) -> None:  # pragma: no cover
-        """
-        Validates the properties of an ABI type against the solidity ABI spec:
-
-        https://solidity.readthedocs.io/en/develop/abi-spec.html
-
-        Raises :class:`~faster_eth_abi.exceptions.ABITypeError` if validation fails.
-        """
-        raise NotImplementedError("Must implement `validate`")
-
-    def invalidate(self, error_msg: str) -> NoReturn:
-        # Invalidates an ABI type with the given error message.  Expects that a
-        # parsimonious node was provided from the original parsing operation
-        # that yielded this type.
-        node = self.node
-
-        raise ABITypeError(
-            f"For '{node.text}' type at column {node.start + 1} "
-            f"in '{node.full_text}': {error_msg}"
-        )
-
-    @property
-    def is_array(self) -> bool:
-        """
-        Equal to ``True`` if a type is an array type (i.e. if it has an array
-        dimension list).  Otherwise, equal to ``False``.
-        """
-        return self.arrlist is not None
-
-    @property
-    def is_dynamic(self) -> bool:
-        """
-        Equal to ``True`` if a type has a dynamically sized encoding.
-        Otherwise, equal to ``False``.
-        """
-        raise NotImplementedError("Must implement `is_dynamic`")
-
-    @property
-    def _has_dynamic_arrlist(self) -> bool:
-        return self.is_array and any(len(dim) == 0 for dim in self.arrlist)
-
-
-TComp = TypeVar("TComp", bound=ABIType)
-
-
-@final
-class TupleType(ABIType):
-    """
-    Represents the result of parsing a tuple type string e.g. "(int,bool)".
-    """
-
-    __slots__ = ("components",)
-
-    def __init__(
-        self,
-        components: Tuple[TComp, ...],
-        arrlist: Optional[Sequence] = None,
-        *,
-        node: Optional[Node] = None,
-    ) -> None:
-        super().__init__(arrlist, node)
-
-        self.components: Final = components
-        """
-        A tuple of :class:`~faster_eth_abi.grammar.ABIType` instances for each of the
-        tuple type's components.
-        """
-
-    def to_type_str(self) -> TypeStr:
-        arrlist = self.arrlist
-
-        if isinstance(arrlist, tuple):
-            arrlist = "".join(repr(list(a)) for a in arrlist)
-        else:
-            arrlist = ""
-
-        return f"({','.join(c.to_type_str() for c in self.components)}){arrlist}"
-
-    @property
-    def item_type(self) -> Self:
-        if not self.is_array:
-            raise ValueError(
-                f"Cannot determine item type for non-array type '{self.to_type_str()}'"
-            )
-
-        return type(self)(
-            self.components,
-            self.arrlist[:-1] or None,  # type: ignore [index]
-            node=self.node,
-        )
-
-    def validate(self) -> None:
-        for c in self.components:
-            c.validate()
-
-    @property
-    def is_dynamic(self) -> bool:
-        if self._has_dynamic_arrlist:
-            return True
-
-        return any(c.is_dynamic for c in self.components)
-
-
-@final
-class BasicType(ABIType):
-    """
-    Represents the result of parsing a basic type string e.g. "uint", "address",
-    "ufixed128x19[][2]".
-    """
-
-    __slots__ = ("base", "sub")
-
-    def __init__(
-        self,
-        base: str,
-        sub: Any = None,
-        arrlist: Optional[Sequence] = None,
-        *,
-        node: Optional[Node] = None,
-    ) -> None:
-        super().__init__(arrlist, node)
-
-        self.base: Final = base
-        """The base of a basic type e.g. "uint" for "uint256" etc."""
-
-        self.sub: Final = sub
-        """
-        The sub type of a basic type e.g. ``256`` for "uint256" or ``(128, 18)``
-        for "ufixed128x18" etc.  Equal to ``None`` if type string has no sub
-        type.
-        """
-
-    def to_type_str(self) -> TypeStr:
-        sub, arrlist = self.sub, self.arrlist
-
-        if isinstance(sub, int):
-            substr = str(sub)
-        elif isinstance(sub, tuple):
-            substr = "x".join(str(s) for s in sub)
-        else:
-            substr = ""
-
-        if isinstance(arrlist, tuple):
-            return self.base + substr + "".join(repr(list(a)) for a in arrlist)
-        else:
-            return self.base + substr
-
-    @property
-    def item_type(self) -> Self:
-        if not self.is_array:
-            raise ValueError(
-                f"Cannot determine item type for non-array type '{self.to_type_str()}'"
-            )
-
-        return type(self)(
-            self.base,
-            self.sub,
-            self.arrlist[:-1] or None,  # type: ignore [index]
-            node=self.node,
-        )
-
-    @property
-    def is_dynamic(self) -> bool:
-        if self._has_dynamic_arrlist:
-            return True
-
-        if self.base == "string":
-            return True
-
-        if self.base == "bytes" and self.sub is None:
-            return True
-
-        return False
-
-    def validate(self) -> None:
-        base, sub = self.base, self.sub
-
-        # Check validity of string type
-        if base == "string":
-            if sub is not None:
-                self.invalidate("string type cannot have suffix")
-
-        # Check validity of bytes type
-        elif base == "bytes":
-            if not (sub is None or isinstance(sub, int)):
-                self.invalidate(
-                    "bytes type must have either no suffix or a numerical suffix"
-                )
-
-            if isinstance(sub, int) and sub > 32:
-                self.invalidate("maximum 32 bytes for fixed-length bytes")
-
-        # Check validity of integer type
-        elif base in ("int", "uint"):
-            if not isinstance(sub, int):
-                self.invalidate("integer type must have numerical suffix")
-
-            if sub < 8 or sub > 256:
-                self.invalidate("integer size out of bounds (max 256 bits)")
-
-            if sub % 8 != 0:
-                self.invalidate("integer size must be multiple of 8")
-
-        # Check validity of fixed type
-        elif base in ("fixed", "ufixed"):
-            if not isinstance(sub, tuple):
-                self.invalidate(
-                    "fixed type must have suffix of form <bits>x<exponent>, "
-                    "e.g. 128x19",
-                )
-
-            bits, minus_e = sub
-
-            if bits < 8 or bits > 256:
-                self.invalidate("fixed size out of bounds (max 256 bits)")
-
-            if bits % 8 != 0:
-                self.invalidate("fixed size must be multiple of 8")
-
-            if minus_e < 1 or minus_e > 80:
-                self.invalidate(
-                    f"fixed exponent size out of bounds, {minus_e} must be in 1-80"
-                )
-
-        # Check validity of hash type
-        elif base == "hash":
-            if not isinstance(sub, int):
-                self.invalidate("hash type must have numerical suffix")
-
-        # Check validity of address type
-        elif base == "address":
-            if sub is not None:
-                self.invalidate("address cannot have suffix")
-
-
-TYPE_ALIASES: Final = {
-    "int": "int256",
-    "uint": "uint256",
-    "fixed": "fixed128x18",
-    "ufixed": "ufixed128x18",
-    "function": "bytes24",
-    "byte": "bytes1",
-}
-
-TYPE_ALIAS_RE: Final = re.compile(
-    rf"\b({'|'.join(re.escape(a) for a in TYPE_ALIASES.keys())})\b"
-)
-
-
-def normalize(type_str: TypeStr) -> TypeStr:
-    """
-    Normalizes a type string into its canonical version e.g. the type string
-    'int' becomes 'int256', etc.
-
-    :param type_str: The type string to be normalized.
-    :returns: The canonical version of the input type string.
-    """
-    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
 
 
-parse: Final = visitor.parse
+__all__ = ["NodeVisitor", "ABIType", "TupleType", "BasicType", "grammar", "parse", "normalize", "visitor", "TYPE_ALIASES", "TYPE_ALIAS_RE"]

faster_eth_abi/registry.py

@@ -1,17 +1,24 @@
 import abc
-import copy
 import functools
+from copy import copy
 from typing import (
     Any,
     Callable,
+    Dict,
+    Final,
+    Generic,
     Optional,
     Type,
+    TypeVar,
     Union,
 )
 
 from eth_typing import (
     TypeStr,
 )
+from typing_extensions import (
+    Self,
+)
 
 from . import (
     decoding,
@@ -30,6 +37,8 @@ from .io import (
     ContextFramesBytesIO,
 )
 
+T = TypeVar("T")
+
 Lookup = Union[TypeStr, Callable[[TypeStr], bool]]
 
 EncoderCallable = Callable[[Any], bytes]
@@ -51,34 +60,35 @@ class Copyable(abc.ABC):
         return self.copy()
 
 
-class PredicateMapping(Copyable):
+class PredicateMapping(Copyable, Generic[T]):
     """
     Acts as a mapping from predicate functions to values.  Values are retrieved
     when their corresponding predicate matches a given input.  Predicates can
     also be labeled to facilitate removal from the mapping.
     """
 
-    def __init__(self, name):
-        self._name = name
-        self._values = {}
-        self._labeled_predicates = {}
+    def __init__(self, name: str):
+        self._name: Final = name
+        self._values: Dict[Lookup, T] = {}
+        self._labeled_predicates: Dict[str, Lookup] = {}
 
-    def add(self, predicate, value, label=None):
+    def add(self, predicate: Lookup, value: T, label: Optional[str] = None) -> None:
         if predicate in self._values:
             raise ValueError(f"Matcher {predicate!r} already exists in {self._name}")
 
         if label is not None:
-            if label in self._labeled_predicates:
+            labeled_predicates = self._labeled_predicates
+            if label in labeled_predicates:
                 raise ValueError(
                     f"Matcher {predicate!r} with label '{label}' "
                     f"already exists in {self._name}"
                 )
 
-            self._labeled_predicates[label] = predicate
+            labeled_predicates[label] = predicate
 
         self._values[predicate] = value
 
-    def find(self, type_str):
+    def find(self, type_str: TypeStr) -> T:
         results = tuple(
             (predicate, value)
             for predicate, value in self._values.items()
@@ -103,9 +113,9 @@ class PredicateMapping(Copyable):
                 "documentation for more information."
             )
 
-        return values[0]
+        return values[0]  # type: ignore [no-any-return]
 
-    def remove_by_equality(self, predicate):
+    def remove_by_equality(self, predicate: Lookup) -> None:
         # Delete the predicate mapping to the previously stored value
         try:
             del self._values[predicate]
@@ -120,7 +130,7 @@ class PredicateMapping(Copyable):
         else:
             del self._labeled_predicates[label]
 
-    def _label_for_predicate(self, predicate):
+    def _label_for_predicate(self, predicate: Lookup) -> str:
         # Both keys and values in `_labeled_predicates` are unique since the
         # `add` method enforces this
         for key, value in self._labeled_predicates.items():
@@ -131,16 +141,17 @@ class PredicateMapping(Copyable):
             f"Matcher {predicate!r} not referred to by any label in {self._name}"
         )
 
-    def remove_by_label(self, label):
+    def remove_by_label(self, label: str) -> None:
+        labeled_predicates = self._labeled_predicates
         try:
-            predicate = self._labeled_predicates[label]
+            predicate = labeled_predicates[label]
         except KeyError:
             raise KeyError(f"Label '{label}' not found in {self._name}")
 
-        del self._labeled_predicates[label]
+        del labeled_predicates[label]
         del self._values[predicate]
 
-    def remove(self, predicate_or_label):
+    def remove(self, predicate_or_label: Union[Lookup, str]) -> None:
         if callable(predicate_or_label):
             self.remove_by_equality(predicate_or_label)
         elif isinstance(predicate_or_label, str):
@@ -151,11 +162,11 @@ class PredicateMapping(Copyable):
                 f"{type(predicate_or_label)}"
             )
 
-    def copy(self):
+    def copy(self) -> Self:
         cpy = type(self)(self._name)
 
-        cpy._values = copy.copy(self._values)
-        cpy._labeled_predicates = copy.copy(self._labeled_predicates)
+        cpy._values = copy(self._values)
+        cpy._labeled_predicates = copy(self._labeled_predicates)
 
         return cpy
 
@@ -282,6 +293,7 @@ def _clear_encoder_cache(old_method: Callable[..., None]) -> Callable[..., None]
     @functools.wraps(old_method)
     def new_method(self: "ABIRegistry", *args: Any, **kwargs: Any) -> None:
         self.get_encoder.cache_clear()
+        self.get_tuple_encoder.cache_clear()
         return old_method(self, *args, **kwargs)
 
     return new_method
@@ -291,6 +303,7 @@ def _clear_decoder_cache(old_method: Callable[..., None]) -> Callable[..., None]
     @functools.wraps(old_method)
     def new_method(self: "ABIRegistry", *args: Any, **kwargs: Any) -> None:
         self.get_decoder.cache_clear()
+        self.get_tuple_decoder.cache_clear()
         return old_method(self, *args, **kwargs)
 
     return new_method
@@ -343,8 +356,8 @@ class BaseRegistry:
 
 class ABIRegistry(Copyable, BaseRegistry):
     def __init__(self):
-        self._encoders = PredicateMapping("encoder registry")
-        self._decoders = PredicateMapping("decoder registry")
+        self._encoders: PredicateMapping[Encoder] = PredicateMapping("encoder registry")
+        self._decoders: PredicateMapping[Decoder] = 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)(
@@ -518,8 +531,8 @@ class ABIRegistry(Copyable, BaseRegistry):
         """
         cpy = type(self)()
 
-        cpy._encoders = copy.copy(self._encoders)
-        cpy._decoders = copy.copy(self._decoders)
+        cpy._encoders = copy(self._encoders)
+        cpy._decoders = copy(self._decoders)
 
         return cpy
 

faster_eth_abi/tools/_strategies.py

@@ -2,7 +2,9 @@ from typing import (
     Callable,
     Final,
     Optional,
+    Tuple,
     Union,
+    cast,
 )
 
 from cchecksum import (
@@ -15,11 +17,13 @@ from hypothesis import (
     strategies as st,
 )
 
-from faster_eth_abi.grammar import (
+from faster_eth_abi._grammar import (
     ABIType,
     BasicType,
     TupleType,
     normalize,
+)
+from faster_eth_abi.grammar import (
     parse,
 )
 from faster_eth_abi.registry import (
@@ -81,7 +85,7 @@ class StrategyRegistry(BaseRegistry):
 def get_uint_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits = abi_type.sub
+    bits = cast(int, abi_type.sub)
 
     return st.integers(
         min_value=0,
@@ -92,7 +96,7 @@ def get_uint_strategy(
 def get_int_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits = abi_type.sub
+    bits = cast(int, abi_type.sub)
 
     return st.integers(
         min_value=-(2 ** (bits - 1)),
@@ -107,7 +111,7 @@ bool_strategy: Final = st.booleans()
 def get_ufixed_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits, places = abi_type.sub
+    bits, places = cast(Tuple[int, int], abi_type.sub)
 
     return st.decimals(
         min_value=0,
@@ -119,7 +123,7 @@ def get_ufixed_strategy(
 def get_fixed_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits, places = abi_type.sub
+    bits, places = cast(Tuple[int, int], abi_type.sub)
 
     return st.decimals(
         min_value=-(2 ** (bits - 1)),

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: faster_eth_abi
-Version: 5.2.10
+Version: 5.2.12
 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
@@ -25,6 +25,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cchecksum<0.4,>=0.2.6
 Requires-Dist: faster-eth-utils>=2.0.0
+Requires-Dist: eth-abi<6,>=5.0.1
 Requires-Dist: eth-typing>=3.0.0
 Requires-Dist: mypy_extensions
 Requires-Dist: parsimonious<0.11.0,>=0.10.0
@@ -32,7 +33,7 @@ Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
 Requires-Dist: bump_my_version>=0.19.0; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
-Requires-Dist: mypy==1.10.0; extra == "dev"
+Requires-Dist: mypy==1.18.2; extra == "dev"
 Requires-Dist: pre-commit>=3.4.0; extra == "dev"
 Requires-Dist: tox>=4.0.0; extra == "dev"
 Requires-Dist: twine; extra == "dev"
@@ -42,7 +43,7 @@ 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"
-Requires-Dist: towncrier<25,>=24; extra == "dev"
+Requires-Dist: towncrier<26,>=25; extra == "dev"
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-timeout>=2.0.0; extra == "dev"
 Requires-Dist: pytest-xdist>=2.4.0; extra == "dev"
@@ -53,7 +54,7 @@ Provides-Extra: docs
 Requires-Dist: sphinx>=6.0.0; extra == "docs"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "docs"
-Requires-Dist: towncrier<25,>=24; extra == "docs"
+Requires-Dist: towncrier<26,>=25; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pytest>=7.0.0; extra == "test"
 Requires-Dist: pytest-timeout>=2.0.0; extra == "test"
@@ -85,10 +86,14 @@ Dynamic: summary
 
 ##### 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.
+##### Starting in [v5.2.12](https://github.com/BobTheBuidler/faster-eth-abi/releases/tag/v5.2.12), all `faster-eth-abi` Exception classes inherit from the matching Exception class in `eth-abi`, so porting to `faster-eth-abi` does not require any change to your existing exception handlers. All existing exception handling in your codebase will continue to work as it did when originaly implemented.
 
 ##### 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).
 
+##### You can find the compiled C code and header files in the [build](https://github.com/BobTheBuidler/faster-eth-abi/tree/master/build) directory.
+
+###### You may also be interested in: [faster-web3.py](https://github.com/BobTheBuidler/faster-web3.py/), [faster-hexbytes](https://github.com/BobTheBuidler/faster-hexbytes/), and [faster-eth-utils](https://github.com/BobTheBuidler/faster-eth-utils/)
+
 ##### The original eth-abi readme is below:
 
 # Ethereum Contract Interface (ABI) Utility

faster_eth_abi-5.2.12.dist-info/RECORD

@@ -0,0 +1,46 @@
+faster_eth_abi__mypyc.cp310-win_amd64.pyd,sha256=G-oUQASs9sUGEgHiPoouJV8sRNpisxQautk-LhqitsA,207360
+faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
+faster_eth_abi/_codec.cp310-win_amd64.pyd,sha256=e76x-FkX73DNnZF6rAI0RIZdjIj_eA2NDln4fGyj8DI,10752
+faster_eth_abi/_codec.py,sha256=9l49XZv5CHdbSU_WShfvjCOGwrRhH75aFsh6eaZ-e0E,2341
+faster_eth_abi/_decoding.cp310-win_amd64.pyd,sha256=qXzYkVgHbuMnbOQ93xFFVRNvyZH9nF3K5ytUcBCMrcg,10752
+faster_eth_abi/_decoding.py,sha256=06ddzblp834cZ_6SA5Q3J3_XnQTa0gmWeM4gYRxrcSk,4555
+faster_eth_abi/_encoding.cp310-win_amd64.pyd,sha256=UFOm6TWrx4zdFcqSclhNGYdu_YxpjB1HHFkE3xV9l6g,10752
+faster_eth_abi/_encoding.py,sha256=rsZihtFUqYu80ANOsxP9QwpFJDH73VBVJSzOrllBm2k,3340
+faster_eth_abi/_grammar.cp310-win_amd64.pyd,sha256=ZjkUTFCNAe8Ru9kNgGH667-LlJVXGnHjRXNEaJVWW7s,10752
+faster_eth_abi/_grammar.py,sha256=IyftL6Ayb-6C1jR2xAt4y_NRnqdGtH08gwoz5zrF3rc,10491
+faster_eth_abi/abi.cp310-win_amd64.pyd,sha256=pomCaJ8-Bh3kMhoIKa5-lAtYuIK-q74AcStB8xBGmnE,10752
+faster_eth_abi/abi.py,sha256=-t9OVBSCxy6SuWpCu3cxHrCqkx8_svPIRb0MSFXEl5Q,383
+faster_eth_abi/base.py,sha256=y4IXpQJWGfUISl3xjCO420Grxido3tE2ebPV2rK-DvM,1229
+faster_eth_abi/codec.py,sha256=QZFGQ8Fg2BRVGDVLVpmrkmqjtkdMVG1Gqr9AD7dSEI0,4557
+faster_eth_abi/constants.cp310-win_amd64.pyd,sha256=G1k8lM9KRyaabjnonXsOeW6d0s2LuGqP-3PZOjEjtYY,10752
+faster_eth_abi/constants.py,sha256=q3FGynS-Eb78cnrL6mBoAvTDz16PF3tW2OylTMd6ajs,114
+faster_eth_abi/decoding.py,sha256=7zOcSLdiQhAJWnCOSAdFg2AtSMoj8ZdN2IYE_aZKHQU,17028
+faster_eth_abi/encoding.py,sha256=P1svhYylcZa55cQ9LPj6jV8iJVLSL_c5SIZT1Umol58,19679
+faster_eth_abi/exceptions.py,sha256=r4O6bmcxRzw44lNNgz_QdhukQfrnRfTm10xK2wPuba4,3701
+faster_eth_abi/from_type_str.cp310-win_amd64.pyd,sha256=qMgKmXl8xh7Nwp4OhU-ev8Ac78haG9ECSd097_pnKo4,10752
+faster_eth_abi/from_type_str.py,sha256=PV697XdxjhwHYCBbaA-H_9I2CrfkQ5vsSkSxpCOt8eg,4474
+faster_eth_abi/grammar.py,sha256=a2FopTc3TtRvjYVHlOPo18IPEXueuD8IqDdCyiuFStM,4681
+faster_eth_abi/io.py,sha256=E_QX7aYAjGYnkNAZmJMmSmx1lqvl_FDNmMFruTi9UX4,3831
+faster_eth_abi/packed.cp310-win_amd64.pyd,sha256=QfRCtyg9QK5QUx22wPGijrVWe63Y6zm8DXZ3USyWkrc,10752
+faster_eth_abi/packed.py,sha256=RZ2chvsx9_AL9OxY1ixHTsaUJHaR_tmrNdViOIp-xSg,316
+faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/registry.py,sha256=WYkH4BF2of91Pv8xLxBPTgBP0xV2uJ0FsYlYx-XrUcc,21758
+faster_eth_abi/tools/__init__.cp310-win_amd64.pyd,sha256=nIQKnKmfxaVQtrUIMLh9ANKjLMQ3fQTVl7SlGPDvGo8,10752
+faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
+faster_eth_abi/tools/_strategies.cp310-win_amd64.pyd,sha256=vuNeDYUsjSjFoZSMf00B1aiKFCoch3EBb_7gmMCnT7w,10752
+faster_eth_abi/tools/_strategies.py,sha256=02wmJpj336nOFu7pBVaH4ucj3FORweKkiGqlaRgy-8c,6330
+faster_eth_abi/utils/__init__.cp310-win_amd64.pyd,sha256=LH4XOJ5cLQ0txCCb4TVlcbNCDEdLJCwIzUafbQ22ln4,10752
+faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faster_eth_abi/utils/numeric.cp310-win_amd64.pyd,sha256=8NVMO3t4fg1bm-05fqQ-8QQ0w-Gq65YmlpLoziUNTEc,10752
+faster_eth_abi/utils/numeric.py,sha256=saAVL12dfDrMXZeao3u2jar-U2y57YKVUqF6VOzoLxs,3395
+faster_eth_abi/utils/padding.cp310-win_amd64.pyd,sha256=dIz4GLQbhFJtBSVFPvOrTmsta1eJmdwOtk3_nij17Q4,10752
+faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
+faster_eth_abi/utils/string.cp310-win_amd64.pyd,sha256=rjjsh8knd-UGtskNV3P-6wQzCnhxZsEaYt64nvVFk6U,10752
+faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
+faster_eth_abi/utils/validation.cp310-win_amd64.pyd,sha256=aKSjQpDE6WXh2IABYYD-MnGyhNV-AGFZJxOnr67Xiu4,10752
+faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
+faster_eth_abi-5.2.12.dist-info/licenses/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
+faster_eth_abi-5.2.12.dist-info/METADATA,sha256=E4sFIP3_tN7CYkNFZ9jmQqKB4jZs0fRhDuGuceQvPwo,6210
+faster_eth_abi-5.2.12.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+faster_eth_abi-5.2.12.dist-info/top_level.txt,sha256=Y0kTTMPnPpssaR0jlmJwQ2XbkYXMEj_80Ewd7quo1Cg,37
+faster_eth_abi-5.2.12.dist-info/RECORD,,

faster_eth_abi-5.2.12.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+faster_eth_abi
+faster_eth_abi__mypyc

faster_eth_abi-5.2.10.dist-info/RECORD

@@ -1,44 +0,0 @@
-76f9a3652d4d2667c55c__mypyc.cp310-win_amd64.pyd,sha256=MZoVKEvo2-6KbXZP_A50-VQ060ea-OmOZI8P-zWMTE0,165376
-faster_eth_abi/__init__.py,sha256=JpTfPTiusUGMmX8sEsGAxvILxFbvhh3MEyfiKOd5o9g,217
-faster_eth_abi/_codec.cp310-win_amd64.pyd,sha256=q3nX6wdxsXXo__2PsfRL4nb5RbXFHDQt47qu2R5XV3w,10752
-faster_eth_abi/_codec.py,sha256=fLRvqvrD8F38U4m1wZztvx-7JJbZaPikwXS5u9BzY14,2509
-faster_eth_abi/_decoding.cp310-win_amd64.pyd,sha256=IpUOb4AVj-bxSR9S_IJA7oxS3VMk03OzZWJx87PXyRE,10752
-faster_eth_abi/_decoding.py,sha256=06ddzblp834cZ_6SA5Q3J3_XnQTa0gmWeM4gYRxrcSk,4555
-faster_eth_abi/_encoding.cp310-win_amd64.pyd,sha256=hhJghgdMJUg0EVy6ZvTRxjCpxA2_FUsXmIDcbDjkeGg,10752
-faster_eth_abi/_encoding.py,sha256=rsZihtFUqYu80ANOsxP9QwpFJDH73VBVJSzOrllBm2k,3340
-faster_eth_abi/abi.cp310-win_amd64.pyd,sha256=8AyZ76PVTggbuQy65OrAedcl6z8gn9bCuvTz8Fahp50,10752
-faster_eth_abi/abi.py,sha256=-t9OVBSCxy6SuWpCu3cxHrCqkx8_svPIRb0MSFXEl5Q,383
-faster_eth_abi/base.py,sha256=y4IXpQJWGfUISl3xjCO420Grxido3tE2ebPV2rK-DvM,1229
-faster_eth_abi/codec.py,sha256=e1uO8BJrXRn0Ih70eUa5qipD2wcg2aZSR4fyVuGpFoY,4580
-faster_eth_abi/constants.cp310-win_amd64.pyd,sha256=sBtn8irTmvQlIGWkNZfs6cAwnDPtyRL8S9A0Swi3onY,10752
-faster_eth_abi/constants.py,sha256=q3FGynS-Eb78cnrL6mBoAvTDz16PF3tW2OylTMd6ajs,114
-faster_eth_abi/decoding.py,sha256=7zOcSLdiQhAJWnCOSAdFg2AtSMoj8ZdN2IYE_aZKHQU,17028
-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.cp310-win_amd64.pyd,sha256=sSs_Tv2kIlg9GsvNkapHOgUKETC411t9teg-5ea6C7Y,10752
-faster_eth_abi/from_type_str.py,sha256=WLRP3OIyrJORgloX-7V0x2KdrZj0kLay-J9I8f-H36s,4446
-faster_eth_abi/grammar.py,sha256=lhEmp3ZwMTzm1-jJiMUVD4zrBgU4MEZCRiND4WxfOes,13839
-faster_eth_abi/io.py,sha256=E_QX7aYAjGYnkNAZmJMmSmx1lqvl_FDNmMFruTi9UX4,3831
-faster_eth_abi/packed.cp310-win_amd64.pyd,sha256=dm4JgEfYsOJIBgV0I65-lY3y4emMKz7KWYO5ZQ3q4Y0,10752
-faster_eth_abi/packed.py,sha256=RZ2chvsx9_AL9OxY1ixHTsaUJHaR_tmrNdViOIp-xSg,316
-faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/registry.py,sha256=gU5-k_1eYUjs7-NAKoH9nncCJ36tZZHM5ZXvwmXt0cw,21192
-faster_eth_abi/tools/__init__.cp310-win_amd64.pyd,sha256=oL9D3WrlR5ZlkLYMy5NxRct66VBOHEwgouqxPWMML_8,10752
-faster_eth_abi/tools/__init__.py,sha256=jxyQnb34ldRjCTYi3Ajb5h5QlFQ6ODfKQNhOCVwR7Ao,54
-faster_eth_abi/tools/_strategies.cp310-win_amd64.pyd,sha256=FIHPw3W2PY9amxIpn1bdsJwM1CHcOS9ddjho5lUIYuA,10752
-faster_eth_abi/tools/_strategies.py,sha256=HCFdQFLa84SMf7Deui2-szTH34hxTfc0Rog_kmpTg_w,6197
-faster_eth_abi/utils/__init__.cp310-win_amd64.pyd,sha256=LDDdNhEb0rCuIGeC0oBI84EmihLN7aHw3Lp5DlQAmuQ,10752
-faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/utils/numeric.cp310-win_amd64.pyd,sha256=I7VmpCpnvR1MRpddK9cd6-WFwv1tcLyWE1pYCMhrzY8,10752
-faster_eth_abi/utils/numeric.py,sha256=saAVL12dfDrMXZeao3u2jar-U2y57YKVUqF6VOzoLxs,3395
-faster_eth_abi/utils/padding.cp310-win_amd64.pyd,sha256=mgLssSD11VTNXy_l7O3wK8hqLxQCAeWvVbC7qKPL9_k,10752
-faster_eth_abi/utils/padding.py,sha256=k6dkOiQ3k0OhQUZ6blCiL1VOQVYGyynucafbySjcFfY,515
-faster_eth_abi/utils/string.cp310-win_amd64.pyd,sha256=h_3W35xq8OkeOAZTcxVwFpnBYVgPY-urlJeoQ13X1iU,10752
-faster_eth_abi/utils/string.py,sha256=wYcvWof4kuitrGGSe_NOduQaxE4HHYmpraCPXKcZxMs,455
-faster_eth_abi/utils/validation.cp310-win_amd64.pyd,sha256=yq66eslHK901f1BBBl0Ap1Ot1Npxlo_iFQXBaL8Thhs,10752
-faster_eth_abi/utils/validation.py,sha256=9veO7wyQsmcFgeaGrsKdSifjV1gaXfTDDKAt1EbKHYY,539
-faster_eth_abi-5.2.10.dist-info/licenses/LICENSE,sha256=Q1lDDWXR057JL2Y7HTAwclCF32_LCloN4sGUkXO1YeI,1127
-faster_eth_abi-5.2.10.dist-info/METADATA,sha256=3Fa7x64NATEJZqCSbkEInZ9LqpR2h52CZKVSQoIcdsc,5499
-faster_eth_abi-5.2.10.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
-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/top_level.txt

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