use crate::types::{RoundNumber, SlotNumber};
use core::ops::Range;
pub const SLOT_MS: u64 = 400;
pub const SPAN_SLOTS: u64 = 2;
pub const SAMPLE_LOOKBACK_SLOTS: u64 = 64;
pub const PROOF_DEADLINE_SLOTS: u64 = 2;
pub const CONFIRMATION_SLOTS: u64 = 1;
pub const ATTESTATION_WINDOW_SLOTS: u64 = 2;
pub const CERTIFICATE_GOSSIP_SLOTS: u64 = 1;
pub const FINALITY_SLOTS: u64 = 32;
pub const SETTLE_DEADLINE_SLOTS: u64 = FINALITY_SLOTS + 8;
pub const MAX_PENDING_ROUNDS: usize = (SETTLE_DEADLINE_SLOTS / round_width_slots() + 3) as usize;
pub const fn round_width_slots() -> u64 {
let tail = if PROOF_DEADLINE_SLOTS > ATTESTATION_WINDOW_SLOTS {
PROOF_DEADLINE_SLOTS
} else {
ATTESTATION_WINDOW_SLOTS
};
SPAN_SLOTS + tail + CERTIFICATE_GOSSIP_SLOTS
}
#[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 entropy_window(&self, round: RoundNumber) -> Range<u64> {
let base = self.base_slot(round).as_u64();
base..base + SPAN_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 < SPAN_SLOTS)
.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 [5, 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 windows_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 window = schedule.entropy_window(RoundNumber(round));
for slot in window.clone() {
assert_eq!(
schedule.round_at(SlotNumber(slot)),
Some(RoundNumber(round))
);
}
assert_eq!(schedule.round_at(SlotNumber(window.end)), None);
assert_eq!(
schedule.round_by(SlotNumber(window.start + 24)),
Some(RoundNumber(round))
);
assert_eq!(
schedule.sample_cutoff(RoundNumber(round)).as_u64(),
window.start - SAMPLE_LOOKBACK_SLOTS
);
}
assert_eq!(schedule.settling_rounds(), 2);
}
#[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));
}
}