refactor: drop model_copy in favour of in-place mutation (leanEthereum#789)

* refactor: drop model_copy in favour of in-place mutation

StrictBaseModel was previously frozen, which forced every state update to
go through model_copy(update={...}) and produced a verbose functional
style throughout the codebase. The frozen constraint was introduced as
groundwork for formal verification, which we are not yet using; in the
meantime the indirection hurts readability.

Changes:
- src/lean_spec/base.py: drop frozen=True from StrictBaseModel and update
  the docstring (no longer claims immutability).
- .claude/rules/ssz-patterns.md: drop "immutability" from the SSZModel
  principle bullet so the rule matches the new behavior.
- All 115 model_copy(update=...) call sites across src/, tests/, and
  packages/testing/ converted to direct field assignment. Intermediate
  dict-building variables inlined where the result was used only once.

Exceptions:
- The three JustifiedSlots collection helpers (with_justified,
  extend_to_slot, shift_window) still return new instances, but via
  type(self)(data=...) instead of model_copy. This preserves the
  return-new contract that callers rely on for SSZ collection methods.
- The api_endpoint test fixture's "return self.model_copy(update=handler(
  store, self))" pattern becomes a setattr loop over handler's output dict,
  then return self.
- MockStore in tests/lean_spec/node/chain/test_service.py loses its
  hand-rolled model_copy method (no longer needed; it's a plain dataclass
  and is mutable by default).

just check passes (ruff lint + format, ty type check, codespell, mdformat).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix: restore hashability and pure-function semantics where required

Dropping frozen globally lost two side effects the codebase relied on:
hashability of value types used as dict keys / set elements, and the
"returns a new state" contract that callers of process_slots and
state_transition were depending on. Both are restored surgically.

Hashability:
- Re-freeze the value types used as dict keys / set elements:
  Checkpoint, AttestationData, Attestation, Signature,
  TypeOneMultiSignature, TypeTwoMultiSignature, KeyPair,
  ValidatorKeyPair, Eth2Data. Per-class model_config override leaves
  the stateful types (Store, State, Block, BlockHeader, ENR, etc.)
  unfrozen and mutable.
- Add explicit __hash__ on Signature, TypeOneMultiSignature, and
  TypeTwoMultiSignature: their nested list-bearing fields break the
  auto-derived hash, so the SSZ-encoded bytes drive the hash instead.

Pure-function semantics:
- process_slots now deepcopies its input at entry, matching the
  existing docstring ("returns a new state with slot == target_slot").
  This makes state_transition and build_block trivially pure.
- Slot assertion relaxed from < to <= so process_slots is idempotent
  under repeated calls with the same target (build_block needs this).
- Two Checkpoint mutations in process_block_header replaced with
  construction now that Checkpoint is frozen again.

Test fixture in BlockSpec.build_signed_block_with_store deepcopies
the store at entry: the simulation pipeline (on_tick,
on_gossip_attestation, aggregate, accept_new_attestations) mutates
store directly, so the caller's store needs an explicit barrier.

Test fixes:
- _replace_head_at_slot and _add_block_at_slot in test_service.py
  construct new Block instances instead of mutating the original
  (the AST conversion had broken them).
- Corrupted-proof tests construct new TypeOneMultiSignature rather
  than mutating .proof on a frozen instance.
- test_combined_path_rejects_{depth_mismatch,odd_depth} construct
  new HashSubTree to avoid polluting the prf_trees fixture across
  tests.
- Dropped test_frozen_rejects_assignment on StrictBaseModel (the
  base itself is no longer frozen by design).
- Dropped the "store is not store_before" identity check that was
  only meaningful when on_gossip_attestation returned a new store.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix(spec): restore strict process_slots assertion

Loosening the assertion to state.slot <= target_slot was a workaround
for the mutation cascade through build_block. Now that process_slots
deepcopies its input at entry, the caller's state.slot is never
advanced across repeated calls, so the original strict inequality
holds again. The spec filler test
test_process_slots_target_equal_to_state_slot_rejected was relying on
the strict form.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix(forks/lstar): restore Checkpoint frozen override after merge

The merge from main clobbered the per-class `frozen=True` model_config
override on Checkpoint. That override was added in 24a0e7b alongside
the same override on eight other value types used as dict keys / set
members; Checkpoint was the only one that moved files in the merge
(the deleted lean_spec/types/checkpoint.py from leanEthereum#790 collided with the
new home spec/forks/lstar/containers.py from leanEthereum#785) and so it was the
only one whose override was lost.

Without the override AttestationData (which embeds Checkpoint) is no
longer hashable, and on_gossip_attestation crashes when it inserts
into store.attestation_signatures.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: tcoratger

.claude/rules/ssz-patterns.md

@@ -29,7 +29,7 @@ When creating SSZ types, follow these established patterns:
 - These use Pydantic models with a `data` field for contents
 - Example: `MyList(data=[1, 2, 3])` *has* a list of data with SSZ serialization
 
-**Key principle**: If the type conceptually *holds* or *contains* other data, use SSZModel for consistent validation and immutability.
+**Key principle**: If the type conceptually *holds* or *contains* other data, use SSZModel for consistent validation and SSZ encoding.
 
 ## Modular Architecture
 

packages/testing/src/consensus_testing/test_fixtures/api_endpoint.py

@@ -283,4 +283,6 @@ def make_fixture(self) -> "ApiEndpointTest":
             genesis_time=self.genesis_params.get("genesisTime", 0),
             anchor_slot=self.genesis_params.get("anchorSlot", 0),
         )
-        return self.model_copy(update=handler(store, self))
+        for k, v in handler(store, self).items():
+            setattr(self, k, v)
+        return self

