faster-eth-abi 5.2.9__cp314-cp314t-musllinux_1_2_x86_64.whl → 5.2.11__cp314-cp314t-musllinux_1_2_x86_64.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/_decoding.py

@@ -10,6 +10,7 @@ from faster_eth_utils import (
 
 from faster_eth_abi.exceptions import (
     InsufficientDataBytes,
+    NonEmptyPaddingBytes,
 )
 from faster_eth_abi.io import (
     BytesIO,
@@ -26,6 +27,7 @@ if TYPE_CHECKING:
     )
 
 
+# Helpers
 def decode_uint_256(stream: ContextFramesBytesIO) -> int:
     """
     This function is a faster version of decode_uint_256 in decoding.py.
@@ -39,6 +41,10 @@ def decode_uint_256(stream: ContextFramesBytesIO) -> int:
     raise InsufficientDataBytes(f"Tried to read 32 bytes, only got {len(data)} bytes.")
 
 
+def get_value_byte_size(decoder: "FixedByteSizeDecoder") -> int:
+    return decoder.value_bit_size // 8
+
+
 # HeadTailDecoder
 def decode_head_tail(self: "HeadTailDecoder", stream: ContextFramesBytesIO) -> Any:
     # Decode the offset and move the stream cursor forward 32 bytes
@@ -107,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/_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/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,
@@ -303,29 +307,14 @@ class FixedByteSizeDecoder(SingleDecoder):
         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) -> int:
-        return self.value_bit_size // 8
+        # This is unused, but it is kept in to preserve the eth-abi api
+        return get_value_byte_size(self)
 
 
 class Fixed32ByteSizeDecoder(FixedByteSizeDecoder):
@@ -336,16 +325,7 @@ class BooleanDecoder(Fixed32ByteSizeDecoder):
     value_bit_size = 8
     is_big_endian = True
 
-    @staticmethod
-    def decoder_fn(data: bytes) -> bool:
-        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):
@@ -392,7 +372,7 @@ class SignedIntegerDecoder(Fixed32ByteSizeDecoder):
             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:
@@ -471,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/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,
 )