function to trigger nullification period, tests for the new functionality and expansion of NetworkData trait

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

Cargo.lock

@@ -3648,7 +3648,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-networks"
-version = "0.7.197"
+version = "0.1.4"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3656,6 +3656,8 @@ dependencies = [
  "ghost-core-primitives",
  "ghost-traits",
  "pallet-balances",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
  "parity-scale-codec",
  "scale-info",
  "sp-io 30.0.0",
@@ -3866,7 +3868,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-traits"
-version = "0.3.19"
+version = "0.3.20"
 dependencies = [
  "frame-support",
  "sp-runtime 31.0.1",

pallets/networks/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "ghost-networks"
+version = "0.1.5"
 license.workspace = true
 authors.workspace = true
-version.workspace = true
 edition.workspace = true
 homepage.workspace = true
 repository.workspace = true
@@ -14,36 +14,42 @@ codec = { workspace = true, features = ["max-encoded-len"] }
 frame-benchmarking = { workspace = true, optional = true }
 frame-support = { workspace = true }
 frame-system = { workspace = true }
+pallet-staking = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
 ghost-traits = { workspace = true }
 
 [dev-dependencies]
 primitives = { workspace = true }
-pallet-balances = { workspace = true }
 sp-io = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-staking-reward-curve = { workspace = true }
 
 [features]
 default = ["std"]
 std = [
-	"scale-info/std",
+    "scale-info/std",
-	"codec/std",
+    "codec/std",
-	"frame-support/std",
+    "frame-support/std",
-	"frame-system/std",
+    "frame-system/std",
-	"frame-benchmarking?/std",
+    "frame-benchmarking?/std",
-	"sp-runtime/std",
+    "sp-runtime/std",
-	"sp-std/std",
+    "sp-std/std",
-	"sp-io/std",
+    "sp-io/std",
-	"ghost-traits/std",
+    "ghost-traits/std",
-	"pallet-balances/std",
+    "pallet-staking/std",
+    "pallet-balances/std",
 ]
 runtime-benchmarks = [
-	"frame-benchmarking/runtime-benchmarks",
+    "frame-benchmarking/runtime-benchmarks",
-	"frame-support/runtime-benchmarks",
+    "frame-support/runtime-benchmarks",
-	"frame-system/runtime-benchmarks",
+    "frame-system/runtime-benchmarks",
-	"sp-runtime/runtime-benchmarks",
+    "sp-runtime/runtime-benchmarks",
+    "pallet-staking/runtime-benchmarks",
 ]
 try-runtime = [
-	"frame-support/try-runtime",
+    "frame-support/try-runtime",
-	"frame-system/try-runtime",
+    "frame-system/try-runtime",
+    "pallet-staking/try-runtime",
+    "pallet-balances/try-runtime",
 ]

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::{prelude::*, 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,50 @@ pub struct NetworkData {
     pub outgoing_fee: u32,
 }
 
+#[derive(Default, Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct BridgeAdjustment<Balance> {
+    pub bridged_out: Balance,
+    pub 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)),
+        };
+
+        NullifyNeeded::<T>::set(true);
+
+        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 +113,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 +167,35 @@ pub mod module {
         NetworkRemoved { chain_id: T::NetworkId },
     }
 
+    #[pallet::storage]
+    #[pallet::getter(fn nullify_needed)]
+    pub type NullifyNeeded<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+    #[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>)>,
@@ -150,7 +227,18 @@ pub mod module {
     pub struct Pallet<T>(PhantomData<T>);
 
     #[pallet::hooks]
-    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+            T::DbWeight::get().reads_writes(1, 1)
+        }
+
+        fn on_finalize(_: BlockNumberFor<T>) {
+            if Self::nullify_needed() {
+                Self::nullify_commission();
+                NullifyNeeded::<T>::put(false);
+            }
+        }
+    }
 
     #[pallet::call]
     impl<T: Config> Pallet<T> {
@@ -525,9 +613,13 @@ impl<T: Config> NetworkDataInspectHandler<NetworkData> for Pallet<T> {
     fn iter() -> PrefixIterator<(Self::NetworkId, NetworkData)> {
         Networks::<T>::iter()
     }
+
+    fn is_nullification_period() -> bool {
+        NullifyNeeded::<T>::get()
+    }
 }
 
-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 +627,83 @@ 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());
+    }
+
+    fn trigger_nullification() {
+        if NullifyNeeded::<T>::get() {
+            Self::nullify_commission();
+            NullifyNeeded::<T>::put(false);
+        } else {
+            NullifyNeeded::<T>::put(true);
+        }
+    }
 }

