2019-02-27 14:41:46 -08:00
|
|
|
use crate::leader_schedule::LeaderSchedule;
|
|
|
|
use solana_runtime::bank::Bank;
|
2019-11-02 00:38:30 -07:00
|
|
|
use solana_sdk::{
|
|
|
|
clock::{Epoch, Slot, NUM_CONSECUTIVE_LEADER_SLOTS},
|
|
|
|
pubkey::Pubkey,
|
|
|
|
};
|
2019-02-27 14:41:46 -08:00
|
|
|
|
|
|
|
/// Return the leader schedule for the given epoch.
|
2019-11-02 00:38:30 -07:00
|
|
|
pub fn leader_schedule(epoch: Epoch, bank: &Bank) -> Option<LeaderSchedule> {
|
2020-12-17 13:22:50 -08:00
|
|
|
bank.epoch_staked_nodes(epoch).map(|stakes| {
|
2019-03-07 15:49:07 -08:00
|
|
|
let mut seed = [0u8; 32];
|
2019-07-19 07:31:18 -07:00
|
|
|
seed[0..8].copy_from_slice(&epoch.to_le_bytes());
|
2019-03-07 15:49:07 -08:00
|
|
|
let mut stakes: Vec<_> = stakes.into_iter().collect();
|
|
|
|
sort_stakes(&mut stakes);
|
2019-03-19 06:36:45 -07:00
|
|
|
LeaderSchedule::new(
|
|
|
|
&stakes,
|
|
|
|
seed,
|
2019-07-19 07:31:18 -07:00
|
|
|
bank.get_slots_in_epoch(epoch),
|
2019-03-19 06:36:45 -07:00
|
|
|
NUM_CONSECUTIVE_LEADER_SLOTS,
|
|
|
|
)
|
2019-03-07 15:49:07 -08:00
|
|
|
})
|
2019-02-27 14:41:46 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Return the leader for the given slot.
|
2019-11-02 00:38:30 -07:00
|
|
|
pub fn slot_leader_at(slot: Slot, bank: &Bank) -> Option<Pubkey> {
|
2019-03-06 14:44:21 -08:00
|
|
|
let (epoch, slot_index) = bank.get_epoch_and_slot_index(slot);
|
2019-02-27 14:41:46 -08:00
|
|
|
|
2019-03-14 16:06:56 -07:00
|
|
|
leader_schedule(epoch, bank).map(|leader_schedule| leader_schedule[slot_index])
|
|
|
|
}
|
|
|
|
|
2019-02-27 14:41:46 -08:00
|
|
|
// 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 {
|
2019-10-16 12:53:11 -07:00
|
|
|
bank.ticks_per_slot() - tick_height % bank.ticks_per_slot()
|
2019-02-27 14:41:46 -08:00
|
|
|
}
|
|
|
|
|
2019-04-19 02:39:44 -07: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.
|
2019-05-23 23:20:04 -07:00
|
|
|
stakes.sort_unstable_by(|(l_pubkey, l_stake), (r_pubkey, r_stake)| {
|
2019-04-19 02:39:44 -07:00
|
|
|
if r_stake == l_stake {
|
2019-05-23 23:20:04 -07:00
|
|
|
r_pubkey.cmp(&l_pubkey)
|
2019-04-19 02:39:44 -07:00
|
|
|
} 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
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2019-05-07 22:22:43 -07:00
|
|
|
use solana_runtime::genesis_utils::{
|
2020-11-20 00:21:03 -08:00
|
|
|
bootstrap_validator_stake_lamports, create_genesis_config_with_leader,
|
2019-05-07 22:22:43 -07:00
|
|
|
};
|
2019-03-21 07:43:21 -07:00
|
|
|
|
2019-02-27 14:41:46 -08:00
|
|
|
#[test]
|
|
|
|
fn test_leader_schedule_via_bank() {
|
2020-10-19 12:12:08 -07:00
|
|
|
let pubkey = solana_sdk::pubkey::new_rand();
|
2019-11-08 20:56:57 -08:00
|
|
|
let genesis_config =
|
2020-11-20 00:21:03 -08:00
|
|
|
create_genesis_config_with_leader(0, &pubkey, bootstrap_validator_stake_lamports())
|
2020-01-22 08:22:09 -08:00
|
|
|
.genesis_config;
|
2019-11-08 20:56:57 -08:00
|
|
|
let bank = Bank::new(&genesis_config);
|
2019-02-27 14:41:46 -08:00
|
|
|
|
2020-12-17 13:22:50 -08:00
|
|
|
let pubkeys_and_stakes: Vec<_> = bank.staked_nodes().into_iter().collect();
|
2019-02-27 14:41:46 -08:00
|
|
|
let seed = [0u8; 32];
|
2019-03-19 06:36:45 -07:00
|
|
|
let leader_schedule = LeaderSchedule::new(
|
2019-05-23 23:20:04 -07:00
|
|
|
&pubkeys_and_stakes,
|
2019-03-19 06:36:45 -07:00
|
|
|
seed,
|
2019-11-08 20:56:57 -08:00
|
|
|
genesis_config.epoch_schedule.slots_per_epoch,
|
2019-03-19 06:36:45 -07:00
|
|
|
NUM_CONSECUTIVE_LEADER_SLOTS,
|
|
|
|
);
|
2019-02-27 14:41:46 -08:00
|
|
|
|
|
|
|
assert_eq!(leader_schedule[0], pubkey);
|
|
|
|
assert_eq!(leader_schedule[1], pubkey);
|
|
|
|
assert_eq!(leader_schedule[2], pubkey);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_leader_scheduler1_basic() {
|
2020-10-19 12:12:08 -07:00
|
|
|
let pubkey = solana_sdk::pubkey::new_rand();
|
2020-11-25 14:14:45 -08:00
|
|
|
let genesis_config =
|
|
|
|
create_genesis_config_with_leader(42, &pubkey, bootstrap_validator_stake_lamports())
|
|
|
|
.genesis_config;
|
2019-11-08 20:56:57 -08:00
|
|
|
let bank = Bank::new(&genesis_config);
|
2019-03-07 15:49:07 -08:00
|
|
|
assert_eq!(slot_leader_at(bank.slot(), &bank).unwrap(), pubkey);
|
2019-02-27 14:41:46 -08:00
|
|
|
}
|
2019-02-28 17:08:45 -08:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_sort_stakes_basic() {
|
2020-10-19 12:12:08 -07:00
|
|
|
let pubkey0 = solana_sdk::pubkey::new_rand();
|
|
|
|
let pubkey1 = solana_sdk::pubkey::new_rand();
|
2019-02-28 17:08:45 -08:00
|
|
|
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() {
|
2020-10-19 12:12:08 -07:00
|
|
|
let pubkey0 = solana_sdk::pubkey::new_rand();
|
|
|
|
let pubkey1 = solana_sdk::pubkey::new_rand();
|
2019-02-28 17:08:45 -08:00
|
|
|
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();
|
2020-10-19 12:12:08 -07:00
|
|
|
let pubkey1 = solana_sdk::pubkey::new_rand();
|
2019-02-28 17:08:45 -08:00
|
|
|
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
|
|
|
}
|