Add compute_cycle_transitions and Rename total_deposits to total_balance as spec

Author: hwwhww

eth/beacon/state_machines/base.py

@@ -15,7 +15,6 @@
     to_tuple,
 )
 
-
 from eth.constants import (
     GENESIS_PARENT_HASH,
 )
@@ -44,7 +43,9 @@
 from eth.beacon.types.active_states import ActiveState
 from eth.beacon.types.attestation_records import AttestationRecord  # noqa: F401
 from eth.beacon.types.blocks import BaseBeaconBlock
+from eth.beacon.types.crosslink_records import CrosslinkRecord  # noqa: F401
 from eth.beacon.types.crystallized_states import CrystallizedState
+from eth.beacon.types.validator_records import ValidatorRecord  # noqa: F401
 from eth.beacon.state_machines.configs import BeaconConfig  # noqa: F401
 
 from .validation import (
@@ -272,16 +273,16 @@ def import_block(
 
         self.block = processing_block
         self._update_the_states(processed_crystallized_state, processed_active_state)
+
         # TODO: persist states in BeaconChain if needed
 
         return self.block, self.crystallized_state, self.active_state
 
     #
     # Process block APIs
     #
-    @classmethod
     def process_block(
-            cls,
+            self,
             crystallized_state: CrystallizedState,
             active_state: ActiveState,
             block: BaseBeaconBlock,
@@ -293,7 +294,7 @@ def process_block(
         Process ``block`` and return the new crystallized state and active state.
         """
         # Process per block state changes (ActiveState)
-        processing_active_state = cls.compute_per_block_transition(
+        processing_active_state = self.compute_per_block_transition(
             crystallized_state,
             active_state,
             block,
@@ -303,17 +304,18 @@ def process_block(
         )
 
         # Process per cycle state changes (CrystallizedState and ActiveState)
-        processed_crystallized_state, processed_active_state = cls.compute_cycle_transitions(
+        processed_crystallized_state, processed_active_state = self.compute_cycle_transitions(
             crystallized_state,
             processing_active_state,
+            block,
+            config,
         )
 
         # Return the copy
         result_block = block.copy()
         return result_block, processed_crystallized_state, processed_active_state
 
-    @classmethod
-    def compute_per_block_transition(cls,
+    def compute_per_block_transition(self,
                                      crystallized_state: CrystallizedState,
                                      active_state: ActiveState,
                                      block: BaseBeaconBlock,
@@ -323,7 +325,6 @@ def compute_per_block_transition(cls,
         """
         Process ``block`` and return the new ActiveState.
 
-
         TODO: It doesn't match the latest spec.
         There will be more fields need to be updated in ActiveState.
         """
@@ -344,7 +345,8 @@ def compute_per_block_transition(cls,
             )
 
         # TODO: to implement the RANDAO reveal validation.
-        cls.validate_randao_reveal()
+        self.validate_randao_reveal()
+
         for attestation in block.attestations:
             validate_attestation(
                 block,
@@ -364,14 +366,92 @@ def compute_per_block_transition(cls,
             ),
         )
 
-    @classmethod
     def compute_cycle_transitions(
-            cls,
+            self,
             crystallized_state: CrystallizedState,
-            active_state: ActiveState) -> Tuple[CrystallizedState, ActiveState]:
-        # TODO: it's a stub
+            active_state: ActiveState,
+            block: BaseBeaconBlock,
+            config: BeaconConfig) -> Tuple[CrystallizedState, ActiveState]:
+        """
+        Compute the cycle transitions and return processed CrystallizedState and ActiveState.
+        """
+        while block.slot_number >= crystallized_state.last_state_recalc + config.CYCLE_LENGTH:
+            crystallized_state, active_state = self.compute_per_cycle_transition(
+                crystallized_state,
+                active_state,
+                block,
+                config,
+            )
+
+            if self.ready_for_dynasty_transition(crystallized_state, block, config):
+                crystallized_state = self.compute_dynasty_transition(
+                    crystallized_state,
+                    block,
+                    config
+                )
+
         return crystallized_state, active_state
 
+    def compute_per_cycle_transition(
+            self,
+            crystallized_state: CrystallizedState,
+            active_state: ActiveState,
+            block: BaseBeaconBlock,
+            config: BeaconConfig) -> Tuple[CrystallizedState, ActiveState]:
+        """
+        Initialize a new cycle.
+        """
+        # TODO
+        return crystallized_state, active_state
+
+    #
+    # Crosslinks
+    #
+    def compute_crosslinks(self,
+                           crystallized_state: CrystallizedState,
+                           active_state: ActiveState,
+                           block: BaseBeaconBlock,
+                           config: BeaconConfig) -> Tuple['CrosslinkRecord', ...]:
+        # TODO
+        return ()
+
+    #
+    # Rewards and penalties
+    #
+    def apply_rewards_and_penalties(self,
+                                    crystallized_state: CrystallizedState,
+                                    active_state: ActiveState,
+                                    block: BaseBeaconBlock,
+                                    config: BeaconConfig) -> Tuple['ValidatorRecord', ...]:
+        """
+        Apply the rewards and penalties to the validators and return the updated ValidatorRecords.
+        """
+        # TODO
+        return ()
+
+    #
+    # Dynasty
+    #
+    def ready_for_dynasty_transition(self,
+                                     crystallized_state: CrystallizedState,
+                                     block: BaseBeaconBlock,
+                                     config: BeaconConfig) -> bool:
+        """
+        Check if it's ready for dynasty transition.
+        """
+        # TODO
+        return False
+
+    def compute_dynasty_transition(self,
+                                   crystallized_state: CrystallizedState,
+                                   block: BaseBeaconBlock,
+                                   config: BeaconConfig) -> CrystallizedState:
+        """
+        Compute the dynasty transition.
+        """
+        # TODO
+        return crystallized_state
+
     #
     #
     # Proposer APIs

eth/beacon/types/crystallized_states.py

@@ -106,7 +106,7 @@ def active_validator_indices(self) -> Tuple[int]:
         )
 
     @property
-    def total_deposits(self) -> int:
+    def total_balance(self) -> int:
         return sum(
             self.validators[index].balance
             for index in self.active_validator_indices

tests/beacon/test_genesis_helpers.py

@@ -28,7 +28,7 @@ def test_get_genesis_crystallized_state(genesis_validators,
         shard_count,
     )
     len_shard_and_committee_for_slots = cycle_length * 2
-    total_deposits = deposit_size * len(genesis_validators)
+    total_balance = deposit_size * len(genesis_validators)
 
     assert crystallized_state.validators == genesis_validators
     assert crystallized_state.last_state_recalc == 0
@@ -43,7 +43,7 @@ def test_get_genesis_crystallized_state(genesis_validators,
         assert crosslink.hash == ZERO_HASH32
         assert crosslink.slot == 0
         assert crosslink.dynasty == 0
-    assert crystallized_state.total_deposits == total_deposits
+    assert crystallized_state.total_balance == total_balance
     assert crystallized_state.dynasty_seed == init_shuffling_seed
     assert crystallized_state.dynasty_start == 0
 

tests/beacon/types/test_crystallized_state.py

@@ -85,10 +85,10 @@ def test_num_crosslink_records(expected,
         (20),
     ]
 )
-def test_total_deposits(num_active_validators,
-                        deposit_size,
-                        default_end_dynasty,
-                        empty_crystallized_state):
+def test_total_balance(num_active_validators,
+                       deposit_size,
+                       default_end_dynasty,
+                       empty_crystallized_state):
     start_dynasty = 10
     active_validators = [
         mock_validator_record(
@@ -115,8 +115,8 @@ def test_total_deposits(num_active_validators,
 
     assert len(crystallized_state.active_validator_indices) == len(active_validators)
 
-    expected_total_deposits = deposit_size * num_active_validators
-    assert crystallized_state.total_deposits == expected_total_deposits
+    expected_total_balance = deposit_size * num_active_validators
+    assert crystallized_state.total_balance == expected_total_balance
 
 
 def test_hash(sample_crystallized_state_params):