ghostchain/ghost-node
30
0
Fork 3
Code Issues 5 Pull Requests 24 Actions Packages Projects Releases Wiki Activity

remove unnecessary storage entry in pallet

Browse Source 
Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>
This commit is contained in:
Uncle Stinky 2026-02-21 14:15:51 +03:00
parent 7a7712df0b
commit d3cc3ac1b3
Signed by: st1nky
GPG Key ID: 016064BD97603B40
4 changed files with 86 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pallets/networks/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "ghost-networks"
version = "0.1.21"
version = "0.1.22"
license.workspace = true
authors.workspace = true
edition.workspace = true

42
pallets/networks/src/lib.rs
View File

@ -97,16 +97,14 @@ where
_era_duration_in_millis: u64,
) -> (Balance, Balance) {
let reward_curve = RewardCurve::get();
let bridged_imbalance = BridgedImbalance::<T>::get();
let accumulated_commission = AccumulatedCommission::<T>::get();
let bridged_imbalance = BridgedImbalance::<T>::take();
let accumulated_commission = AccumulatedCommission::<T>::take();
let accumulated_commission: Balance = accumulated_commission.into();
let adjusted_issuance: Balance = total_issuance
.saturating_add(bridged_imbalance.bridged_out.into())
.saturating_sub(bridged_imbalance.bridged_in.into());
NullifyNeeded::<T>::set(true);
let estimated_reward =
reward_curve.calculate_for_fraction_times_denominator(total_staked, adjusted_issuance);
@ -243,10 +241,6 @@ pub mod module {
},
}
#[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> =
@ -304,20 +298,6 @@ pub mod module {
#[pallet::without_storage_info]
pub struct Pallet<T>(PhantomData<T>);
#[pallet::hooks]
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> {
#[pallet::call_index(0)]
@ -775,10 +755,6 @@ 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, BalanceOf<T>> for Pallet<T> {
@ -865,18 +841,4 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
}
})
}
fn nullify_commission() {
AccumulatedCommission::<T>::set(Default::default());
BridgedImbalance::<T>::set(Default::default());
}
fn trigger_nullification() {
if NullifyNeeded::<T>::get() {
Self::nullify_commission();
NullifyNeeded::<T>::put(false);
} else {
NullifyNeeded::<T>::put(true);
}
}
}

26
pallets/networks/src/migrations/v1.rs
View File

