faster-eth-abi 5.2.12__cp312-cp312-win_amd64.whl → 5.2.13__cp312-cp312-win_amd64.whl

benchmarks/test_io_benchmarks.py

@@ -0,0 +1,99 @@
+"""
+Benchmarks for faster_eth_abi.decoding.ContextFramesBytesIO
+
+This file benchmarks the performance of ContextFramesBytesIO, a subclass of BytesIO
+that supports contextual frame management for nested ABI decoding.
+"""
+
+import pytest
+
+import eth_abi.decoding
+from pytest_codspeed import (
+    BenchmarkFixture,
+)
+
+from benchmarks.batch import (
+    batch,
+)
+import faster_eth_abi.decoding
+
+# Test parameters
+BUFFER_SIZES = [0, 32, 1024, 4096, 65536]
+FRAME_DEPTHS = [1, 5, 10, 50]
+
+
+@pytest.mark.benchmark(group="ContextFramesBytesIO-init")
+@pytest.mark.parametrize("size", BUFFER_SIZES)
+def test_contextframesbytesio_init(benchmark: BenchmarkFixture, size):
+    data = b"\x01" * size
+    benchmark(batch, 1000, eth_abi.decoding.ContextFramesBytesIO, data)
+
+
+@pytest.mark.benchmark(group="ContextFramesBytesIO-init")
+@pytest.mark.parametrize("size", BUFFER_SIZES)
+def test_faster_contextframesbytesio_init(benchmark: BenchmarkFixture, size):
+    data = b"\x01" * size
+    benchmark(batch, 1000, faster_eth_abi.decoding.ContextFramesBytesIO, data)
+
+
+@pytest.mark.benchmark(group="ContextFramesBytesIO-push-pop")
+@pytest.mark.parametrize("depth", FRAME_DEPTHS)
+def test_contextframesbytesio_push_pop(benchmark: BenchmarkFixture, depth):
+    data = b"\x01" * 1024
+    stream = eth_abi.decoding.ContextFramesBytesIO(data)
+
+    def push_pop():
+        for i in range(depth):
+            stream.push_frame(i * 10)
+        for _ in range(depth):
+            stream.pop_frame()
+
+    benchmark(batch, 100, push_pop)
+
+
+@pytest.mark.benchmark(group="ContextFramesBytesIO-push-pop")
+@pytest.mark.parametrize("depth", FRAME_DEPTHS)
+def test_faster_contextframesbytesio_push_pop(benchmark: BenchmarkFixture, depth):
+    data = b"\x01" * 1024
+    stream = faster_eth_abi.decoding.ContextFramesBytesIO(data)
+    ints = list(range(depth))
+
+    def push_pop():
+        for i in ints:
+            stream.push_frame(i * 10)
+        for _ in ints:
+            stream.pop_frame()
+
+    benchmark(batch, 100, push_pop)
+
+
+@pytest.mark.benchmark(group="ContextFramesBytesIO-seek-in-frame")
+@pytest.mark.parametrize("depth", FRAME_DEPTHS)
+def test_contextframesbytesio_seek_in_frame(benchmark: BenchmarkFixture, depth):
+    data = b"\x01" * 1024
+    stream = eth_abi.decoding.ContextFramesBytesIO(data)
+    # Set up the frame stack before timing
+    for i in range(depth):
+        stream.push_frame(i * 10)
+
+    def seek_in_frame_ops():
+        for i in range(depth):
+            stream.seek_in_frame(i)
+
+    benchmark(batch, 100, seek_in_frame_ops)
+
+
+@pytest.mark.benchmark(group="ContextFramesBytesIO-seek-in-frame")
+@pytest.mark.parametrize("depth", FRAME_DEPTHS)
+def test_faster_contextframesbytesio_seek_in_frame(benchmark: BenchmarkFixture, depth):
+    data = b"\x01" * 1024
+    stream = faster_eth_abi.decoding.ContextFramesBytesIO(data)
+    # Set up the frame stack before timing
+    for i in range(depth):
+        stream.push_frame(i * 10)
+
+    def seek_in_frame_ops():
+        for i in range(depth):
+            stream.seek_in_frame(i)
+
+    benchmark(batch, 100, seek_in_frame_ops)

benchmarks/test_packed_benchmarks.py

