faster-eth-abi 5.2.3__cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl

faster_eth_abi/__init__.py

@@ -0,0 +1,12 @@
+from importlib.metadata import (
+    version as __version,
+)
+
+from faster_eth_abi.abi import (
+    decode,
+    encode,
+    is_encodable,
+    is_encodable_type,
+)
+
+__version__ = __version("faster-eth-abi")

faster_eth_abi/abi.py

@@ -0,0 +1,17 @@
+from typing import (
+    Final,
+)
+
+from faster_eth_abi.codec import (
+    ABICodec,
+)
+from faster_eth_abi.registry import (
+    registry,
+)
+
+default_codec: Final = ABICodec(registry)
+
+encode: Final = default_codec.encode
+decode: Final = default_codec.decode
+is_encodable: Final = default_codec.is_encodable
+is_encodable_type: Final = default_codec.is_encodable_type

faster_eth_abi/base.py

@@ -0,0 +1,41 @@
+from typing import (
+    Any,
+)
+
+
+class BaseCoder:
+    """
+    Base class for all encoder and decoder classes.
+    """
+
+    is_dynamic = False
+
+    def __init__(self, **kwargs: Any) -> None:
+        cls = type(self)
+
+        # Ensure no unrecognized kwargs were given
+        for key, value in kwargs.items():
+            if not hasattr(cls, key):
+                raise AttributeError(
+                    "Property {key} not found on {cls_name} class. "
+                    "`{cls_name}.__init__` only accepts keyword arguments which are "
+                    "present on the {cls_name} class.".format(
+                        key=key,
+                        cls_name=cls.__name__,
+                    )
+                )
+            setattr(self, key, value)
+
+        # Validate given combination of kwargs
+        self.validate()
+
+    def validate(self):
+        pass
+
+    @classmethod
+    def from_type_str(cls, type_str, registry):  # pragma: no cover
+        """
+        Used by :any:`ABIRegistry` to get an appropriate encoder or decoder
+        instance for the given type string and type registry.
+        """
+        raise NotImplementedError("Must implement `from_type_str`")

faster_eth_abi/codec.py

@@ -0,0 +1,167 @@
+from typing import (
+    Any,
+    Iterable,
+    Tuple,
+    cast,
+)
+
+from eth_typing.abi import (
+    Decodable,
+    TypeStr,
+)
+
+from faster_eth_abi.decoding import (
+    ContextFramesBytesIO,
+    TupleDecoder,
+)
+from faster_eth_abi.encoding import (
+    TupleEncoder,
+)
+from faster_eth_abi.exceptions import (
+    EncodingError,
+)
+from faster_eth_abi.registry import (
+    ABIRegistry,
+)
+from faster_eth_abi.utils.validation import (
+    validate_bytes_param,
+    validate_list_like_param,
+)
+
+
+class BaseABICoder:
+    """
+    Base class for porcelain coding APIs.  These are classes which wrap
+    instances of :class:`~faster_eth_abi.registry.ABIRegistry` to provide last-mile
+    coding functionality.
+    """
+
+    def __init__(self, registry: ABIRegistry):
+        """
+        Constructor.
+
+        :param registry: The registry providing the encoders to be used when
+            encoding values.
+        """
+        self._registry = registry
+
+
+class ABIEncoder(BaseABICoder):
+    """
+    Wraps a registry to provide last-mile encoding functionality.
+    """
+
+    def encode(self, 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")
+
+        encoders = tuple(self._registry.get_encoder(type_str) for type_str in types)
+
+        encoder = TupleEncoder(encoders=encoders)
+
+        return encoder(args)
+
+    def is_encodable(self, typ: TypeStr, arg: Any) -> bool:
+        """
+        Determines if the python value ``arg`` is encodable as a value of the
+        ABI type ``typ``.
+
+        :param typ: A string representation for the ABI type against which the
+            python value ``arg`` will be checked e.g. ``'uint256'``,
+            ``'bytes[]'``, ``'(int,int)'``, etc.
+        :param arg: The python value whose encodability should be checked.
+
+        :returns: ``True`` if ``arg`` is encodable as a value of the ABI type
+            ``typ``.  Otherwise, ``False``.
+        """
+        if not self.is_encodable_type(typ):
+            return False
+
+        encoder = self._registry.get_encoder(typ)
+
+        try:
+            encoder.validate_value(arg)
+        except EncodingError:
+            return False
+        except AttributeError:
+            try:
+                encoder(arg)
+            except EncodingError:
+                return False
+
+        return True
+
+    def is_encodable_type(self, typ: TypeStr) -> bool:
+        """
+        Returns ``True`` if values for the ABI type ``typ`` can be encoded by
+        this codec.
+
+        :param typ: A string representation for the ABI type that will be
+            checked for encodability e.g. ``'uint256'``, ``'bytes[]'``,
+            ``'(int,int)'``, etc.
+
+        :returns: ``True`` if values for ``typ`` can be encoded by this codec.
+            Otherwise, ``False``.
+        """
+        return self._registry.has_encoder(typ)
+
+
+class ABIDecoder(BaseABICoder):
+    """
+    Wraps a registry to provide last-mile decoding functionality.
+    """
+
+    stream_class = ContextFramesBytesIO
+
+    def decode(
+        self,
+        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")
+
+        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))
+
+
+class ABICodec(ABIEncoder, ABIDecoder):
+    pass

faster_eth_abi/constants.py

@@ -0,0 +1,7 @@
+from typing import (
+    Final,
+)
+
+TT256: Final = 2**256
+TT256M1: Final = 2**256 - 1
+TT255: Final = 2**255