feat: min liquidity limit in omnipool::add_token

integration-tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "runtime-integration-tests"
-version = "1.20.2"
+version = "1.20.3"
 description = "Integration tests"
 authors = ["GalacticCouncil"]
 edition = "2021"

integration-tests/src/circuit_breaker.rs

@@ -315,6 +315,104 @@ fn add_liquidity_to_omnipool_should_fail_when_liquidity_limit_per_block_exceeded
 	});
 }
 
+#[test]
+fn add_token_with_minimum_liquidity_to_omnipool_can_disable_adding_liquidity() {
+	Hydra::execute_with(|| {
+		//Arrange
+		init_omnipool();
+
+		let ed = <pallet_asset_registry::Pallet<hydradx_runtime::Runtime> as hydradx_traits::registry::Inspect
+		>::existential_deposit(DOT);
+		let minimum_initial_liquidity = 20 * ed.unwrap();
+
+		assert_ok!(Tokens::set_balance(
+			RawOrigin::Root.into(),
+			hydradx_runtime::Omnipool::protocol_account(),
+			DOT,
+			minimum_initial_liquidity,
+			0,
+		));
+
+		assert_ok!(hydradx_runtime::Omnipool::add_token(
+			hydradx_runtime::RuntimeOrigin::root(),
+			DOT,
+			FixedU128::from(1),
+			Permill::from_percent(100),
+			hydradx_runtime::Omnipool::protocol_account(),
+		));
+
+		let min_added_liquidity = <hydradx_runtime::Runtime as pallet_omnipool::Config>::MinimumPoolLiquidity::get();
+
+		assert_ok!(Tokens::set_balance(
+			RawOrigin::Root.into(),
+			ALICE.into(),
+			DOT,
+			min_added_liquidity,
+			0,
+		));
+
+		set_relaychain_block_number(300);
+
+		//Act and assert
+		// ED >= 1_000_000, adding MinimumPoolLiquidity should not trigger the circuit breaker
+		assert_ok!(Omnipool::add_liquidity(
+			hydradx_runtime::RuntimeOrigin::signed(ALICE.into()),
+			DOT,
+			min_added_liquidity,
+		));
+	});
+
+	TestNet::reset();
+
+	Hydra::execute_with(|| {
+		//Arrange
+		init_omnipool();
+
+		let ed = <pallet_asset_registry::Pallet<hydradx_runtime::Runtime> as hydradx_traits::registry::Inspect
+		>::existential_deposit(BTC);
+		let minimum_initial_liquidity = 20 * ed.unwrap();
+
+		assert_ok!(Tokens::set_balance(
+			RawOrigin::Root.into(),
+			hydradx_runtime::Omnipool::protocol_account(),
+			BTC,
+			minimum_initial_liquidity,
+			0,
+		));
+
+		assert_ok!(hydradx_runtime::Omnipool::add_token(
+			hydradx_runtime::RuntimeOrigin::root(),
+			BTC,
+			FixedU128::from(1),
+			Permill::from_percent(100),
+			hydradx_runtime::Omnipool::protocol_account(),
+		));
+
+		let min_added_liquidity = <hydradx_runtime::Runtime as pallet_omnipool::Config>::MinimumPoolLiquidity::get();
+
+		assert_ok!(Tokens::set_balance(
+			RawOrigin::Root.into(),
+			ALICE.into(),
+			BTC,
+			min_added_liquidity,
+			0,
+		));
+
+		set_relaychain_block_number(300);
+
+		//Act and assert
+		// ED < 1_000_000, adding MinimumPoolLiquidity triggers the circuit breaker
+		assert_noop!(
+			Omnipool::add_liquidity(
+				hydradx_runtime::RuntimeOrigin::signed(ALICE.into()),
+				BTC,
+				min_added_liquidity,
+			),
+			pallet_circuit_breaker::Error::<hydradx_runtime::Runtime>::MaxLiquidityLimitPerBlockReached
+		);
+	});
+}
+
 #[test]
 fn add_liquidity_to_omnipool_should_not_fail_when_liquidity_limit_per_block_exceeded_but_called_by_whitelisted() {
 	Hydra::execute_with(|| {

integration-tests/src/evm.rs

@@ -1157,12 +1157,11 @@ fn dispatch_should_work_with_buying_insufficient_asset() {
 		.unwrap();
 
 		create_xyk_pool_with_amounts(shitcoin, 1000000 * UNITS, HDX, 1000000 * UNITS);
-		let evm_address = EVMAccounts::evm_address(&Into::<AccountId>::into(ALICE));
 		init_omnipool_with_oracle_for_block_10();
 
 		assert_ok!(hydradx_runtime::Currencies::update_balance(
 			hydradx_runtime::RuntimeOrigin::root(),
-			currency_precompile::alice_substrate_evm_addr().into(),
+			currency_precompile::alice_substrate_evm_addr(),
 			WETH,
 			(100 * UNITS * 1_000_000) as i128,
 		));
@@ -1186,9 +1185,9 @@ fn dispatch_should_work_with_buying_insufficient_asset() {
 		let router_swap = RuntimeCall::Router(pallet_route_executor::Call::buy {
 			asset_in: WETH,
 			asset_out: shitcoin,
-			amount_out: 1 * UNITS,
+			amount_out: UNITS,
 			max_amount_in: u128::MAX,
-			route: swap_route.clone(),
+			route: swap_route,
 		});
 
 		//Arrange
@@ -1217,7 +1216,7 @@ fn dispatch_should_work_with_buying_insufficient_asset() {
 		//EVM call passes even when the substrate tx fails, so we need to check if the tx is executed
 		expect_hydra_events(vec![pallet_evm::Event::Executed { address: DISPATCH_ADDR }.into()]);
 		let new_balance = Tokens::free_balance(shitcoin, &currency_precompile::alice_substrate_evm_addr());
-		assert_eq!(new_balance, 1 * UNITS);
+		assert_eq!(new_balance, UNITS);
 	});
 }
 

integration-tests/src/polkadot_test_net.rs

@@ -429,7 +429,7 @@ pub mod hydra {
 					(
 						Some(DOT),
 						Some(b"DOT".to_vec().try_into().unwrap()),
-						1_000u128,
+						1_000_000u128,
 						None,
 						None,
 						None,

pallets/asset-registry/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-asset-registry"
-version = "3.2.1"
+version = "3.2.2"
 description = "Pallet for asset registry management"
 authors = ["GalacticCouncil"]
 edition = "2021"

pallets/asset-registry/src/lib.rs

@@ -689,7 +689,7 @@ impl<T: Config> Inspect for Pallet<T> {
 	}
 }
 
-impl<T: Config> Mutate for Pallet<T> {
+impl<T: Config> Mutate<Balance> for Pallet<T> {
 	type Error = DispatchError;
 
 	fn set_location(asset_id: Self::AssetId, location: T::AssetNativeLocation) -> Result<(), Self::Error> {

pallets/asset-registry/src/tests/inspect_trait.rs

@@ -274,31 +274,19 @@ fn existential_deposit_should_work() {
 	let asset_one_symbol = b"TKN".to_vec();
 
 	ExtBuilder::default()
-		.with_assets(vec![
-			(
-				Some(1),
-				Some(b"Tkn1".to_vec().try_into().unwrap()),
-				UNIT,
-				Some(asset_one_symbol.try_into().unwrap()),
-				None,
-				None,
-				true,
-			),
-			(Some(2), None, UNIT, None, None, None, false),
-			(
-				Some(3),
-				Some(b"Tkn3".to_vec().try_into().unwrap()),
-				2 * UNIT,
-				None,
-				None,
-				None,
-				true,
-			),
-		])
+		.with_assets(vec![(
+			Some(1),
+			Some(b"Tkn1".to_vec().try_into().unwrap()),
+			2 * UNIT,
+			Some(asset_one_symbol.try_into().unwrap()),
+			None,
+			None,
+			true,
+		)])
 		.build()
 		.execute_with(|| {
 			//Act & assert
-			assert_eq!(<Registry as Inspect>::existential_deposit(3), Some(2 * UNIT));
+			assert_eq!(<Registry as Inspect>::existential_deposit(1), Some(2 * UNIT));
 
 			assert_eq!(<Registry as Inspect>::existential_deposit(non_existing_id), None);
 		});

pallets/asset-registry/src/tests/mutate_trait.rs

@@ -29,7 +29,7 @@ fn set_location_should_work_when_location_was_not_set_yet() {
 			assert_eq!(Registry::locations(asset_id), None);
 
 			//Act
-			assert_ok!(<Registry as Mutate>::set_location(asset_id, location.clone()));
+			assert_ok!(<Registry as Mutate<Balance>>::set_location(asset_id, location.clone()));
 
 			//Assert
 			assert_eq!(Registry::location_assets(location.clone()), Some(asset_id));
@@ -59,7 +59,7 @@ fn set_location_should_not_work_when_location_was_not() {
 
 			//Act
 			assert_noop!(
-				<Registry as Mutate>::set_location(asset_id, location),
+				<Registry as Mutate<Balance>>::set_location(asset_id, location),
 				Error::<Test>::LocationAlreadyRegistered
 			);
 		});
@@ -75,7 +75,7 @@ fn set_location_should_not_work_when_asset_does_not_exists() {
 
 		//Act
 		assert_noop!(
-			<Registry as Mutate>::set_location(non_existing_id, location),
+			<Registry as Mutate<Balance>>::set_location(non_existing_id, location),
 			Error::<Test>::AssetNotFound
 		);
 	});

pallets/circuit-breaker/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-circuit-breaker"
-version = "1.1.21"
+version = "1.1.22"
 authors = ["GalacticCouncil <hydradx@galacticcouncil.io>"]
 edition = "2021"
 license = "Apache-2.0"

pallets/circuit-breaker/src/tests/mock.rs

@@ -405,7 +405,7 @@ where
 	}
 
 	fn existential_deposit(_id: Self::AssetId) -> Option<u128> {
-		unimplemented!()
+		Some(1u128)
 	}
 }
 

pallets/dca/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = 'pallet-dca'
-version = "1.4.3"
+version = "1.4.4"
 description = 'A pallet to manage DCA scheduling'
 authors = ['GalacticCouncil']
 edition = '2021'