use live stakes for consensus (#5426)
* use live stakes for consensus * lint * re-enable leader_failure_4 * fixups * re-ignore leader_failure_4
This commit is contained in:
Rob Walker
GitHub
@@ -1,5 +1,4 @@
|
||||
use crate::bank_forks::BankForks;
|
||||
use crate::staking_utils;
|
||||
use solana_metrics::datapoint_info;
|
||||
use solana_runtime::bank::Bank;
|
||||
use solana_sdk::account::Account;
|
||||
@@ -13,15 +12,6 @@ pub const VOTE_THRESHOLD_DEPTH: usize = 8;
|
||||
pub const VOTE_THRESHOLD_SIZE: f64 = 2f64 / 3f64;
|
||||
pub const MAX_RECENT_VOTES: usize = 16;
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct EpochStakes {
|
||||
epoch: u64,
|
||||
stakes: HashMap<Pubkey, u64>,
|
||||
self_staked: u64,
|
||||
total_staked: u64,
|
||||
delegate_pubkey: Pubkey,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct StakeLockout {
|
||||
lockout: u64,
|
||||
@@ -39,89 +29,49 @@ impl StakeLockout {
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Tower {
|
||||
epoch_stakes: EpochStakes,
|
||||
node_pubkey: Pubkey,
|
||||
threshold_depth: usize,
|
||||
threshold_size: f64,
|
||||
lockouts: VoteState,
|
||||
recent_votes: VecDeque<Vote>,
|
||||
}
|
||||
|
||||
impl EpochStakes {
|
||||
pub fn new(epoch: u64, stakes: HashMap<Pubkey, u64>, delegate_pubkey: &Pubkey) -> Self {
|
||||
let total_staked = stakes.values().sum();
|
||||
let self_staked = *stakes.get(&delegate_pubkey).unwrap_or(&0);
|
||||
Self {
|
||||
epoch,
|
||||
stakes,
|
||||
total_staked,
|
||||
self_staked,
|
||||
delegate_pubkey: *delegate_pubkey,
|
||||
}
|
||||
}
|
||||
pub fn new_for_tests(lamports: u64) -> Self {
|
||||
Self::new(
|
||||
0,
|
||||
vec![(Pubkey::default(), lamports)].into_iter().collect(),
|
||||
&Pubkey::default(),
|
||||
)
|
||||
}
|
||||
pub fn new_from_stakes(epoch: u64, accounts: &[(Pubkey, (u64, Account))]) -> Self {
|
||||
let stakes = accounts.iter().map(|(k, (v, _))| (*k, *v)).collect();
|
||||
Self::new(epoch, stakes, &accounts[0].0)
|
||||
}
|
||||
pub fn new_from_bank(bank: &Bank, my_pubkey: &Pubkey) -> Self {
|
||||
let bank_epoch = bank.get_epoch_and_slot_index(bank.slot()).0;
|
||||
let stakes = staking_utils::vote_account_stakes_at_epoch(bank, bank_epoch)
|
||||
.expect("voting require a bank with stakes");
|
||||
Self::new(bank_epoch, stakes, my_pubkey)
|
||||
}
|
||||
}
|
||||
|
||||
impl Tower {
|
||||
pub fn new_from_forks(bank_forks: &BankForks, my_pubkey: &Pubkey) -> Self {
|
||||
let mut frozen_banks: Vec<_> = bank_forks.frozen_banks().values().cloned().collect();
|
||||
frozen_banks.sort_by_key(|b| (b.parents().len(), b.slot()));
|
||||
let epoch_stakes = {
|
||||
if let Some(bank) = frozen_banks.last() {
|
||||
EpochStakes::new_from_bank(bank, my_pubkey)
|
||||
} else {
|
||||
return Self::default();
|
||||
}
|
||||
};
|
||||
|
||||
pub fn new(node_pubkey: &Pubkey, vote_account_pubkey: &Pubkey, bank_forks: &BankForks) -> Self {
|
||||
let mut tower = Self {
|
||||
epoch_stakes,
|
||||
node_pubkey: *node_pubkey,
|
||||
threshold_depth: VOTE_THRESHOLD_DEPTH,
|
||||
threshold_size: VOTE_THRESHOLD_SIZE,
|
||||
lockouts: VoteState::default(),
|
||||
recent_votes: VecDeque::default(),
|
||||
};
|
||||
|
||||
let bank = tower.find_heaviest_bank(bank_forks).unwrap();
|
||||
tower.lockouts = Self::initialize_lockouts_from_bank(&bank, tower.epoch_stakes.epoch);
|
||||
tower.initialize_lockouts_from_bank_forks(&bank_forks, vote_account_pubkey);
|
||||
|
||||
tower
|
||||
}
|
||||
pub fn new(epoch_stakes: EpochStakes, threshold_depth: usize, threshold_size: f64) -> Self {
|
||||
|
||||
#[cfg(test)]
|
||||
pub fn new_for_tests(threshold_depth: usize, threshold_size: f64) -> Self {
|
||||
Self {
|
||||
epoch_stakes,
|
||||
threshold_depth,
|
||||
threshold_size,
|
||||
lockouts: VoteState::default(),
|
||||
recent_votes: VecDeque::default(),
|
||||
..Tower::default()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn collect_vote_lockouts<F>(
|
||||
&self,
|
||||
bank_slot: u64,
|
||||
vote_accounts: F,
|
||||
ancestors: &HashMap<u64, HashSet<u64>>,
|
||||
) -> HashMap<u64, StakeLockout>
|
||||
) -> (HashMap<u64, StakeLockout>, u64)
|
||||
where
|
||||
F: Iterator<Item = (Pubkey, (u64, Account))>,
|
||||
{
|
||||
let mut stake_lockouts = HashMap::new();
|
||||
for (key, (_, account)) in vote_accounts {
|
||||
let lamports: u64 = *self.epoch_stakes.stakes.get(&key).unwrap_or(&0);
|
||||
let mut total_stake = 0;
|
||||
for (key, (lamports, account)) in vote_accounts {
|
||||
if lamports == 0 {
|
||||
continue;
|
||||
}
|
||||
@@ -139,9 +89,7 @@ impl Tower {
|
||||
}
|
||||
let mut vote_state = vote_state.unwrap();
|
||||
|
||||
if key == self.epoch_stakes.delegate_pubkey
|
||||
|| vote_state.node_pubkey == self.epoch_stakes.delegate_pubkey
|
||||
{
|
||||
if key == self.node_pubkey || vote_state.node_pubkey == self.node_pubkey {
|
||||
debug!("vote state {:?}", vote_state);
|
||||
debug!(
|
||||
"observed slot {}",
|
||||
@@ -200,50 +148,23 @@ impl Tower {
|
||||
// Update all the parents of this last vote with the stake of this vote account
|
||||
Self::update_ancestor_stakes(&mut stake_lockouts, vote.slot, lamports, ancestors);
|
||||
}
|
||||
total_stake += lamports;
|
||||
}
|
||||
stake_lockouts
|
||||
(stake_lockouts, total_stake)
|
||||
}
|
||||
|
||||
pub fn is_slot_confirmed(&self, slot: u64, lockouts: &HashMap<u64, StakeLockout>) -> bool {
|
||||
pub fn is_slot_confirmed(
|
||||
&self,
|
||||
slot: u64,
|
||||
lockouts: &HashMap<u64, StakeLockout>,
|
||||
total_staked: u64,
|
||||
) -> bool {
|
||||
lockouts
|
||||
.get(&slot)
|
||||
.map(|lockout| {
|
||||
(lockout.stake as f64 / self.epoch_stakes.total_staked as f64) > self.threshold_size
|
||||
})
|
||||
.map(|lockout| (lockout.stake as f64 / total_staked as f64) > self.threshold_size)
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
pub fn is_recent_epoch(&self, bank: &Bank) -> bool {
|
||||
bank.epoch() >= self.epoch_stakes.epoch
|
||||
}
|
||||
|
||||
pub fn update_epoch(&mut self, bank: &Bank) {
|
||||
trace!(
|
||||
"updating bank epoch slot: {} epoch: {}",
|
||||
bank.slot(),
|
||||
self.epoch_stakes.epoch
|
||||
);
|
||||
if bank.epoch() != self.epoch_stakes.epoch {
|
||||
assert!(
|
||||
self.is_recent_epoch(bank),
|
||||
"epoch_stakes cannot move backwards"
|
||||
);
|
||||
info!(
|
||||
"Tower updated epoch bank slot: {} epoch: {}",
|
||||
bank.slot(),
|
||||
self.epoch_stakes.epoch
|
||||
);
|
||||
self.epoch_stakes =
|
||||
EpochStakes::new_from_bank(bank, &self.epoch_stakes.delegate_pubkey);
|
||||
datapoint_info!(
|
||||
"tower-epoch",
|
||||
("epoch", self.epoch_stakes.epoch, i64),
|
||||
("self_staked", self.epoch_stakes.self_staked, i64),
|
||||
("total_staked", self.epoch_stakes.total_staked, i64)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn record_vote(&mut self, slot: u64, hash: Hash) -> Option<u64> {
|
||||
let root_slot = self.lockouts.root_slot;
|
||||
let vote = Vote { slot, hash };
|
||||
@@ -281,10 +202,6 @@ impl Tower {
|
||||
self.lockouts.root_slot
|
||||
}
|
||||
|
||||
pub fn total_epoch_stakes(&self) -> u64 {
|
||||
self.epoch_stakes.total_staked
|
||||
}
|
||||
|
||||
pub fn calculate_weight(&self, stake_lockouts: &HashMap<u64, StakeLockout>) -> u128 {
|
||||
let mut sum = 0u128;
|
||||
let root_slot = self.lockouts.root_slot.unwrap_or(0);
|
||||
@@ -328,14 +245,14 @@ impl Tower {
|
||||
&self,
|
||||
slot: u64,
|
||||
stake_lockouts: &HashMap<u64, StakeLockout>,
|
||||
total_staked: u64,
|
||||
) -> bool {
|
||||
let mut lockouts = self.lockouts.clone();
|
||||
lockouts.process_slot_vote_unchecked(slot);
|
||||
let vote = lockouts.nth_recent_vote(self.threshold_depth);
|
||||
if let Some(vote) = vote {
|
||||
if let Some(fork_stake) = stake_lockouts.get(&vote.slot) {
|
||||
(fork_stake.stake as f64 / self.epoch_stakes.total_staked as f64)
|
||||
> self.threshold_size
|
||||
(fork_stake.stake as f64 / total_staked as f64) > self.threshold_size
|
||||
} else {
|
||||
false
|
||||
}
|
||||
@@ -396,7 +313,7 @@ impl Tower {
|
||||
}
|
||||
|
||||
fn bank_weight(&self, bank: &Bank, ancestors: &HashMap<u64, HashSet<u64>>) -> u128 {
|
||||
let stake_lockouts =
|
||||
let (stake_lockouts, _) =
|
||||
self.collect_vote_lockouts(bank.slot(), bank.vote_accounts().into_iter(), ancestors);
|
||||
self.calculate_weight(&stake_lockouts)
|
||||
}
|
||||
@@ -418,19 +335,22 @@ impl Tower {
|
||||
bank_weights.pop().map(|b| b.2)
|
||||
}
|
||||
|
||||
fn initialize_lockouts_from_bank(bank: &Bank, current_epoch: u64) -> VoteState {
|
||||
let mut lockouts = VoteState::default();
|
||||
if let Some(iter) = bank.epoch_vote_accounts(current_epoch) {
|
||||
for (delegate_pubkey, (_, account)) in iter {
|
||||
if delegate_pubkey == bank.collector_id() {
|
||||
let state = VoteState::deserialize(&account.data).expect("votes");
|
||||
if lockouts.votes.len() < state.votes.len() {
|
||||
lockouts = state;
|
||||
}
|
||||
}
|
||||
fn initialize_lockouts_from_bank_forks(
|
||||
&mut self,
|
||||
bank_forks: &BankForks,
|
||||
vote_account_pubkey: &Pubkey,
|
||||
) {
|
||||
if let Some(bank) = self.find_heaviest_bank(bank_forks) {
|
||||
if let Some((_stake, vote_account)) = bank.vote_accounts().get(vote_account_pubkey) {
|
||||
let vote_state = VoteState::deserialize(&vote_account.data)
|
||||
.expect("vote_account isn't a VoteState?");
|
||||
assert_eq!(
|
||||
vote_state.node_pubkey, self.node_pubkey,
|
||||
"vote account's node_pubkey doesn't match",
|
||||
);
|
||||
self.lockouts = vote_state;
|
||||
}
|
||||
};
|
||||
lockouts
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -456,32 +376,19 @@ mod test {
|
||||
stakes
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_collect_vote_lockouts_no_epoch_stakes() {
|
||||
let accounts = gen_stakes(&[(1, &[0])]);
|
||||
let epoch_stakes = EpochStakes::new_for_tests(2);
|
||||
let tower = Tower::new(epoch_stakes, 0, 0.67);
|
||||
let ancestors = vec![(1, vec![0].into_iter().collect()), (0, HashSet::new())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
let staked_lockouts = tower.collect_vote_lockouts(1, accounts.into_iter(), &ancestors);
|
||||
assert!(staked_lockouts.is_empty());
|
||||
assert_eq!(tower.epoch_stakes.total_staked, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_collect_vote_lockouts_sums() {
|
||||
//two accounts voting for slot 0 with 1 token staked
|
||||
let accounts = gen_stakes(&[(1, &[0]), (1, &[0])]);
|
||||
let epoch_stakes = EpochStakes::new_from_stakes(0, &accounts);
|
||||
let tower = Tower::new(epoch_stakes, 0, 0.67);
|
||||
let tower = Tower::new_for_tests(0, 0.67);
|
||||
let ancestors = vec![(1, vec![0].into_iter().collect()), (0, HashSet::new())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
let staked_lockouts = tower.collect_vote_lockouts(1, accounts.into_iter(), &ancestors);
|
||||
let (staked_lockouts, total_staked) =
|
||||
tower.collect_vote_lockouts(1, accounts.into_iter(), &ancestors);
|
||||
assert_eq!(staked_lockouts[&0].stake, 2);
|
||||
assert_eq!(staked_lockouts[&0].lockout, 2 + 2 + 4 + 4);
|
||||
assert_eq!(tower.epoch_stakes.total_staked, 2);
|
||||
assert_eq!(total_staked, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -489,15 +396,14 @@ mod test {
|
||||
let votes: Vec<u64> = (0..MAX_LOCKOUT_HISTORY as u64).into_iter().collect();
|
||||
//two accounts voting for slot 0 with 1 token staked
|
||||
let accounts = gen_stakes(&[(1, &votes), (1, &votes)]);
|
||||
let epoch_stakes = EpochStakes::new_from_stakes(0, &accounts);
|
||||
let mut tower = Tower::new(epoch_stakes, 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let mut ancestors = HashMap::new();
|
||||
for i in 0..(MAX_LOCKOUT_HISTORY + 1) {
|
||||
tower.record_vote(i as u64, Hash::default());
|
||||
ancestors.insert(i as u64, (0..i as u64).into_iter().collect());
|
||||
}
|
||||
assert_eq!(tower.lockouts.root_slot, Some(0));
|
||||
let staked_lockouts = tower.collect_vote_lockouts(
|
||||
let (staked_lockouts, _total_staked) = tower.collect_vote_lockouts(
|
||||
MAX_LOCKOUT_HISTORY as u64,
|
||||
accounts.into_iter(),
|
||||
&ancestors,
|
||||
@@ -511,7 +417,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_calculate_weight_skips_root() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
tower.lockouts.root_slot = Some(1);
|
||||
let stakes = vec![
|
||||
(
|
||||
@@ -536,7 +442,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_calculate_weight() {
|
||||
let tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let tower = Tower::new_for_tests(0, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -551,7 +457,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_check_vote_threshold_without_votes() {
|
||||
let tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -561,12 +467,12 @@ mod test {
|
||||
)]
|
||||
.into_iter()
|
||||
.collect();
|
||||
assert!(tower.check_vote_stake_threshold(0, &stakes));
|
||||
assert!(tower.check_vote_stake_threshold(0, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_aggregate_stake_lockouts() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
tower.lockouts.root_slot = Some(1);
|
||||
let stakes = vec![
|
||||
(
|
||||
@@ -619,7 +525,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_is_slot_confirmed_not_enough_stake_failure() {
|
||||
let tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -629,19 +535,19 @@ mod test {
|
||||
)]
|
||||
.into_iter()
|
||||
.collect();
|
||||
assert!(!tower.is_slot_confirmed(0, &stakes));
|
||||
assert!(!tower.is_slot_confirmed(0, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_slot_confirmed_unknown_slot() {
|
||||
let tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = HashMap::new();
|
||||
assert!(!tower.is_slot_confirmed(0, &stakes));
|
||||
assert!(!tower.is_slot_confirmed(0, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_slot_confirmed_pass() {
|
||||
let tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -651,19 +557,19 @@ mod test {
|
||||
)]
|
||||
.into_iter()
|
||||
.collect();
|
||||
assert!(tower.is_slot_confirmed(0, &stakes));
|
||||
assert!(tower.is_slot_confirmed(0, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_empty() {
|
||||
let tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = HashMap::new();
|
||||
assert!(!tower.is_locked_out(0, &descendants));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_root_slot_child_pass() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = vec![(0, vec![1].into_iter().collect())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
@@ -673,7 +579,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_root_slot_sibling_fail() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = vec![(0, vec![1].into_iter().collect())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
@@ -683,7 +589,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_check_already_voted() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
tower.record_vote(0, Hash::default());
|
||||
assert!(tower.has_voted(0));
|
||||
assert!(!tower.has_voted(1));
|
||||
@@ -691,7 +597,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_double_vote() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = vec![(0, vec![1].into_iter().collect()), (1, HashSet::new())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
@@ -702,7 +608,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_child() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = vec![(0, vec![1].into_iter().collect())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
@@ -712,7 +618,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_sibling() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = vec![
|
||||
(0, vec![1, 2].into_iter().collect()),
|
||||
(1, HashSet::new()),
|
||||
@@ -727,7 +633,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_is_locked_out_last_vote_expired() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 0, 0.67);
|
||||
let mut tower = Tower::new_for_tests(0, 0.67);
|
||||
let descendants = vec![(0, vec![1, 4].into_iter().collect()), (1, HashSet::new())]
|
||||
.into_iter()
|
||||
.collect();
|
||||
@@ -743,7 +649,7 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_check_vote_threshold_below_threshold() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let mut tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -754,11 +660,11 @@ mod test {
|
||||
.into_iter()
|
||||
.collect();
|
||||
tower.record_vote(0, Hash::default());
|
||||
assert!(!tower.check_vote_stake_threshold(1, &stakes));
|
||||
assert!(!tower.check_vote_stake_threshold(1, &stakes, 2));
|
||||
}
|
||||
#[test]
|
||||
fn test_check_vote_threshold_above_threshold() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let mut tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -769,12 +675,12 @@ mod test {
|
||||
.into_iter()
|
||||
.collect();
|
||||
tower.record_vote(0, Hash::default());
|
||||
assert!(tower.check_vote_stake_threshold(1, &stakes));
|
||||
assert!(tower.check_vote_stake_threshold(1, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_vote_threshold_above_threshold_after_pop() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let mut tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = vec![(
|
||||
0,
|
||||
StakeLockout {
|
||||
@@ -787,15 +693,15 @@ mod test {
|
||||
tower.record_vote(0, Hash::default());
|
||||
tower.record_vote(1, Hash::default());
|
||||
tower.record_vote(2, Hash::default());
|
||||
assert!(tower.check_vote_stake_threshold(6, &stakes));
|
||||
assert!(tower.check_vote_stake_threshold(6, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_vote_threshold_above_threshold_no_stake() {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let mut tower = Tower::new_for_tests(1, 0.67);
|
||||
let stakes = HashMap::new();
|
||||
tower.record_vote(0, Hash::default());
|
||||
assert!(!tower.check_vote_stake_threshold(1, &stakes));
|
||||
assert!(!tower.check_vote_stake_threshold(1, &stakes, 2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -875,9 +781,7 @@ mod test {
|
||||
]);
|
||||
|
||||
// Initialize tower
|
||||
let stakes: HashMap<_, _> = accounts.iter().map(|(pk, (s, _))| (*pk, *s)).collect();
|
||||
let epoch_stakes = EpochStakes::new(0, stakes, &Pubkey::default());
|
||||
let mut tower = Tower::new(epoch_stakes, VOTE_THRESHOLD_DEPTH, threshold_size);
|
||||
let mut tower = Tower::new_for_tests(VOTE_THRESHOLD_DEPTH, threshold_size);
|
||||
|
||||
// CASE 1: Record the first VOTE_THRESHOLD tower votes for fork 2. We want to
|
||||
// evaluate a vote on slot VOTE_THRESHOLD_DEPTH. The nth most recent vote should be
|
||||
@@ -887,21 +791,25 @@ mod test {
|
||||
for vote in &tower_votes {
|
||||
tower.record_vote(*vote, Hash::default());
|
||||
}
|
||||
let staked_lockouts =
|
||||
let (staked_lockouts, total_staked) =
|
||||
tower.collect_vote_lockouts(vote_to_evaluate, accounts.clone().into_iter(), &ancestors);
|
||||
assert!(tower.check_vote_stake_threshold(vote_to_evaluate, &staked_lockouts));
|
||||
assert!(tower.check_vote_stake_threshold(vote_to_evaluate, &staked_lockouts, total_staked));
|
||||
|
||||
// CASE 2: Now we want to evaluate a vote for slot VOTE_THRESHOLD_DEPTH + 1. This slot
|
||||
// will expire the vote in one of the vote accounts, so we should have insufficient
|
||||
// stake to pass the threshold
|
||||
let vote_to_evaluate = VOTE_THRESHOLD_DEPTH as u64 + 1;
|
||||
let staked_lockouts =
|
||||
let (staked_lockouts, total_staked) =
|
||||
tower.collect_vote_lockouts(vote_to_evaluate, accounts.into_iter(), &ancestors);
|
||||
assert!(!tower.check_vote_stake_threshold(vote_to_evaluate, &staked_lockouts));
|
||||
assert!(!tower.check_vote_stake_threshold(
|
||||
vote_to_evaluate,
|
||||
&staked_lockouts,
|
||||
total_staked
|
||||
));
|
||||
}
|
||||
|
||||
fn vote_and_check_recent(num_votes: usize) {
|
||||
let mut tower = Tower::new(EpochStakes::new_for_tests(2), 1, 0.67);
|
||||
let mut tower = Tower::new_for_tests(1, 0.67);
|
||||
let start = num_votes.saturating_sub(MAX_RECENT_VOTES);
|
||||
let expected: Vec<_> = (start..num_votes)
|
||||
.map(|i| Vote::new(i as u64, Hash::default()))
|
||||
|
||||
Reference in New Issue
Block a user