Merge pull request #884 from interlay/fix/no-rewards-when-not-accepting-issues

fix: set stake in reward pool to 0 when vault is not accepting new issues

Author: gregdhill

crates/vault-registry/src/lib.rs

@@ -240,6 +240,7 @@ pub mod pallet {
             let vault_id = VaultId::new(account_id, currency_pair.collateral, currency_pair.wrapped);
             let mut vault = Self::get_active_rich_vault_from_id(&vault_id)?;
             vault.set_accept_new_issues(accept_new_issues)?;
+            PoolManager::<T>::on_vault_settings_change(&vault_id)?;
             Ok(().into())
         }
 
@@ -262,7 +263,7 @@ pub mod pallet {
             let account_id = ensure_signed(origin)?;
             let vault_id = VaultId::new(account_id, currency_pair.collateral, currency_pair.wrapped);
             Self::try_set_vault_custom_secure_threshold(&vault_id, custom_threshold)?;
-            PoolManager::<T>::on_set_secure_collateral_threshold(&vault_id)?;
+            PoolManager::<T>::on_vault_settings_change(&vault_id)?;
             Ok(().into())
         }
 
@@ -1932,11 +1933,15 @@ impl<T: Config> Pallet<T> {
             assert!(reserved.ge(&backing_collateral).unwrap());
 
             let rich_vault: RichVault<T> = vault.clone().into();
-            let expected_stake = rich_vault
-                .get_total_collateral()
-                .unwrap()
-                .checked_div(&rich_vault.get_secure_threshold().unwrap())
-                .unwrap();
+            let expected_stake = if !vault.accepts_new_issues() {
+                Amount::zero(vault_id.collateral_currency())
+            } else {
+                rich_vault
+                    .get_total_collateral()
+                    .unwrap()
+                    .checked_div(&rich_vault.get_secure_threshold().unwrap())
+                    .unwrap()
+            };
 
             assert_eq!(ext::reward::get_stake::<T>(&vault_id).unwrap(), expected_stake.amount());
         }

crates/vault-registry/src/pool_manager.rs

@@ -47,18 +47,26 @@ impl<T: Config> PoolManager<T> {
         Ok(ret)
     }
 
