beacon: process_proposer_slashing

beacon/src/executive/transition/per_block/eth1.rs

+use crate::primitives::*;
+use crate::types::*;
+use crate::{Config, BeaconState, Error};
+use bm_le::tree_root;
+
+impl<C: Config> BeaconState<C> {
+	/// Process eth1 data vote given in a block.
+	pub fn process_eth1_data(&mut self, body: &BeaconBlockBody<C>) {
+		self.eth1_data_votes.push(body.eth1_data.clone());
+		if self.eth1_data_votes.iter()
+			.filter(|d| d == &&body.eth1_data)
+			.count() * 2 >
+			C::slots_per_eth1_voting_period() as usize
+		{
+			self.eth1_data = body.eth1_data.clone();
+		}
+	}
+}

beacon/src/executive/transition/per_block/mod.rs

 mod header;
 mod randao;
+mod eth1;
+mod operations;

beacon/src/executive/transition/per_block/operations/mod.rs

+mod proposer_slashing;

beacon/src/executive/transition/per_block/operations/proposer_slashing.rs

+use crate::primitives::*;
+use crate::types::*;
+use crate::{Config, BeaconState, Error, utils};
+use bm_le::tree_root;
+
+impl<C: Config> BeaconState<C> {
+	/// Push a new `ProposerSlashing` to the state.
+	pub fn process_proposer_slashing(
+		&mut self,
+		proposer_slashing: ProposerSlashing
+	) -> Result<(), Error> {
+		if utils::epoch_of_slot::<C>(proposer_slashing.header_1.slot) !=
+			utils::epoch_of_slot::<C>(proposer_slashing.header_2.slot)
+		{
+			return Err(Error::ProposerSlashingInvalidSlot)
+		}
+
+		if proposer_slashing.header_1 == proposer_slashing.header_2 {
+			return Err(Error::ProposerSlashingSameHeader)
+		}
+
+		{
+			if proposer_slashing.proposer_index as usize >= self.validators.len() {
+				return Err(Error::ProposerSlashingInvalidProposerIndex)
+			}
+
+			let proposer = &self.validators[
+				proposer_slashing.proposer_index as usize
+			];
+
+			if !proposer.is_slashable(self.current_epoch()) {
+				return Err(Error::ProposerSlashingAlreadySlashed)
+			}
+
+			for header in &[&proposer_slashing.header_1, &proposer_slashing.header_2] {
+				let domain = self.domain(
+					C::domain_beacon_proposer(),
+					Some(utils::epoch_of_slot::<C>(header.slot))
+				);
+
+				if !C::bls_verify(
+					&proposer.pubkey,
+					&tree_root::<C::Digest, _>(&SigningBeaconBlockHeader::from((*header).clone())),
+					&header.signature,
+					domain,
+				) {
+					return Err(Error::ProposerSlashingInvalidSignature)
+				}
+			}
+		}
+
+		self.slash_validator(proposer_slashing.proposer_index, None)
+	}
+}