lib.rs

		fn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult {
			Pallet::<T>::reserve(GetCurrencyId::get(), who, value)
		}

		fn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance {
			Pallet::<T>::unreserve(GetCurrencyId::get(), who, value)
		}

		fn repatriate_reserved(
			slashed: &T::AccountId,
			beneficiary: &T::AccountId,
			value: Self::Balance,
			status: Status,
		) -> sp_std::result::Result<Self::Balance, DispatchError> {
			Pallet::<T>::repatriate_reserved(GetCurrencyId::get(), slashed, beneficiary, value, status)
		}
	}

	impl<T, GetCurrencyId> PalletLockableCurrency<T::AccountId> for CurrencyAdapter<T, GetCurrencyId>
	where
		T: Config,
		GetCurrencyId: Get<T::CurrencyId>,
	{
		type Moment = T::BlockNumber;
		type MaxLocks = ();

		fn set_lock(id: LockIdentifier, who: &T::AccountId, amount: Self::Balance, _reasons: WithdrawReasons) {
			let _ = Pallet::<T>::set_lock(id, GetCurrencyId::get(), who, amount);
		}

		fn extend_lock(id: LockIdentifier, who: &T::AccountId, amount: Self::Balance, _reasons: WithdrawReasons) {
			let _ = Pallet::<T>::extend_lock(id, GetCurrencyId::get(), who, amount);
		}

		fn remove_lock(id: LockIdentifier, who: &T::AccountId) {
			let _ = Pallet::<T>::remove_lock(id, GetCurrencyId::get(), who);
		}
	}

	impl<T: Config> MergeAccount<T::AccountId> for Pallet<T> {
		#[transactional]
		fn merge_account(source: &T::AccountId, dest: &T::AccountId) -> DispatchResult {
			Accounts::<T>::iter_prefix(source).try_for_each(|(currency_id, account_data)| -> DispatchResult {
				// ensure the account has no active reserved of non-native token
				ensure!(account_data.reserved.is_zero(), Error::<T>::StillHasActiveReserved);

				// transfer all free to recipient
				<Self as MultiCurrency<T::AccountId>>::transfer(currency_id, source, dest, account_data.free)?;
				Ok(())
			})
		}
	}
}