diff --git a/js/e2e/index.ts b/js/e2e/index.ts
index fc42a8c1dd..e9bece4ab6 100644
--- a/js/e2e/index.ts
+++ b/js/e2e/index.ts
@@ -326,7 +326,6 @@ const TESTS = (api: ApiPromise, config: ExtrinsicConfig): Extrinsic[] => {
             args: [
                 ASSET_ID_A,
                 PINT.mul(ASSET_ID_A_UNITS),
-                PARENT_LOCATION,
                 PINT.mul(ASSET_ID_A_AMOUNT),
             ],
             verify: async (before: Balance) => {
diff --git a/pallets/asset-index/src/benchmarking.rs b/pallets/asset-index/src/benchmarking.rs
index dcf5f8f91c..86de8da873 100644
--- a/pallets/asset-index/src/benchmarking.rs
+++ b/pallets/asset-index/src/benchmarking.rs
@@ -29,10 +29,17 @@ benchmarks! {
 		let origin = T::AdminOrigin::successful_origin();
 		let million = 1_000_000u32.into();
 		let location = MultiLocation::Null;
+
+		assert_ok!(
+			AssetIndex::<T>::register_asset(
+				origin.clone(),
+				asset_id,
+				AssetAvailability::Liquid(MultiLocation::Null)
+			)
+		);
 		let call = Call::<T>::add_asset(
 					asset_id,
 					million,
-					location.clone(),
 					million
 		);
 		let balance = T::Currency::total_balance(asset_id, &T::TreasuryPalletId::get().into_account());
@@ -56,11 +63,15 @@ benchmarks! {
 		let deposit_units = 1000_u32.into();
 
 		// create liquid assets
-		assert_ok!(<AssetIndex<T>>::add_asset(
+		assert_ok!(AssetIndex::<T>::register_asset(
+			origin.clone(),
+			asset_id,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::<T>::add_asset(
 			origin.clone(),
 			asset_id,
 			units,
-			MultiLocation::Null,
 			tokens
 		));
 
@@ -69,7 +80,7 @@ benchmarks! {
 
 		// deposit some funds into the index from an user account
 		assert_ok!(T::Currency::deposit(asset_id, &origin_account_id, deposit_units));
-		assert_ok!(<AssetIndex<T>>::deposit(origin.clone(), asset_id, deposit_units));
+		assert_ok!(AssetIndex::<T>::deposit(origin.clone(), asset_id, deposit_units));
 
 		// advance the block number so that the lock expires
 		<frame_system::Pallet<T>>::set_block_number(
@@ -79,7 +90,7 @@ benchmarks! {
 		);
 
 		// start withdraw
-		assert_ok!(<AssetIndex<T>>::withdraw(
+		assert_ok!(AssetIndex::<T>::withdraw(
 			origin.clone(),
 			42_u32.into(),
 		));
@@ -95,11 +106,15 @@ benchmarks! {
 		let admin_deposit = 1_000_000u32;
 		let units = 1_000u32.into();
 
+		assert_ok!(AssetIndex::<T>::register_asset(
+			origin.clone(),
+			asset_id,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
 		assert_ok!(AssetIndex::<T>::add_asset(
 			origin.clone(),
 			asset_id,
 			100u32.into(),
-			MultiLocation::Null,
 			admin_deposit.into(),
 		));
 
@@ -208,11 +223,15 @@ benchmarks! {
 		let deposit_units = 1_000_u32.into();
 
 		// create liquid assets
-		assert_ok!(<AssetIndex<T>>::add_asset(
+		assert_ok!(AssetIndex::<T>::register_asset(
+			origin.clone(),
+			asset_id,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::<T>::add_asset(
 			origin.clone(),
 			asset_id,
 			units,
-			MultiLocation::Null,
 			tokens
 		));
 
@@ -221,7 +240,7 @@ benchmarks! {
 
 		// deposit some funds into the index from an user account
 		assert_ok!(T::Currency::deposit(asset_id, &origin_account_id, deposit_units));
-		assert_ok!(<AssetIndex<T>>::deposit(origin.clone(), asset_id, deposit_units));
+		assert_ok!(AssetIndex::<T>::deposit(origin.clone(), asset_id, deposit_units));
 
 		// advance the block number so that the lock expires
 		<frame_system::Pallet<T>>::set_block_number(
@@ -245,15 +264,20 @@ benchmarks! {
 		// create price feed
 		T::PriceFeedBenchmarks::create_feed(origin_account_id.clone(), asset_id).unwrap();
 
-		assert_ok!(AssetIndex::<T>::add_asset(origin.clone(), asset_id, units, MultiLocation::Null, amount));
+		assert_ok!(AssetIndex::<T>::register_asset(
+			origin.clone(),
+			asset_id,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::<T>::add_asset(origin.clone(), asset_id, units, amount));
 		assert_ok!(T::Currency::deposit(asset_id, &origin_account_id, units));
-		assert_ok!(<AssetIndex<T>>::deposit(origin.clone(), asset_id, units));
+		assert_ok!(AssetIndex::<T>::deposit(origin.clone(), asset_id, units));
 
 		let call = Call::<T>::unlock();
 	}: { call.dispatch_bypass_filter(origin)? } verify {
-		assert_eq!(<pallet::IndexTokenLocks<T>>::get(&origin_account_id), vec![types::IndexTokenLock{
-			locked: <AssetIndex<T>>::index_token_equivalent(asset_id, units).unwrap(),
-			end_block: <frame_system::Pallet<T>>::block_number() + T::LockupPeriod::get() - 1u32.into()
+		assert_eq!(pallet::IndexTokenLocks::<T>::get(&origin_account_id), vec![types::IndexTokenLock{
+			locked: AssetIndex::<T>::index_token_equivalent(asset_id, units).unwrap(),
+			end_block: frame_system::Pallet::<T>::block_number() + T::LockupPeriod::get() - 1u32.into()
 		}]);
 	}
 }
diff --git a/pallets/asset-index/src/lib.rs b/pallets/asset-index/src/lib.rs
index ce54d83d06..1ab151c19b 100644
--- a/pallets/asset-index/src/lib.rs
+++ b/pallets/asset-index/src/lib.rs
@@ -319,6 +319,8 @@ pub mod pallet {
 		NoPendingWithdrawals,
 		/// Thrown if the asset that should be added is already registered
 		AssetAlreadyExists,
+		/// Thrown if the asset that should be added has not been registered.
+		AssetNotExists,
 		/// This gets thrown if the total supply of index tokens is 0 so no NAV can be calculated to
 		/// determine the Asset/Index Token rate.
 		InsufficientIndexTokens,
@@ -352,10 +354,9 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			asset_id: T::AssetId,
 			units: T::Balance,
-			location: MultiLocation,
 			amount: T::Balance,
 		) -> DispatchResultWithPostInfo {
-			Self::do_add_asset(T::AdminOrigin::ensure_origin(origin)?, asset_id, units, location, amount)
+			Self::do_add_asset(T::AdminOrigin::ensure_origin(origin)?, asset_id, units, amount)
 		}
 
 		/// Add liquid asset with root origin, see `add_asset`
@@ -364,12 +365,11 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			asset_id: T::AssetId,
 			units: T::Balance,
-			location: MultiLocation,
 			amount: T::Balance,
 			recipient: T::AccountId,
 		) -> DispatchResultWithPostInfo {
 			ensure_root(origin)?;
-			Self::do_add_asset(recipient, asset_id, units, location, amount)
+			Self::do_add_asset(recipient, asset_id, units, amount)
 		}
 
 		/// Dispatches transfer to move assets out of the index’s account,
@@ -417,6 +417,9 @@ pub mod pallet {
 		) -> DispatchResult {
 			T::AdminOrigin::ensure_origin(origin)?;
 
+			// native asset can't be registered
+			Self::ensure_not_native_asset(&asset_id)?;
+
 			Assets::<T>::try_mutate(asset_id, |maybe_available| -> DispatchResult {
 				// allow new assets only
 				ensure!(maybe_available.replace(availability.clone()).is_none(), Error::<T>::AssetAlreadyExists);
@@ -754,32 +757,17 @@ pub mod pallet {
 			recipient: T::AccountId,
 			asset_id: T::AssetId,
 			units: T::Balance,
-			location: MultiLocation,
 			amount: T::Balance,
 		) -> DispatchResultWithPostInfo {
+			Assets::<T>::get(&asset_id).ok_or(Error::<T>::AssetNotExists)?;
+
 			if units.is_zero() {
 				return Ok(().into());
 			}
 
-			let availability = AssetAvailability::Liquid(location);
-
-			// check whether this is a new asset and make sure locations match otherwise
-			let is_new_asset = if let Some(asset) = Assets::<T>::get(&asset_id) {
-				ensure!(asset == availability, Error::<T>::AssetAlreadyExists);
-				false
-			} else {
-				true
-			};
-
 			// transfer the caller's fund into the treasury account
 			Self::add_liquid(&recipient, asset_id, units, amount)?;
 
-			// register asset if not yet known
-			if is_new_asset {
-				Assets::<T>::insert(asset_id, availability.clone());
-				Self::deposit_event(Event::AssetRegistered(asset_id, availability));
-			}
-
 			Self::deposit_event(Event::AssetAdded(asset_id, units, recipient, amount));
 			Ok(().into())
 		}
@@ -1157,7 +1145,16 @@ pub mod pallet {
 			let origin_account_id = T::AdminOrigin::ensure_origin(origin.clone()).unwrap();
 
 			T::PriceFeedBenchmarks::create_feed(origin_account_id, asset_id)?;
-			Self::add_asset(T::AdminOrigin::successful_origin(), asset_id, units, location, amount)
+
+			// the tests of benchmarks register assets by default
+			if Assets::<T>::get(asset_id).is_none() {
+				Self::register_asset(
+					T::AdminOrigin::successful_origin(),
+					asset_id,
+					AssetAvailability::Liquid(location),
+				)?;
+			}
+			Self::add_asset(T::AdminOrigin::successful_origin(), asset_id, units, amount)
 		}
 
 		/// deposit index tokens to the testing account with saft_nav
diff --git a/pallets/asset-index/src/tests.rs b/pallets/asset-index/src/tests.rs
index d0f0264baf..24bce05865 100644
--- a/pallets/asset-index/src/tests.rs
+++ b/pallets/asset-index/src/tests.rs
@@ -16,10 +16,37 @@ use primitives::{
 use crate as pallet;
 use crate::{mock::*, types::DepositRange};
 
+#[test]
+fn can_register_asset() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_eq!(pallet::Assets::<Test>::get(ASSET_A_ID), Some(AssetAvailability::Liquid(MultiLocation::Null)));
+	})
+}
+
+#[test]
+fn cannot_add_asset_before_register() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, 5),
+			pallet::Error::<Test>::AssetNotExists,
+		);
+	})
+}
+
 #[test]
 fn can_add_asset() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, MultiLocation::Null, 5));
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, 5));
 		assert_eq!(pallet::Assets::<Test>::get(ASSET_A_ID), Some(AssetAvailability::Liquid(MultiLocation::Null)));
 		assert_eq!(AssetIndex::index_total_asset_balance(ASSET_A_ID), 100);
 
@@ -34,7 +61,11 @@ fn can_add_asset() {
 fn native_asset_disallowed() {
 	new_test_ext().execute_with(|| {
 		assert_noop!(
-			AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), PINT_ASSET_ID, 100, MultiLocation::Null, 5),
+			AssetIndex::register_asset(
+				Origin::signed(ACCOUNT_ID),
+				PINT_ASSET_ID,
+				AssetAvailability::Liquid(MultiLocation::Null)
+			),
 			pallet::Error::<Test>::NativeAssetDisallowed
 		);
 	});
@@ -43,8 +74,13 @@ fn native_asset_disallowed() {
 #[test]
 fn can_add_asset_twice_and_units_accumulate() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, MultiLocation::Null, 5));
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, MultiLocation::Null, 5));
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, 5));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, 5));
 		assert_eq!(pallet::Assets::<Test>::get(ASSET_A_ID), Some(AssetAvailability::Liquid(MultiLocation::Null)));
 		assert_eq!(AssetIndex::index_total_asset_balance(ASSET_A_ID), 200);
 		assert_eq!(Balances::free_balance(ACCOUNT_ID), 10);
@@ -107,11 +143,15 @@ fn can_add_saft() {
 		// we first need to contribute some assets in order to mint an intial supply of pint
 		let initial_liquid_supply = 1_000;
 		let initial_tokens = 2_0000;
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
 		assert_ok!(AssetIndex::add_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
 			initial_liquid_supply,
-			MultiLocation::Null,
 			initial_tokens
 		));
 		let index_token_supply = AssetIndex::index_token_issuance();
@@ -139,7 +179,12 @@ fn can_add_saft() {
 fn add_saft_fails_on_liquid_already_registered() {
 	let balance = vec![(ACCOUNT_ID, UNKNOWN_ASSET_ID, 1000)];
 	new_test_ext_with_balance(balance).execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), UNKNOWN_ASSET_ID, 100, MultiLocation::Null, 5));
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			UNKNOWN_ASSET_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), UNKNOWN_ASSET_ID, 100, 5));
 		assert_noop!(AssetIndex::add_saft(&ACCOUNT_ID, UNKNOWN_ASSET_ID, 100, 5), pallet::Error::<Test>::ExpectedSAFT);
 	})
 }
