beacon 0.2.0

Minimal Serenity beacon chain implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::primitives::*;
use crate::types::*;
use crate::{Config, BeaconState, Error, utils};
use bm_le::tree_root;
use core::cmp::Ordering;

impl<C: Config> BeaconState<C> {
	/// Get attestations with matching source at given epoch.
	pub fn matching_source_attestations(
		&self,
		epoch: Epoch
	) -> Result<Vec<PendingAttestation<C>>, Error> {
		if epoch == self.current_epoch() {
			Ok(self.current_epoch_attestations.clone().into())
		} else if epoch == self.previous_epoch() {
			Ok(self.previous_epoch_attestations.clone().into())
		} else {
			Err(Error::EpochOutOfRange)
		}
	}

	/// Get attestations with matching target at given epoch.
	pub fn matching_target_attestations(
		&self,
		epoch: Epoch
	) -> Result<Vec<PendingAttestation<C>>, Error> {
		let block_root = self.block_root(epoch)?;
		Ok(self.matching_source_attestations(epoch)?.into_iter()
		   .filter(|a| a.data.target.root == block_root)
		   .collect())
	}

	/// Get attestations with matching head at given epoch.
	pub fn matching_head_attestations(
		&self,
		epoch: Epoch
	) -> Result<Vec<PendingAttestation<C>>, Error> {
		self.matching_source_attestations(epoch)?.into_iter()
			.map(|a| {
				Ok((a.data.beacon_block_root == self.block_root_at_slot(
					self.attestation_data_slot(&a.data)?
				)?, a))
			})
			.collect::<Result<Vec<_>, _>>()
			.map(|r| {
				r.into_iter()
					.filter(|(c, _)| *c)
					.map(|(_, v)| v)
					.collect::<Vec<_>>()
			})
	}

	/// Get indices of all unslashed validators within attestations.
	pub fn unslashed_attesting_indices(
		&self, attestations: &[PendingAttestation<C>]
	) -> Result<Vec<ValidatorIndex>, Error> {
		let mut ret = Vec::new();
		for a in attestations {
			for index in self.attesting_indices(&a.data, &a.aggregation_bits)? {
				if !ret.contains(&index) {
					ret.push(index);
				}
			}
		}
		ret.retain(|index| {
			!self.validators[*index as usize].slashed
		});
		ret.sort();
		Ok(ret)
	}

	/// Get the total attesting balance given a list of attestations.
	pub fn attesting_balance(
		&self, attestations: &[PendingAttestation<C>]
	) -> Result<Gwei, Error> {
		Ok(self.total_balance(&self.unslashed_attesting_indices(attestations)?))
	}

	/// Get the winning crosslink and attesting indices.
	pub fn winning_crosslink_and_attesting_indices(
		&self, epoch: Epoch, shard: Shard
	) -> Result<(Crosslink, Vec<ValidatorIndex>), Error> {
		let attestations = self.matching_source_attestations(epoch)?.into_iter()
			.filter(|a| a.data.crosslink.shard == shard)
			.collect::<Vec<_>>();
		let crosslinks = attestations.clone().into_iter()
			.map(|a| a.data.crosslink)
			.filter(|c| {
				let current_root = tree_root::<C::Digest, _>(
					&self.current_crosslinks[shard as usize]
				);
				let root = tree_root::<C::Digest, _>(c);

				current_root == root || current_root == c.parent_root
			})
			.collect::<Vec<_>>();

		let attestations_for = |crosslink: &Crosslink| {
			attestations.clone().into_iter()
				.filter(|a| &a.data.crosslink == crosslink)
				.collect::<Vec<_>>()
		};
		let winning_crosslink = if crosslinks.len() == 0 {
			Crosslink::default()
		} else {
			crosslinks
				.iter()
				.fold(Ok(crosslinks[0].clone()), |a, b| {
					let a = a?;
					let cmp1 = self.attesting_balance(&attestations_for(&a))?
						.cmp(&self.attesting_balance(&attestations_for(b))?);
					let cmp2 = utils::compare_hash(&a.data_root, &b.data_root);

					Ok(match (cmp1, cmp2) {
						(Ordering::Greater, _) |
						(Ordering::Equal, Ordering::Greater) => a,
						_ => b.clone(),
					})
				})?
		};
		let winning_attestations = attestations_for(&winning_crosslink);

		Ok((winning_crosslink, self.unslashed_attesting_indices(&winning_attestations)?))
	}
}