pallets/networks/src/mock.rs

@@ -1,19 +1,25 @@
-use crate as ghost_networks;
+use crate::{self as ghost_networks};
 use frame_system::EnsureSignedBy;
 use frame_support::{
-    construct_runtime, ord_parameter_types, parameter_types, traits::{ConstU128, ConstU32, Everything}
+    construct_runtime, ord_parameter_types, parameter_types,
+    traits::{ConstU128, ConstU32, Everything},
 };
 pub use primitives::{
     AccountId, Balance, Nonce, BlockNumber, Hash,
     ReserveIdentifier, FreezeIdentifier,
 };
 use sp_runtime::{
-    traits::{BlakeTwo256, AccountIdLookup},
+    curve::PiecewiseLinear,
-    BuildStorage,
+    traits::{AccountIdLookup, BlakeTwo256},
+    BuildStorage
 };
 
 parameter_types! {
     pub const BlockHashCount: BlockNumber = 250;
+    pub static SlashDeferDuration: u32 = 0;
+    pub static Period: BlockNumber = 5;
+    pub static Offset: BlockNumber = 0;
+    pub static MaxControllersInDeprecationBatch: u32 = 5_000;
 }
 
 impl frame_system::Config for Test {
@@ -64,6 +70,21 @@ impl pallet_balances::Config for Test {
     type MaxFreezes = ConstU32<50>;
 }
 
+pallet_staking_reward_curve::build! {
+    const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+        min_inflation: 0_006_900,
+        max_inflation: 1_000_000,
+        ideal_stake: 0_690_000,
+        falloff: 0_050_000,
+        max_piece_count: 100,
+        test_precision: 0_005_000,
+    );
+}
+
+parameter_types! {
+    pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+}
+
 ord_parameter_types! {
     pub const RegistererAccount: AccountId = AccountId::from([1u8; 32]);
     pub const UpdaterAccount: AccountId = AccountId::from([2u8; 32]);
@@ -73,6 +94,7 @@ ord_parameter_types! {
 
 impl ghost_networks::Config for Test {
     type RuntimeEvent = RuntimeEvent;
+    type Currency = Balances;
     type NetworkId = u32;
     type RegisterOrigin = EnsureSignedBy::<RegistererAccount, AccountId>;
     type UpdateOrigin = EnsureSignedBy::<UpdaterAccount, AccountId>;
@@ -80,7 +102,7 @@ impl ghost_networks::Config for Test {
     type WeightInfo = crate::weights::SubstrateWeight<Test>;
 }
 
-type Block = frame_system::mocking::MockBlockU32<Test>;
+type Block = frame_system::mocking::MockBlock<Test>;
 
 construct_runtime!(
     pub enum Test {

pallets/networks/src/tests.rs

@@ -1,16 +1,16 @@
 use mock::{
     ExtBuilder, System, RegistererAccount, UpdaterAccount, RemoverAccount, 
-    RandomAccount, GhostNetworks, Test, RuntimeEvent, RuntimeOrigin,
+    RandomAccount, GhostNetworks, Test, RuntimeEvent, RuntimeOrigin, RewardCurve,
 };
 use frame_support::{assert_err, assert_ok};
 use sp_runtime::DispatchError;
+use pallet_staking::EraPayout;
 use super::*;
 
 fn prepare_network_data() -> (u32, NetworkData) {
     (1u32, NetworkData {
         chain_name: "Ethereum".into(),
-        default_endpoint:
+        default_endpoint: "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
-            "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
         finality_delay: Some(69),
         release_delay: Some(69),
         network_type: NetworkType::Evm,
@@ -635,3 +635,315 @@ fn could_not_remove_non_existent_network() {
             assert_eq!(Networks::<Test>::get(chain_id), None);
         });
 }
+
+#[test]
+fn bridge_storage_is_empty_by_default() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_eq!(BridgedImbalance::<Test>::get(),
+                BridgeAdjustment::default());
+        });
+}
+
+#[test]
+fn gatekeeper_amount_changes_correctly() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            let amount_in: u128 = 420;
+            let amount_out: u128 = 69;
+            let result = amount_in - 3 * amount_out;
+
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
+            assert_eq!(BridgedImbalance::<Test>::get(),
+                BridgeAdjustment::default());
+
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount_in));
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(&chain_id, &amount_out));
+
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), result);
+            assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
+                bridged_out: 3 * amount_out,
+                bridged_in: amount_in });
+        });
+}
+
+#[test]
+fn commission_accumulation_is_correct() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let commission_first: u128 = 420;
+            let commission_second: u128 = 69;
+            let result = commission_first + commission_second;
+
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_ok!(GhostNetworks::accumulate_commission(&commission_first));
+            assert_ok!(GhostNetworks::accumulate_commission(&commission_second));
+            assert_eq!(AccumulatedCommission::<Test>::get(), result);
+        });
+}
+
+#[test]
+fn commission_overflow_and_underflow_emits_error() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let commission: u128 = u128::MAX - 69;
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_ok!(GhostNetworks::accumulate_commission(&commission));
+            assert_err!(GhostNetworks::accumulate_commission(&commission), ());
+            assert_eq!(AccumulatedCommission::<Test>::get(), commission);
+        });
+}
+
+#[test]
+fn gatekeeper_amount_overflow_and_underflow_emits_error() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            let commission: u128 = u128::MAX - 69;
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), (commission, commission));
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), ());
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), commission);
+            assert_ok!(GhostNetworks::decrease_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), (0, commission));
+            assert_err!(GhostNetworks::decrease_gatekeeper_amount(
+                    &chain_id,
+                    &commission,
+            ), ());
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id), 0);
+            assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
+                bridged_out: commission,
+                bridged_in: commission,
+            });
+        });
+}
+
+#[test]
+fn bridged_amount_overflow_and_underflow_emits_error() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id_first: u32 = 1;
+            let chain_id_second: u32 = 2;
+            let commission: u128 = u128::MAX - 69;
+            assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment {
+                bridged_out: 0,
+                bridged_in: 0,
+            });
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_first,
+                    &commission,
+            ), (commission, commission));
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_second,
+                    &commission,
+            ), ());
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_first,
+                    &u128::MAX,
+            ), ());
+            assert_err!(GhostNetworks::increase_gatekeeper_amount(
+                    &chain_id_first,
+                    &commission,
+            ), ());
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id_first), commission);
+            assert_eq!(GatekeeperAmount::<Test>::get(&chain_id_second), 0);
+            assert_err!(GhostNetworks::decrease_gatekeeper_amount(
+                    &chain_id_second,
+                    &commission,
+            ), ());
+        });
+}
+
+#[test]
+fn accumulated_commission_could_be_nullified() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let commission_first: u128 = 420;
+            let commission_second: u128 = 69;
+
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+            assert_ok!(GhostNetworks::accumulate_commission(
+                    &commission_first
+            ), commission_first);
+            assert_ok!(GhostNetworks::accumulate_commission(
+                    &commission_second,
+            ), commission_first + commission_second);
+            assert_eq!(AccumulatedCommission::<Test>::get(),
+                commission_first + commission_second);
+            GhostNetworks::nullify_commission();
+            assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+        });
+}
+
+#[test]
+fn bridged_inlation_reward_works() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            let amount: u128 = 1337 * 1_000_000_000;
+            let commission: u128 = amount / 100; // 1% commission
+            let total_staked_ideal: u128 = 69;
+            let total_staked_not_ideal: u128 = 68;
+            let total_issuance: u128 = 100;
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000,
+                    total_issuance * 1_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000_000_000_000_000, 0), (0, 0));
+
+            assert_ok!(GhostNetworks::accumulate_commission(&commission));
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (commission, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (commission, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (commission, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (13177472000, 192528000));
+            assert_eq!(13177472000 + 192528000, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (13177568884, 192431116));
+            assert_eq!(13177568884 + 192431116, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (13177568884, 192431116));
+            assert_eq!(13177568884 + 192431116, commission);
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000 + amount, 0),
+                (92386700, 13277613300));
+            assert_eq!(92386700 + 13277613300, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000 + amount, 0),
+                (92253000, 13277747000));
+            assert_eq!(92253000 + 13277747000, commission);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000_000_000_000_000 + amount, 0),
+                (92253000, 13277747000));
+            assert_eq!(92253000 + 13277747000, commission);
+
+            GhostNetworks::nullify_commission();
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000,
+                    total_issuance * 1_000_000_000_000 + amount,
+                    0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_not_ideal * 1_000_000_000_000_000_000_000_000,
+                    total_issuance * 1_000_000_000_000_000_000_000_000 + amount,
+                    0), (0, 0));
+
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000 + amount, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000 + amount, 0), (0, 0));
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    1, total_issuance * 1_000_000_000_000_000_000_000_000 + amount, 0), (0, 0));
+        });
+}
+
+#[test]
+fn bridged_inflation_era_payout_triggers_need_of_nullification() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            let chain_id: u32 = 1;
+            let amount: u128 = 1337 * 1_000_000_000;
+            let commission: u128 = amount / 100; // 1% commission
+            let total_staked_ideal: u128 = 69;
+            let total_issuance: u128 = 100;
+
+            assert_ok!(GhostNetworks::accumulate_commission(&commission));
+            assert_ok!(GhostNetworks::increase_gatekeeper_amount(&chain_id, &amount));
+            assert_eq!(NullifyNeeded::<Test>::get(), false);
+            assert_eq!(BridgedInflationCurve::<RewardCurve, Test>::era_payout(
+                    total_staked_ideal * 1_000,
+                    total_issuance * 1_000 + amount,
+                    0), (commission, 0));
+            assert_eq!(NullifyNeeded::<Test>::get(), true);
+            GhostNetworks::on_finalize(69);
+            assert_eq!(NullifyNeeded::<Test>::get(), false);
+        });
+}
+
+#[test]
+fn trigger_nullification_works_as_expected() {
+    ExtBuilder::build()
+        .execute_with(|| {
+            assert_eq!(NullifyNeeded::<Test>::get(), false);
+            GhostNetworks::trigger_nullification();
+            assert_eq!(NullifyNeeded::<Test>::get(), true);
+            GhostNetworks::trigger_nullification();
+            assert_eq!(NullifyNeeded::<Test>::get(), false);
+        });
+}

