Merge branch 'master' into fix_claim_account

Author: enthusiastmartin

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-omnipool"
-version = "5.1.10"
+version = "5.1.11"
 authors = ['GalacticCouncil']
 edition = "2021"
 license = "Apache-2.0"

pallets/omnipool/Cargo.toml

@@ -2103,12 +2103,23 @@ impl<T: Config> Pallet<T> {
 			.filter(|fee| fee.amount > 0) // filter out when we zero percentage is configured for fees
 			.collect();
 
-		let taken_fee_total: Balance = taken_fee_entries.iter().map(|fee| fee.amount).sum();
+		// Total fee taken as reported from the hook
+		let taken_fee_total: Balance = taken_fee_entries
+			.iter()
+			.try_fold(Balance::zero(), |acc, fee| acc.checked_add(fee.amount))
+			.ok_or(ArithmeticError::Overflow)?;
 
 		let asset_reserve = T::Currency::free_balance(asset, &account);
-		let diff = original_asset_reserve.saturating_sub(asset_reserve);
-		ensure!(diff <= allowed_amount, Error::<T>::FeeOverdraft);
-		ensure!(diff == taken_fee_total, Error::<T>::FeeOverdraft);
+		let actual_fee_taken = original_asset_reserve.saturating_sub(asset_reserve);
+
+		// We allowed `allowed_amount` as the max fee that can be taken by external sources
+		// To support Atokens, we need to allow a tolerance of 1 extra unit.
+		ensure!(
+			actual_fee_taken <= allowed_amount.saturating_add(Balance::one()),
+			Error::<T>::FeeOverdraft
+		);
+		// And the actual fee taken must be equal to the reported amount!
+		ensure!(actual_fee_taken == taken_fee_total, Error::<T>::FeeOverdraft);
 
 		let protocol_fee_amount = amount.saturating_sub(taken_fee_total);
 

pallets/omnipool/src/lib.rs

@@ -1107,3 +1107,71 @@ fn buy_with_all_fees_and_extra_withdrawal_works() {
 			assert_eq!(initial_reserve, omnipool_200_reserve + buy_amount + fee_collector);
 		});
 }
+
+#[test]
+fn buy_allows_tolerance_when_part_of_fee_is_taken() {
+	ExtBuilder::default()
+		.with_endowed_accounts(vec![
+			(Omnipool::protocol_account(), DAI, 1000 * ONE),
+			(Omnipool::protocol_account(), HDX, NATIVE_AMOUNT),
+			(LP2, 100, 2000 * ONE),
+			(LP3, 200, 2000 * ONE),
+			(LP1, 100, 1000 * ONE),
+		])
+		.with_registered_asset(100)
+		.with_registered_asset(200)
+		.with_asset_fee(Permill::from_percent(10))
+		.with_protocol_fee(Permill::from_percent(3))
+		.with_burn_fee(Permill::from_percent(50))
+		.with_on_trade_withdrawal(Permill::from_percent(100))
+		.with_on_trade_withdrawal_extra(Balance::one())
+		.with_initial_pool(FixedU128::from(1), FixedU128::from(1))
+		.with_token(100, FixedU128::one(), LP2, 2000 * ONE)
+		.with_token(200, FixedU128::one(), LP3, 2000 * ONE)
+		.build()
+		.execute_with(|| {
+			let buy_amount = 10 * ONE;
+
+			assert_ok!(Omnipool::buy(
+				RuntimeOrigin::signed(LP1),
+				200,
+				100,
+				buy_amount,
+				u128::MAX,
+			));
+
+			assert_asset_state!(
+				100,
+				AssetReserveState {
+					reserve: 2011585471818340,
+					hub_reserve: 1988481253239648,
+					shares: 2000000000000000,
+					protocol_shares: Balance::zero(),
+					cap: DEFAULT_WEIGHT_CAP,
+					tradable: Tradability::default(),
+				}
+			);
+			assert_asset_state!(
+				200,
+				AssetReserveState {
+					reserve: 1988888888888888,
+					hub_reserve: 2011173184357542,
+					shares: 2000 * ONE,
+					protocol_shares: Balance::zero(),
+					cap: DEFAULT_WEIGHT_CAP,
+					tradable: Tradability::default(),
+				}
+			);
+
+			assert_eq!(Tokens::free_balance(100, &LP1), 988414528181660);
+			assert_eq!(Tokens::free_balance(200, &LP1), buy_amount);
+			assert_eq!(Tokens::free_balance(200, &TRADE_FEE_COLLECTOR), 1111111111112);
+			assert_eq!(Tokens::free_balance(LRNA, &PROTOCOL_FEE_COLLECTOR), 172781201405);
+
+			// Account for 200 asset
+			let initial_reserve = 2000 * ONE;
+			let omnipool_200_reserve = Tokens::free_balance(200, &Omnipool::protocol_account());
+			let fee_collector = Tokens::free_balance(200, &TRADE_FEE_COLLECTOR);
+			assert_eq!(initial_reserve, omnipool_200_reserve + buy_amount + fee_collector);
+		});
+}

