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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::primitives::*;
use crate::{Config, BeaconState, Error, utils, consts};

impl<C: Config> BeaconState<C> {
	fn base_reward(&self, index: ValidatorIndex) -> Gwei {
		let total_balance = self.total_active_balance();

		let effective_balance =
			self.validators[index as usize].effective_balance;

		effective_balance * C::base_reward_factor() /
			utils::integer_squareroot(total_balance) /
			consts::BASE_REWARDS_PER_EPOCH
	}

	fn attestation_deltas(&self) -> Result<(Vec<Gwei>, Vec<Gwei>), Error> {
		let previous_epoch = self.previous_epoch();
		let total_balance = self.total_active_balance();
		let mut rewards = (0..self.validators.len())
			.map(|_| 0).collect::<Vec<_>>();
		let mut penalties = (0..self.validators.len())
			.map(|_| 0).collect::<Vec<_>>();
		let eligible_validator_indices = self.validators.iter()
			.enumerate()
			.filter(|(_, v)| {
				v.is_active(previous_epoch) ||
					(v.slashed && previous_epoch + 1 < v.withdrawable_epoch)
			})
			.map(|(i, _)| i as u64)
			.collect::<Vec<_>>();

		// Micro-incentives for matching FFG source, FFG target, and head
		let matching_source_attestations =
			self.matching_source_attestations(previous_epoch)?;
		let matching_target_attestations =
			self.matching_target_attestations(previous_epoch)?;
		let matching_head_attestations =
			self.matching_head_attestations(previous_epoch)?;
		for attestations in &[&matching_source_attestations,
							  &matching_target_attestations,
							  &matching_head_attestations]
		{
			let unslashed_attesting_indices =
				self.unslashed_attesting_indices(attestations)?;
			let attesting_balance = self.total_balance(&unslashed_attesting_indices);
			for index in &eligible_validator_indices {
				if unslashed_attesting_indices.contains(index) {
					rewards[*index as usize] += self.base_reward(*index) *
						attesting_balance / total_balance;
				} else {
					penalties[*index as usize] += self.base_reward(*index);
				}
			}
		}

		// Proposer and inclusion delay micro-rewards
		for index in self.unslashed_attesting_indices(&matching_source_attestations)? {
			let attestation = matching_source_attestations.iter()
				.map(|a| Ok((
					a,
					self.attesting_indices(&a.data, &a.aggregation_bits)?
						.contains(&index)
				)))
				.collect::<Result<Vec<_>, _>>()?
				.into_iter()
				.filter(|(_, c)| *c)
				.map(|(a, _)| a)
				.fold(matching_source_attestations[0].clone(), |a, b| {
					if a.inclusion_delay < b.inclusion_delay { a } else { b.clone() }
				});

			let proposer_reward = self.base_reward(index) / C::proposer_reward_quotient();
			rewards[attestation.proposer_index as usize] += proposer_reward;
			let max_attester_reward = self.base_reward(index) - proposer_reward;
			rewards[index as usize] += max_attester_reward *
				(C::slots_per_epoch() + C::min_attestation_inclusion_delay() -
				 attestation.inclusion_delay) /
				C::slots_per_epoch();
		}

		// Inactivity penalty
		let finality_delay = previous_epoch - self.finalized_checkpoint.epoch;
		if finality_delay > C::min_epochs_to_inactivity_penalty() {
			let matching_target_attesting_indices =
				self.unslashed_attesting_indices(&matching_target_attestations)?;
			for index in &eligible_validator_indices {
				penalties[*index as usize] += consts::BASE_REWARDS_PER_EPOCH *
					self.base_reward(*index);
				if !matching_target_attesting_indices.contains(index) {
					penalties[*index as usize] +=
						self.validators[*index as usize].effective_balance *
						finality_delay / C::inactivity_penalty_quotient();
				}
			}
		}

		Ok((rewards, penalties))
	}

	fn crosslink_deltas(&self) -> Result<(Vec<Gwei>, Vec<Gwei>), Error> {
		let mut rewards = (0..self.validators.len())
			.map(|_| 0).collect::<Vec<_>>();
		let mut penalties = (0..self.validators.len())
			.map(|_| 0).collect::<Vec<_>>();
		let epoch = self.previous_epoch();

		for offset in 0..self.committee_count(epoch) {
			let shard = (self.start_shard(epoch)? + offset) % C::shard_count();
			let crosslink_committee = self.crosslink_committee(epoch, shard)?;
			let (_winning_crosslink, attesting_indices) =
				self.winning_crosslink_and_attesting_indices(epoch, shard)?;
			let attesting_balance = self.total_balance(&attesting_indices);
			let committee_balance = self.total_balance(&crosslink_committee);
			for index in crosslink_committee {
				let base_reward = self.base_reward(index);
				if attesting_indices.contains(&index) {
					rewards[index as usize] += base_reward * attesting_balance /
						committee_balance;
				} else {
					penalties[index as usize] += base_reward;
				}
			}
		}

		Ok((rewards, penalties))
	}

	/// Process rewards and penalties
	pub fn process_rewards_and_penalties(&mut self) -> Result<(), Error> {
		if self.current_epoch() == C::genesis_epoch() {
			return Ok(())
		}

		let (rewards1, penalties1) = self.attestation_deltas()?;
		let (rewards2, penalties2) = self.crosslink_deltas()?;
		for i in 0..self.validators.len() {
			self.increase_balance(i as u64, rewards1[i] + rewards2[i]);
			self.decrease_balance(i as u64, penalties1[i] + penalties2[i]);
		}

		Ok(())
	}
}