Move state trans fns into state_processing

eth2/state_processing/src/common/exit_validator.rs

@@ -0,0 +1,22 @@
+use types::{BeaconStateError as Error, *};
+
+/// Exit the validator of the given `index`.
+///
+/// Spec v0.5.0
+pub fn exit_validator(
+    state: &mut BeaconState,
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    if validator_index >= state.validator_registry.len() {
+        return Err(Error::UnknownValidator);
+    }
+
+    let delayed_epoch = state.get_delayed_activation_exit_epoch(state.current_epoch(spec), spec);
+
+    if state.validator_registry[validator_index].exit_epoch > delayed_epoch {
+        state.validator_registry[validator_index].exit_epoch = delayed_epoch;
+    }
+
+    Ok(())
+}

eth2/state_processing/src/common/mod.rs

@@ -0,0 +1,7 @@
+mod exit_validator;
+mod slash_validator;
+mod verify_bitfield;
+
+pub use exit_validator::exit_validator;
+pub use slash_validator::slash_validator;
+pub use verify_bitfield::verify_bitfield_length;

eth2/state_processing/src/common/slash_validator.rs

@@ -0,0 +1,62 @@
+use crate::common::exit_validator;
+use types::{BeaconStateError as Error, *};
+
+/// Slash the validator with index ``index``.
+///
+/// Spec v0.5.0
+pub fn slash_validator(
+    state: &mut BeaconState,
+    validator_index: usize,
+    spec: &ChainSpec,
+) -> Result<(), Error> {
+    let current_epoch = state.current_epoch(spec);
+
+    if (validator_index >= state.validator_registry.len())
+        | (validator_index >= state.validator_balances.len())
+    {
+        return Err(BeaconStateError::UnknownValidator);
+    }
+
+    let validator = &state.validator_registry[validator_index];
+
+    let effective_balance = state.get_effective_balance(validator_index, spec)?;
+
+    // A validator that is withdrawn cannot be slashed.
+    //
+    // This constraint will be lifted in Phase 0.
+    if state.slot
+        >= validator
+            .withdrawable_epoch
+            .start_slot(spec.slots_per_epoch)
+    {
+        return Err(Error::ValidatorIsWithdrawable);
+    }
+
+    exit_validator(state, validator_index, spec)?;
+
+    state.set_slashed_balance(
+        current_epoch,
+        state.get_slashed_balance(current_epoch, spec)? + effective_balance,
+        spec,
+    )?;
+
+    let whistleblower_index =
+        state.get_beacon_proposer_index(state.slot, RelativeEpoch::Current, spec)?;
+    let whistleblower_reward = effective_balance / spec.whistleblower_reward_quotient;
+
+    safe_add_assign!(
+        state.validator_balances[whistleblower_index as usize],
+        whistleblower_reward
+    );
+    safe_sub_assign!(
+        state.validator_balances[validator_index],
+        whistleblower_reward
+    );
+
+    state.validator_registry[validator_index].slashed = true;
+
+    state.validator_registry[validator_index].withdrawable_epoch =
+        current_epoch + Epoch::from(spec.latest_slashed_exit_length);
+
+    Ok(())
+}

eth2/state_processing/src/common/verify_bitfield.rs

@@ -0,0 +1,20 @@
+use types::*;
+
+/// Verify ``bitfield`` against the ``committee_size``.
+///
+/// Is title `verify_bitfield` in spec.
+///
+/// Spec v0.4.0
+pub fn verify_bitfield_length(bitfield: &Bitfield, committee_size: usize) -> bool {
+    if bitfield.num_bytes() != ((committee_size + 7) / 8) {
+        return false;
+    }
+
+    for i in committee_size..(bitfield.num_bytes() * 8) {
+        if bitfield.get(i).unwrap_or(false) {
+            return false;
+        }
+    }
+
+    true
+}