@@ -155,11 +200,15 @@ fn deposit_only_works_for_added_liquid_assets() {
 		// mint and intial supply of pint
 		let initial_liquid_supply = 1_000;
 		let initial_tokens = 2_0000;
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
 		assert_ok!(AssetIndex::add_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
 			initial_liquid_supply,
-			MultiLocation::Null,
 			initial_tokens
 		));
 
@@ -185,7 +234,12 @@ fn deposit_fail_for_native_asset() {
 #[test]
 fn deposit_fails_for_unknown_assets() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, MultiLocation::Null, 5));
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, 5));
 		assert_noop!(
 			AssetIndex::deposit(Origin::signed(ASHLEY), UNKNOWN_ASSET_ID, 1_000),
 			pallet::Error::<Test>::UnsupportedAsset
@@ -205,13 +259,12 @@ fn can_calculate_nav_upon_deposit() {
 		let index_token_units = 5;
 		let asset_amount = 100;
 		let asset_price = MockPriceFeed::get_price(ASSET_A_ID).unwrap();
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			asset_amount,
-			MultiLocation::Null,
-			index_token_units
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, asset_amount, index_token_units));
 
 		// per token value (NAV) is now the value of all deposited assets over index token supply
 		let nav = AssetIndex::nav().unwrap();
