faster-eth-abi 5.2.12__cp314-cp314-macosx_11_0_arm64.whl → 5.2.14__cp314-cp314-macosx_11_0_arm64.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,45 @@
+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,
+)
+
+
+ITERATIONS = 50_000
+
+
+@pytest.mark.benchmark(group="RegistryGetEncoder")
+@pytest.mark.parametrize("type_str", type_strings)
+def test_get_encoder(benchmark: BenchmarkFixture, type_str):
+    benchmark(batch, ITERATIONS, 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, ITERATIONS, 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, ITERATIONS, 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, ITERATIONS, 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/_codec.py

@@ -43,7 +43,7 @@ def encode_c(
 
     encoder = self._registry.get_tuple_encoder(*types)
 
-    return encoder(args)
+    return encoder.encode(args)
 
 
 def decode_c(

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/_encoding.py

@@ -2,29 +2,59 @@ 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:
@@ -46,6 +76,111 @@ 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],