faster-eth-abi 5.2.3__cp314-cp314t-macosx_11_0_arm64.whl

faster_eth_abi/exceptions.py

@@ -0,0 +1,115 @@
+import parsimonious
+
+
+class EncodingError(Exception):
+    """
+    Base exception for any error that occurs during encoding.
+    """
+
+
+class EncodingTypeError(EncodingError):
+    """
+    Raised when trying to encode a python value whose type is not supported for
+    the output ABI type.
+    """
+
+
+class IllegalValue(EncodingError):
+    """
+    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.
+
+    .. code-block:: python
+
+        fixed128x19_encoder(Decimal('NaN'))  # cannot encode NaN
+
+    """
+
+
+class ValueOutOfBounds(IllegalValue):
+    """
+    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
+    type.
+
+    .. code-block:: python
+
+        ufixed8x1_encoder(Decimal('25.6'))  # out of bounds
+
+    """
+
+
+class DecodingError(Exception):
+    """
+    Base exception for any error that occurs during decoding.
+    """
+
+
+class InsufficientDataBytes(DecodingError):
+    """
+    Raised when there are insufficient data to decode a value for a given ABI type.
+    """
+
+
+class NonEmptyPaddingBytes(DecodingError):
+    """
+    Raised when the padding bytes of an ABI value are malformed.
+    """
+
+
+class InvalidPointer(DecodingError):
+    """
+    Raised when the pointer to a value in the ABI encoding is invalid.
+    """
+
+
+class ParseError(parsimonious.ParseError):  # type: ignore[misc] # subclasses Any
+    """
+    Raised when an ABI type string cannot be parsed.
+    """
+
+    def __str__(self) -> str:
+        return (
+            f"Parse error at '{self.text[self.pos : self.pos + 5]}' "
+            f"(column {self.column()}) in type string '{self.text}'"
+        )
+
+
+class ABITypeError(ValueError):
+    """
+    Raised when a parsed ABI type has inconsistent properties; for example,
+    when trying to parse the type string ``'uint7'`` (which has a bit-width
+    that is not congruent with zero modulo eight).
+    """
+
+
+class PredicateMappingError(Exception):
+    """
+    Raised when an error occurs in a registry's internal mapping.
+    """
+
+
+class NoEntriesFound(ValueError, PredicateMappingError):
+    """
+    Raised when no registration is found for a type string in a registry's
+    internal mapping.
+
+    .. warning::
+
+        In a future version of ``faster-eth-abi``, this error class will no longer
+        inherit from ``ValueError``.
+    """
+
+
+class MultipleEntriesFound(ValueError, PredicateMappingError):
+    """
+    Raised when multiple registrations are found for a type string in a
+    registry's internal mapping.  This error is non-recoverable and indicates
+    that a registry was configured incorrectly.  Registrations are expected to
+    cover completely distinct ranges of type strings.
+
+    .. warning::
+
+        In a future version of ``faster-eth-abi``, this error class will no longer
+        inherit from ``ValueError``.
+    """

faster_eth_abi/from_type_str.py

@@ -0,0 +1,135 @@
+import functools
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Optional,
+    Type,
+    TypeVar,
+)
+
+from eth_typing import (
+    TypeStr,
+)
+
+from .grammar import (
+    ABIType,
+    BasicType,
+    TupleType,
+    normalize,
+    parse,
+)
+
+if TYPE_CHECKING:
+    from .base import (
+        BaseCoder,
+    )
+
+
+TType = TypeVar("TType", bound=Type["BaseCoder"])
+OldFromTypeStr = Callable[["BaseCoder", ABIType, Any], TType]
+if TYPE_CHECKING:
+    NewFromTypeStr = classmethod[TType, [TypeStr, Any], TType]
+
+
+def parse_type_str(
+    expected_base: Optional[str] = None,
+    with_arrlist: bool = False,
+) -> Callable[[OldFromTypeStr[TType]], "NewFromTypeStr[TType]"]:
+    """
+    Used by BaseCoder subclasses as a convenience for implementing the
+    ``from_type_str`` method required by ``ABIRegistry``.  Useful if normalizing
+    then parsing a type string with an (optional) expected base is required in
+    that method.
+    """
+
+    def decorator(old_from_type_str: OldFromTypeStr[TType]) -> "NewFromTypeStr[TType]":
+        @functools.wraps(old_from_type_str)
+        def new_from_type_str(cls: TType, type_str: TypeStr, registry: Any) -> TType:
+            normalized_type_str = normalize(type_str)
+            abi_type = parse(normalized_type_str)
+
+            type_str_repr = repr(type_str)
+            if type_str != normalized_type_str:
+                type_str_repr = (
+                    f"{type_str_repr} (normalized to {normalized_type_str!r})"
+                )
+
+            if expected_base is not None:
+                if not isinstance(abi_type, BasicType):
+                    raise ValueError(
+                        "Cannot create {} for non-basic type {}".format(
+                            cls.__name__,
+                            type_str_repr,
+                        )
+                    )
+                if abi_type.base != expected_base:
+                    raise ValueError(
+                        "Cannot create {} for type {}: expected type with "
+                        "base '{}'".format(
+                            cls.__name__,
+                            type_str_repr,
+                            expected_base,
+                        )
+                    )
+
+            if not with_arrlist and abi_type.arrlist is not None:
+                raise ValueError(
+                    "Cannot create {} for type {}: expected type with "
+                    "no array dimension list".format(
+                        cls.__name__,
+                        type_str_repr,
+                    )
+                )
+            if with_arrlist and abi_type.arrlist is None:
+                raise ValueError(
+                    "Cannot create {} for type {}: expected type with "
+                    "array dimension list".format(
+                        cls.__name__,
+                        type_str_repr,
+                    )
+                )
+
+            # Perform general validation of default solidity types
+            abi_type.validate()
+
+            return old_from_type_str(cls, abi_type, registry)
+
+        return classmethod(new_from_type_str)
+
+    return decorator
+
+
+def parse_tuple_type_str(
+    old_from_type_str: OldFromTypeStr[TType],
+) -> "NewFromTypeStr[TType]":
+    """
+    Used by BaseCoder subclasses as a convenience for implementing the
+    ``from_type_str`` method required by ``ABIRegistry``.  Useful if normalizing
+    then parsing a tuple type string is required in that method.
+    """
+
+    @functools.wraps(old_from_type_str)
+    def new_from_type_str(cls: TType, type_str: TypeStr, registry: Any) -> TType:
+        normalized_type_str = normalize(type_str)
+        abi_type = parse(normalized_type_str)
+
+        if not isinstance(abi_type, TupleType):
+            type_str_repr = repr(type_str)
+            if type_str != normalized_type_str:
+                type_str_repr = "{} (normalized to {})".format(
+                    type_str_repr,
+                    repr(normalized_type_str),
+                )
+            raise ValueError(
+                "Cannot create {} for non-tuple type {}".format(
+                    cls.__name__,
+                    type_str_repr,
+                )
+            )
+
+        abi_type.validate()
+
+        return old_from_type_str(cls, abi_type, registry)
+
+    return classmethod(new_from_type_str)