packages/testing/src/consensus_testing/test_fixtures/fork_choice.py

@@ -233,22 +233,14 @@ def make_fixture(self) -> Self:
         for i, validator in enumerate(self.anchor_state.validators):
             idx = ValidatorIndex(i)
             attestation_pubkey, proposal_pubkey = key_manager.get_public_keys(idx)
-            validator = validator.model_copy(
-                update={
-                    "attestation_pubkey": attestation_pubkey.encode_bytes(),
-                    "proposal_pubkey": proposal_pubkey.encode_bytes(),
-                }
-            )
+            validator.attestation_pubkey = attestation_pubkey.encode_bytes()
+            validator.proposal_pubkey = proposal_pubkey.encode_bytes()
             updated_validators.append(validator)
 
         # Updating validators changes the state root.
         # We must also update the anchor block to match.
-        self.anchor_state = self.anchor_state.model_copy(
-            update={"validators": Validators(data=updated_validators)}
-        )
-        self.anchor_block = self.anchor_block.model_copy(
-            update={"state_root": hash_tree_root(self.anchor_state)}
-        )
+        self.anchor_state.validators = Validators(data=updated_validators)
+        self.anchor_block.state_root = hash_tree_root(self.anchor_state)
 
         # Store initialization
         #

packages/testing/src/consensus_testing/test_fixtures/gossipsub_handler.py

@@ -159,8 +159,8 @@ class GossipsubHandlerTest(BaseConsensusFixture):
 
     def make_fixture(self) -> "GossipsubHandlerTest":
         """Produce the completed fixture with expected outputs filled in."""
-        expected = asyncio.run(self._execute())
-        return self.model_copy(update={"expected": expected})
+        self.expected = asyncio.run(self._execute())
+        return self
 
     async def _execute(self) -> dict[str, Any]:
         """

packages/testing/src/consensus_testing/test_fixtures/justifiability.py

@@ -46,8 +46,8 @@ def make_fixture(self) -> "JustifiabilityTest":
         delta = self.slot - self.finalized_slot
         justifiable = s.is_justifiable_after(f)
 
-        output = {
+        self.output = {
             "delta": delta,
             "isJustifiable": justifiable,
         }
-        return self.model_copy(update={"output": output})
+        return self

packages/testing/src/consensus_testing/test_fixtures/networking_codec.py

@@ -96,7 +96,8 @@ def make_fixture(self) -> "NetworkingCodecTest":
                 output = self._make_decode_failure()
             case _:
                 raise ValueError(f"Unknown codec: {self.codec_name}")
-        return self.model_copy(update={"output": output})
+        self.output = output
+        return self
 
     def _make_decode_failure(self) -> dict[str, Any]:
         """Assert that decoding `input.bytes` with `input.decoder` raises.

packages/testing/src/consensus_testing/test_fixtures/poseidon_permutation.py

@@ -60,6 +60,5 @@ def make_fixture(self) -> "PoseidonPermutationTest":
         input_state = [Fp(v) for v in state_ints]
         output_state = engine.permute(input_state)
 
-        return self.model_copy(
-            update={"output": {"outputState": [str(int(fp)) for fp in output_state]}}
-        )
+        self.output = {"outputState": [str(int(fp)) for fp in output_state]}
+        return self

packages/testing/src/consensus_testing/test_fixtures/slot_clock.py

@@ -61,8 +61,8 @@ def make_fixture(self) -> "SlotClockTest":
                 result = self._make_total_intervals()
             case _:
                 raise ValueError(f"Unknown operation: {self.operation}")
-        output = {"config": config, **result}
-        return self.model_copy(update={"output": output})
+        self.output = {"config": config, **result}
+        return self
 
     def _make_from_unix_time(self) -> dict[str, Any]:
         """Convert unix timestamp to interval count since genesis."""

packages/testing/src/consensus_testing/test_fixtures/ssz.py

@@ -98,12 +98,9 @@ def make_fixture(self) -> "SSZTest":
 
         root = hash_tree_root(self.value)
 
-        return self.model_copy(
-            update={
-                "serialized": "0x" + ssz_bytes.hex(),
-                "root": "0x" + root.hex(),
-            }
-        )
+        self.serialized = "0x" + ssz_bytes.hex()
+        self.root = "0x" + root.hex()
+        return self
 
     def _make_decode_failure(self) -> "SSZTest":
         """Run the decode-failure path: assert decoding `raw_bytes` raises.
@@ -138,9 +135,6 @@ def _make_decode_failure(self) -> "SSZTest":
                 f"{type(exception_raised).__name__}: {exception_raised}"
             )
 
-        return self.model_copy(
-            update={
-                "serialized": "0x" + raw.hex(),
-                "root": "",
-            }
-        )
+        self.serialized = "0x" + raw.hex()
+        self.root = ""
+        return self

packages/testing/src/consensus_testing/test_fixtures/state_transition.py

@@ -283,24 +283,16 @@ def _build_block_from_spec(
                 )
                 for fa in spec.forced_attestations
             ]
-            block = block.model_copy(
-                update={
-                    "body": block.body.model_copy(
-                        update={
-                            "attestations": AggregatedAttestations(
-                                data=[*block.body.attestations.data, *forced]
-                            )
-                        }
-                    )
-                }
+            block.body.attestations = AggregatedAttestations(
+                data=[*block.body.attestations.data, *forced]
             )
 
             # The body changed, so re-run the transition to get the correct
             # post-state and state root.
             if post_state is not None:
                 post_state = LstarSpec().process_slots(state, spec.slot)
                 post_state = LstarSpec().process_block(post_state, block)
-                block = block.model_copy(update={"state_root": hash_tree_root(post_state)})
+                block.state_root = hash_tree_root(post_state)
 
         return block, post_state