2019-02-27 14:41:46 -08:00
|
|
|
use crate::leader_schedule::LeaderSchedule;
|
2019-02-28 13:15:25 -08:00
|
|
|
use crate::staking_utils;
|
2019-02-27 14:41:46 -08:00
|
|
|
use solana_runtime::bank::Bank;
|
|
|
|
use solana_sdk::pubkey::Pubkey;
|
|
|
|
|
|
|
|
/// Return the leader schedule for the given epoch.
|
|
|
|
fn leader_schedule(epoch_height: u64, bank: &Bank) -> LeaderSchedule {
|
2019-02-28 17:08:45 -08:00
|
|
|
let stakes = staking_utils::node_stakes_at_epoch(bank, epoch_height);
|
2019-02-27 14:41:46 -08:00
|
|
|
let mut seed = [0u8; 32];
|
|
|
|
seed[0..8].copy_from_slice(&epoch_height.to_le_bytes());
|
2019-02-28 17:08:45 -08:00
|
|
|
let mut stakes: Vec<_> = stakes.into_iter().collect();
|
|
|
|
sort_stakes(&mut stakes);
|
2019-02-27 14:41:46 -08:00
|
|
|
LeaderSchedule::new(&stakes, seed, bank.slots_per_epoch())
|
|
|
|
}
|
|
|
|
|
2019-02-28 17:08:45 -08:00
|
|
|
fn sort_stakes(stakes: &mut Vec<(Pubkey, u64)>) {
|
|
|
|
// Sort first by stake. If stakes are the same, sort by pubkey to ensure a
|
|
|
|
// deterministic result.
|
|
|
|
// Note: Use unstable sort, because we dedup right after to remove the equal elements.
|
|
|
|
stakes.sort_unstable_by(|(l_id, l_stake), (r_id, r_stake)| {
|
|
|
|
if r_stake == l_stake {
|
|
|
|
r_id.cmp(&l_id)
|
|
|
|
} else {
|
|
|
|
r_stake.cmp(&l_stake)
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
// Now that it's sorted, we can do an O(n) dedup.
|
|
|
|
stakes.dedup();
|
|
|
|
}
|
|
|
|
|
2019-02-27 14:41:46 -08:00
|
|
|
/// Return the leader for the slot at the slot_index and epoch_height returned
|
|
|
|
/// by the given function.
|
|
|
|
fn slot_leader_by<F>(bank: &Bank, get_slot_index: F) -> Pubkey
|
|
|
|
where
|
|
|
|
F: Fn(u64, u64, u64) -> (u64, u64),
|
|
|
|
{
|
|
|
|
let (slot_index, epoch_height) = get_slot_index(
|
|
|
|
bank.slot_index(),
|
|
|
|
bank.epoch_height(),
|
|
|
|
bank.slots_per_epoch(),
|
|
|
|
);
|
|
|
|
let leader_schedule = leader_schedule(epoch_height, bank);
|
|
|
|
leader_schedule[slot_index as usize]
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the leader for the current slot.
|
|
|
|
pub fn slot_leader(bank: &Bank) -> Pubkey {
|
|
|
|
slot_leader_by(bank, |slot_index, epoch_height, _| {
|
|
|
|
(slot_index, epoch_height)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the leader for the given slot.
|
|
|
|
pub fn slot_leader_at(slot: u64, bank: &Bank) -> Pubkey {
|
2019-02-28 15:18:08 -08:00
|
|
|
slot_leader_by(bank, |_, _, _| {
|
|
|
|
(slot % bank.slots_per_epoch(), slot / bank.slots_per_epoch())
|
|
|
|
})
|
2019-02-27 14:41:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the epoch height and slot index of the slot before the current slot.
|
|
|
|
fn prev_slot_leader_index(slot_index: u64, epoch_height: u64, slots_per_epoch: u64) -> (u64, u64) {
|
|
|
|
if epoch_height == 0 && slot_index == 0 {
|
|
|
|
return (0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if slot_index == 0 {
|
|
|
|
(slots_per_epoch - 1, epoch_height - 1)
|
|
|
|
} else {
|
|
|
|
(slot_index - 1, epoch_height)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the slot_index and epoch height of the slot following the current slot.
|
|
|
|
fn next_slot_leader_index(slot_index: u64, epoch_height: u64, slots_per_epoch: u64) -> (u64, u64) {
|
|
|
|
if slot_index + 1 == slots_per_epoch {
|
|
|
|
(0, epoch_height + 1)
|
|
|
|
} else {
|
|
|
|
(slot_index + 1, epoch_height)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the leader for the slot before the current slot.
|
|
|
|
pub fn prev_slot_leader(bank: &Bank) -> Pubkey {
|
|
|
|
slot_leader_by(bank, prev_slot_leader_index)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the leader for the slot following the current slot.
|
|
|
|
pub fn next_slot_leader(bank: &Bank) -> Pubkey {
|
|
|
|
slot_leader_by(bank, next_slot_leader_index)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the number of ticks remaining from the specified tick_height to the end of the
|
|
|
|
// slot implied by the tick_height
|
|
|
|
pub fn num_ticks_left_in_slot(bank: &Bank, tick_height: u64) -> u64 {
|
|
|
|
bank.ticks_per_slot() - tick_height % bank.ticks_per_slot() - 1
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-02-28 13:15:25 -08:00
|
|
|
use crate::staking_utils;
|
2019-03-01 11:46:44 -08:00
|
|
|
use solana_sdk::genesis_block::{GenesisBlock, BOOTSTRAP_LEADER_TOKENS};
|
2019-02-27 14:41:46 -08:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil};
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_leader_schedule_via_bank() {
|
|
|
|
let pubkey = Keypair::new().pubkey();
|
2019-03-01 11:46:44 -08:00
|
|
|
let (genesis_block, _mint_keypair) =
|
|
|
|
GenesisBlock::new_with_leader(BOOTSTRAP_LEADER_TOKENS, pubkey, BOOTSTRAP_LEADER_TOKENS);
|
2019-02-27 14:41:46 -08:00
|
|
|
let bank = Bank::new(&genesis_block);
|
|
|
|
|
2019-02-28 17:08:45 -08:00
|
|
|
let ids_and_stakes: Vec<_> = staking_utils::node_stakes(&bank).into_iter().collect();
|
2019-02-27 14:41:46 -08:00
|
|
|
let seed = [0u8; 32];
|
|
|
|
let leader_schedule =
|
|
|
|
LeaderSchedule::new(&ids_and_stakes, seed, genesis_block.slots_per_epoch);
|
|
|
|
|
|
|
|
assert_eq!(leader_schedule[0], pubkey);
|
|
|
|
assert_eq!(leader_schedule[1], pubkey);
|
|
|
|
assert_eq!(leader_schedule[2], pubkey);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_leader_scheduler1_basic() {
|
|
|
|
let pubkey = Keypair::new().pubkey();
|
2019-03-01 11:46:44 -08:00
|
|
|
let genesis_block =
|
|
|
|
GenesisBlock::new_with_leader(BOOTSTRAP_LEADER_TOKENS, pubkey, BOOTSTRAP_LEADER_TOKENS)
|
|
|
|
.0;
|
2019-02-27 14:41:46 -08:00
|
|
|
let bank = Bank::new(&genesis_block);
|
|
|
|
assert_eq!(slot_leader(&bank), pubkey);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_leader_scheduler1_prev_slot_leader_index() {
|
|
|
|
assert_eq!(prev_slot_leader_index(0, 0, 2), (0, 0));
|
|
|
|
assert_eq!(prev_slot_leader_index(1, 0, 2), (0, 0));
|
|
|
|
assert_eq!(prev_slot_leader_index(0, 1, 2), (1, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_leader_scheduler1_next_slot_leader_index() {
|
|
|
|
assert_eq!(next_slot_leader_index(0, 0, 2), (1, 0));
|
|
|
|
assert_eq!(next_slot_leader_index(1, 0, 2), (0, 1));
|
|
|
|
}
|
2019-02-28 17:08:45 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_sort_stakes_basic() {
|
|
|
|
let pubkey0 = Keypair::new().pubkey();
|
|
|
|
let pubkey1 = Keypair::new().pubkey();
|
|
|
|
let mut stakes = vec![(pubkey0, 1), (pubkey1, 2)];
|
|
|
|
sort_stakes(&mut stakes);
|
|
|
|
assert_eq!(stakes, vec![(pubkey1, 2), (pubkey0, 1)]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_sort_stakes_with_dup() {
|
|
|
|
let pubkey0 = Keypair::new().pubkey();
|
|
|
|
let pubkey1 = Keypair::new().pubkey();
|
|
|
|
let mut stakes = vec![(pubkey0, 1), (pubkey1, 2), (pubkey0, 1)];
|
|
|
|
sort_stakes(&mut stakes);
|
|
|
|
assert_eq!(stakes, vec![(pubkey1, 2), (pubkey0, 1)]);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_sort_stakes_with_equal_stakes() {
|
|
|
|
let pubkey0 = Pubkey::default();
|
|
|
|
let pubkey1 = Keypair::new().pubkey();
|
|
|
|
let mut stakes = vec![(pubkey0, 1), (pubkey1, 1)];
|
|
|
|
sort_stakes(&mut stakes);
|
|
|
|
assert_eq!(stakes, vec![(pubkey1, 1), (pubkey0, 1)]);
|
|
|
|
}
|
2019-02-27 14:41:46 -08:00
|
|
|
}
|