@@ -306,13 +359,12 @@ fn can_calculate_random_nav() {
 fn deposit_works_with_user_balance() {
 	new_test_ext().execute_with(|| {
 		let initial_units = 1_000;
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			100,
-			MultiLocation::Null,
-			initial_units
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, initial_units));
 
 		let nav = AssetIndex::nav().unwrap();
 		let deposit = 1_000;
@@ -338,7 +390,12 @@ fn deposit_works_with_user_balance() {
 fn deposit_fail_for_unsupported_assets() {
 	let balance = vec![(ACCOUNT_ID, UNKNOWN_ASSET_ID, 1000)];
 	new_test_ext_with_balance(balance).execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), UNKNOWN_ASSET_ID, 100, MultiLocation::Null, 5));
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			UNKNOWN_ASSET_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), UNKNOWN_ASSET_ID, 100, 5));
 		assert_ok!(Currency::deposit(UNKNOWN_ASSET_ID, &ASHLEY, 1_000));
 		assert_noop!(
 			AssetIndex::deposit(Origin::signed(ASHLEY), UNKNOWN_ASSET_ID, 100),
@@ -350,7 +407,12 @@ fn deposit_fail_for_unsupported_assets() {
 #[test]
 fn deposit_fails_on_missing_assets() {
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, MultiLocation::Null, 5));
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ACCOUNT_ID),
+			ASSET_A_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, 5));
 
 		assert_noop!(
 			AssetIndex::deposit(Origin::signed(ASHLEY), ASSET_A_ID, Balance::MAX),
@@ -399,14 +461,12 @@ fn deposit_fails_on_invalid_deposit_range() {
 	let initial_units = 1_000;
 
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			100,
-			MultiLocation::Null,
-			initial_units
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
-
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, initial_units));
 		assert_ok!(Currency::deposit(ASSET_A_ID, &ASHLEY, 100_000));
 
 		// fund account to cover index deposits