pallets/traits/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-traits"
-version = "0.3.19"
+version = "0.3.21"
 license.workspace = true
 authors.workspace = true
 edition.workspace = true

pallets/traits/src/networks.rs

@@ -21,9 +21,22 @@ pub trait NetworkDataBasicHandler {
 pub trait NetworkDataInspectHandler<Network>: NetworkDataBasicHandler {
     fn get(n: &Self::NetworkId) -> Option<Network>;
     fn iter() -> PrefixIterator<(Self::NetworkId, Network)>;
+    fn is_nullification_period() -> bool;
 }
 
-pub trait NetworkDataMutateHandler<Network>: NetworkDataInspectHandler<Network> {
+pub trait NetworkDataMutateHandler<Network, Balance>: NetworkDataInspectHandler<Network> {
     fn register(chain_id: Self::NetworkId, network: Network) -> DispatchResult;
     fn remove(chain_id: Self::NetworkId) -> DispatchResult;
+
+    fn increase_gatekeeper_amount(
+        chain_id: &Self::NetworkId, 
+        amount: &Balance,
+    ) -> Result<(Balance, Balance), ()>;
+    fn decrease_gatekeeper_amount(
+        chain_id: &Self::NetworkId, 
+        amount: &Balance,
+    ) -> Result<(Balance, Balance), ()>;
+    fn accumulate_commission(commission: &Balance) -> Result<Balance, ()>;
+    fn nullify_commission();
+    fn trigger_nullification();
 }