add inflation to genesis (#4652)

* add inflation to genesis

* avoid having to write new()

sdk/src/genesis_block.rs

@@ -3,6 +3,7 @@
 use crate::account::Account;
 use crate::fee_calculator::FeeCalculator;
 use crate::hash::{hash, Hash};
+use crate::inflation::Inflation;
 use crate::poh_config::PohConfig;
 use crate::pubkey::Pubkey;
 use crate::signature::{Keypair, KeypairUtil};
@@ -22,6 +23,7 @@ pub struct GenesisBlock {
     pub stakers_slot_offset: u64,
     pub epoch_warmup: bool,
     pub poh_config: PohConfig,
+    pub inflation: Inflation,
 }
 
 // useful for basic tests
@@ -50,6 +52,7 @@ impl Default for GenesisBlock {
             stakers_slot_offset: DEFAULT_SLOTS_PER_EPOCH,
             ticks_per_slot: DEFAULT_TICKS_PER_SLOT,
             poh_config: PohConfig::default(),
+            inflation: Inflation::default(),
         }
     }
 }

sdk/src/inflation.rs

@@ -0,0 +1,118 @@
+//! configuration for network inflation
+
+#[derive(Serialize, Deserialize, PartialEq, Clone, Debug)]
+pub struct Inflation {
+    /// Initial inflation percentage, from time=0
+    pub initial: f64,
+
+    /// Terminal inflation percentage, to time=INF
+    pub terminal: f64,
+
+    /// Rate per year, at which inflation is lowered until reaching terminal
+    ///  i.e. inflation(year) == MAX(terminal, initial*((1-taper)^year))
+    pub taper: f64,
+
+    /// Percentage of total inflation allocated to the foundation
+    pub foundation: f64,
+    /// Duration of foundationt pool inflation, in years
+    pub foundation_term: f64,
+
+    /// Percentage of total inflation allocated to grant pools
+    pub grant: f64,
+    /// Duration of grant pool inflation, in years
+    pub grant_term: f64,
+
+    /// Percentage of total inflation allocated to replicator rewards
+    pub replicator: f64,
+}
+
+const DEFAULT_INITIAL: f64 = 0.15;
+const DEFAULT_TERMINAL: f64 = 0.015;
+const DEFAULT_TAPER: f64 = 0.15;
+const DEFAULT_FOUNDATION: f64 = 0.05;
+const DEFAULT_GRANT: f64 = 0.05;
+const DEFAULT_FOUNDATION_GRANT_TERM: f64 = 7.0;
+const DEFAULT_REPLICATOR: f64 = 0.10;
+
+impl Default for Inflation {
+    fn default() -> Self {
+        Self {
+            initial: DEFAULT_INITIAL,
+            terminal: DEFAULT_TERMINAL,
+            taper: DEFAULT_TAPER,
+            foundation: DEFAULT_FOUNDATION,
+            foundation_term: DEFAULT_FOUNDATION_GRANT_TERM,
+            grant: DEFAULT_GRANT,
+            grant_term: DEFAULT_FOUNDATION_GRANT_TERM,
+            replicator: DEFAULT_REPLICATOR,
+        }
+    }
+}
+
+impl Inflation {
+    /// inflation rate at year
+    pub fn total(&self, year: f64) -> f64 {
+        let tapered = self.initial * ((1.0 - self.taper).powf(year));
+
+        if tapered > self.terminal {
+            tapered
+        } else {
+            self.terminal
+        }
+    }
+
+    /// portion of total that goes to validators
+    pub fn validator(&self, year: f64) -> f64 {
+        self.total(year) - self.replicator(year) - self.grant(year) - self.foundation(year)
+    }
+
+    /// portion of total that goes to replicators
+    pub fn replicator(&self, year: f64) -> f64 {
+        self.total(year) * self.replicator
+    }
+
+    /// portion of total that goes to grant pools
+    pub fn grant(&self, year: f64) -> f64 {
+        if year < self.grant_term {
+            self.total(year) * self.grant
+        } else {
+            0.0
+        }
+    }
+
+    /// portion of total that goes to foundation
+    pub fn foundation(&self, year: f64) -> f64 {
+        if year < self.foundation_term {
+            self.total(year) * self.foundation
+        } else {
+            0.0
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_inflation_basic() {
+        let inflation = Inflation::default();
+
+        let mut last = inflation.total(0.0);
+
+        for year in &[0.1, 0.5, 1.0, DEFAULT_FOUNDATION_GRANT_TERM, 100.0] {
+            let total = inflation.total(*year);
+            assert_eq!(
+                total,
+                inflation.validator(*year)
+                    + inflation.replicator(*year)
+                    + inflation.grant(*year)
+                    + inflation.foundation(*year)
+            );
+            assert!(total < last);
+            assert!(total >= inflation.terminal);
+            last = total;
+        }
+        assert_eq!(last, inflation.terminal);
+    }
+}

sdk/src/lib.rs

@@ -5,6 +5,7 @@ pub mod client;
 pub mod fee_calculator;
 pub mod genesis_block;
 pub mod hash;
+pub mod inflation;
 pub mod instruction;
 pub mod instruction_processor_utils;
 pub mod loader_instruction;