Use cls.config in StateMachine

hwwhww · hwwhww · commit a5ed661cfdf4 · 2018-10-20T00:55:11.000+08:00
diff --git a/eth/beacon/state_machines/base.py b/eth/beacon/state_machines/base.py
@@ -260,7 +260,6 @@ def import_block(
             self.active_state,
             block,
             self.chaindb,
-            self.config,
             is_validating_signatures=True,
         )
 
@@ -278,49 +277,53 @@ def import_block(
 
         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
     #
+    @classmethod
     def process_block(
-            self,
+            cls,
             crystallized_state: CrystallizedState,
             active_state: ActiveState,
             block: BaseBeaconBlock,
             chaindb: BaseBeaconChainDB,
-            config: BeaconConfig,
             is_validating_signatures: bool=True
     ) -> Tuple[BaseBeaconBlock, CrystallizedState, ActiveState]:
         """
         Process ``block`` and return the new crystallized state and active state.
         """
         # Process per block state changes (ActiveState)
-        processing_active_state = self.compute_per_block_transition(
+        processing_active_state = cls.compute_per_block_transition(
             crystallized_state,
             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 = self.compute_cycle_transitions(
+        processed_crystallized_state, processed_active_state = cls.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
 
-    def compute_per_block_transition(self,
+    @classmethod
+    def compute_per_block_transition(cls,
                                      crystallized_state: CrystallizedState,
                                      active_state: ActiveState,
                                      block: BaseBeaconBlock,
                                      chaindb: BaseBeaconChainDB,
-                                     cycle_length: int,
                                      is_validating_signatures: bool=True) -> ActiveState:
         """
         Process ``block`` and return the new ActiveState.
@@ -341,11 +344,11 @@ def compute_per_block_transition(self,
                 crystallized_state,
                 block,
                 parent_block,
-                cycle_length,
+                cls.config.CYCLE_LENGTH,
             )
 
         # TODO: to implement the RANDAO reveal validation.
-        self.validate_randao_reveal()
+        cls.validate_randao_reveal()
 
         for attestation in block.attestations:
             validate_attestation(
@@ -355,7 +358,7 @@ def compute_per_block_transition(self,
                 recent_block_hashes,
                 attestation,
                 chaindb,
-                cycle_length,
+                cls.config.CYCLE_LENGTH,
                 is_validating_signatures=is_validating_signatures,
             )
 
@@ -366,38 +369,36 @@ def compute_per_block_transition(self,
             ),
         )
 
+    @classmethod
     def compute_cycle_transitions(
-            self,
+            cls,
             crystallized_state: CrystallizedState,
             active_state: ActiveState,
-            block: BaseBeaconBlock,
-            config: BeaconConfig) -> Tuple[CrystallizedState, 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 + config.CYCLE_LENGTH:
-            crystallized_state, active_state = self.compute_per_cycle_transition(
+        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,
-                config,
             )
 
-            if self.ready_for_dynasty_transition(crystallized_state, block, config):
-                crystallized_state = self.compute_dynasty_transition(
+            if cls.ready_for_dynasty_transition(crystallized_state, block):
+                crystallized_state = cls.compute_dynasty_transition(
                     crystallized_state,
                     block,
-                    config
                 )
 
         return crystallized_state, active_state
 
+    @classmethod
     def compute_per_cycle_transition(
-            self,
+            cls,
             crystallized_state: CrystallizedState,
             active_state: ActiveState,
-            block: BaseBeaconBlock,
-            config: BeaconConfig) -> Tuple[CrystallizedState, ActiveState]:
+            block: BaseBeaconBlock) -> Tuple[CrystallizedState, ActiveState]:
         """
         Initialize a new cycle.
         """
@@ -407,22 +408,22 @@ def compute_per_cycle_transition(
     #
     # Crosslinks
     #
-    def compute_crosslinks(self,
+    @classmethod
+    def compute_crosslinks(cls,
                            crystallized_state: CrystallizedState,
                            active_state: ActiveState,
-                           block: BaseBeaconBlock,
-                           config: BeaconConfig) -> Tuple['CrosslinkRecord', ...]:
+                           block: BaseBeaconBlock) -> Tuple['CrosslinkRecord', ...]:
         # TODO
         return ()
 
     #
     # Rewards and penalties
     #
-    def apply_rewards_and_penalties(self,
+    @classmethod
+    def apply_rewards_and_penalties(cls,
                                     crystallized_state: CrystallizedState,
                                     active_state: ActiveState,
-                                    block: BaseBeaconBlock,
-                                    config: BeaconConfig) -> Tuple['ValidatorRecord', ...]:
+                                    block: BaseBeaconBlock) -> Tuple['ValidatorRecord', ...]:
         """
         Apply the rewards and penalties to the validators and return the updated ValidatorRecords.
         """
@@ -432,20 +433,20 @@ def apply_rewards_and_penalties(self,
     #
     # Dynasty
     #
-    def ready_for_dynasty_transition(self,
+    @classmethod
+    def ready_for_dynasty_transition(cls,
                                      crystallized_state: CrystallizedState,
-                                     block: BaseBeaconBlock,
-                                     config: BeaconConfig) -> bool:
+                                     block: BaseBeaconBlock) -> bool:
         """
         Check if it's ready for dynasty transition.
         """
         # TODO
         return False
 
-    def compute_dynasty_transition(self,
+    @classmethod
+    def compute_dynasty_transition(cls,
                                    crystallized_state: CrystallizedState,
-                                   block: BaseBeaconBlock,
-                                   config: BeaconConfig) -> CrystallizedState:
+                                   block: BaseBeaconBlock) -> CrystallizedState:
         """
         Compute the dynasty transition.
         """
@@ -457,24 +458,23 @@ def compute_dynasty_transition(self,
     # 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,
         )
 
@@ -489,28 +489,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.
@@ -520,7 +513,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(
@@ -536,7 +529,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(
@@ -551,7 +544,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=(),
diff --git a/tests/beacon/state_machines/test_block_validation.py b/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,
         )
     )
diff --git a/tests/beacon/state_machines/test_proposer.py b/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,
         )
     )

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,6 @@ def attestation_validation_fixture(fixture_sm_class,`
`70`	`70`	`active_state=sm.active_state,`
`71`	`71`	`block_proposal=block_proposal,`
`72`	`72`	`chaindb=sm.chaindb,`
`73`		`- config=sm.config,`
`74`	`73`	`private_key=private_key,`
`75`	`74`	`)`
`76`	`75`	`)`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,6 @@ def test_propose_block(fixture_sm_class,`
`62`	`62`	`active_state=sm.active_state,`
`63`	`63`	`block_proposal=block_proposal,`
`64`	`64`	`chaindb=sm.chaindb,`
`65`		`- config=sm.config,`
`66`	`65`	`private_key=private_key,`
`67`	`66`	`)`
`68`	`67`	`)`
`@@ -119,7 +118,6 @@ def test_propose_block(fixture_sm_class,`
`119`	`118`	`active_state=sm.active_state,`
`120`	`119`	`block_proposal=block_proposal,`
`121`	`120`	`chaindb=sm.chaindb,`
`122`		`- config=sm.config,`
`123`	`121`	`private_key=private_key,`
`124`	`122`	`)`
`125`	`123`	`)`