pallets/omnipool/src/tests/buy.rs

@@ -80,6 +80,7 @@ thread_local! {
 	pub static WITHDRAWAL_FEE: RefCell<Permill> = const { RefCell::new(Permill::from_percent(0)) };
 	pub static WITHDRAWAL_ADJUSTMENT: RefCell<(u32,u32, bool)> = const { RefCell::new((0u32,0u32, false)) };
 	pub static ON_TRADE_WITHDRAWAL: RefCell<Permill> = const { RefCell::new(Permill::from_percent(0)) };
+	pub static ON_TRADE_WITHDRAWAL_EXTRA: RefCell<Balance> = const { RefCell::new(0) };
 }
 
 construct_runtime!(
@@ -280,6 +281,12 @@ impl Default for ExtBuilder {
 		WITHDRAWAL_ADJUSTMENT.with(|v| {
 			*v.borrow_mut() = (0, 0, false);
 		});
+		ON_TRADE_WITHDRAWAL.with(|v| {
+			*v.borrow_mut() = Permill::from_percent(0);
+		});
+		ON_TRADE_WITHDRAWAL_EXTRA.with(|v| {
+			*v.borrow_mut() = Balance::zero();
+		});
 
 		Self {
 			endowed_accounts: vec![
@@ -383,6 +390,11 @@ impl ExtBuilder {
 		self
 	}
 
+	pub fn with_on_trade_withdrawal_extra(self, extra: Balance) -> Self {
+		ON_TRADE_WITHDRAWAL_EXTRA.with(|v| *v.borrow_mut() = extra);
+		self
+	}
+
 	pub fn with_token(
 		mut self,
 		asset_id: AssetId,
@@ -747,8 +759,9 @@ impl OmnipoolHooks<RuntimeOrigin, AccountId, AssetId, Balance> for MockHooks {
 	) -> Result<Vec<Option<(Balance, AccountId)>>, Self::Error> {
 		let percentage = ON_TRADE_WITHDRAWAL.with(|v| *v.borrow());
 		let to_take = percentage.mul_floor(amount);
-		<Tokens as MultiCurrency<AccountId>>::transfer(asset, &fee_account, &TRADE_FEE_COLLECTOR, to_take)?;
-		Ok(vec![Some((to_take, TRADE_FEE_COLLECTOR))])
+		let add_extra = ON_TRADE_WITHDRAWAL_EXTRA.with(|v| *v.borrow());
+		<Tokens as MultiCurrency<AccountId>>::transfer(asset, &fee_account, &TRADE_FEE_COLLECTOR, to_take + add_extra)?;
+		Ok(vec![Some((to_take + add_extra, TRADE_FEE_COLLECTOR))])
 	}
 
 	fn consume_protocol_fee(

pallets/omnipool/src/tests/mock.rs

@@ -1061,3 +1061,72 @@ fn sell_with_all_fees_and_extra_withdrawal_works() {
 			assert_eq!(initial_reserve, omnipool_200_reserve + buy_amount + fee_collector);
 		});
 }
+
+#[test]
+fn sell_allows_tolerance_when_part_of_fee_is_taken() {
+	ExtBuilder::default()
+		.with_endowed_accounts(vec![
+			(Omnipool::protocol_account(), DAI, 1000 * ONE),
+			(Omnipool::protocol_account(), HDX, NATIVE_AMOUNT),
+			(LP2, 100, 2000 * ONE),
+			(LP3, 200, 2000 * ONE),
+			(LP1, 100, 1000 * ONE),
+		])
+		.with_registered_asset(100)
+		.with_registered_asset(200)
+		.with_asset_fee(Permill::from_percent(10))
+		.with_protocol_fee(Permill::from_percent(3))
+		.with_burn_fee(Permill::from_percent(50))
+		.with_on_trade_withdrawal(Permill::from_percent(100))
+		.with_on_trade_withdrawal_extra(1)
+		.with_initial_pool(FixedU128::from(1), FixedU128::from(1))
+		.with_token(100, FixedU128::one(), LP2, 2000 * ONE)
+		.with_token(200, FixedU128::one(), LP3, 2000 * ONE)
+		.build()
+		.execute_with(|| {
+			let sell_amount = 50 * ONE;
+			let min_limit = 10 * ONE;
+
+			assert_ok!(Omnipool::sell(
+				RuntimeOrigin::signed(LP1),
+				100,
+				200,
+				sell_amount,
+				min_limit
+			));
+
+			assert_asset_state!(
+				100,
+				AssetReserveState {
+					reserve: 2000 * ONE + sell_amount,
+					hub_reserve: 1951219512195122,
+					shares: 2000000000000000,
+					protocol_shares: Balance::zero(),
+					cap: DEFAULT_WEIGHT_CAP,
+					tradable: Tradability::default(),
+				}
+			);
+			assert_asset_state!(
+				200,
+				AssetReserveState {
+					reserve: 1953776507028830,
+					hub_reserve: 2047317073170732,
+					shares: 2000 * ONE,
+					protocol_shares: Balance::zero(),
+					cap: DEFAULT_WEIGHT_CAP,
+					tradable: Tradability::default(),
+				}
+			);
+
+			assert_eq!(Tokens::free_balance(100, &LP1), 950_000_000_000_000);
+			assert_eq!(Tokens::free_balance(200, &LP1), 41601143674053);
+			assert_eq!(Tokens::free_balance(200, &TRADE_FEE_COLLECTOR), 4622349297117);
+			assert_eq!(Tokens::free_balance(LRNA, &PROTOCOL_FEE_COLLECTOR), 731707317073);
+			// Account for 200 asset
+			let initial_reserve = 2000 * ONE;
+			let omnipool_200_reserve = Tokens::free_balance(200, &Omnipool::protocol_account());
+			let fee_collector = Tokens::free_balance(200, &TRADE_FEE_COLLECTOR);
+			let buy_amount = Tokens::free_balance(200, &LP1);
+			assert_eq!(initial_reserve, omnipool_200_reserve + buy_amount + fee_collector);
+		});
+}

pallets/omnipool/src/tests/sell.rs

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-referrals"
-version = "1.3.0"
+version = "1.3.1"
 authors = ['GalacticCouncil']
 edition = "2021"
 license = "Apache-2.0"

pallets/referrals/Cargo.toml

@@ -51,7 +51,7 @@ pub mod traits;
 
 use codec::{Decode, Encode, MaxEncodedLen};
 use frame_support::pallet_prelude::{DispatchResult, Get};
-use frame_support::traits::fungibles::Mutate;
+use frame_support::traits::fungibles::{Inspect, Mutate};
 use frame_support::traits::tokens::Preservation;
 use frame_support::{defensive, ensure, transactional};
 use frame_system::{
@@ -696,13 +696,15 @@ impl<T: Config> Pallet<T> {
 			.saturating_add(trader_reward)
 			.saturating_add(external_reward);
 		ensure!(total_taken <= amount, Error::<T>::IncorrectRewardCalculation);
+		let balance_before = T::Currency::total_balance(asset_id.clone(), &Self::pot_account_id());
 		T::Currency::transfer(
 			asset_id.clone(),
 			&source,
 			&Self::pot_account_id(),
 			total_taken,
 			Preservation::Preserve,
 		)?;
+		let balance_after = T::Currency::total_balance(asset_id.clone(), &Self::pot_account_id());
 
 		let referrer_shares = if ref_account.is_some() {
 			multiply_by_rational_with_rounding(referrer_reward, price.n, price.d, Rounding::Down)
@@ -750,6 +752,13 @@ impl<T: Config> Pallet<T> {
 			PendingConversions::<T>::insert(asset_id, ());
 		}
 
-		Ok(Some((total_taken, Self::pot_account_id())))
+		// To support ATokens - we might need to allow tolerance of 1 unit
+		// we calculated the shares based on calculated total_taken (which is correct)
+		// but we need to report back that we have actually taken +1 sometimes.
+		let actual_taken = balance_after.saturating_sub(balance_before);
+		let actual_diff = actual_taken.abs_diff(total_taken);
+		ensure!(actual_diff <= 1, ArithmeticError::Overflow);
+
+		Ok(Some((actual_taken, Self::pot_account_id())))
 	}
 }

pallets/referrals/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-staking"
-version = "4.1.6"
+version = "4.1.7"
 authors = ['GalacticCouncil']
 edition = "2021"
 license = "Apache-2.0"

pallets/staking/Cargo.toml

@@ -983,8 +983,16 @@ impl<T: Config> Pallet<T> {
 		amount: Balance,
 	) -> Result<Option<(Balance, T::AccountId)>, DispatchError> {
 		if asset == T::NativeAssetId::get() && Self::is_initialized() {
+			let balance_before = T::Currency::total_balance(asset, &Self::pot_account_id());
 			T::Currency::transfer(asset, &source, &Self::pot_account_id(), amount)?;
-			Ok(Some((amount, Self::pot_account_id())))
+			let balance_after = T::Currency::total_balance(asset, &Self::pot_account_id());
+
+			// To support ATokens - we might need to allow tolerance of 1 unit
+			// and we need to report back that we have actually taken +1 sometimes.
+			let actual_taken = balance_after.saturating_sub(balance_before);
+			let actual_diff = actual_taken.abs_diff(amount);
+			ensure!(actual_diff <= 1, Error::<T>::Arithmetic);
+			Ok(Some((actual_taken, Self::pot_account_id())))
 		} else {
 			Ok(None)
 		}