faster-eth-abi 5.2.8__cp314-cp314t-win_amd64.whl → 5.2.19__cp314-cp314t-win_amd64.whl

faster_eth_abi/_codec.py

@@ -1,3 +1,9 @@
+"""Internal codec helpers for encoding and decoding sequences of values using the head-tail mechanism.
+
+Provides encode_c and decode_c functions for binary serialization and deserialization of values
+according to ABI type specifications.
+"""
+
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -39,13 +45,11 @@ 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)
 
-    return encoder(args)
+    return encoder.encode(args)
 
 
 def decode_c(
@@ -71,8 +75,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

@@ -1,54 +1,65 @@
+"""Private helpers for decoding logic, intended for C compilation.
+
+This file exists because the original decoding.py is not ready to be fully compiled to C.
+This module contains functions and logic that we wish to compile.
+"""
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
+    Dict,
+    Final,
     Tuple,
 )
 
+from faster_eth_utils import (
+    big_endian_to_int,
+)
+
 from faster_eth_abi.exceptions import (
     InsufficientDataBytes,
+    InvalidPointer,
+    NonEmptyPaddingBytes,
 )
 from faster_eth_abi.io import (
     BytesIO,
     ContextFramesBytesIO,
 )
+from faster_eth_abi.typing import (
+    T,
+)
 
 if TYPE_CHECKING:
     from .decoding import (
+        BaseArrayDecoder,
         DynamicArrayDecoder,
         FixedByteSizeDecoder,
         HeadTailDecoder,
+        SignedIntegerDecoder,
         SizedArrayDecoder,
         TupleDecoder,
-        UnsignedIntegerDecoder,
     )
 
 
-_UINT256_DECODER: Optional["UnsignedIntegerDecoder"] = None
-
-
-def __set_uint256_decoder() -> "UnsignedIntegerDecoder":
-    # this helper breaks a circular dependency on the non-compiled decoding module
-    from . import (
-        decoding,
-    )
-
-    global _UINT256_DECODER
-    _UINT256_DECODER = decoding.decode_uint_256
+# Helpers
+def decode_uint_256(stream: ContextFramesBytesIO) -> int:
+    """
+    A faster version of :func:`~decoding.decode_uint_256` in decoding.py.
 
-    return _UINT256_DECODER
+    It recreates the logic from the UnsignedIntegerDecoder, but we can
+    skip a lot because we know the value of many vars.
+    """
+    # read data from stream
+    if len(data := stream.read(32)) == 32:
+        return big_endian_to_int(data)
+    raise InsufficientDataBytes(f"Tried to read 32 bytes, only got {len(data)} bytes.")
 
 
-def decode_uint_256(stream: ContextFramesBytesIO) -> int:
-    decoder = _UINT256_DECODER
-    if decoder is None:
-        decoder = __set_uint256_decoder()
-    decoded: int = decoder(stream)
-    return decoded
+def get_value_byte_size(decoder: "FixedByteSizeDecoder") -> int:
+    return decoder.value_bit_size // 8
 
 
 # HeadTailDecoder
-def decode_head_tail(self: "HeadTailDecoder", stream: ContextFramesBytesIO) -> Any:
+def decode_head_tail(self: "HeadTailDecoder[T]", stream: ContextFramesBytesIO) -> T:
     # Decode the offset and move the stream cursor forward 32 bytes
     start_pos = decode_uint_256(stream)
     # Jump ahead to the start of the value
@@ -59,7 +70,7 @@ def decode_head_tail(self: "HeadTailDecoder", stream: ContextFramesBytesIO) -> A
     if tail_decoder is None:
         raise AssertionError("`tail_decoder` is None")
     # Decode the value
-    value = tail_decoder(stream)
+    value: T = tail_decoder(stream)
     # Return the cursor
     stream.pop_frame()
 
@@ -67,15 +78,117 @@ def decode_head_tail(self: "HeadTailDecoder", stream: ContextFramesBytesIO) -> A
 
 
 # TupleDecoder
