Implemented compounding inflation for native tokens.

Cargo.toml

@@ -90,8 +90,8 @@ libc = "0.2.97"
 libloading = "0.7.2"
 libsecp256k1 = {git = "https://github.com/heliaxdev/libsecp256k1", rev = "bbb3bd44a49db361f21d9db80f9a087c194c0ae9", default-features = false, features = ["std", "static-context"]}
 # branch = "murisi/namada-integration"
-masp_primitives = { git = "https://github.com/anoma/masp", rev = "50acc5028fbcd52a05970fe7991c7850ab04358e" }
-masp_proofs = { git = "https://github.com/anoma/masp", rev = "50acc5028fbcd52a05970fe7991c7850ab04358e", default-features = false, features = ["local-prover"] }
+masp_primitives = { git = "https://github.com/anoma/masp", rev = "1345b463e8fa3b3a6fa13e4a43fb1c410690ad62" }
+masp_proofs = { git = "https://github.com/anoma/masp", rev = "1345b463e8fa3b3a6fa13e4a43fb1c410690ad62", default-features = false, features = ["local-prover"] }
 num256 = "0.3.5"
 num_cpus = "1.13.0"
 num-derive = "0.3.3"

apps/src/lib/client/rpc.rs

@@ -2126,7 +2126,7 @@ pub async fn query_conversions<
     // Track whether any non-sentinel conversions are found
     let mut conversions_found = false;
     for ((addr, _), epoch, conv, _) in conv_state.assets.values() {
-        let amt: masp_primitives::transaction::components::I32Sum =
+        let amt: masp_primitives::transaction::components::I128Sum =
             conv.clone().into();
         // If the user has specified any targets, then meet them
         // If we have a sentinel conversion, then skip printing
@@ -2181,7 +2181,7 @@ pub async fn query_conversion<C: namada::ledger::queries::Client + Sync>(
     Address,
     MaspDenom,
     Epoch,
-    masp_primitives::transaction::components::I32Sum,
+    masp_primitives::transaction::components::I128Sum,
     MerklePath<Node>,
 )> {
     namada::sdk::rpc::query_conversion(client, asset_type).await

apps/src/lib/config/genesis.rs

@@ -213,6 +213,8 @@ pub mod genesis_config {
         pub vp: Option<String>,
         // Initial balances held by accounts defined elsewhere.
         pub balances: Option<HashMap<String, token::Amount>>,
+        // Token parameters
+        pub parameters: Option<token::Parameters>,
     }
 
     #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -404,6 +406,9 @@ pub mod genesis_config {
         implicit_accounts: &HashMap<String, ImplicitAccount>,
     ) -> TokenAccount {
         TokenAccount {
+            last_locked_ratio: Dec::zero(),
+            last_inflation: token::Amount::zero(),
+            parameters: config.parameters.as_ref().unwrap().to_owned(),
             address: Address::decode(config.address.as_ref().unwrap()).unwrap(),
             denom: config.denom,
             balances: config
@@ -818,6 +823,12 @@ pub struct TokenAccount {
     /// Accounts' balances of this token
     #[derivative(PartialOrd = "ignore", Ord = "ignore")]
     pub balances: HashMap<Address, token::Amount>,
+    /// Token parameters
+    pub parameters: token::Parameters,
+    /// Token inflation from the last epoch (read + write for every epoch)
+    pub last_inflation: token::Amount,
+    /// Token shielded ratio from the last epoch (read + write for every epoch)
+    pub last_locked_ratio: Dec,
 }
 
 #[derive(
@@ -1001,8 +1012,8 @@ pub fn genesis(num_validators: u64) -> Genesis {
         implicit_vp_code_path: vp_implicit_path.into(),
         implicit_vp_sha256: Default::default(),
         max_signatures_per_transaction: 15,
-        epochs_per_year: 525_600, /* seconds in yr (60*60*24*365) div seconds
-                                   * per epoch (60 = min_duration) */
+        epochs_per_year: 365, /* seconds in yr (60*60*24*365) div seconds
+                               * per epoch (60 = min_duration) */
         pos_gain_p: Dec::new(1, 1).expect("This can't fail"),
         pos_gain_d: Dec::new(1, 1).expect("This can't fail"),
         staked_ratio: Dec::zero(),
@@ -1100,6 +1111,9 @@ pub fn genesis(num_validators: u64) -> Genesis {
                 .into_iter()
                 .map(|(k, v)| (k, token::Amount::from_uint(v, denom).unwrap()))
                 .collect(),
+            parameters: token::Parameters::default(),
+            last_inflation: token::Amount::zero(),
+            last_locked_ratio: Dec::zero(),
         })
         .collect();
     Genesis {

apps/src/lib/node/ledger/shell/finalize_block.rs

@@ -3,6 +3,7 @@
 use std::collections::HashMap;
 
 use data_encoding::HEXUPPER;
+use namada::core::ledger::inflation;
 use namada::core::ledger::pgf::ADDRESS as pgf_address;
 use namada::ledger::events::EventType;
 use namada::ledger::gas::{GasMetering, TxGasMeter};
@@ -11,7 +12,7 @@ use namada::ledger::pos::{namada_proof_of_stake, staking_token_address};
 use namada::ledger::storage::EPOCH_SWITCH_BLOCKS_DELAY;
 use namada::ledger::storage_api::token::credit_tokens;
 use namada::ledger::storage_api::{pgf, StorageRead, StorageWrite};
-use namada::ledger::{inflation, protocol, replay_protection};
+use namada::ledger::{protocol, replay_protection};
 use namada::proof_of_stake::{
     delegator_rewards_products_handle, find_validator_by_raw_hash,
     read_last_block_proposer_address, read_pos_params, read_total_stake,
@@ -617,10 +618,8 @@ where
     /// with respect to the previous epoch.
     fn apply_inflation(&mut self, current_epoch: Epoch) -> Result<()> {
         let last_epoch = current_epoch.prev();
-        // Get input values needed for the PD controller for PoS and MASP.
+        // Get input values needed for the PD controller for PoS.
         // Run the PD controllers to calculate new rates.
-        //
-        // MASP is included below just for some completeness.
 
         let params = read_pos_params(&self.wl_storage)?;
 
@@ -652,19 +651,11 @@ where
         let pos_locked_ratio_target = params.target_staked_ratio;
         let pos_max_inflation_rate = params.max_inflation_rate;
 
-        // TODO: properly fetch these values (arbitrary for now)
-        let masp_locked_supply: Amount = Amount::default();
-        let masp_locked_ratio_target = Dec::new(5, 1).expect("Cannot fail");
-        let masp_locked_ratio_last = Dec::new(5, 1).expect("Cannot fail");
-        let masp_max_inflation_rate = Dec::new(2, 1).expect("Cannot fail");
-        let masp_last_inflation_rate = Dec::new(12, 2).expect("Cannot fail");
-        let masp_p_gain = Dec::new(1, 1).expect("Cannot fail");
-        let masp_d_gain = Dec::new(1, 1).expect("Cannot fail");
-
         // Run rewards PD controller
         let pos_controller = inflation::RewardsController {
             locked_tokens: pos_locked_supply,
             total_tokens,
+            total_native_tokens: total_tokens,
             locked_ratio_target: pos_locked_ratio_target,
             locked_ratio_last: pos_last_staked_ratio,
             max_reward_rate: pos_max_inflation_rate,
@@ -673,26 +664,12 @@ where
             d_gain_nom: pos_d_gain_nom,
             epochs_per_year,
         };
-        let _masp_controller = inflation::RewardsController {
-            locked_tokens: masp_locked_supply,
-            total_tokens,
-            locked_ratio_target: masp_locked_ratio_target,
-            locked_ratio_last: masp_locked_ratio_last,
-            max_reward_rate: masp_max_inflation_rate,
-            last_inflation_amount: token::Amount::from(
-                masp_last_inflation_rate,
-            ),
-            p_gain_nom: masp_p_gain,
-            d_gain_nom: masp_d_gain,
-            epochs_per_year,
-        };
 
         // Run the rewards controllers
         let inflation::ValsToUpdate {
             locked_ratio,
             inflation,
         } = pos_controller.run();
-        // let new_masp_vals = _masp_controller.run();
 
         // Get the number of blocks in the last epoch
         let first_block_of_last_epoch = self

apps/src/lib/node/ledger/shell/init_chain.rs

@@ -330,14 +330,41 @@ where
             address,
             denom,
             balances,
+            parameters,
+            last_inflation,
+            last_locked_ratio,
         } in accounts
         {
+            // Init token parameters and last inflation and caching rates
+            parameters.init_storage(&address, &mut self.wl_storage);
+            self.wl_storage
+                .write(
+                    &token::masp_last_inflation_key(&address),
+                    last_inflation,
+                )
+                .unwrap();
+            self.wl_storage
+                .write(
+                    &token::masp_last_locked_ratio_key(&address),
+                    last_locked_ratio,
+                )
+                .unwrap();
             // associate a token with its denomination.
             write_denom(&mut self.wl_storage, &address, denom).unwrap();
+
+            let mut total_balance_for_token = token::Amount::default();
             for (owner, amount) in balances {
+                total_balance_for_token += amount;
                 credit_tokens(&mut self.wl_storage, &address, &owner, amount)
                     .unwrap();
             }
+            // Write the total amount of tokens for the ratio
+            self.wl_storage
+                .write(
+                    &token::minted_balance_key(&address),
+                    total_balance_for_token,
+                )
+                .unwrap();
         }
     }
 

apps/src/lib/node/ledger/shell/mod.rs

@@ -1980,6 +1980,7 @@ mod test_utils {
 
     /// We test that on shell shutdown, the tx queue gets persisted in a DB, and
     /// on startup it is read successfully
+    #[cfg(feature = "testing")]
     #[test]
     fn test_tx_queue_persistence() {
         let base_dir = tempdir().unwrap().as_ref().canonicalize().unwrap();
@@ -2017,6 +2018,7 @@ mod test_utils {
             .storage
             .begin_block(BlockHash::default(), BlockHeight(1))
             .expect("begin_block failed");
+        token::testing::init_token_storage(&mut shell.wl_storage, 60);
         let keypair = gen_keypair();
         // enqueue a wrapper tx
         let mut wrapper =

apps/src/lib/node/ledger/storage/mod.rs

@@ -118,6 +118,7 @@ mod tests {
         assert_eq!(result, None);
     }
 
+    #[cfg(feature = "testing")]
     #[test]
     fn test_commit_block() {
         let db_path =
@@ -144,6 +145,7 @@ mod tests {
         storage.block.pred_epochs.new_epoch(BlockHeight(100));
         // make wl_storage to update conversion for a new epoch
         let mut wl_storage = WlStorage::new(WriteLog::default(), storage);
+        namada::types::token::testing::init_token_storage(&mut wl_storage, 60);
         update_allowed_conversions(&mut wl_storage)
             .expect("update conversions failed");
         wl_storage.commit_block().expect("commit failed");

shared/src/ledger/inflation.rs → core/src/ledger/inflation.rs

@@ -2,8 +2,7 @@
 //! proof-of-stake, providing liquity to shielded asset pools, and public goods
 //! funding.
 
-use namada_core::types::dec::Dec;
-
+use crate::types::dec::Dec;
 use crate::types::token;
 
 /// The domains of inflation
@@ -30,6 +29,8 @@ pub struct RewardsController {
     pub locked_tokens: token::Amount,
     /// Total token supply
     pub total_tokens: token::Amount,
+    /// Total native token supply
+    pub total_native_tokens: token::Amount,
     /// PD target locked ratio
     pub locked_ratio_target: Dec,
     /// PD last locked ratio
@@ -52,6 +53,7 @@ impl RewardsController {
         let Self {
             locked_tokens,
             total_tokens,
+            total_native_tokens,
             locked_ratio_target,
             locked_ratio_last,
             max_reward_rate,
@@ -67,10 +69,12 @@ impl RewardsController {
             .expect("Should not fail to convert token Amount to Dec");
         let total = Dec::try_from(total_tokens.raw_amount())
             .expect("Should not fail to convert token Amount to Dec");
+        let total_native = Dec::try_from(total_native_tokens.raw_amount())
+            .expect("Should not fail to convert token Amount to Dec");
         let epochs_py: Dec = epochs_per_year.into();
 
         let locked_ratio = locked / total;
-        let max_inflation = total * max_reward_rate / epochs_py;
+        let max_inflation = total_native * max_reward_rate / epochs_py;
         let p_gain = p_gain_nom * max_inflation;
         let d_gain = d_gain_nom * max_inflation;
 
@@ -114,9 +118,8 @@ impl RewardsController {
 mod test {
     use std::str::FromStr;
 
-    use namada_core::types::token::NATIVE_MAX_DECIMAL_PLACES;
-
     use super::*;
+    use crate::types::token::NATIVE_MAX_DECIMAL_PLACES;
 
     #[test]
     fn test_inflation_calc_up() {
@@ -131,6 +134,11 @@ mod test {
                 NATIVE_MAX_DECIMAL_PLACES,
             )
             .unwrap(),
+            total_native_tokens: token::Amount::from_uint(
+                4_000,
+                NATIVE_MAX_DECIMAL_PLACES,
+            )
+            .unwrap(),
             locked_ratio_target: Dec::from_str("0.66666666").unwrap(),
             locked_ratio_last: Dec::from_str("0.5").unwrap(),
             max_reward_rate: Dec::from_str("0.1").unwrap(),
@@ -202,6 +210,11 @@ mod test {
                 NATIVE_MAX_DECIMAL_PLACES,
             )
             .unwrap(),
+            total_native_tokens: token::Amount::from_uint(
+                1_000,
+                NATIVE_MAX_DECIMAL_PLACES,
+            )
+            .unwrap(),
             locked_ratio_target: Dec::from_str("0.66666666").unwrap(),
             locked_ratio_last: Dec::from_str("0.9").unwrap(),
             max_reward_rate: Dec::from_str("0.1").unwrap(),

core/src/ledger/mod.rs

@@ -5,6 +5,7 @@ pub mod gas;
 pub mod governance;
 #[cfg(any(feature = "abciplus", feature = "abcipp"))]
 pub mod ibc;
+pub mod inflation;
 pub mod parameters;
 pub mod pgf;
 pub mod replay_protection;