@@ -437,13 +497,12 @@ fn deposit_fails_on_exceeding_limit() {
 	let initial_units = 1_000;
 
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			100,
-			MultiLocation::Null,
-			initial_units
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, initial_units));
 
 		// fund account to cover index deposits
 		assert_ok!(Currency::deposit(ASSET_A_ID, &ASHLEY, deposit));
@@ -465,13 +524,12 @@ fn redemption_fee_works_on_completing_withdraw() {
 	let initial_units = 1_000;
 
 	new_test_ext().execute_with(|| {
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			100,
-			MultiLocation::Null,
-			initial_units
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, 100, initial_units));
 		assert_ok!(Currency::deposit(ASSET_A_ID, &ASHLEY, deposit));
 		for _ in 0..50 {
 			assert_ok!(AssetIndex::deposit(Origin::signed(ASHLEY), ASSET_A_ID, initial_units / 50));
@@ -511,13 +569,12 @@ fn can_calculate_nav() {
 		let index_token_units = 5;
 		let saft_units = 50;
 
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			a_units,
-			MultiLocation::Null,
-			index_token_units
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, a_units, index_token_units));
 		assert_ok!(AssetIndex::add_saft(&ACCOUNT_ID, ASSET_B_ID, b_units, saft_units));
 
 		let total_supply = AssetIndex::index_token_issuance();
@@ -542,20 +599,19 @@ fn can_withdraw() {
 		let b_tokens = 100;
 
 		// create liquid assets
-		assert_ok!(AssetIndex::add_asset(
+
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_A_ID,
-			a_units,
-			MultiLocation::Null,
-			a_tokens
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
-		assert_ok!(AssetIndex::add_asset(
+		assert_ok!(AssetIndex::register_asset(
 			Origin::signed(ACCOUNT_ID),
 			ASSET_B_ID,
-			b_units,
-			MultiLocation::Null,
-			b_tokens
+			AssetAvailability::Liquid(MultiLocation::Null)
 		));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_A_ID, a_units, a_tokens));
+		assert_ok!(AssetIndex::add_asset(Origin::signed(ACCOUNT_ID), ASSET_B_ID, b_units, b_tokens));
 
 		// deposit some funds into the index from an user account
 		assert_ok!(Currency::deposit(ASSET_A_ID, &ASHLEY, 1_000));
diff --git a/pallets/remote-asset-manager/src/tests.rs b/pallets/remote-asset-manager/src/tests.rs
index 192c0352d8..57c8db204a 100644
--- a/pallets/remote-asset-manager/src/tests.rs
+++ b/pallets/remote-asset-manager/src/tests.rs
@@ -21,7 +21,7 @@ use crate::{
 };
 use frame_support::traits::Hooks;
 use pallet_price_feed::PriceFeed;
-use primitives::traits::NavProvider;
+use primitives::{traits::NavProvider, AssetAvailability};
 
 #[allow(unused)]
 fn print_events<T: frame_system::Config>(context: &str) {
@@ -50,11 +50,15 @@ fn register_relay() {
 	// prepare index fund so NAV is available
 	let deposit = 1_000;
 	assert_ok!(orml_tokens::Pallet::<para::Runtime>::deposit(RELAY_CHAIN_ASSET, &ADMIN_ACCOUNT, 1_000));
+	assert_ok!(pallet_asset_index::Pallet::<para::Runtime>::register_asset(
+		para::Origin::signed(ADMIN_ACCOUNT),
+		RELAY_CHAIN_ASSET,
+		AssetAvailability::Liquid(X1(Parent)),
+	));
 	assert_ok!(pallet_asset_index::Pallet::<para::Runtime>::add_asset(
 		para::Origin::signed(ADMIN_ACCOUNT),
 		RELAY_CHAIN_ASSET,
 		deposit,
-		X1(Parent),
 		deposit
 	));
 	assert!(pallet_asset_index::Pallet::<para::Runtime>::is_liquid_asset(&RELAY_CHAIN_ASSET));
diff --git a/pallets/saft-registry/src/mock.rs b/pallets/saft-registry/src/mock.rs
index da9c353b73..47924ea314 100644
--- a/pallets/saft-registry/src/mock.rs
+++ b/pallets/saft-registry/src/mock.rs
@@ -22,6 +22,7 @@ use pallet_price_feed::{AssetPricePair, Price, PriceFeed};
 use xcm::v0::MultiLocation;
 
 use frame_support::traits::Everything;
+use primitives::AssetAvailability;
 use sp_core::H256;
 use sp_runtime::{
 	testing::Header,
@@ -226,11 +227,15 @@ pub fn new_test_ext() -> sp_io::TestExternalities {
 	t.execute_with(|| {
 		// mint and intial supply of pint
 		let initial_liquid_supply = 1_000;
+		assert_ok!(AssetIndex::register_asset(
+			Origin::signed(ADMIN_ACCOUNT_ID),
+			LIQUID_ASSET_ID,
+			AssetAvailability::Liquid(MultiLocation::Null)
+		));
 		assert_ok!(AssetIndex::add_asset(
 			Origin::signed(ADMIN_ACCOUNT_ID),
 			LIQUID_ASSET_ID,
 			initial_liquid_supply,
-			MultiLocation::Null,
 			INDEX_TOKEN_SUPPLY,
 		));