update exchange rate formula & default reserve factor (#1337)

* update exchange rate formula & default reserve factor

Signed-off-by: Cheng JIANG <[email protected]>

* remove dbg point

Signed-off-by: Cheng JIANG <[email protected]>

* simplify

Signed-off-by: Cheng JIANG <[email protected]>

Author: 0x8f701

node/parallel/src/chain_spec/heiko.rs

@@ -260,7 +260,7 @@ fn heiko_genesis(
         parachain_info: ParachainInfoConfig { parachain_id: id },
         liquid_staking: LiquidStakingConfig {
             exchange_rate: Rate::saturating_from_rational(100_u32, 100_u32), // 1
-            reserve_factor: Zero::zero(),
+            reserve_factor: Ratio::from_rational(125u32, 1000_000u32),
         },
         democracy: DemocracyConfig::default(),
         general_council: GeneralCouncilConfig::default(),

node/parallel/src/chain_spec/parallel.rs

@@ -272,7 +272,7 @@ fn parallel_genesis(
         parachain_info: ParachainInfoConfig { parachain_id: id },
         liquid_staking: LiquidStakingConfig {
             exchange_rate: Rate::saturating_from_rational(100_u32, 100_u32), // 1
-            reserve_factor: Zero::zero(),
+            reserve_factor: Ratio::from_rational(5u32, 10_000u32),
         },
         democracy: DemocracyConfig::default(),
         general_council: GeneralCouncilConfig::default(),

node/parallel/src/chain_spec/vanilla.rs

@@ -305,7 +305,7 @@ fn vanilla_genesis(
         parachain_info: ParachainInfoConfig { parachain_id: id },
         liquid_staking: LiquidStakingConfig {
             exchange_rate: Rate::saturating_from_rational(100u32, 100u32), // 1
-            reserve_factor: Zero::zero(),
+            reserve_factor: Ratio::from_rational(125u32, 1000_000u32),
         },
         democracy: DemocracyConfig::default(),
         general_council: GeneralCouncilConfig::default(),

pallets/liquid-staking/src/lib.rs

@@ -363,21 +363,21 @@ pub mod pallet {
                 Error::<T>::UnstakeTooSmall
             );
 
-            let asset_amount =
+            let staking_amount =
                 Self::liquid_to_staking(liquid_amount).ok_or(Error::<T>::InvalidExchangeRate)?;
 
             let target_blocknumber = T::RelayChainBlockNumberProvider::current_block_number()
                 .checked_add(&T::BondingDuration::get())
                 .ok_or(ArithmeticError::Overflow)?;
-            Self::do_push_back(&who, asset_amount, target_blocknumber)?;
+            Self::do_push_back(&who, staking_amount, target_blocknumber)?;
 
             T::Assets::burn_from(Self::liquid_currency()?, &who, liquid_amount)?;
 
             MatchingPool::<T>::try_mutate(|p| -> DispatchResult {
-                p.update_total_unstake_amount(liquid_amount, ArithmeticKind::Addition)
+                p.update_total_unstake_amount(staking_amount, ArithmeticKind::Addition)
             })?;
 
-            Self::deposit_event(Event::<T>::Unstaked(who, liquid_amount, asset_amount));
+            Self::deposit_event(Event::<T>::Unstaked(who, liquid_amount, staking_amount));
             Ok(().into())
         }
 
@@ -434,7 +434,7 @@ pub mod pallet {
 
             let old_matching_ledger = Self::matching_pool();
             let (bond_amount, rebond_amount, unbond_amount) =
-                MatchingPool::<T>::try_mutate(|b| b.matching::<Self>(unbonding_amount))?;
+                MatchingPool::<T>::try_mutate(|b| b.matching(unbonding_amount))?;
 
             if bonding_amount.is_zero() && unbonding_amount.is_zero() {
                 Self::do_bond(bond_amount, RewardDestination::Staked)?;
@@ -667,10 +667,7 @@ pub mod pallet {
                 Self::notify_placeholder(),
             )?;
 
-            let liquid_amount =
-                Self::staking_to_liquid(amount).ok_or(Error::<T>::InvalidExchangeRate)?;
-
-            XcmRequests::<T>::insert(query_id, XcmRequest::Unbond { liquid_amount });
+            XcmRequests::<T>::insert(query_id, XcmRequest::Unbond { amount });
 
             Self::deposit_event(Event::<T>::Unbonding(amount));
 
@@ -682,14 +679,18 @@ pub mod pallet {
             if amount.is_zero() {
                 return Ok(());
             }
+
             let query_id = T::XCM::do_rebond(
                 amount,
                 Self::staking_currency()?,
                 T::DerivativeIndex::get(),
                 Self::notify_placeholder(),
             )?;
+
             XcmRequests::<T>::insert(query_id, XcmRequest::Rebond { amount });
+
             Self::deposit_event(Event::<T>::Rebonding(amount));
+
             Ok(())
         }
 
@@ -739,25 +740,26 @@ pub mod pallet {
             res: Option<(u32, XcmError)>,
         ) -> DispatchResult {
             let executed = res.is_none();
+            use XcmRequest::*;
 
             match request {
-                XcmRequest::Bond { amount, .. } | XcmRequest::BondExtra { amount } if executed => {
+                Bond { amount, .. } | BondExtra { amount } if executed => {
                     MatchingPool::<T>::try_mutate(|p| -> DispatchResult {
                         p.update_total_stake_amount(amount, ArithmeticKind::Subtraction)
                     })?;
                     T::Assets::burn_from(Self::staking_currency()?, &Self::account_id(), amount)?;
                 }
-                XcmRequest::Unbond { liquid_amount } if executed => {
+                Unbond { amount } if executed => {
                     MatchingPool::<T>::try_mutate(|p| -> DispatchResult {
-                        p.update_total_unstake_amount(liquid_amount, ArithmeticKind::Subtraction)
+                        p.update_total_unstake_amount(amount, ArithmeticKind::Subtraction)
                     })?;
                 }
-                XcmRequest::Rebond { amount } if executed => {
+                Rebond { amount } if executed => {
                     MatchingPool::<T>::try_mutate(|p| -> DispatchResult {
                         p.update_total_stake_amount(amount, ArithmeticKind::Subtraction)
                     })?;
                 }
-                XcmRequest::WithdrawUnbonded {
+                WithdrawUnbonded {
                     num_slashing_spans: _,
                     amount,
                 } if executed => {
@@ -769,6 +771,7 @@ pub mod pallet {
             if executed {
                 XcmRequests::<T>::remove(&query_id);
             }
+
             Ok(())
         }
 
@@ -780,10 +783,9 @@ pub mod pallet {
             match Rate::checked_from_rational(
                 bonding_amount
                     .checked_add(old_matching_ledger.total_stake_amount)
+                    .and_then(|r| r.checked_sub(old_matching_ledger.total_unstake_amount))
                     .ok_or(ArithmeticError::Overflow)?,
-                T::Assets::total_issuance(Self::liquid_currency()?)
-                    .checked_add(old_matching_ledger.total_unstake_amount)
-                    .ok_or(ArithmeticError::Overflow)?,
+                T::Assets::total_issuance(Self::liquid_currency()?),
             ) {
                 Some(exchange_rate) if exchange_rate != Self::exchange_rate() => {
                     ExchangeRate::<T>::put(exchange_rate);

pallets/liquid-staking/src/tests.rs

@@ -77,30 +77,33 @@ fn test_settlement_should_work() {
     use StakeOp::*;
     TestNet::reset();
     ParaA::execute_with(|| {
-        let test_case: Vec<(Vec<StakeOp>, Balance, (Balance, Balance, Balance))> = vec![
+        let test_case: Vec<(Vec<StakeOp>, Balance, Balance, (Balance, Balance, Balance))> = vec![
             (
                 vec![Stake(ksm(5000f64)), Unstake(ksm(1000f64))],
                 0,
+                0,
                 (ksm(3975f64), 0, 0),
             ),
             // Calculate right here.
             (
                 vec![Unstake(ksm(10f64)), Unstake(ksm(5f64)), Stake(ksm(10f64))],
+                ksm(3975f64),
                 0,
                 (0, 0, ksm(5.05f64)),
             ),
-            (vec![], 0, (0, 0, 0)),
+            // (vec![], 0, (0, 0, 0)),
         ];
-        for (i, (stake_ops, unbonding_amount, matching_result)) in test_case.into_iter().enumerate()
+        for (i, (stake_ops, bonding_amount, unbonding_amount, matching_result)) in
+            test_case.into_iter().enumerate()
         {
             stake_ops.into_iter().for_each(StakeOp::execute);
             assert_eq!(
-                LiquidStaking::matching_pool().matching::<LiquidStaking>(unbonding_amount),
+                LiquidStaking::matching_pool().matching(unbonding_amount),
                 Ok(matching_result)
             );
             assert_ok!(LiquidStaking::settlement(
                 Origin::signed(ALICE),
-                ksm(0f64),
+                bonding_amount,
                 unbonding_amount,
             ));
             LiquidStaking::notification_received(

pallets/liquid-staking/src/types.rs

@@ -2,7 +2,7 @@ use codec::{Decode, Encode};
 
 use super::{BalanceOf, Config};
 use frame_support::{dispatch::DispatchResult, traits::tokens::Balance as BalanceT};
-use primitives::{ArithmeticKind, LiquidStakingConvert};
+use primitives::ArithmeticKind;
 use scale_info::TypeInfo;
 use sp_runtime::{traits::Zero, ArithmeticError, DispatchError, FixedPointOperand, RuntimeDebug};
 use sp_std::{cmp::Ordering, result::Result, vec::Vec};
@@ -22,26 +22,23 @@ impl<Balance: BalanceT + FixedPointOperand> MatchingLedger<Balance> {
     /// `unbonding_amount` is the total amount of the unbonding asset on the relaychain.
     ///
     /// the returned tri-tuple is formed as `(bond_amount, rebond_amount, unbond_amount)`.
-    pub fn matching<T: LiquidStakingConvert<Balance>>(
+    pub fn matching(
         &mut self,
         unbonding_amount: Balance,
     ) -> Result<(Balance, Balance, Balance), DispatchError> {
         use Ordering::*;
 
-        let unstake_asset_amout =
-            T::liquid_to_staking(self.total_unstake_amount).ok_or(ArithmeticError::Overflow)?;
-
         let (bond_amount, rebond_amount, unbond_amount) = if matches!(
-            self.total_stake_amount.cmp(&unstake_asset_amout),
+            self.total_stake_amount.cmp(&self.total_unstake_amount),
             Less | Equal
         ) {
             (
                 Zero::zero(),
                 Zero::zero(),
-                unstake_asset_amout - self.total_stake_amount,
+                self.total_unstake_amount - self.total_stake_amount,
             )
         } else {
-            let amount = self.total_stake_amount - unstake_asset_amout;
+            let amount = self.total_stake_amount - self.total_unstake_amount;
             if amount < unbonding_amount {
                 (Zero::zero(), amount, Zero::zero())
             } else {
@@ -52,12 +49,7 @@ impl<Balance: BalanceT + FixedPointOperand> MatchingLedger<Balance> {
         self.total_stake_amount = bond_amount
             .checked_add(&rebond_amount)
             .ok_or(ArithmeticError::Overflow)?;
-        if unbond_amount.is_zero() {
-            self.total_unstake_amount = Zero::zero();
-        } else {
-            self.total_unstake_amount =
-                T::staking_to_liquid(unbond_amount).ok_or(ArithmeticError::Overflow)?;
-        }
+        self.total_unstake_amount = unbond_amount;
 
         Ok((bond_amount, rebond_amount, unbond_amount))
     }
@@ -117,7 +109,7 @@ pub enum XcmRequest<T: Config> {
         amount: BalanceOf<T>,
     },
     Unbond {
-        liquid_amount: BalanceOf<T>,
+        amount: BalanceOf<T>,
     },
     Rebond {
         amount: BalanceOf<T>,