@ -1,10 +1,11 @@
use frame_support::{
traits::{Get, UncheckedOnRuntimeUpgrade},
migration::clear_storage_prefix,
traits::{Get, PalletInfoAccess, UncheckedOnRuntimeUpgrade},
weights::Weight,
};
use sp_std::marker::PhantomData;
use crate::{BoundedVec, Config, NetworkIndexes, Networks, Vec, LOG_TARGET};
use crate::{BoundedVec, Config, NetworkIndexes, Networks, Pallet, Vec, LOG_TARGET};
pub struct StoreNetworkIdsIntoBoundedVec<T>(PhantomData<T>);
impl<T: Config> UncheckedOnRuntimeUpgrade for StoreNetworkIdsIntoBoundedVec<T> {
@ -16,11 +17,28 @@ impl<T: Config> UncheckedOnRuntimeUpgrade for StoreNetworkIdsIntoBoundedVec<T> {
weight = weight.saturating_add(T::DbWeight::get().reads(networks_count as u64));
let clear_results = clear_storage_prefix(
Pallet::<T>::name().as_bytes(),
"NullifyNeeded".as_bytes(),
&[],
Some(1),
None,
);
log::info!(
target: LOG_TARGET,
"⛓️ NullifyNeeded storage succesfully removed: Loops (reads): {}, Unique removed (writes): {}",
clear_results.loops,
clear_results.unique,
);
weight = weight.saturating_add(T::DbWeight::get().reads(clear_results.loops as u64));
weight = weight.saturating_add(T::DbWeight::get().writes(clear_results.unique as u64));
let writes = BoundedVec::<T::NetworkId, T::MaxNetworks>::try_from(network_ids)
.inspect_err(|err| {
log::error!(
target: LOG_TARGET,
"⛓️ Network ids to bounded_vec migration failed: {:?}",
"⛓️ Network ids to bounded_vec migration failed: {:?}",
err,
)
})
@ -29,7 +47,7 @@ impl<T: Config> UncheckedOnRuntimeUpgrade for StoreNetworkIdsIntoBoundedVec<T> {
NetworkIndexes::<T>::put(bounded_networks);
log::info!(
target: LOG_TARGET,
"⛓️ Network ids to bounded_vec migration success: {} networks moved",
"⛓️ Network ids to bounded_vec migration success: {} networks moved",
networks_count,
);
1u64

126
pallets/networks/src/tests.rs
View File

@ -1278,7 +1278,7 @@ fn bridged_amount_overflow_and_underflow_emits_error() {
}
#[test]
fn accumulated_commission_could_be_nullified() {
fn accumulated_commission_nullified_after_era_payout() {
ExtBuilder::build().execute_with(|| {
let commission_first: u128 = 420;
let commission_second: u128 = 69;
@ -1292,12 +1292,20 @@ fn accumulated_commission_could_be_nullified() {
GhostNetworks::accumulate_commission(&commission_second,),
commission_first + commission_second
);
assert_eq!(
AccumulatedCommission::<Test>::get(),
commission_first + commission_second
);
GhostNetworks::nullify_commission();
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(1, 1, 1),
(0, commission_first + commission_second)
);
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(1, 1, 1),
(0, 0)
);
});
}
@ -1385,7 +1393,6 @@ fn bridged_inlation_reward_works() {
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_ideal * 1_000,
@ -1394,6 +1401,9 @@ fn bridged_inlation_reward_works() {
),
(commission, 0)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_ideal * 1_000_000_000_000,
@ -1402,6 +1412,9 @@ fn bridged_inlation_reward_works() {
),
(commission, 0)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_ideal * 1_000_000_000_000_000_000_000_000,
@ -1411,6 +1424,8 @@ fn bridged_inlation_reward_works() {
(commission, 0)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_not_ideal * 1_000,
@ -1419,6 +1434,9 @@ fn bridged_inlation_reward_works() {
),
(13177472000, 192528000)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(13177472000 + 192528000, commission);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@ -1428,6 +1446,9 @@ fn bridged_inlation_reward_works() {
),
(13177568884, 192431116)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(13177568884 + 192431116, commission);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@ -1437,8 +1458,10 @@ fn bridged_inlation_reward_works() {
),
(13177568884, 192431116)
);
assert_eq!(13177568884 + 192431116, commission);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(13177568884 + 192431116, commission);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
1,
@ -1447,6 +1470,9 @@ fn bridged_inlation_reward_works() {
),
(92386700, 13277613300)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(92386700 + 13277613300, commission);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@ -1456,6 +1482,9 @@ fn bridged_inlation_reward_works() {
),
(92253000, 13277747000)
);
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(92253000 + 13277747000, commission);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@ -1465,10 +1494,8 @@ fn bridged_inlation_reward_works() {
),
(92253000, 13277747000)
);
assert_eq!(92253000 + 13277747000, commission);
GhostNetworks::nullify_commission();
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_ideal * 1_000,
@ -1547,7 +1574,7 @@ fn bridged_inlation_reward_works() {
}
#[test]
fn bridged_inflation_era_payout_triggers_need_of_nullification() {
fn bridged_inflation_era_payout_clears_storage() {
ExtBuilder::build().execute_with(|| {
let amount_full: u128 = 1337 * 1_000_000_000;
let commission: u128 = amount_full / 100; // 1% commission
@ -1558,7 +1585,13 @@ fn bridged_inflation_era_payout_triggers_need_of_nullification() {
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
assert_eq!(NullifyNeeded::<Test>::get(), false);
let bridged_adjustment = BridgeAdjustment {
bridged_in: amount,
bridged_out: 0,
};
assert_eq!(BridgedImbalance::<Test>::get(), bridged_adjustment);
assert_eq!(AccumulatedCommission::<Test>::get(), commission);
assert_eq!(
BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_ideal * 1_000,
@ -1567,37 +1600,8 @@ fn bridged_inflation_era_payout_triggers_need_of_nullification() {
),
(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(|| {
let commission: u128 = 69;
let imbalance = BridgeAdjustment {
bridged_in: 1337u128,
bridged_out: 420u128,
};
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment::default());
AccumulatedCommission::<Test>::set(commission);
BridgedImbalance::<Test>::set(imbalance.clone());
assert_eq!(AccumulatedCommission::<Test>::get(), commission);
assert_eq!(BridgedImbalance::<Test>::get(), imbalance);
assert_eq!(NullifyNeeded::<Test>::get(), false);
GhostNetworks::trigger_nullification();
assert_eq!(NullifyNeeded::<Test>::get(), true);
GhostNetworks::trigger_nullification();
assert_eq!(NullifyNeeded::<Test>::get(), false);
assert_eq!(AccumulatedCommission::<Test>::get(), 0);
assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment::default());
assert_eq!(BridgedImbalance::<Test>::get(), Default::default());
assert_eq!(AccumulatedCommission::<Test>::get(), Default::default());
});
}
@ -1680,7 +1684,6 @@ fn check_bridged_inflation_curve_for_overflow() {
let commission: u128 = amount_full / 100; // 1% commission
let amount: u128 = amount_full - commission;
let tollerance: u128 = commission / 100; // 1% tollerance
let precomputed_payout: u128 = 13177568884;
let precomputed_rest: u128 = 192431116;
assert_eq!(precomputed_payout + precomputed_rest, commission);
@ -1689,10 +1692,10 @@ fn check_bridged_inflation_curve_for_overflow() {
let mut total_staked_not_ideal: u128 = 68_000;
let mut total_issuance: u128 = 100_000;
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
loop {
assert_ok!(GhostNetworks::accumulate_commission(&commission));
assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
total_staked_ideal = match total_staked_ideal.checked_mul(1_000) {
Some(value) => value,
None => break,
@ -1713,27 +1716,6 @@ fn check_bridged_inflation_curve_for_overflow() {
),
(commission, 0)
);
let (payout, rest) = BridgedInflationCurve::<RewardCurve, Test>::era_payout(
total_staked_not_ideal,
total_issuance + amount,
0,
);
let payout_deviation = if precomputed_payout > payout {
precomputed_payout - payout
} else {
payout - precomputed_payout
};
let rest_deviation = if precomputed_rest > rest {
precomputed_rest - rest
} else {
rest - precomputed_rest
};
assert!(payout_deviation < tollerance);
assert!(rest_deviation < tollerance);
}
});
}
@ -1796,6 +1778,17 @@ fn migration_from_v0_to_v1_works() {
let (chain_id, network) = prepare_network_data();
let other_chain_id = chain_id.saturating_add(1);
let removed_pallet_name = <Pallet<Test> as PalletInfoAccess>::name();
let removed_storage = "NullifyNeeded";
let key = [
sp_io::hashing::twox_128(removed_pallet_name.as_bytes()).to_vec(),
sp_io::hashing::twox_128(removed_storage.as_bytes()).to_vec(),
]
.concat();
frame_support::storage::unhashed::put_raw(&key, &true.encode());
assert_eq!(Networks::<Test>::get(chain_id), None);
assert_ok!(GhostNetworks::register_network(
RuntimeOrigin::signed(RegistererAccount::get()),
@ -1809,12 +1802,15 @@ fn migration_from_v0_to_v1_works() {
));
NetworkIndexes::<Test>::kill();
assert!(frame_support::storage::unhashed::exists(&key));
assert_eq!(Networks::<Test>::get(chain_id), Some(network.clone()));
assert_eq!(Networks::<Test>::get(other_chain_id), Some(network));
assert_eq!(NetworkIndexes::<Test>::get(), vec![]);
type Migrate = crate::migrations::MigrateV0ToV1<Test>;
<Migrate as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade();
assert!(!frame_support::storage::unhashed::exists(&key));
assert_eq!(
NetworkIndexes::<Test>::get(),
vec![chain_id, other_chain_id]