use crate::types::{RoundNumber, SlotNumber};
pub const SLOT_MS: u64 = 400;
const MILLIS_PER_SECOND: u64 = 1_000;
pub const PROOF_DEADLINE_SLOTS: u64 = 2;
pub const ATTESTATION_WINDOW_SLOTS: u64 = 4;
pub const CERTIFICATE_GOSSIP_SLOTS: u64 = 1;
pub const FINALITY_SLOTS: u64 = 32;
pub const SETTLE_DEADLINE_SLOTS: u64 = FINALITY_SLOTS + 8;
pub const SAMPLE_LOOKBACK_SLOTS: u64 = SETTLE_DEADLINE_SLOTS + FINALITY_SLOTS;
pub const MAX_PENDING_ROUNDS: usize = (SETTLE_DEADLINE_SLOTS / round_width_slots() + 3) as usize;
pub const fn attest_deadline_slots() -> u64 {
PROOF_DEADLINE_SLOTS + ATTESTATION_WINDOW_SLOTS
}
pub const fn round_width_slots() -> u64 {
attest_deadline_slots() + CERTIFICATE_GOSSIP_SLOTS
}
pub fn rounds_in_seconds(seconds: u64, interval_slots: u64, slot_ms: u64) -> u64 {
let round_ms = interval_slots.saturating_mul(slot_ms).max(1);
let span_ms = seconds.saturating_mul(MILLIS_PER_SECOND);
span_ms.div_ceil(round_ms).max(1)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ScheduleError {
RoundsOverlap {
interval: u64,
width: u64,
},
SlotOverflow,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Schedule {
pub epoch_start_slot: SlotNumber,
pub interval_slots: u64,
first_slot: SlotNumber,
}
impl Schedule {
pub fn for_epoch(
epoch_start_slot: SlotNumber,
interval_slots: u64,
) -> Result<Self, ScheduleError> {
let width = round_width_slots();
if interval_slots < width {
return Err(ScheduleError::RoundsOverlap {
interval: interval_slots,
width,
});
}
let start = epoch_start_slot.as_u64();
let offset = (interval_slots - start % interval_slots) % interval_slots;
let first_slot = start
.checked_add(offset)
.ok_or(ScheduleError::SlotOverflow)?;
Ok(Self {
epoch_start_slot,
interval_slots,
first_slot: SlotNumber(first_slot),
})
}
pub fn first_slot(&self) -> SlotNumber {
self.first_slot
}
pub fn base_slot(&self, round: RoundNumber) -> SlotNumber {
SlotNumber(self.first_slot.as_u64() + round.as_u64() * self.interval_slots)
}
pub fn sample_cutoff(&self, round: RoundNumber) -> SlotNumber {
SlotNumber(
self.base_slot(round)
.as_u64()
.saturating_sub(SAMPLE_LOOKBACK_SLOTS),
)
}
pub fn skipped_rounds(
&self,
parent_slot: SlotNumber,
slot: SlotNumber,
) -> impl Iterator<Item = RoundNumber> {
let first = self.round_from(SlotNumber(parent_slot.as_u64().saturating_add(1)));
let end = self.round_from(slot);
(first.as_u64()..end.as_u64()).map(RoundNumber)
}
pub fn round_from(&self, slot: SlotNumber) -> RoundNumber {
RoundNumber(
slot.as_u64()
.saturating_sub(self.first_slot.as_u64())
.div_ceil(self.interval_slots),
)
}
pub fn settling_rounds(&self) -> u64 {
SETTLE_DEADLINE_SLOTS.div_ceil(self.interval_slots)
}
pub fn round_by(&self, slot: SlotNumber) -> Option<RoundNumber> {
let offset = slot.as_u64().checked_sub(self.first_slot.as_u64())?;
Some(RoundNumber(offset / self.interval_slots))
}
pub fn round_at(&self, slot: SlotNumber) -> Option<RoundNumber> {
let offset = slot.as_u64().checked_sub(self.first_slot.as_u64())?;
(offset % self.interval_slots == 0).then_some(RoundNumber(offset / self.interval_slots))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn refuses_overlap_and_overflow() {
for interval in 0..round_width_slots() {
assert!(Schedule::for_epoch(SlotNumber(0), interval).is_err());
}
assert_eq!(
Schedule::for_epoch(SlotNumber(u64::MAX), 10),
Err(ScheduleError::SlotOverflow)
);
}
#[test]
fn epoch_boundary_never_moves_the_grid() {
for interval in [7, 10, 25, 100] {
for boundary in 101..201 {
let old = Schedule::for_epoch(SlotNumber(0), interval).unwrap();
let new = Schedule::for_epoch(SlotNumber(boundary), interval).unwrap();
assert!(new.first_slot().as_u64() >= boundary);
assert!(new.first_slot().as_u64() < boundary + interval);
for round in 0..10 {
let slot = new.base_slot(RoundNumber(round));
assert_eq!(slot.as_u64() % interval, 0);
assert!(old.round_at(slot).is_some());
assert_eq!(new.round_at(slot), Some(RoundNumber(round)));
}
}
}
}
#[test]
fn openings_and_gaps_follow_configured_interval() {
let schedule = Schedule::for_epoch(SlotNumber(101), 25).unwrap();
assert_eq!(schedule.first_slot(), SlotNumber(125));
assert_eq!(schedule.round_at(SlotNumber(124)), None);
assert_eq!(schedule.round_by(SlotNumber(124)), None);
for round in [0, 1, 100, 1_000_000] {
let base = schedule.base_slot(RoundNumber(round)).as_u64();
assert_eq!(schedule.round_at(SlotNumber(base)), Some(RoundNumber(round)));
assert_eq!(
schedule.round_by(SlotNumber(base + 24)),
Some(RoundNumber(round))
);
assert_eq!(
schedule.sample_cutoff(RoundNumber(round)).as_u64(),
base - SAMPLE_LOOKBACK_SLOTS
);
}
assert_eq!(schedule.settling_rounds(), 2);
}
#[test]
fn one_slot_per_round() {
let schedule = Schedule::for_epoch(SlotNumber(101), 25).expect("a grid");
for round in [0, 1, 100, 1_000_000] {
let base = schedule.base_slot(RoundNumber(round)).as_u64();
assert_eq!(schedule.round_at(SlotNumber(base)), Some(RoundNumber(round)));
assert_eq!(schedule.round_at(SlotNumber(base + 1)), None);
assert_eq!(schedule.round_at(SlotNumber(base - 1)), None);
}
}
#[test]
fn first_round_from() {
let schedule = Schedule::for_epoch(SlotNumber(100), 25).expect("a grid");
let first = schedule.first_slot().as_u64();
assert_eq!(schedule.round_from(SlotNumber(first - 30)), RoundNumber(0));
assert_eq!(schedule.round_from(SlotNumber(first)), RoundNumber(0));
assert_eq!(schedule.round_from(SlotNumber(first + 1)), RoundNumber(1));
assert_eq!(schedule.round_from(SlotNumber(first + 25)), RoundNumber(1));
assert_eq!(schedule.round_from(SlotNumber(first + 26)), RoundNumber(2));
}
#[test]
fn skipped_openings() {
let schedule = Schedule::for_epoch(SlotNumber(100), 25).expect("a grid");
let first = schedule.first_slot().as_u64();
let skipped = |from: u64, to: u64| -> Vec<RoundNumber> {
schedule
.skipped_rounds(SlotNumber(from), SlotNumber(to))
.collect()
};
assert_eq!(skipped(first, first + 1), Vec::new());
assert_eq!(skipped(first + 24, first + 25), Vec::new());
assert_eq!(skipped(first + 25, first + 26), Vec::new());
assert_eq!(skipped(first + 24, first + 26), vec![RoundNumber(1)]);
assert_eq!(
skipped(first, first + 51),
vec![RoundNumber(1), RoundNumber(2)]
);
assert_eq!(skipped(first - 40, first + 1), vec![RoundNumber(0)]);
}
#[test]
fn rounds_cover_a_span() {
assert_eq!(rounds_in_seconds(120, 300, 200), 2);
assert_eq!(rounds_in_seconds(121, 300, 200), 3);
assert_eq!(rounds_in_seconds(90, 300, 200), 2);
assert_eq!(rounds_in_seconds(240, 180, 166), 9);
assert_eq!(rounds_in_seconds(225, 180, 166), 8);
assert_eq!(rounds_in_seconds(75, 180, 166), 3);
assert_eq!(rounds_in_seconds(1, 300, 200), 1);
assert_eq!(rounds_in_seconds(0, 300, 200), 1);
}
#[test]
fn sparse_rounds_still_have_a_settlement_window() {
let schedule = Schedule::for_epoch(SlotNumber(0), 100).unwrap();
assert_eq!(schedule.settling_rounds(), 1);
assert_eq!(schedule.sample_cutoff(RoundNumber(0)), SlotNumber(0));
}
}