-def decode_tuple(self: "TupleDecoder", stream: ContextFramesBytesIO) -> Tuple[Any, ...]:
-    self.validate_pointers(stream)
-    return tuple(decoder(stream) for decoder in self.decoders)
+def decode_tuple(
+    self: "TupleDecoder[T]", stream: ContextFramesBytesIO
+) -> Tuple[T, ...]:
+    # NOTE: the original implementation would do this but it's
+    # kinda wasteful, so we rebuilt the logic within this function
+    # validate_pointers_tuple(self, stream)
+
+    current_location = stream.tell()
+    if self._no_head_tail:
+        # TODO: if all(isinstance(d, TupleDecoder) for d in self._decoders)
+        #           return tuple(decode_tuple(stream) for _ in range(len(self.decoders))
+        #       and other types with compiled decode funcs
+        return tuple(decoder(stream) for decoder in self.decoders)
+
+    end_of_offsets = current_location + 32 * self.len_of_head
+    total_stream_length = len(stream.getbuffer())
+    items = []
+    for decoder, is_head_tail in zip(self.decoders, self._is_head_tail):
+        if is_head_tail:
+            # the next 32 bytes are a pointer that we should validate
+            # checkpoint the stream location so we can reset it after validation
+            step_location = stream.tell()
+
+            offset = decode_uint_256(stream)
+            indicated_idx = current_location + offset
+            if indicated_idx < end_of_offsets or indicated_idx >= total_stream_length:
+                # the pointer is indicating its data is located either within the
+                # offsets section of the stream or beyond the end of the stream,
+                # both of which are invalid
+                raise InvalidPointer(
+                    "Invalid pointer in tuple at location "
+                    f"{stream.tell() - 32} in payload"
+                )
+
+            # reset the stream so we can decode
+            stream.seek(step_location)
+
+        items.append(decoder(stream))
+
+    # return the stream to its original location for actual decoding
+    stream.seek(current_location)
+
+    return tuple(items)
+
+
+def validate_pointers_tuple(
+    self: "TupleDecoder",
+    stream: ContextFramesBytesIO,
+) -> None:
+    """
+    Verify that all pointers point to a valid location in the stream.
+    """
+    current_location = stream.tell()
+    if self._no_head_tail:
+        for decoder in self.decoders:
+            decoder(stream)
+    else:
+        end_of_offsets = current_location + 32 * self.len_of_head
+        total_stream_length = len(stream.getbuffer())
+        for decoder, is_head_tail in zip(self.decoders, self._is_head_tail):
+            if not is_head_tail:
+                # the next 32 bytes are not a pointer,
+                # so progress the stream per the decoder
+                decoder(stream)
+            else:
+                # the next 32 bytes are a pointer
+                offset = decode_uint_256(stream)
+                indicated_idx = current_location + offset
+                if (
+                    indicated_idx < end_of_offsets
+                    or indicated_idx >= total_stream_length
+                ):
+                    # the pointer is indicating its data is located either within the
+                    # offsets section of the stream or beyond the end of the stream,
+                    # both of which are invalid
+                    raise InvalidPointer(
+                        "Invalid pointer in tuple at location "
+                        f"{stream.tell() - 32} in payload"
+                    )
+    # return the stream to its original location for actual decoding
+    stream.seek(current_location)
+
+
+# BaseArrayDecoder
+def validate_pointers_array(
+    self: "BaseArrayDecoder", stream: ContextFramesBytesIO, array_size: int
+) -> None:
+    """
+    Verify that all pointers point to a valid location in the stream.
+    """
+    current_location = stream.tell()
+    end_of_offsets = current_location + 32 * array_size
+    total_stream_length = len(stream.getbuffer())
+    for _ in range(array_size):
+        offset = decode_uint_256(stream)
+        indicated_idx = current_location + offset
+        if indicated_idx < end_of_offsets or indicated_idx >= total_stream_length:
+            # the pointer is indicating its data is located either within the
+            # offsets section of the stream or beyond the end of the stream,
+            # both of which are invalid
+            raise InvalidPointer(
+                "Invalid pointer in array at location "
+                f"{stream.tell() - 32} in payload"
+            )
+    stream.seek(current_location)
 
 
 # SizedArrayDecoder
 def decode_sized_array(
-    self: "SizedArrayDecoder", stream: ContextFramesBytesIO
-) -> Tuple[Any, ...]:
+    self: "SizedArrayDecoder[T]", stream: ContextFramesBytesIO
+) -> Tuple[T, ...]:
     item_decoder = self.item_decoder
     if item_decoder is None:
         raise AssertionError("`item_decoder` is None")
@@ -87,8 +200,8 @@ def decode_sized_array(
 
 # DynamicArrayDecoder
 def decode_dynamic_array(
-    self: "DynamicArrayDecoder", stream: ContextFramesBytesIO
-) -> Tuple[Any, ...]:
+    self: "DynamicArrayDecoder[T]", stream: ContextFramesBytesIO
+) -> Tuple[T, ...]:
     array_size = decode_uint_256(stream)
     stream.push_frame(32)
     if self.item_decoder is None:
