Refine mining asset (paritytech#168)

* Do not need to exclude PCX in OnAssetChanged methods

* Add referral reward split

* Add GatewayInterface in mining/asset

* Test asset mining reward

* Add some docs

Author: liuchengxu

runtime/src/lib.rs

@@ -753,14 +753,23 @@ impl xpallet_mining_staking::Trait for Runtime {
     type SessionDuration = SessionDuration;
     type SessionInterface = Self;
     type TreasuryAccount = SimpleTreasuryAccount;
-    type AssetMining = ();
+    type AssetMining = XMiningAsset;
     type DetermineRewardPotAccount =
         xpallet_mining_staking::SimpleValidatorRewardPotAccountDeterminer<Runtime>;
 }
 
+pub struct DummyReferralGetter;
+impl xpallet_mining_asset::GatewayInterface<AccountId> for DummyReferralGetter {
+    fn referral_of(_who: &AccountId) -> Option<AccountId> {
+        // FIXME impl this in gateway
+        None
+    }
+}
+
 impl xpallet_mining_asset::Trait for Runtime {
     type Event = Event;
     type StakingInterface = Self;
+    type GatewayInterface = DummyReferralGetter;
     type TreasuryAccount = SimpleTreasuryAccount;
     type DetermineRewardPotAccount =
         xpallet_mining_asset::SimpleAssetRewardPotAccountDeterminer<Runtime>;
@@ -1038,10 +1047,9 @@ impl_runtime_apis! {
         }
 
         fn trustee_session_info(chain: Chain) -> Option<GenericTrusteeSessionInfo<AccountId>> {
-            let number = match XGatewayCommon::trustee_session_info_len(chain).checked_sub(1) {
-                Some(r) => r,
-                None => u32::max_value(),
-            };
+            let number = XGatewayCommon::trustee_session_info_len(chain)
+                .checked_sub(1)
+                .unwrap_or_else(u32::max_value);
             XGatewayCommon::trustee_session_info_of(chain, number)
         }
 

xpallets/mining/asset/src/impls.rs

@@ -1,8 +1,7 @@
 use super::*;
 use codec::Encode;
 use sp_core::crypto::UncheckedFrom;
-use sp_runtime::traits::Hash;
-use sp_runtime::traits::Saturating;
+use sp_runtime::traits::{Hash, Saturating};
 use xp_mining_common::{
     generic_weight_factors, BaseMiningWeight, Claim, ComputeMiningWeight, WeightFactors, WeightType,
 };
@@ -76,11 +75,20 @@ impl<T: Trait> ComputeMiningWeight<T::AccountId, T::BlockNumber> for Module<T> {
     }
 }
 
+// ChainX now uses pallet_balances for native coin PCX, therefore we do not
+// have to exclude PCX asset in these OnAssetChanged methods:
+//
+// * `on_issue_pre`
+// * `on_issue_post`
+// * `on_move_pre`
+//
+// ```rust
+// if xpallet_protocol::PCX == *target {
+//     return Ok(());
+// }
+// ```
 impl<T: Trait> xpallet_assets::OnAssetChanged<T::AccountId, BalanceOf<T>> for Module<T> {
     fn on_issue_pre(target: &AssetId, source: &T::AccountId) {
-        if xpallet_protocol::PCX == *target {
-            return;
-        }
         let current_block = <frame_system::Module<T>>::block_number();
         Self::init_receiver_mining_ledger(source, target, current_block);
 
@@ -92,9 +100,6 @@ impl<T: Trait> xpallet_assets::OnAssetChanged<T::AccountId, BalanceOf<T>> for Mo
         source: &T::AccountId,
         _value: BalanceOf<T>,
     ) -> DispatchResult {
-        if xpallet_protocol::PCX == *target {
-            return Ok(());
-        }
         Self::issue_deposit_reward(source, target)
     }
 
@@ -106,9 +111,10 @@ impl<T: Trait> xpallet_assets::OnAssetChanged<T::AccountId, BalanceOf<T>> for Mo
         _: AssetType,
         _: BalanceOf<T>,
     ) {
-        if xpallet_protocol::PCX == *asset_id || from == to {
+        if from == to {
             return;
         }
+
         let current_block = <frame_system::Module<T>>::block_number();
         Self::init_receiver_mining_ledger(to, asset_id, current_block);
 
@@ -123,15 +129,32 @@ impl<T: Trait> xpallet_assets::OnAssetChanged<T::AccountId, BalanceOf<T>> for Mo
 }
 
 impl<T: Trait> Module<T> {
+    /// Allocates the dividend to claimer and referral(treasury) accordingly.
+    ///
+    /// Each asset miner can have a referral, which splits the 10% of
+    /// of total asset mining dividend. The 10% split will be transferred
+    /// to the treasury account if the claimer does not have a referral.
+    ///
+    /// total_asset_miner_dividend
+    ///   ├──> referral(treasury) 10%
+    ///   └──> claimer            90%
     fn allocate_dividend(
+        claimee_reward_pot: &T::AccountId,
         claimer: &T::AccountId,
-        _claimee: &AssetId,
-        _claimee_reward_pot: &T::AccountId,
         dividend: BalanceOf<T>,
     ) -> Result<(), Error<T>> {
-        // todo!("referral_or_treasury 10%, claimer 90%")
-        // FIXME
-        // let _ = xpallet_assets::Module::<T>::pcx_issue(claimer, dividend);
+        let to_referral_or_treasury = dividend / 10.saturated_into();
+        let reward_splitter = T::GatewayInterface::referral_of(claimer)
+            .unwrap_or_else(|| T::TreasuryAccount::treasury_account());
+        Self::transfer(
+            claimee_reward_pot,
+            &reward_splitter,
+            to_referral_or_treasury,
+        )?;
+
+        let to_claimer = dividend - to_referral_or_treasury;
+        Self::transfer(claimee_reward_pot, claimer, to_claimer)?;
+
         Ok(())
     }
 }
@@ -151,8 +174,7 @@ impl<T: Trait> Claim<T::AccountId> for Module<T> {
         Self::passed_enough_interval(claimer, claimee, frequency_limit, current_block)?;
 
         let claimee_reward_pot = T::DetermineRewardPotAccount::reward_pot_account_for(claimee);
-        let reward_pot_balance =
-            <T as xpallet_assets::Trait>::Currency::free_balance(&claimee_reward_pot);
+        let reward_pot_balance = Self::free_balance(&claimee_reward_pot);
 
         let (dividend, source_weight, target_weight) =
             <Self as ComputeMiningWeight<T::AccountId, _>>::compute_dividend(
@@ -164,7 +186,7 @@ impl<T: Trait> Claim<T::AccountId> for Module<T> {
 
         Self::has_enough_staking(claimer, dividend, staking_requirement)?;
 
-        Self::allocate_dividend(claimer, claimee, &claimee_reward_pot, dividend)?;
+        Self::allocate_dividend(&claimee_reward_pot, claimer, dividend)?;
 
         Self::apply_update_miner_mining_weight(claimer, claimee, 0, current_block);
         Self::apply_update_asset_mining_weight(
@@ -177,6 +199,8 @@ impl<T: Trait> Claim<T::AccountId> for Module<T> {
             miner_ledger.last_claim = Some(current_block);
         });
 
+        Self::deposit_event(RawEvent::Claim(claimer.clone(), claimee.clone(), dividend));
+
         Ok(())
     }
 }

xpallets/mining/asset/src/lib.rs

@@ -12,7 +12,7 @@ mod tests;
 
 use frame_support::{
     decl_error, decl_event, decl_module, decl_storage,
-    dispatch::DispatchResult,
+    dispatch::{DispatchError, DispatchResult},
     ensure,
     storage::IterableStorageMap,
     traits::{Currency, ExistenceRequirement},
@@ -42,20 +42,29 @@ pub trait Trait: xpallet_assets::Trait {
     /// The overarching event type.
     type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;
 
-    ///
+    /// Get the staked balances of asset miner.
     type StakingInterface: StakingInterface<Self::AccountId, u128>;
 
-    ///
+    /// Get the possible referral of asset miner.
+    type GatewayInterface: GatewayInterface<Self::AccountId>;
+
+    /// Get the treasury account.
     type TreasuryAccount: TreasuryAccount<Self::AccountId>;
 
-    ///
+    /// Generate the reward pot account for mining asset.
     type DetermineRewardPotAccount: RewardPotAccountFor<Self::AccountId, AssetId>;
 }
 
 pub trait StakingInterface<AccountId, Balance> {
     fn staked_of(who: &AccountId) -> Balance;
 }
 
+impl<AccountId, Balance: Default> StakingInterface<AccountId, Balance> for () {
+    fn staked_of(_: &AccountId) -> Balance {
+        Default::default()
+    }
+}
+
 impl<T: Trait> StakingInterface<<T as frame_system::Trait>::AccountId, u128> for T
 where
     T: xpallet_mining_staking::Trait,
@@ -65,23 +74,33 @@ where
     }
 }
 
+pub trait GatewayInterface<AccountId> {
+    fn referral_of(who: &AccountId) -> Option<AccountId>;
+}
+
+impl<AccountId> GatewayInterface<AccountId> for () {
+    fn referral_of(_: &AccountId) -> Option<AccountId> {
+        None
+    }
+}
+
 decl_storage! {
     trait Store for Module<T: Trait> as XMiningAsset {
-        ///
+        /// Possible reward for the new asset owners that does not have native coins yet.
         pub DepositReward get(fn deposit_reward): BalanceOf<T> = 100_000.into();
 
-        ///
+        /// Can not claim if the claimer violates the restriction.
         pub ClaimRestrictionOf get(fn claim_restriction_of):
             map hasher(twox_64_concat) AssetId => ClaimRestriction<T::BlockNumber>;
 
         /// External Assets that have the mining rights.
         pub MiningPrevilegedAssets get(fn mining_previleged_assets): Vec<AssetId>;
 
-        /// Mining weight information of the asset.
+        /// Mining weight information of the mining assets.
         pub AssetLedgers get(fn asset_ledgers):
             map hasher(twox_64_concat) AssetId => AssetLedger<T::BlockNumber>;
 
-        /// The map from nominator to the vote weight ledger of all nominees.
+        /// The map from nominator to the vote weight ledger of all mining assets.
         pub MinerLedgers get(fn miner_ledgers):
             double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) AssetId
             => MinerLedger<T::BlockNumber>;
@@ -113,24 +132,24 @@ decl_event!(
         Balance = BalanceOf<T>,
         <T as frame_system::Trait>::AccountId,
     {
-        ///
-        Claim(AccountId, AccountId, Balance),
+        /// Claimed the asset mining rewards. [claimer, asset_id, amount]
+        Claim(AccountId, AssetId, Balance),
     }
 );
 
 decl_error! {
     /// Error for the staking module.
     pub enum Error for Module<T: Trait> {
         /// The asset does not have the mining rights.
-        UnprevilegedAsset,
+        NotPrevilegedAsset,
         /// Claimer does not have enough Staking locked balance.
         InsufficientStaking,
         /// Claimer just did a claim recently, the next frequency limit is not expired.
         UnexpiredFrequencyLimit,
-        /// Asset error.
-        AssetError,
         /// Zero mining weight.
-        ZeroMiningWeight
+        ZeroMiningWeight,
+        /// Balances error.
+        DispatchError
     }
 }
 
@@ -140,6 +159,12 @@ impl<T: Trait> From<ZeroMiningWeightError> for Error<T> {
     }
 }
 
+impl<T: Trait> From<DispatchError> for Error<T> {
+    fn from(_: DispatchError) -> Self {
+        Self::DispatchError
+    }
+}
+
 decl_module! {
     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
         type Error = Error<T>;
@@ -153,7 +178,7 @@ decl_module! {
 
             ensure!(
                 Self::mining_previleged_assets().contains(&target),
-                Error::<T>::UnprevilegedAsset
+                Error::<T>::NotPrevilegedAsset
             );
 
             <Self as Claim<T::AccountId>>::claim(&sender, &target)?;
@@ -174,6 +199,12 @@ decl_module! {
                 restriction.frequency_limit = new;
             });
         }
+
+        #[weight = 10]
+        fn set_x_asset_power(origin, asset_id: AssetId, new: FixedAssetPower) {
+            ensure_root(origin)?;
+            XTypeAssetPowerMap::insert(asset_id, new);
+        }
     }
 }
 
@@ -183,6 +214,21 @@ impl<T: Trait> Module<T> {
         MinerLedgers::<T>::get(who, asset_id).last_claim
     }
 
+    #[inline]
+    fn free_balance(who: &T::AccountId) -> BalanceOf<T> {
+        <T as xpallet_assets::Trait>::Currency::free_balance(who)
+    }
+
+    #[inline]
+    fn transfer(from: &T::AccountId, to: &T::AccountId, value: BalanceOf<T>) -> DispatchResult {
+        <T as xpallet_assets::Trait>::Currency::transfer(
+            from,
+            to,
+            value,
+            ExistenceRequirement::KeepAlive,
+        )
+    }
+
     /// This rule doesn't take effect if the interval is zero.
     fn passed_enough_interval(
         who: &T::AccountId,
@@ -302,17 +348,14 @@ impl<T: Trait> Module<T> {
         Self::update_asset_mining_weight(target, current_block);
     }
 
+    /// Gives a tiny reward to the depositor in case of it
+    /// does not have enough balances to claim the mining reward.
     fn issue_deposit_reward(depositor: &T::AccountId, target: &AssetId) -> DispatchResult {
         let deposit_reward = Self::deposit_reward();
         let reward_pot = T::DetermineRewardPotAccount::reward_pot_account_for(target);
-        let reward_pot_balance = <T as xpallet_assets::Trait>::Currency::free_balance(&reward_pot);
-        if reward_pot_balance >= deposit_reward {
-            <T as xpallet_assets::Trait>::Currency::transfer(
-                &reward_pot,
-                depositor,
-                deposit_reward,
-                ExistenceRequirement::KeepAlive,
-            )?;
+        let reward_pot_balance = Self::free_balance(&reward_pot);
+        if reward_pot_balance >= deposit_reward && Self::free_balance(depositor) <= deposit_reward {
+            Self::transfer(&reward_pot, depositor, deposit_reward)?;
         } else {
             warn!("asset {}'s reward pot has only {:?}, skipped issuing deposit reward for depositor {:?}", target, reward_pot_balance, depositor);
         }