@@ -0,0 +1,41 @@
+import pytest
+
+import eth_abi.packed
+from pytest_codspeed import (
+    BenchmarkFixture,
+)
+
+from benchmarks.batch import (
+    batch,
+)
+from benchmarks.data import (
+    packed_cases,
+    packed_ids,
+)
+import faster_eth_abi.packed
+
+
+# Packed encoding
+@pytest.mark.benchmark(group="PackedEncoder")
+@pytest.mark.parametrize("abi_type,value", packed_cases, ids=packed_ids)
+def test_encode_packed(benchmark: BenchmarkFixture, abi_type, value):
+    benchmark(batch, 100, eth_abi.packed.encode_packed, [abi_type], [value])
+
+
+@pytest.mark.benchmark(group="PackedEncoder")
+@pytest.mark.parametrize("abi_type,value", packed_cases, ids=packed_ids)
+def test_faster_encode_packed(benchmark: BenchmarkFixture, abi_type, value):
+    benchmark(batch, 100, faster_eth_abi.packed.encode_packed, [abi_type], [value])
+
+
+# Packed is_encodable
+@pytest.mark.benchmark(group="PackedIsEncodable")
+@pytest.mark.parametrize("abi_type,value", packed_cases, ids=packed_ids)
+def test_is_encodable_packed(benchmark: BenchmarkFixture, abi_type, value):
+    benchmark(batch, 100, eth_abi.packed.is_encodable_packed, abi_type, value)
+
+
+@pytest.mark.benchmark(group="PackedIsEncodable")
+@pytest.mark.parametrize("abi_type,value", packed_cases, ids=packed_ids)
+def test_faster_is_encodable_packed(benchmark: BenchmarkFixture, abi_type, value):
+    benchmark(batch, 100, faster_eth_abi.packed.is_encodable_packed, abi_type, value)

benchmarks/test_registry_benchmarks.py

@@ -0,0 +1,42 @@
+import pytest
+
+from eth_abi.registry import (
+    registry,
+)
+from pytest_codspeed import (
+    BenchmarkFixture,
+)
+
+from benchmarks.batch import (
+    batch,
+)
+from benchmarks.type_strings import (
+    type_strings,
+)
+from faster_eth_abi.registry import (
+    registry as faster_registry,
+)
+
+
+@pytest.mark.benchmark(group="RegistryGetEncoder")
+@pytest.mark.parametrize("type_str", type_strings)
+def test_get_encoder(benchmark: BenchmarkFixture, type_str):
+    benchmark(batch, 1000, registry.get_encoder, type_str)
+
+
+@pytest.mark.benchmark(group="RegistryGetEncoder")
+@pytest.mark.parametrize("type_str", type_strings)
+def test_faster_get_encoder(benchmark: BenchmarkFixture, type_str):
+    benchmark(batch, 1000, faster_registry.get_encoder, type_str)
+
+
+@pytest.mark.benchmark(group="RegistryGetDecoder")
+@pytest.mark.parametrize("type_str", type_strings)
+def test_get_decoder(benchmark: BenchmarkFixture, type_str):
+    benchmark(batch, 1000, registry.get_decoder, type_str)
+
+
+@pytest.mark.benchmark(group="RegistryGetDecoder")
+@pytest.mark.parametrize("type_str", type_strings)
+def test_faster_get_decoder(benchmark: BenchmarkFixture, type_str):
+    benchmark(batch, 1000, faster_registry.get_decoder, type_str)

benchmarks/type_strings.py

@@ -0,0 +1,26 @@
+# Shared list of all ABI type strings used in benchmarks
+
+type_strings = [
+    "uint256",
+    "int8",
+    "address",
+    "bytes32",
+    "string",
+    "bool",
+    "uint256[2]",
+    "string[]",
+    "(uint256,bool)",
+    "(address,uint8)",
+    "(string,bytes)",
+    "(uint256[2],string)",
+    "(uint8,(bool,string))",
+    "((uint8,uint8),uint8)",
+    "(uint8[2],(string,bool[2]))",
+    "(uint256[],(string[],bool))",
+    "((uint8[2],(string,bool)),bytes32)",
+    "(uint8[2][2],(string[2],bool[2]))",
+    "uint8[]",
+    "bytes",
+    "fixed128x18",
+    "ufixed128x18",
+]

faster_eth_abi/_decoding.py

@@ -1,6 +1,8 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Dict,
+    Final,
     Tuple,
 )
 
