solana-sdk 0.20.1

//! configuration for network rent

#[derive(Serialize, Deserialize, PartialEq, Clone, Copy, Debug)]
pub struct RentCalculator {
    /// Rental rate
    pub lamports_per_byte_year: u64,

    /// exemption threshold, in years
    pub exemption_threshold: f64,

    // What portion of collected rent are to be destroyed, percentage-wise
    pub burn_percent: u8,
}

/// default rental rate in lamports/byte-year, based on:
///  2^^34 lamports per Sol
///  $1 per Sol
///  $0.01 per megabyte day
///  $3.65 per megabyte year
pub const DEFAULT_LAMPORTS_PER_BYTE_YEAR: u64 = 0; //17_179_869_184 / 100 * 365 / (1024 * 1024);

/// default amount of time (in years) the balance has to include rent for
pub const DEFAULT_EXEMPTION_THRESHOLD: f64 = 2.0;

/// default amount of rent to burn, as a fraction of std::u8::MAX
pub const DEFAULT_BURN_PERCENT: u8 = ((50usize * std::u8::MAX as usize) / 100usize) as u8;

impl Default for RentCalculator {
    fn default() -> Self {
        Self {
            lamports_per_byte_year: DEFAULT_LAMPORTS_PER_BYTE_YEAR,
            exemption_threshold: DEFAULT_EXEMPTION_THRESHOLD,
            burn_percent: DEFAULT_BURN_PERCENT,
        }
    }
}

impl RentCalculator {
    /// minimum balance due for a given size Account::data.len()
    pub fn minimum_balance(&self, data_len: usize) -> u64 {
        let bytes = data_len as u64;
        bytes * (self.exemption_threshold * self.lamports_per_byte_year as f64) as u64
    }

    /// whether a given balance and data_len would be exempt
    pub fn is_exempt(&self, balance: u64, data_len: usize) -> bool {
        balance >= self.minimum_balance(data_len)
    }

    /// rent due on account's data_len with balance
    pub fn due(&self, balance: u64, data_len: usize, years_elapsed: f64) -> (u64, bool) {
        if self.is_exempt(balance, data_len) {
            (0, true)
        } else {
            (
                ((self.lamports_per_byte_year * data_len as u64) as f64 * years_elapsed) as u64,
                false,
            )
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_due() {
        let rent_calculator = RentCalculator::default();

        assert_eq!(
            rent_calculator.due(0, 1, 1.0),
            (
                DEFAULT_LAMPORTS_PER_BYTE_YEAR,
                DEFAULT_LAMPORTS_PER_BYTE_YEAR == 0
            )
        );
        assert_eq!(
            rent_calculator.due(
                DEFAULT_LAMPORTS_PER_BYTE_YEAR * DEFAULT_EXEMPTION_THRESHOLD as u64,
                1,
                1.0
            ),
            (0, true)
        );
    }

    // uncomment me and make my eprintlns macros
    //    #[test]
    //    fn test_rent_model() {
    //        use crate::timing::*;
    //
    //        const SECONDS_PER_YEAR: f64 = (365.25 * 24.0 * 60.0 * 60.0);
    //        const SLOTS_PER_YEAR: f64 =
    //            SECONDS_PER_YEAR / (DEFAULT_TICKS_PER_SLOT as f64 / DEFAULT_TICKS_PER_SECOND as f64);
    //
    //        let rent_calculator = RentCalculator::default();
    //
    //        eprintln();
    //        // lamports charged per byte per slot at $1/MByear, rent per slot is zero
    //        eprintln(
    //            "{} lamports per byte-slot, rent_calculator.due(): {}",
    //            (1.0 / SLOTS_PER_YEAR) * DEFAULT_LAMPORTS_PER_BYTE_YEAR as f64,
    //            rent_calculator.due(0, 1, 1.0 / SLOTS_PER_YEAR).0,
    //        );
    //        // lamports charged per byte per _epoch_ starts to have some significant digits
    //        eprintln(
    //            "{} lamports per byte-epoch, rent_calculator.due(): {}",
    //            (1.0 / SLOTS_PER_YEAR)
    //                * (DEFAULT_LAMPORTS_PER_BYTE_YEAR * DEFAULT_SLOTS_PER_EPOCH) as f64,
    //            rent_calculator.due(
    //                0,
    //                1,
    //                (1.0 / SLOTS_PER_YEAR) * DEFAULT_SLOTS_PER_EPOCH as f64
    //            )
    //            .0,
    //        );
    //        // have a look at what a large-ish sysvar would cost, were it a real account...
    //        eprintln(
    //            "stake_history: {}kB == {} lamports per epoch",
    //            crate::sysvar::stake_history::StakeHistory::size_of() / 1024,
    //            rent_calculator.due(
    //                0,
    //                crate::sysvar::stake_history::StakeHistory::size_of(),
    //                (1.0 / SLOTS_PER_YEAR) * DEFAULT_SLOTS_PER_EPOCH as f64
    //            )
    //            .0,
    //        );
    //    }
}