kill rent calculator (#6625)

sdk/src/rent.rs

@@ -0,0 +1,131 @@
+//! configuration for network rent
+
+#[repr(C)]
+#[derive(Serialize, Deserialize, PartialEq, Clone, Copy, Debug)]
+pub struct Rent {
+    /// 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:
+///  10^9 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; //1_000_000_000 / 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 Rent {
+    fn default() -> Self {
+        Self {
+            lamports_per_byte_year: DEFAULT_LAMPORTS_PER_BYTE_YEAR,
+            exemption_threshold: DEFAULT_EXEMPTION_THRESHOLD,
+            burn_percent: DEFAULT_BURN_PERCENT,
+        }
+    }
+}
+
+impl Rent {
+    /// 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 = Rent::default();
+
+        assert_eq!(
+            rent.due(0, 1, 1.0),
+            (
+                DEFAULT_LAMPORTS_PER_BYTE_YEAR,
+                DEFAULT_LAMPORTS_PER_BYTE_YEAR == 0
+            )
+        );
+        assert_eq!(
+            rent.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 = Rent::default();
+    //
+    //        eprintln();
+    //        // lamports charged per byte per slot at $1/MByear, rent per slot is zero
+    //        eprintln(
+    //            "{} lamports per byte-slot, rent.due(): {}",
+    //            (1.0 / SLOTS_PER_YEAR) * DEFAULT_LAMPORTS_PER_BYTE_YEAR as f64,
+    //            rent.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.due(): {}",
+    //            (1.0 / SLOTS_PER_YEAR)
+    //                * (DEFAULT_LAMPORTS_PER_BYTE_YEAR * DEFAULT_SLOTS_PER_EPOCH) as f64,
+    //            rent.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.due(
+    //                0,
+    //                crate::sysvar::stake_history::StakeHistory::size_of(),
+    //                (1.0 / SLOTS_PER_YEAR) * DEFAULT_SLOTS_PER_EPOCH as f64
+    //            )
+    //            .0,
+    //        );
+    //    }
+}