bitfields: capability to return a list from a slice key (leanEthereum#180)

* bitfields: capability to return a list from a slice key

* fix MAX_TRIES in test config

* primitive touchups

Author: tcoratger

src/lean_spec/subspecs/containers/block/block.py

@@ -145,7 +145,7 @@ def verify_signatures(self, parent_state: "State") -> bool:
         # This creates a single list containing both:
         # 1. Block body attestations (from other validators)
         # 2. Proposer attestation (from the block producer)
-        all_attestations = list(block.body.attestations) + [self.message.proposer_attestation]
+        all_attestations = block.body.attestations + [self.message.proposer_attestation]
 
         # Verify signature count matches attestation count
         #

src/lean_spec/subspecs/containers/state/state.py

@@ -257,12 +257,12 @@ def process_block_header(self, block: Block) -> "State":
 
         # Build new historical hashes list
         new_historical_hashes_data = (
-            list(self.historical_block_hashes) + [parent_root] + ([ZERO_HASH] * num_empty_slots)
+            self.historical_block_hashes + [parent_root] + ([ZERO_HASH] * num_empty_slots)
         )
 
         # Build new justified slots list
         new_justified_slots_data = (
-            list(self.justified_slots)
+            self.justified_slots
             + [Boolean(is_genesis_parent)]
             + ([Boolean(False)] * num_empty_slots)
         )
@@ -354,11 +354,9 @@ def process_attestations(
         #   - each segment corresponds to one block root,
         #   - each segment has length equal to the number of validators,
         #   - and the ordering of block roots is preserved.
-        flat_justifications = list(self.justifications_validators)
-
         justifications = (
             {
-                root: flat_justifications[
+                root: self.justifications_validators[
                     i * self.validators.count : (i + 1) * self.validators.count
                 ]
                 for i, root in enumerate(self.justifications_roots)
@@ -370,7 +368,7 @@ def process_attestations(
         # Track state changes to be applied at the end
         latest_justified = self.latest_justified
         latest_finalized = self.latest_finalized
-        justified_slots = list(self.justified_slots)
+        justified_slots = self.justified_slots
 
         # Process each attestation in the block.
         for attestation in attestations:

src/lean_spec/subspecs/xmss/constants.py

@@ -131,7 +131,7 @@ def SIGNATURE_LEN_BYTES(self) -> int:  # noqa: N802
     BASE=4,
     FINAL_LAYER=6,
     TARGET_SUM=6,
-    MAX_TRIES=1_000,
+    MAX_TRIES=100_000,
     PARAMETER_LEN=5,
     TWEAK_LEN_FE=2,
     MSG_LEN_FE=9,

src/lean_spec/types/bitfields.py

@@ -22,6 +22,7 @@
     Any,
     ClassVar,
     Tuple,
+    overload,
 )
 
 from pydantic import Field, field_validator
@@ -157,10 +158,34 @@ def _validate_list_data(cls, v: Any) -> Tuple[Boolean, ...]:
         except Exception as e:
             raise ValueError(f"Cannot convert elements to Boolean: {e}") from e
 
-    def __getitem__(self, key: int | slice) -> Boolean | tuple[Boolean, ...]:
+    @overload
+    def __getitem__(self, key: int) -> Boolean: ...
+
+    @overload
+    def __getitem__(self, key: slice) -> list[Boolean]: ...
+
+    def __getitem__(self, key: int | slice) -> Boolean | list[Boolean]:
         """Get a bit by index or slice."""
+        if isinstance(key, slice):
+            return list(self.data[key])
         return self.data[key]
 
+    def __setitem__(self, key: int, value: bool | Boolean) -> None:
+        """Set a bit by index."""
+        new_data = list(self.data)
+        new_data[key] = Boolean(value)
+        object.__setattr__(self, "data", tuple(new_data))
+
+    def __add__(self, other: Any) -> Self:
+        """Concatenate this bitlist with another sequence."""
+        if isinstance(other, BaseBitlist):
+            new_data = self.data + other.data
+        elif isinstance(other, (list, tuple)):
+            new_data = self.data + tuple(Boolean(b) for b in other)
+        else:
+            return NotImplemented
+        return type(self)(data=new_data)
+
     @classmethod
     def is_fixed_size(cls) -> bool:
         """A Bitlist is never fixed-size (length varies from 0 to LIMIT)."""

src/lean_spec/types/collections.py

@@ -227,6 +227,16 @@ def _validate_list_data(cls, v: Any) -> Tuple[SSZType, ...]:
 
         return tuple(typed_values)
 
+    def __add__(self, other: Any) -> Self:
+        """Concatenate this list with another sequence."""
+        if isinstance(other, SSZList):
+            new_data = self.data + other.data
+        elif isinstance(other, (list, tuple)):
+            new_data = self.data + tuple(other)
+        else:
+            return NotImplemented
+        return type(self)(data=new_data)
+
     @classmethod
     def is_fixed_size(cls) -> bool:
         """An SSZList is never fixed-size (length varies from 0 to LIMIT)."""

tests/lean_spec/types/test_bitfields.py

@@ -166,6 +166,41 @@ class Bitlist8(BaseBitlist):
         with pytest.raises(ValidationError):
             model(value=invalid_value)
 
+    def test_add_with_list(self) -> None:
+        """Tests concatenating a Bitlist with a regular list."""
+
+        class Bitlist8(BaseBitlist):
+            LIMIT = 8
+
+        bitlist = Bitlist8(data=[True, False, True])
+        result = bitlist + [False, True]
+        assert len(result) == 5
+        assert list(result.data) == [True, False, True, False, True]
+        assert isinstance(result, Bitlist8)
+
+    def test_add_with_bitlist(self) -> None:
+        """Tests concatenating two Bitlists of the same type."""
+
+        class Bitlist8(BaseBitlist):
+            LIMIT = 8
+
+        bitlist1 = Bitlist8(data=[True, False])
+        bitlist2 = Bitlist8(data=[True, True])
+        result = bitlist1 + bitlist2
+        assert len(result) == 4
+        assert list(result.data) == [True, False, True, True]
+        assert isinstance(result, Bitlist8)
+
+    def test_add_exceeding_limit_raises_error(self) -> None:
+        """Tests that concatenating beyond the limit raises an error."""
+
+        class Bitlist4(BaseBitlist):
+            LIMIT = 4
+
+        bitlist = Bitlist4(data=[True, False, True])
+        with pytest.raises(ValueError, match="cannot contain more than 4 bits"):
+            bitlist + [False, True]
+
 
 class TestBitfieldSerialization:
     """Tests the `encode_bytes` and `decode_bytes` methods for bitfields."""

tests/lean_spec/types/test_collections.py

@@ -287,6 +287,27 @@ def test_extend_over_limit_raises_error(self) -> None:
         with pytest.raises(ValueError, match="cannot contain more than 4 elements"):
             BooleanList4(data=[True, False, True, False, True])
 
+    def test_add_with_list(self) -> None:
+        """Tests concatenating an SSZList with a regular list."""
+        list1 = Uint8List10(data=[1, 2, 3])
+        result = list1 + [4, 5]
+        assert list(result) == [Uint8(1), Uint8(2), Uint8(3), Uint8(4), Uint8(5)]
+        assert isinstance(result, Uint8List10)
+
+    def test_add_with_sszlist(self) -> None:
+        """Tests concatenating two SSZLists of the same type."""
+        list1 = Uint8List10(data=[1, 2])
+        list2 = Uint8List10(data=[3, 4])
+        result = list1 + list2
+        assert list(result) == [Uint8(1), Uint8(2), Uint8(3), Uint8(4)]
+        assert isinstance(result, Uint8List10)
+
+    def test_add_exceeding_limit_raises_error(self) -> None:
+        """Tests that concatenating beyond the limit raises an error."""
+        list1 = Uint8List4(data=[1, 2, 3])
+        with pytest.raises(ValueError, match="cannot contain more than 4 elements"):
+            list1 + [4, 5]
+
 
 class TestSSZVectorSerialization:
     """Tests SSZ serialization and deserialization for the SSZVector type."""