113 lines
3.3 KiB
Rust
113 lines
3.3 KiB
Rust
//! A type to hold data for the [`StakeHistory` sysvar][sv].
|
|
//!
|
|
//! [sv]: https://docs.solana.com/developing/runtime-facilities/sysvars#stakehistory
|
|
//!
|
|
//! The sysvar ID is declared in [`sysvar::stake_history`].
|
|
//!
|
|
//! [`sysvar::stake_history`]: crate::sysvar::stake_history
|
|
|
|
pub use crate::clock::Epoch;
|
|
use std::ops::Deref;
|
|
|
|
pub const MAX_ENTRIES: usize = 512; // it should never take as many as 512 epochs to warm up or cool down
|
|
|
|
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Default, Clone, AbiExample)]
|
|
pub struct StakeHistoryEntry {
|
|
pub effective: u64, // effective stake at this epoch
|
|
pub activating: u64, // sum of portion of stakes not fully warmed up
|
|
pub deactivating: u64, // requested to be cooled down, not fully deactivated yet
|
|
}
|
|
|
|
impl StakeHistoryEntry {
|
|
pub fn with_effective(effective: u64) -> Self {
|
|
Self {
|
|
effective,
|
|
..Self::default()
|
|
}
|
|
}
|
|
|
|
pub fn with_effective_and_activating(effective: u64, activating: u64) -> Self {
|
|
Self {
|
|
effective,
|
|
activating,
|
|
..Self::default()
|
|
}
|
|
}
|
|
|
|
pub fn with_deactivating(deactivating: u64) -> Self {
|
|
Self {
|
|
effective: deactivating,
|
|
deactivating,
|
|
..Self::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::ops::Add for StakeHistoryEntry {
|
|
type Output = StakeHistoryEntry;
|
|
fn add(self, rhs: StakeHistoryEntry) -> Self::Output {
|
|
Self {
|
|
effective: self.effective.saturating_add(rhs.effective),
|
|
activating: self.activating.saturating_add(rhs.activating),
|
|
deactivating: self.deactivating.saturating_add(rhs.deactivating),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Default, Clone, AbiExample)]
|
|
pub struct StakeHistory(Vec<(Epoch, StakeHistoryEntry)>);
|
|
|
|
impl StakeHistory {
|
|
pub fn get(&self, epoch: Epoch) -> Option<&StakeHistoryEntry> {
|
|
self.binary_search_by(|probe| epoch.cmp(&probe.0))
|
|
.ok()
|
|
.map(|index| &self[index].1)
|
|
}
|
|
|
|
pub fn add(&mut self, epoch: Epoch, entry: StakeHistoryEntry) {
|
|
match self.binary_search_by(|probe| epoch.cmp(&probe.0)) {
|
|
Ok(index) => (self.0)[index] = (epoch, entry),
|
|
Err(index) => (self.0).insert(index, (epoch, entry)),
|
|
}
|
|
(self.0).truncate(MAX_ENTRIES);
|
|
}
|
|
}
|
|
|
|
impl Deref for StakeHistory {
|
|
type Target = Vec<(Epoch, StakeHistoryEntry)>;
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_stake_history() {
|
|
let mut stake_history = StakeHistory::default();
|
|
|
|
for i in 0..MAX_ENTRIES as u64 + 1 {
|
|
stake_history.add(
|
|
i,
|
|
StakeHistoryEntry {
|
|
activating: i,
|
|
..StakeHistoryEntry::default()
|
|
},
|
|
);
|
|
}
|
|
assert_eq!(stake_history.len(), MAX_ENTRIES);
|
|
assert_eq!(stake_history.iter().map(|entry| entry.0).min().unwrap(), 1);
|
|
assert_eq!(stake_history.get(0), None);
|
|
assert_eq!(
|
|
stake_history.get(1),
|
|
Some(&StakeHistoryEntry {
|
|
activating: 1,
|
|
..StakeHistoryEntry::default()
|
|
})
|
|
);
|
|
}
|
|
}
|