-    // hook to be called _after_ the value has been written
-    pub fn on_set_secure_collateral_threshold(vault_id: &DefaultVaultId<T>) -> Result<(), DispatchError> {
+    // hook to be called _after_ one of the vault parameters that influences
+    // capacity has been written. This is called when the custom secure threshold or
+    // the accept_new_issues setting changes.
+    pub fn on_vault_settings_change(vault_id: &DefaultVaultId<T>) -> Result<(), DispatchError> {
         ext::fee::distribute_all_vault_rewards::<T>(vault_id)?;
         Self::update_reward_stake(vault_id)
     }
 
     // NOTE: temporarily public for reward migration
     pub(crate) fn update_reward_stake(vault_id: &DefaultVaultId<T>) -> Result<(), DispatchError> {
-        let total_collateral = ext::staking::total_current_stake::<T>(vault_id)?;
-        let secure_threshold = Pallet::<T>::get_vault_secure_threshold(vault_id)?;
-
-        let new_reward_stake = total_collateral.checked_div(&secure_threshold)?;
+        let vault = Pallet::<T>::get_vault_from_id(vault_id)?;
+        let new_reward_stake = if !vault.accepts_new_issues() {
+            // if the vault is not accepting new issues it's not getting rewards
+            Amount::zero(vault_id.collateral_currency())
+        } else {
+            let total_collateral = ext::staking::total_current_stake::<T>(vault_id)?;
+            let secure_threshold = Pallet::<T>::get_vault_secure_threshold(vault_id)?;
+
+            total_collateral.checked_div(&secure_threshold)?
+        };
 
         ext::reward::set_stake(vault_id, &new_reward_stake)?;
 

crates/vault-registry/src/types.rs

@@ -217,6 +217,10 @@ impl<
     pub fn is_liquidated(&self) -> bool {
         matches!(self.status, VaultStatus::Liquidated)
     }
+
+    pub fn accepts_new_issues(&self) -> bool {
+        matches!(self.status, VaultStatus::Active(true))
+    }
 }
 
 pub type DefaultVault<T> = Vault<

standalone/runtime/tests/mock/reward_testing_utils.rs

@@ -8,6 +8,7 @@ pub type StakeId = (VaultId, AccountId);
 pub struct IdealRewardPool {
     exchange_rate: BTreeMap<CurrencyId, FixedU128>,
     secure_threshold: BTreeMap<VaultId, FixedU128>,
+    accept_new_issues: BTreeMap<VaultId, bool>,
     commission: BTreeMap<VaultId, FixedU128>,
     collateral: BTreeMap<StakeId, u128>,
     rewards: BTreeMap<AccountId, (FixedU128, FixedU128)>,
@@ -72,6 +73,10 @@ impl IdealRewardPool {
             .map(|(stake_id, _)| self.stake(stake_id))
             .fold(Zero::zero(), |x: FixedU128, y: FixedU128| x + y);
 
+        if total_stake.is_zero() {
+            return self;
+        }
+
         for (stake_id, _) in self.collateral.iter() {
             let stake = self.stake(stake_id);
             let reward = (stake * reward) / total_stake;
@@ -95,6 +100,12 @@ impl IdealRewardPool {
         self
     }
 
+    pub fn accept_new_issues(&mut self, vault: &VaultId, accept_new_issues: bool) -> &mut Self {
+        log::debug!("accept_new_issues {:?}", accept_new_issues);
+        self.accept_new_issues.insert(vault.clone(), accept_new_issues);
+        self
+    }
+
     pub fn get_total_reward_for(&self, account: &crate::AccountId) -> u128 {
         self.rewards
             .get(account)
@@ -132,9 +143,13 @@ impl IdealRewardPool {
 
     pub fn stake(&self, (vault_id, nominator_id): &StakeId) -> FixedU128 {
         let currency_id = vault_id.collateral_currency();
-        let threshold = self.secure_threshold[vault_id];
-        let exchange_rate = self.exchange_rate[&currency_id];
-        let collateral = self.collateral[&(vault_id.clone(), nominator_id.clone())];
-        FixedU128::from(collateral) / threshold / exchange_rate
+        if !self.accept_new_issues.get(vault_id).unwrap_or(&true) {
+            Zero::zero()
+        } else {
+            let threshold = self.secure_threshold[vault_id];
+            let exchange_rate = self.exchange_rate[&currency_id];
+            let collateral = self.collateral[&(vault_id.clone(), nominator_id.clone())];
+            FixedU128::from(collateral) / threshold / exchange_rate
+        }
     }
 }

standalone/runtime/tests/test_fee_pool.rs

@@ -413,18 +413,20 @@ enum Action {
     SetSecureThreshold,
     DistributeRewards,
     SetExchangeRate,
+    SetAcceptIssues,
 }
 
 impl Action {
     fn random<R: Rng + ?Sized>(rng: &mut R) -> Action {
-        match rng.gen_range(0..7) {
+        match rng.gen_range(0..8) {
             0 => Self::DepositNominationCollateral,
             1 => Self::WithdrawNominationCollateral,
             2 => Self::DepositVaultCollateral,
             3 => Self::WithdrawVaultCollateral,
             4 => Self::SetSecureThreshold,
             5 => Self::DistributeRewards,
             6 => Self::SetExchangeRate,
+            7 => Self::SetAcceptIssues,
             _ => unreachable!(),
         }
     }
@@ -645,6 +647,16 @@ fn do_random_nomination_sequence() {
                     distribute_rewards(Amount::new(amount, REWARD_CURRENCY));
                     reference_pool.distribute_reward(amount);
                 }
+                Action::SetAcceptIssues => {
+                    let vault_id = vaults[rng.gen_range(0..vaults.len())].clone();
+                    let accept_new_issues = rng.gen_bool(0.5);
+                    assert_ok!(RuntimeCall::VaultRegistry(VaultRegistryCall::accept_new_issues {
+                        currency_pair: vault_id.currencies.clone(),
+                        accept_new_issues,
+                    })
+                    .dispatch(origin_of(vault_id.account_id.clone())));
+                    reference_pool.accept_new_issues(&vault_id, accept_new_issues);
+                }
             };
         }
         for ((vault_id, nominator_id), _) in reference_pool.nominations() {