Merge pull request #1400 from hwwhww/cycle_transition2

Add `compute_cycle_transitions`

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 (
@@ -259,7 +260,6 @@ def import_block(
             self.active_state,
             block,
             self.chaindb,
-            self.config,
             is_validating_signatures=True,
         )
 
@@ -272,10 +272,17 @@ 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
 
+    def _update_the_states(self,
+                           crystallized_state: CrystallizedState,
+                           active_state: ActiveState) -> None:
+        self._crytallized_state = crystallized_state
+        self._active_state = active_state
+
     #
     # Process block APIs
     #
@@ -286,7 +293,6 @@ def process_block(
             active_state: ActiveState,
             block: BaseBeaconBlock,
             chaindb: BaseBeaconChainDB,
-            config: BeaconConfig,
             is_validating_signatures: bool=True
     ) -> Tuple[BaseBeaconBlock, CrystallizedState, ActiveState]:
         """
@@ -298,14 +304,14 @@ def process_block(
             active_state,
             block,
             chaindb,
-            config.CYCLE_LENGTH,
             is_validating_signatures=is_validating_signatures,
         )
 
         # Process per cycle state changes (CrystallizedState and ActiveState)
         processed_crystallized_state, processed_active_state = cls.compute_cycle_transitions(
             crystallized_state,
             processing_active_state,
+            block,
         )
 
         # Return the copy
@@ -318,12 +324,10 @@ def compute_per_block_transition(cls,
                                      active_state: ActiveState,
                                      block: BaseBeaconBlock,
                                      chaindb: BaseBeaconChainDB,
-                                     cycle_length: int,
                                      is_validating_signatures: bool=True) -> ActiveState:
         """
         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.
         """
@@ -340,11 +344,12 @@ def compute_per_block_transition(cls,
                 crystallized_state,
                 block,
                 parent_block,
-                cycle_length,
+                cls.config.CYCLE_LENGTH,
             )
 
         # TODO: to implement the RANDAO reveal validation.
         cls.validate_randao_reveal()
+
         for attestation in block.attestations:
             validate_attestation(
                 block,
@@ -353,7 +358,7 @@ def compute_per_block_transition(cls,
                 recent_block_hashes,
                 attestation,
                 chaindb,
-                cycle_length,
+                cls.config.CYCLE_LENGTH,
                 is_validating_signatures=is_validating_signatures,
             )
 
@@ -368,33 +373,112 @@ def compute_per_block_transition(cls,
     def compute_cycle_transitions(
             cls,
             crystallized_state: CrystallizedState,
-            active_state: ActiveState) -> Tuple[CrystallizedState, ActiveState]:
-        # TODO: it's a stub
+            active_state: ActiveState,
+            block: BaseBeaconBlock) -> Tuple[CrystallizedState, ActiveState]:
+        """
+        Compute the cycle transitions and return processed CrystallizedState and ActiveState.
+        """
+        while block.slot_number >= crystallized_state.last_state_recalc + cls.config.CYCLE_LENGTH:
+            crystallized_state, active_state = cls.compute_per_cycle_transition(
+                crystallized_state,
+                active_state,
+                block,
+            )
+
+            if cls.ready_for_dynasty_transition(crystallized_state, block):
+                crystallized_state = cls.compute_dynasty_transition(
+                    crystallized_state,
+                    block,
+                )
+
+        return crystallized_state, active_state
+
+    @classmethod
+    def compute_per_cycle_transition(
+            cls,
+            crystallized_state: CrystallizedState,
+            active_state: ActiveState,
+            block: BaseBeaconBlock) -> Tuple[CrystallizedState, ActiveState]:
+        """
+        Initialize a new cycle.
+        """
+        # TODO: it's a STUB before we implement compute_per_cycle_transition
+        crystallized_state = crystallized_state.copy(
+            last_state_recalc=crystallized_state.last_state_recalc + cls.config.CYCLE_LENGTH
+        )
+
         return crystallized_state, active_state
 
+    #
+    # Crosslinks
+    #
+    @classmethod
+    def update_crosslinks(cls,
+                          crystallized_state: CrystallizedState,
+                          active_state: ActiveState,
+                          block: BaseBeaconBlock) -> Tuple['CrosslinkRecord', ...]:
+        # TODO
+        return ()
+
+    #
+    # Rewards and penalties
+    #
+    @classmethod
+    def apply_rewards_and_penalties(cls,
+                                    crystallized_state: CrystallizedState,
+                                    active_state: ActiveState,
+                                    block: BaseBeaconBlock) -> Tuple['ValidatorRecord', ...]:
+        """
+        Apply the rewards and penalties to the validators and return the updated ValidatorRecords.
+        """
+        # TODO
+        return ()
+
+    #
+    # Dynasty
+    #
+    @classmethod
+    def ready_for_dynasty_transition(cls,
+                                     crystallized_state: CrystallizedState,
+                                     block: BaseBeaconBlock) -> bool:
+        """
+        Check if it's ready for dynasty transition.
+        """
+        # TODO
+        return False
+
+    @classmethod
+    def compute_dynasty_transition(cls,
+                                   crystallized_state: CrystallizedState,
+                                   block: BaseBeaconBlock) -> CrystallizedState:
+        """
+        Compute the dynasty transition.
+        """
+        # TODO
+        return crystallized_state
+
     #
     #
     # Proposer APIs
     #
     #
+    @classmethod
     def propose_block(
-        self,
+        cls,
         crystallized_state: CrystallizedState,
         active_state: ActiveState,
         block_proposal: 'BlockProposal',
         chaindb: BaseBeaconChainDB,
-        config: BeaconConfig,
         private_key: int
     ) -> Tuple[BaseBeaconBlock, CrystallizedState, ActiveState, 'AttestationRecord']:
         """
         Propose the given block.
         """
-        block, post_crystallized_state, post_active_state = self.process_block(
+        block, post_crystallized_state, post_active_state = cls.process_block(
             crystallized_state,
             active_state,
             block_proposal.block,
             chaindb,
-            config,
             is_validating_signatures=False,
         )
 
@@ -409,28 +493,21 @@ def propose_block(
             shard_block_hash=block_proposal.shard_block_hash,
         )
 
-        proposer_attestation = self.attest_proposed_block(
+        proposer_attestation = cls.attest_proposed_block(
             post_crystallized_state,
             post_active_state,
             filled_block_proposal,
             chaindb,
-            config.CYCLE_LENGTH,
             private_key,
         )
         return post_block, post_crystallized_state, post_active_state, proposer_attestation
 
-    def _update_the_states(self,
-                           crystallized_state: CrystallizedState,
-                           active_state: ActiveState) -> None:
-        self._crytallized_state = crystallized_state
-        self._active_state = active_state
-
-    def attest_proposed_block(self,
+    @classmethod
+    def attest_proposed_block(cls,
                               post_crystallized_state: CrystallizedState,
                               post_active_state: ActiveState,
                               block_proposal: 'BlockProposal',
                               chaindb: BaseBeaconChainDB,
-                              cycle_length: int,
                               private_key: int) -> 'AttestationRecord':
         """
         Return the initial attestation by the block proposer.
@@ -440,7 +517,7 @@ def attest_proposed_block(self,
         block_committees_info = get_block_committees_info(
             block_proposal.block,
             post_crystallized_state,
-            cycle_length,
+            cls.config.CYCLE_LENGTH,
         )
         # Vote
         attester_bitfield = set_voted(
@@ -456,7 +533,7 @@ def attest_proposed_block(self,
         parent_hashes = get_hashes_to_sign(
             post_active_state.recent_block_hashes,
             block_proposal.block,
-            cycle_length,
+            cls.config.CYCLE_LENGTH,
         )
 
         message = create_signing_message(
@@ -471,7 +548,7 @@ def attest_proposed_block(self,
             private_key,
         )
 
-        return self.get_attestation_record_class()(
+        return cls.get_attestation_record_class()(
             slot=block_proposal.block.slot_number,
             shard_id=block_proposal.shard_id,
             oblique_parent_hashes=(),

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/state_machines/test_block_validation.py

@@ -70,7 +70,6 @@ def attestation_validation_fixture(fixture_sm_class,
             active_state=sm.active_state,
             block_proposal=block_proposal,
             chaindb=sm.chaindb,
-            config=sm.config,
             private_key=private_key,
         )
     )

tests/beacon/state_machines/test_proposer.py

@@ -62,7 +62,6 @@ def test_propose_block(fixture_sm_class,
             active_state=sm.active_state,
             block_proposal=block_proposal,
             chaindb=sm.chaindb,
-            config=sm.config,
             private_key=private_key,
         )
     )
@@ -119,7 +118,6 @@ def test_propose_block(fixture_sm_class,
             active_state=sm.active_state,
             block_proposal=block_proposal,
             chaindb=sm.chaindb,
-            config=sm.config,
             private_key=private_key,
         )
     )

tests/beacon/state_machines/test_state_machines.py

@@ -95,3 +95,46 @@ def test_import_block_one(fixture_sm_class,
         [ZERO_HASH32] * (sm.config.CYCLE_LENGTH * 2 - 1) + [genesis_block.hash]
     )
     assert active_state.recent_block_hashes == expect
+
+
+@pytest.mark.parametrize(
+    (
+        'num_validators,cycle_length,min_committee_size,shard_count,'
+        'block_slot,'
+        'prev_last_state_recalculation_slot,'
+        'post_last_state_recalculation_slot'
+    ),
+    [
+        (1000, 20, 10, 100, 1, 0, 0),  # no cycle transition
+        (1000, 20, 10, 100, 20, 0, 20),  # transition: 0 + cycle_length
+        (1000, 20, 10, 100, 60, 5, 45),  # transition: 5 + 2 * cycle_length
+        (1000, 20, 10, 100, 61, 45, 45),  # no cycle transition
+    ]
+)
+def test_compute_cycle_transitions(fixture_sm_class,
+                                   initial_chaindb,
+                                   genesis_block,
+                                   genesis_crystallized_state,
+                                   genesis_active_state,
+                                   block_slot,
+                                   prev_last_state_recalculation_slot,
+                                   post_last_state_recalculation_slot):
+    chaindb = initial_chaindb
+
+    block_1_shell = genesis_block.copy(
+        parent_hash=genesis_block.hash,
+        slot_number=genesis_block.slot_number + 1,
+    )
+
+    sm = fixture_sm_class(chaindb, block_1_shell)
+
+    post_crystallized_state, _ = sm.compute_cycle_transitions(
+        genesis_crystallized_state.copy(
+            last_state_recalc=prev_last_state_recalculation_slot,
+        ),
+        genesis_active_state,
+        genesis_block.copy(
+            slot_number=block_slot,
+        )
+    )
+    assert post_crystallized_state.last_state_recalc == post_last_state_recalculation_slot

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