@@ -10,6 +12,7 @@ from faster_eth_utils import (
 
 from faster_eth_abi.exceptions import (
     InsufficientDataBytes,
+    InvalidPointer,
     NonEmptyPaddingBytes,
 )
 from faster_eth_abi.io import (
@@ -19,9 +22,11 @@ from faster_eth_abi.io import (
 
 if TYPE_CHECKING:
     from .decoding import (
+        BaseArrayDecoder,
         DynamicArrayDecoder,
         FixedByteSizeDecoder,
         HeadTailDecoder,
+        SignedIntegerDecoder,
         SizedArrayDecoder,
         TupleDecoder,
     )
@@ -66,8 +71,107 @@ 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)
+    # 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
@@ -139,10 +243,37 @@ def validate_padding_bytes_fixed_byte_size(
     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 != 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", Dict[bytes, bytes]]
+] = {}
+
+
+def get_expected_padding_bytes(self: "FixedByteSizeDecoder", 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 != b"\x00" * padding_size:
+    if padding_bytes != expected_padding_bytes:
         raise NonEmptyPaddingBytes(f"Padding bytes were not empty: {padding_bytes!r}")
 
 

faster_eth_abi/decoding.py

@@ -1,5 +1,11 @@
 import abc
 import decimal
+from functools import (
+    cached_property,
+)
+from types import (
+    MethodType,
+)
 from typing import (
     Any,
     Callable,
@@ -7,6 +13,7 @@ from typing import (
     Optional,
     Tuple,
     Union,
+    final,
 )
 
 from faster_eth_utils import (
@@ -24,13 +31,14 @@ from faster_eth_abi._decoding import (
     read_fixed_byte_size_data_from_stream,
     split_data_and_padding_fixed_byte_size,
     validate_padding_bytes_fixed_byte_size,
+    validate_padding_bytes_signed_integer,
+    validate_pointers_array,
 )
 from faster_eth_abi.base import (
     BaseCoder,
 )
 from faster_eth_abi.exceptions import (
     InsufficientDataBytes,
-    InvalidPointer,
     NonEmptyPaddingBytes,
 )
 from faster_eth_abi.from_type_str import (
@@ -111,6 +119,10 @@ class TupleDecoder(BaseDecoder):
         self.len_of_head = sum(
             getattr(decoder, "array_size", 1) for decoder in decoders
         )
+        self._is_head_tail = tuple(
+            isinstance(decoder, HeadTailDecoder) for decoder in decoders
+        )
+        self._no_head_tail = not any(self._is_head_tail)
 
     def validate(self) -> None:
         super().validate()
@@ -118,35 +130,9 @@ class TupleDecoder(BaseDecoder):
         if self.decoders is None:
             raise ValueError("No `decoders` set")
 
+    @final
     def validate_pointers(self, stream: ContextFramesBytesIO) -> None:
-        """
-        Verify that all pointers point to a valid location in the stream.
-        """
-        current_location = stream.tell()
-        end_of_offsets = current_location + 32 * self.len_of_head
-        total_stream_length = len(stream.getbuffer())
-        for decoder in self.decoders:
-            if isinstance(decoder, HeadTailDecoder):
-                # 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"
-                    )
-            else:
-                # the next 32 bytes are not a pointer, so progress the stream per
-                # the decoder
-                decoder(stream)
-        # return the stream to its original location for actual decoding
-        stream.seek(current_location)
+        raise NotImplementedError("didnt call __init__")
 
     def decode(self, stream: ContextFramesBytesIO) -> Tuple[Any, ...]:
         return decode_tuple(self, stream)
@@ -171,10 +157,10 @@ class SingleDecoder(BaseDecoder):
         if self.decoder_fn is None:
             raise ValueError("No `decoder_fn` set")
 
-    def validate_padding_bytes(self, value, padding_bytes):
+    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
 
-    def decode(self, stream):
+    def decode(self, stream: ContextFramesBytesIO) -> Any:
         raw_data = self.read_data_from_stream(stream)
         data, padding_bytes = self.split_data_and_padding(raw_data)
         decoder_fn = self.decoder_fn
@@ -204,6 +190,15 @@ class BaseArrayDecoder(BaseDecoder):
         item_decoder = self.item_decoder
         if item_decoder.is_dynamic:
             self.item_decoder = HeadTailDecoder(tail_decoder=item_decoder)
+        else:
+
+            def noop(stream: ContextFramesBytesIO, array_size: int) -> None:
+                ...
+
+            self.validate_pointers = noop
+
+    def decode(self, stream: ContextFramesBytesIO) -> Tuple[Any, ...]:
+        raise NotImplementedError  # this is a type stub
 
     def validate(self) -> None:
         super().validate()
@@ -230,25 +225,7 @@ class BaseArrayDecoder(BaseDecoder):
         """
         Verify that all pointers point to a valid location in the stream.
         """
-        if isinstance(self.item_decoder, HeadTailDecoder):
-            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)
+        validate_pointers_array(self, stream, array_size)
 
 
 class SizedArrayDecoder(BaseArrayDecoder):
@@ -281,6 +258,23 @@ class FixedByteSizeDecoder(SingleDecoder):
     data_byte_size: int = None
     is_big_endian: bool = None
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.read_data_from_stream = MethodType(
+            read_fixed_byte_size_data_from_stream, self
+        )
+        self.split_data_and_padding = MethodType(
+            split_data_and_padding_fixed_byte_size, self
+        )
+        self._get_value_byte_size = MethodType(get_value_byte_size, self)
+
+        # Only assign validate_padding_bytes if not overridden in subclass
+        if type(self).validate_padding_bytes is SingleDecoder.validate_padding_bytes:
+            self.validate_padding_bytes = MethodType(
+                validate_padding_bytes_fixed_byte_size, self
+            )
+
     def validate(self) -> None:
         super().validate()
 
@@ -304,17 +298,14 @@ class FixedByteSizeDecoder(SingleDecoder):
             raise ValueError("Value byte size exceeds data size")
 
     def read_data_from_stream(self, stream: ContextFramesBytesIO) -> bytes:
-        return read_fixed_byte_size_data_from_stream(self, stream)
+        raise NotImplementedError("didnt call __init__")
 
     def split_data_and_padding(self, raw_data: bytes) -> Tuple[bytes, bytes]:
-        return split_data_and_padding_fixed_byte_size(self, raw_data)
-
-    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
-        validate_padding_bytes_fixed_byte_size(self, value, padding_bytes)
+        raise NotImplementedError("didnt call __init__")
 
+    # This is unused, but it is kept in to preserve the eth-abi api
     def _get_value_byte_size(self) -> int:
-        # This is unused, but it is kept in to preserve the eth-abi api
-        return get_value_byte_size(self)
+        raise NotImplementedError("didnt call __init__")
 
 
 class Fixed32ByteSizeDecoder(FixedByteSizeDecoder):
@@ -363,27 +354,22 @@ decode_uint_256 = UnsignedIntegerDecoder(value_bit_size=256)
 class SignedIntegerDecoder(Fixed32ByteSizeDecoder):
     is_big_endian = True
 
-    def decoder_fn(self, data):
-        value = big_endian_to_int(data)
-        value_bit_size = self.value_bit_size
-        if value >= 2 ** (value_bit_size - 1):
-            return value - 2**value_bit_size
-        else:
-            return value
+    @cached_property
+    def neg_threshold(self) -> int:
+        return int(2 ** (self.value_bit_size - 1))
 
-    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
-        value_byte_size = get_value_byte_size(self)
-        padding_size = self.data_byte_size - value_byte_size
+    @cached_property
+    def neg_offset(self) -> int:
+        return int(2**self.value_bit_size)
 
-        if value >= 0:
-            expected_padding_bytes = b"\x00" * padding_size
-        else:
-            expected_padding_bytes = b"\xff" * padding_size
+    def decoder_fn(self, data: bytes) -> int:
+        value = big_endian_to_int(data)
+        if value >= self.neg_threshold:
+            value -= self.neg_offset
+        return value
 
-        if padding_bytes != expected_padding_bytes:
-            raise NonEmptyPaddingBytes(
-                f"Padding bytes were not empty: {padding_bytes!r}"
-            )
+    def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
+        return validate_padding_bytes_signed_integer(self, value, padding_bytes)
 
     @parse_type_str("int")
     def from_type_str(cls, abi_type, registry):
@@ -397,7 +383,7 @@ class BytesDecoder(Fixed32ByteSizeDecoder):
     is_big_endian = False
 
     @staticmethod
-    def decoder_fn(data):
+    def decoder_fn(data: bytes) -> bytes:
         return data
 
     @parse_type_str("bytes")
@@ -417,11 +403,11 @@ class BaseFixedDecoder(Fixed32ByteSizeDecoder):
             raise ValueError("must specify `frac_places`")
 
         if frac_places <= 0 or frac_places > 80:
-            raise ValueError("`frac_places` must be in range (0, 80]")
+            raise ValueError("`frac_places` must be in range (0, 80)")
 
 
 class UnsignedFixedDecoder(BaseFixedDecoder):
-    def decoder_fn(self, data):
+    def decoder_fn(self, data: bytes) -> decimal.Decimal:
         value = big_endian_to_int(data)
 
         with decimal.localcontext(abi_decimal_context):
@@ -437,7 +423,7 @@ class UnsignedFixedDecoder(BaseFixedDecoder):
 
 
 class SignedFixedDecoder(BaseFixedDecoder):
-    def decoder_fn(self, data):
+    def decoder_fn(self, data: bytes) -> decimal.Decimal:
         value = big_endian_to_int(data)
         value_bit_size = self.value_bit_size
         if value >= 2 ** (value_bit_size - 1):
@@ -478,7 +464,7 @@ class ByteStringDecoder(SingleDecoder):
     is_dynamic = True
 
     @staticmethod
-    def decoder_fn(data):
+    def decoder_fn(data: bytes) -> bytes:
         return data
 
     def read_data_from_stream(self, stream: ContextFramesBytesIO) -> bytes: