extend pallet ghost-networks and create BridgedInflationCurve

Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>

pallets/networks/src/lib.rs

@@ -4,15 +4,17 @@
 
 use frame_support::{
     pallet_prelude::*,
-    storage::PrefixIterator, traits::EnsureOrigin,
+    storage::PrefixIterator, traits::{tokens::fungible::Inspect, EnsureOrigin},
 };
 use frame_system::pallet_prelude::*;
 use scale_info::TypeInfo;
 use sp_runtime::{
-    traits::{AtLeast32BitUnsigned, Member},
+    traits::{CheckedSub, CheckedAdd, AtLeast32BitUnsigned, Member},
+    curve::PiecewiseLinear,
     DispatchResult,
 };
 use sp_std::prelude::*;
+use sp_std::convert::TryInto;
 
 pub use ghost_traits::networks::{
     NetworkDataBasicHandler, NetworkDataInspectHandler, 
@@ -31,6 +33,10 @@ mod mock;
 #[cfg(all(feature = "std", test))]
 mod tests;
 
+pub type BalanceOf<T> = <<T as Config>::Currency as Inspect<
+    <T as frame_system::Config>::AccountId,
+>>::Balance;
+
 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub enum NetworkType {
     Evm = 0,
@@ -55,6 +61,48 @@ pub struct NetworkData {
     pub outgoing_fee: u32,
 }
 
+#[derive(Default, Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct BridgeAdjustment<Balance> {
+    bridged_out: Balance,
+    bridged_in: Balance,
+}
+
+pub struct BridgedInflationCurve<RewardCurve, T>(core::marker::PhantomData<(RewardCurve, T)>);
+impl<Balance, RewardCurve, T> pallet_staking::EraPayout<Balance> for BridgedInflationCurve<RewardCurve, T>
+where
+    Balance: Default + AtLeast32BitUnsigned + Clone + Copy + From<u128>,
+    RewardCurve: Get<&'static PiecewiseLinear<'static>>,
+    T: Config,
+{
+    fn era_payout(
+        total_staked: Balance,
+        total_issuance: Balance,
+        _era_duration_in_millis: u64,
+    ) -> (Balance, Balance) {
+        let piecewise_linear = RewardCurve::get();
+        let bridge_adjustment = BridgedImbalance::<T>::get();
+        let accumulated_commission = AccumulatedCommission::<T>::get();
+
+        let bridged_out: u128 = bridge_adjustment.bridged_out.try_into().unwrap_or_default();
+        let bridged_in: u128 = bridge_adjustment.bridged_in.try_into().unwrap_or_default();
+        let accumulated_commission: u128 = accumulated_commission.try_into().unwrap_or_default();
+
+        let accumulated_balance = Balance::from(accumulated_commission);
+        let adjusted_issuance = match bridged_out > bridged_in {
+            true => total_issuance.saturating_add(Balance::from(bridged_out - bridged_in)),
+            false => total_issuance.saturating_sub(Balance::from(bridged_in - bridged_out)),
+        };
+
+        match piecewise_linear
+            .calculate_for_fraction_times_denominator(total_staked, adjusted_issuance)
+            .checked_mul(&accumulated_balance)
+            .and_then(|product| product.checked_div(&adjusted_issuance)) {
+                Some(payout) => (payout, accumulated_balance.saturating_sub(payout)),
+                None => (Balance::default(), Balance::default()),
+            }
+    }
+}
+
 #[frame_support::pallet]
 pub mod module {
     use super::*;
@@ -63,6 +111,9 @@ pub mod module {
     pub trait Config: frame_system::Config {
         type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
+        /// The type used for the internal balance storage.
+        type Currency: Inspect<Self::AccountId>;
+
         /// The type used as a unique network id.
         type NetworkId: Parameter
             + Member
@@ -114,11 +165,31 @@ pub mod module {
         NetworkRemoved { chain_id: T::NetworkId },
     }
 
+    #[pallet::storage]
+    #[pallet::getter(fn bridged_imbalance)]
+    pub type BridgedImbalance<T: Config> =
+        StorageValue<_, BridgeAdjustment<BalanceOf<T>>, ValueQuery>;
+
+    #[pallet::storage]
+    #[pallet::getter(fn accumulated_commission)]
+    pub type AccumulatedCommission<T: Config> =
+        StorageValue<_, BalanceOf<T>, ValueQuery>;
+
     #[pallet::storage]
     #[pallet::getter(fn networks)]
     pub type Networks<T: Config> =
         StorageMap<_, Twox64Concat, T::NetworkId, NetworkData, OptionQuery>;
 
+    #[pallet::storage]
+    #[pallet::getter(fn gatekeeper_amount)]
+    pub type GatekeeperAmount<T: Config> = StorageMap<
+        _,
+        Twox64Concat,
+        T::NetworkId,
+        BalanceOf<T>,
+        ValueQuery,
+    >;
+
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config> {
         pub networks: Vec<(T::NetworkId, Vec<u8>)>,
@@ -527,7 +598,7 @@ impl<T: Config> NetworkDataInspectHandler<NetworkData> for Pallet<T> {
     }
 }
 
-impl<T: Config> NetworkDataMutateHandler<NetworkData> for Pallet<T> {
+impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T> {
     fn register(chain_id: Self::NetworkId, network: NetworkData) -> DispatchResult {
         Self::do_register_network(chain_id, network)
     }
@@ -535,4 +606,74 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData> for Pallet<T> {
     fn remove(chain_id: Self::NetworkId) -> DispatchResult {
         Self::do_remove_network(chain_id)
     }
+
+    fn increase_gatekeeper_amount(
+        network_id: &T::NetworkId,
+        amount: &BalanceOf<T>,
+    ) -> Result<(BalanceOf<T>, BalanceOf<T>), ()> {
+        let new_bridged_in_amount = BridgedImbalance::<T>::mutate(|bridged_imbalance| {
+            match bridged_imbalance.bridged_in.checked_add(amount) {
+                Some(value) => {
+                    (*bridged_imbalance).bridged_in = value;
+                    Ok(value)
+                },
+                None => Err(())
+            }
+        })?;
+
+        let new_gatekeeper_amount = GatekeeperAmount::<T>::mutate(network_id, |gatekeeper_amount| {
+            match gatekeeper_amount.checked_add(amount) {
+                Some(value) => {
+                    *gatekeeper_amount = value;
+                    Ok(value)
+                },
+                None => Err(())
+            }
+        })?;
+
+        Ok((new_gatekeeper_amount, new_bridged_in_amount))
+    }
+
+    fn decrease_gatekeeper_amount(
+        network_id: &T::NetworkId,
+        amount: &BalanceOf<T>,
+    ) -> Result<(BalanceOf<T>, BalanceOf<T>), ()> {
+        let new_gatekeeper_amount = GatekeeperAmount::<T>::mutate(network_id, |gatekeeper_amount| {
+            match gatekeeper_amount.checked_sub(amount) {
+                Some(value) => {
+                    *gatekeeper_amount = value;
+                    Ok(value)
+                },
+                None => Err(())
+            }
+        })?;
+
+        let new_bridged_out_amount = BridgedImbalance::<T>::mutate(|bridged_imbalance| {
+             match bridged_imbalance.bridged_out.checked_add(amount) {
+                 Some(value) => {
+                     (*bridged_imbalance).bridged_out = value;
+                     Ok(value)
+                 },
+                 None => Err(())
+             }
+        })?;
+
+        Ok((new_gatekeeper_amount, new_bridged_out_amount))
+    }
+
+    fn accumulate_commission(commission: &BalanceOf<T>) -> Result<BalanceOf<T>, ()> {
+        AccumulatedCommission::<T>::mutate(|accumulated| {
+            match accumulated.checked_add(commission) {
+                Some(value) => {
+                    *accumulated = value;
+                    Ok(value)
+                },
+                None => Err(()),
+            }
+        })
+    }
+
+    fn nullify_commission() {
+        AccumulatedCommission::<T>::set(Default::default());
+    }
 }