Removed getters in token-issuer.

pallets/stable-asset/src/lib.rs

@@ -401,11 +401,9 @@ pub mod pallet {
 	pub struct Pallet<T>(_);
 
 	#[pallet::storage]
-	#[pallet::getter(fn pool_count)]
 	pub type PoolCount<T: Config> = StorageValue<_, StableAssetPoolId, ValueQuery>;
 
 	#[pallet::storage]
-	#[pallet::getter(fn pools)]
 	pub type Pools<T: Config> = StorageMap<
 		_,
 		Blake2_128Concat,
@@ -420,7 +418,6 @@ pub mod pallet {
 	>;
 
 	#[pallet::storage]
-	#[pallet::getter(fn token_rate_caches)]
 	pub type TokenRateCaches<T: Config> = StorageDoubleMap<
 		_,
 		Twox64Concat,
@@ -431,7 +428,6 @@ pub mod pallet {
 	>;
 
 	#[pallet::storage]
-	#[pallet::getter(fn token_rate_hardcap)]
 	pub type TokenRateHardcap<T: Config> = StorageMap<_, Twox64Concat, T::AssetId, Permill>;
 
 	#[pallet::event]

pallets/stable-asset/src/tests.rs

@@ -17,8 +17,8 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::{
-	mock::*, traits::StableAsset as StableAssetInterface, Error, MintResult, RedeemMultiResult,
-	RedeemProportionResult, RedeemSingleResult, StableAssetPoolInfo, SwapResult,
+	mock::*, traits::StableAsset as StableAssetInterface, Error, MintResult, PoolCount, Pools,
+	RedeemMultiResult, RedeemProportionResult, RedeemSingleResult, StableAssetPoolInfo, SwapResult,
 };
 use frame_support::{assert_noop, assert_ok};
 use orml_traits::MultiCurrency;
@@ -60,7 +60,7 @@ fn create_pool() -> (i64, i64, i64, u64) {
 #[test]
 fn create_pool_successful() {
 	new_test_ext().execute_with(|| {
-		assert_eq!(StableAsset::pool_count(), 0);
+		assert_eq!(PoolCount::<Test>::get(), 0);
 		assert_ok!(StableAsset::create_pool(
 			RuntimeOrigin::signed(1),
 			1,
@@ -75,7 +75,7 @@ fn create_pool_successful() {
 			1000000000000000000u128,
 		));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset: 1,
@@ -150,7 +150,7 @@ fn modify_a_successful() {
 
 		assert_ok!(StableAsset::modify_a(RuntimeOrigin::signed(1), 0, 100, 100));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -206,7 +206,7 @@ fn mint_successful_equal_amounts() {
 		let amounts = vec![10000000u128, 10000000u128];
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -246,7 +246,7 @@ fn mint_successful_different_amounts() {
 		let amounts = vec![10000000u128, 20000000u128];
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -373,7 +373,7 @@ fn swap_successful() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_ok!(StableAsset::swap(RuntimeOrigin::signed(1), 0, 0, 1, 5000000u128, 0, 2));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -547,7 +547,7 @@ fn redeem_proportion_successful() {
 			vec![0u128, 0u128]
 		));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -707,7 +707,7 @@ fn redeem_single_successful() {
 			2,
 		));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -874,7 +874,7 @@ fn redeem_multi_successful() {
 			1100000000000000000u128,
 		));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -992,7 +992,7 @@ fn swap_exact_success() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 
 		let amount = 1000345u128;
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 
 		let result = StableAsset::get_swap_amount_exact(&pool_info, 0, 1, amount).unwrap();
 		let result_two = StableAsset::get_swap_amount(&pool_info, 0, 1, result.dx).unwrap();
@@ -1028,7 +1028,7 @@ fn swap_exact_success_different_precision() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 
 		let amount = 1000345u128;
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 
 		let result = StableAsset::get_swap_amount_exact(&pool_info, 0, 1, amount).unwrap();
 		let result_two = StableAsset::get_swap_amount(&pool_info, 0, 1, result.dx).unwrap();
@@ -1049,7 +1049,7 @@ fn modify_fees_successful() {
 			Some(300)
 		));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -1083,7 +1083,7 @@ fn get_mint_amount_same_as_mint() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts.clone(), 0));
 		assert_ok!(<Test as crate::Config>::Assets::deposit(coin0, &swap_id, 100_000_000_000));
 
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 		assert_eq!(pool_info.balances, vec![99999990000000000u128, 199999990000000000u128]);
 		assert_eq!(
 			StableAsset::get_balance_update_amount(&pool_info).unwrap().balances,
@@ -1132,7 +1132,7 @@ fn get_swap_amount_same_as_swap() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_ok!(<Test as crate::Config>::Assets::deposit(coin0, &swap_id, 100_000_000_000));
 
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 		assert_eq!(pool_info.balances, vec![99999990000000000u128, 199999990000000000u128]);
 		assert_eq!(
 			StableAsset::get_balance_update_amount(&pool_info).unwrap().balances,
@@ -1181,7 +1181,7 @@ fn get_swap_amount_exact_same_as_swap() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_ok!(<Test as crate::Config>::Assets::deposit(coin0, &swap_id, 100_000_000_000));
 
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 		assert_eq!(pool_info.balances, vec![99999990000000000u128, 199999990000000000u128]);
 		assert_eq!(
 			StableAsset::get_balance_update_amount(&pool_info).unwrap().balances,
@@ -1230,7 +1230,7 @@ fn get_redeem_proportion_amount_same_as_redeem_proportion() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_ok!(<Test as crate::Config>::Assets::deposit(coin0, &swap_id, 100_000_000_000));
 
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 		assert_eq!(pool_info.balances, vec![99999990000000000u128, 199999990000000000u128]);
 		assert_eq!(
 			StableAsset::get_balance_update_amount(&pool_info).unwrap().balances,
@@ -1285,7 +1285,7 @@ fn get_redeem_single_amount_same_as_redeem_single() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_ok!(<Test as crate::Config>::Assets::deposit(coin0, &swap_id, 100_000_000_000));
 
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 		assert_eq!(pool_info.balances, vec![99999990000000000u128, 199999990000000000u128]);
 		assert_eq!(
 			StableAsset::get_balance_update_amount(&pool_info).unwrap().balances,
@@ -1342,7 +1342,7 @@ fn get_redeem_multi_amount_same_as_redeem_multi() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(1), 0, amounts, 0));
 		assert_ok!(<Test as crate::Config>::Assets::deposit(coin0, &swap_id, 100_000_000_000));
 
-		let pool_info = StableAsset::pools(0).unwrap();
+		let pool_info = Pools::<Test>::get(0).unwrap();
 		assert_eq!(pool_info.balances, vec![99999990000000000u128, 199999990000000000u128]);
 		assert_eq!(
 			StableAsset::get_balance_update_amount(&pool_info).unwrap().balances,

pallets/stable-pool/src/tests.rs

@@ -17,7 +17,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 use crate::{mock::*, AssetIdOf, AtLeast64BitUnsignedOf, Error};
 use bifrost_primitives::VtokenMintingOperator;
-use bifrost_stable_asset::StableAssetPoolInfo;
+use bifrost_stable_asset::{PoolCount, Pools, StableAssetPoolInfo};
 use frame_support::{assert_noop, assert_ok, BoundedVec};
 use orml_traits::MultiCurrency;
 use sp_runtime::{traits::AccountIdConversion, Permill};
@@ -127,7 +127,7 @@ fn create_pool_successful() {
 	ExtBuilder::default().new_test_ext().build().execute_with(|| {
 		let coin0 = DOT;
 		let coin1 = VDOT;
-		assert_eq!(StableAsset::pool_count(), 0);
+		assert_eq!(PoolCount::<Test>::get(), 0);
 		assert_ok!(StablePool::create_pool(
 			RuntimeOrigin::root(),
 			vec![coin0, coin1],
@@ -141,7 +141,7 @@ fn create_pool_successful() {
 			1000000000000000000u128,
 		));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset: CurrencyId::BLP(0),
@@ -196,7 +196,7 @@ fn mint_successful_equal_amounts() {
 		assert_ok!(StablePool::mint_inner(&3, 0, amounts, 0));
 		// assert_ok!(StableAsset::mint(RuntimeOrigin::signed(3), 0, amounts.clone(), 0));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -246,7 +246,7 @@ fn swap_successful() {
 		assert_ok!(StableAsset::mint(RuntimeOrigin::signed(3), 0, amounts, 0));
 		assert_ok!(StableAsset::swap(RuntimeOrigin::signed(3), 0, 0, 1, 5000000u128, 0, 2));
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,
@@ -339,7 +339,7 @@ fn get_swap_output_amount() {
 			orml_tokens::Error::<Test>::BalanceTooLow
 		);
 		assert_eq!(
-			StableAsset::pools(0),
+			Pools::<Test>::get(0),
 			Some(StableAssetPoolInfo {
 				pool_id: 0,
 				pool_asset,

pallets/system-staking/src/lib.rs

@@ -109,18 +109,15 @@ pub mod pallet {
 
 	/// Current Round Information
 	#[pallet::storage]
-	#[pallet::getter(fn round)]
 	pub(crate) type Round<T: Config> = StorageValue<_, RoundInfo<BlockNumberFor<T>>, OptionQuery>;
 
 	/// The tokenInfo for each currency
 	#[pallet::storage]
-	#[pallet::getter(fn token_status)]
 	pub(crate) type TokenStatus<T: Config> =
 		StorageMap<_, Twox64Concat, CurrencyIdOf<T>, TokenInfo<BalanceOf<T>>, OptionQuery>;
 
 	/// All token sets
 	#[pallet::storage]
-	#[pallet::getter(fn token_list)]
 	pub(crate) type TokenList<T: Config> =
 		StorageValue<_, BoundedVec<CurrencyIdOf<T>, T::MaxTokenLen>, ValueQuery>;
 
@@ -233,7 +230,7 @@ pub mod pallet {
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
 			// Get token list
-			let token_list = Self::token_list();
+			let token_list = TokenList::<T>::get();
 
 			//Get round info, if can't find it in the storage, a new one will be created.
 			let mut round = if let Some(round) = <Round<T>>::get() {
@@ -255,7 +252,7 @@ pub mod pallet {
 				// Iterate through the token list
 				for i in token_list.clone().into_iter() {
 					// Query the token info for each token in the token list
-					if let Some(mut token_info) = Self::token_status(i) {
+					if let Some(mut token_info) = TokenStatus::<T>::get(i) {
 						// Check token_info.current_config != token_info.new_config
 						if token_info.check_config_change() {
 							// Update token_info.current_config , set token_info.current_config =
@@ -278,7 +275,7 @@ pub mod pallet {
 			// Iterate through the token list
 			for i in token_list.into_iter() {
 				// Query the token info for each token in the token list
-				if let Some(token_info) = Self::token_status(i) {
+				if let Some(token_info) = TokenStatus::<T>::get(i) {
 					// Current blockNumber -  BlockNumber of Round Start ==
 					// token_info.current_config.exec_delay ===> true
 					if round.check_delay(n, token_info.current_config.exec_delay) {
@@ -370,7 +367,7 @@ pub mod pallet {
 
 			// If it is a new token, add it to the token list
 			if new_token {
-				let mut token_list = Self::token_list();
+				let mut token_list = TokenList::<T>::get();
 				token_list.try_push(token).map_err(|_| Error::<T>::ExceedMaxTokenLen)?;
 				<TokenList<T>>::put(token_list);
 			}
@@ -401,7 +398,7 @@ pub mod pallet {
 			<TokenStatus<T>>::remove(&token);
 
 			// Remove token from token list
-			let mut token_list = Self::token_list();
+			let mut token_list = TokenList::<T>::get();
 			token_list.retain(|&x| x != token);
 			<TokenList<T>>::put(token_list);
 

pallets/system-staking/src/tests.rs

@@ -111,9 +111,9 @@ fn round_info_should_correct() {
 			None,
 		));
 		roll_one_block();
-		assert_eq!(SystemStaking::round().unwrap().length, 5);
-		assert_eq!(SystemStaking::round().unwrap().current, 1);
-		assert_eq!(SystemStaking::round().unwrap().first, 1001);
+		assert_eq!(Round::<Runtime>::get().unwrap().length, 5);
+		assert_eq!(Round::<Runtime>::get().unwrap().current, 1);
+		assert_eq!(Round::<Runtime>::get().unwrap().first, 1001);
 	});
 }
 

pallets/token-issuer/src/lib.rs

@@ -100,13 +100,11 @@ pub mod pallet {
 
 	/// Accounts in the whitelist can issue the corresponding Currency.
 	#[pallet::storage]
-	#[pallet::getter(fn get_issue_whitelist)]
 	pub type IssueWhiteList<T: Config> =
 		StorageMap<_, Blake2_128Concat, CurrencyId, BoundedVec<AccountIdOf<T>, T::MaxLengthLimit>>;
 
 	/// Accounts in the whitelist can transfer the corresponding Currency.
 	#[pallet::storage]
-	#[pallet::getter(fn get_transfer_whitelist)]
 	pub type TransferWhiteList<T: Config> =
 		StorageMap<_, Blake2_128Concat, CurrencyId, BoundedVec<AccountIdOf<T>, T::MaxLengthLimit>>;
 
@@ -131,7 +129,7 @@ pub mod pallet {
 
 			let issue_whitelist_new: BoundedVec<AccountIdOf<T>, T::MaxLengthLimit>;
 			let mut issue_vec: Vec<AccountIdOf<T>>;
-			match Self::get_issue_whitelist(currency_id) {
+			match IssueWhiteList::<T>::get(currency_id) {
 				None => {
 					issue_vec = vec![account.clone()];
 				},
@@ -189,7 +187,7 @@ pub mod pallet {
 
 			let transfer_whitelist_new: BoundedVec<AccountIdOf<T>, T::MaxLengthLimit>;
 			let mut transfer_vec: Vec<AccountIdOf<T>>;
-			match Self::get_transfer_whitelist(currency_id) {
+			match TransferWhiteList::<T>::get(currency_id) {
 				None => {
 					transfer_vec = vec![account.clone()];
 				},
@@ -253,7 +251,7 @@ pub mod pallet {
 			let issuer = ensure_signed(origin)?;
 
 			let issue_whitelist =
-				Self::get_issue_whitelist(currency_id).ok_or(Error::<T>::NotAllowed)?;
+				IssueWhiteList::<T>::get(currency_id).ok_or(Error::<T>::NotAllowed)?;
 			ensure!(issue_whitelist.contains(&issuer), Error::<T>::NotAllowed);
 
 			T::MultiCurrency::deposit(currency_id, &dest, amount)?;
@@ -277,7 +275,7 @@ pub mod pallet {
 			let transferrer = ensure_signed(origin)?;
 
 			let transfer_whitelist =
-				Self::get_transfer_whitelist(currency_id).ok_or(Error::<T>::NotAllowed)?;
+				TransferWhiteList::<T>::get(currency_id).ok_or(Error::<T>::NotAllowed)?;
 			ensure!(transfer_whitelist.contains(&transferrer), Error::<T>::NotAllowed);
 
 			let balance = T::MultiCurrency::free_balance(currency_id, &transferrer);

pallets/token-issuer/src/tests.rs

@@ -50,7 +50,7 @@ fn add_to_issue_whitelist_should_work() {
 		));
 
 		let bounded_list = BoundedVec::try_from(vec![CHARLIE]).unwrap();
-		assert_eq!(TokenIssuer::get_issue_whitelist(ZLK), Some(bounded_list));
+		assert_eq!(IssueWhiteList::<Runtime>::get(ZLK), Some(bounded_list));
 		// Charlie succuessfully issue 800 unit of ZLK to Alice account
 		assert_ok!(TokenIssuer::issue(RuntimeOrigin::signed(CHARLIE), ALICE, ZLK, 800));
 		assert_eq!(Tokens::free_balance(ZLK, &ALICE), 800);
@@ -112,7 +112,7 @@ fn add_to_transfer_whitelist_should_work() {
 		));
 
 		let bounded_list = BoundedVec::try_from(vec![CHARLIE]).unwrap();
-		assert_eq!(TokenIssuer::get_transfer_whitelist(ZLK), Some(bounded_list));
+		assert_eq!(TransferWhiteList::<Runtime>::get(ZLK), Some(bounded_list));
 		// Charlie succuessfully transfer 800 unit of ZLK to Alice account
 		assert_ok!(TokenIssuer::transfer(RuntimeOrigin::signed(CHARLIE), ALICE, ZLK, 800));
 		assert_eq!(Tokens::free_balance(ZLK, &ALICE), 800);