@@ -104,7 +217,7 @@ def decode_dynamic_array(
 
 # FixedByteSizeDecoder
 def read_fixed_byte_size_data_from_stream(
-    self: "FixedByteSizeDecoder",
+    self: "FixedByteSizeDecoder[Any]",
     # NOTE: use BytesIO here so mypyc doesn't type-check
     # `stream` once we compile ContextFramesBytesIO.
     stream: BytesIO,
@@ -115,3 +228,72 @@ 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[Any]",
+    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[T]",
+    value: T,
+    padding_bytes: bytes,
+) -> None:
+    if padding_bytes != get_expected_padding_bytes(self, b"\x00"):
+        raise NonEmptyPaddingBytes(f"Padding bytes were not empty: {padding_bytes!r}")
+
+
+_expected_padding_bytes_cache: Final[
+    Dict["FixedByteSizeDecoder[Any]", Dict[bytes, bytes]]
+] = {}
+
+
+def get_expected_padding_bytes(
+    self: "FixedByteSizeDecoder[Any]", chunk: bytes
+) -> bytes:
+    instance_cache = _expected_padding_bytes_cache.setdefault(self, {})
+    expected_padding_bytes = instance_cache.get(chunk)
+    if expected_padding_bytes is None:
+        value_byte_size = get_value_byte_size(self)
+        padding_size = self.data_byte_size - value_byte_size
+        expected_padding_bytes = chunk * padding_size
+        instance_cache[chunk] = expected_padding_bytes
+    return expected_padding_bytes
+
+
+def validate_padding_bytes_signed_integer(
+    self: "SignedIntegerDecoder",
+    value: int,
+    padding_bytes: bytes,
+) -> None:
+    if value >= 0:
+        expected_padding_bytes = get_expected_padding_bytes(self, b"\x00")
+    else:
+        expected_padding_bytes = get_expected_padding_bytes(self, b"\xff")
+
+    if padding_bytes != expected_padding_bytes:
+        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,33 +1,65 @@
-from itertools import (
-    accumulate,
-)
+"""Private helpers for encoding logic, intended for C compilation.
+
+This file exists because the original encoding.py is not ready to be fully compiled to C.
+This module contains functions and logic that we do wish to compile.
+"""
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Sequence,
+    Tuple,
     TypeVar,
 )
 
+from faster_eth_utils import (
+    is_list_like,
+)
+
+from faster_eth_abi.exceptions import (
+    ValueOutOfBounds,
+)
+
 if TYPE_CHECKING:
     from faster_eth_abi.encoding import (
         BaseEncoder,
+        TupleEncoder,
     )
 
 
 T = TypeVar("T")
 
 
-def encode_tuple(
-    values: Sequence[Any],
-    encoders: Sequence["BaseEncoder"],
-) -> bytes:
+# TupleEncoder
+def validate_tuple(self: "TupleEncoder", value: Sequence[Any]) -> None:
+    # if we check list and tuple first it compiles to much quicker C code
+    if not isinstance(value, (list, tuple)) and not is_list_like(value):
+        self.invalidate_value(
+            value,
+            msg="must be list-like object such as array or tuple",
+        )
+
+    validators = self.validators
+    if len(value) != len(validators):
+        self.invalidate_value(
+            value,
+            exc=ValueOutOfBounds,
+            msg=f"value has {len(value)} items when {len(validators)} " "were expected",
+        )
+
+    for item, validator in zip(value, validators):
+        validator(item)
+
+
+def encode_tuple(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
     raw_head_chunks: List[Optional[bytes]] = []
     tail_chunks: List[bytes] = []
-    for value, encoder in zip(values, encoders):
-        if getattr(encoder, "is_dynamic", False):
+    for value, encoder, is_dynamic in zip(values, self.encoders, self._is_dynamic):
+        if is_dynamic:
             raw_head_chunks.append(None)
             tail_chunks.append(encoder(value))
         else:
@@ -35,7 +67,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)
@@ -44,6 +81,112 @@ def encode_tuple(
     return b"".join(head_chunks) + b"".join(tail_chunks)
 
 
+def encode_tuple_all_dynamic(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    tail_chunks = [encoder(value) for encoder, value in zip(encoders, values)]
+
+    total_offset = 0
+    head_length = 32 * len(encoders)
+    head_chunks = [encode_uint_256(head_length)]
+    for item in tail_chunks[:-1]:
+        total_offset += len(item)
+        head_chunks.append(encode_uint_256(head_length + total_offset))
+
+    return b"".join(head_chunks) + b"".join(tail_chunks)
+
+
+def encode_tuple_no_dynamic(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(len(encoders)))
+
+
+def encode_tuple_no_dynamic1(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders: Tuple["BaseEncoder"] = self.encoders
+    return encoders[0](values[0])
+
+
+def encode_tuple_no_dynamic2(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder"] = self.encoders
+    return encoders[0](values[0]) + encoders[1](values[1])
+
+
+def encode_tuple_no_dynamic3(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(3))
+
+
+def encode_tuple_no_dynamic4(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(4))
+
+
+def encode_tuple_no_dynamic5(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(5))
+
+
+def encode_tuple_no_dynamic6(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(6))
+
+
+def encode_tuple_no_dynamic7(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(7))
+
+
+def encode_tuple_no_dynamic8(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(8))
+
+
+def encode_tuple_no_dynamic9(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(9))
+
+
+def encode_tuple_no_dynamic10(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(10))
+
+
+encode_tuple_no_dynamic_funcs: Dict[
+    int, Callable[["TupleEncoder", Sequence[Any]], bytes]
+] = {
+    1: encode_tuple_no_dynamic1,
+    2: encode_tuple_no_dynamic2,
+    3: encode_tuple_no_dynamic3,
+    4: encode_tuple_no_dynamic4,
+    5: encode_tuple_no_dynamic5,
+    6: encode_tuple_no_dynamic6,
+    7: encode_tuple_no_dynamic7,
+    8: encode_tuple_no_dynamic8,
+    9: encode_tuple_no_dynamic9,
+    10: encode_tuple_no_dynamic10,
+}
+
+
 def encode_fixed(
     value: Any,
     encode_fn: Callable[[Any], bytes],
@@ -77,7 +220,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
     )