feat: manual oracle activation

integration-tests/src/oracle.rs

@@ -192,3 +192,57 @@ fn xyk_trades_with_insufficient_asset_are_not_tracked_by_oracle() {
 		}
 	});
 }
+
+#[test]
+fn xyk_trades_with_insufficient_asset_are_tracked_by_oracle_when_asset_is_whitelisted() {
+	TestNet::reset();
+
+	Hydra::execute_with(|| {
+		// arrange
+		hydradx_run_to_next_block();
+
+		assert_ok!(hydradx_runtime::Tokens::mint_into(
+			INSUFFICIENT_ASSET,
+			&ALICE.into(),
+			200 * UNITS,
+		));
+
+		assert_ok!(hydradx_runtime::XYK::create_pool(
+			RuntimeOrigin::signed(ALICE.into()),
+			HDX,
+			100 * UNITS,
+			INSUFFICIENT_ASSET,
+			100 * UNITS,
+		));
+
+		assert_ok!(EmaOracle::add_oracle(
+			RuntimeOrigin::root(),
+			XYK_SOURCE,
+			(HDX, INSUFFICIENT_ASSET)
+		));
+
+		assert_ok!(hydradx_runtime::XYK::buy(
+			RuntimeOrigin::signed(ALICE.into()),
+			HDX,
+			INSUFFICIENT_ASSET,
+			2 * UNITS,
+			200 * UNITS,
+			false,
+		));
+
+		// act
+		// will store the data received in the sell as oracle values
+		hydradx_run_to_next_block();
+
+		// assert
+		for supported_period in SUPPORTED_PERIODS {
+			assert!(EmaOracle::get_price(HDX, INSUFFICIENT_ASSET, *supported_period, XYK_SOURCE).is_ok(),);
+		}
+		for unsupported_period in UNSUPPORTED_PERIODS {
+			assert_eq!(
+				EmaOracle::get_price(HDX, INSUFFICIENT_ASSET, *unsupported_period, XYK_SOURCE),
+				Err(OracleError::NotPresent)
+			);
+		}
+	});
+}

pallets/asset-registry/src/lib.rs

@@ -21,6 +21,7 @@ use frame_support::pallet_prelude::*;
 use frame_support::require_transactional;
 use frame_support::sp_runtime::traits::CheckedAdd;
 use frame_support::traits::tokens::fungibles::{Inspect as FungiblesInspect, Mutate as FungiblesMutate};
+use frame_support::traits::Contains;
 use frame_system::pallet_prelude::*;
 use scale_info::TypeInfo;
 use sp_arithmetic::traits::BaseArithmetic;
@@ -756,3 +757,13 @@ impl<T: Config> Create<Balance> for Pallet<T> {
 		}
 	}
 }
+
+/// Oracle whitelist based on the asset sufficiency.
+pub struct OracleWhitelist<T>(PhantomData<T>);
+impl<T: Config> Contains<(hydradx_traits::Source, <T as Config>::AssetId, <T as Config>::AssetId)>
+	for OracleWhitelist<T>
+{
+	fn contains(t: &(hydradx_traits::Source, <T as Config>::AssetId, <T as Config>::AssetId)) -> bool {
+		Pallet::<T>::is_sufficient(t.1) && Pallet::<T>::is_sufficient(t.2)
+	}
+}

pallets/dca/src/tests/mock.rs

@@ -146,13 +146,14 @@ parameter_types! {
 
 impl pallet_ema_oracle::Config for Test {
 	type RuntimeEvent = RuntimeEvent;
-	type WeightInfo = ();
+	type AuthorityOrigin = EnsureRoot<AccountId>;
 	type BlockNumberProvider = MockBlockNumberProvider;
 	type SupportedPeriods = SupportedPeriods;
 	type OracleWhitelist = Everything;
 	type MaxUniqueEntries = ConstU32<20>;
 	#[cfg(feature = "runtime-benchmarks")]
 	type BenchmarkHelper = ();
+	type WeightInfo = ();
 }
 
 impl BlockNumberProvider for MockBlockNumberProvider {

pallets/ema-oracle/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = 'pallet-ema-oracle'
-version = '1.2.1'
+version = '1.3.0'
 description = 'Exponential moving average oracle for AMM pools'
 authors = ['GalacticCouncil']
 edition = '2021'
@@ -35,6 +35,7 @@ pretty_assertions = "1.3.0"
 proptest = "1.0.0"
 rug = { version = "1.17.0", features = ["num-traits"] }
 sp-io = { workspace = true }
+test-utils = { workspace = true }
 
 [features]
 default = ['std']

pallets/ema-oracle/src/benchmarking.rs

@@ -23,7 +23,7 @@ pub const HDX: AssetId = 1_000;
 pub const DOT: AssetId = 2_000;
 
 use frame_benchmarking::benchmarks;
-use frame_support::{assert_ok, traits::Hooks};
+use frame_support::{assert_ok, dispatch::RawOrigin, traits::Hooks};
 
 #[cfg(test)]
 use pretty_assertions::assert_eq;
@@ -33,7 +33,36 @@ use crate::Pallet as EmaOracle;
 /// Default oracle source.
 const SOURCE: Source = *b"dummysrc";
 
+fn fill_whitelist_storage<T: Config>(n: u32) {
+	for i in 0..n {
+		assert_ok!(EmaOracle::<T>::add_oracle(RawOrigin::Root.into(), SOURCE, (HDX, i)));
+	}
+}
 benchmarks! {
+	add_oracle {
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries - 1);
+
+		assert_eq!(WhitelistedAssets::<T>::get().len(), (max_entries - 1) as usize);
+
+	}: _(RawOrigin::Root, SOURCE, (HDX, DOT))
+	verify {
+		assert!(WhitelistedAssets::<T>::get().contains(&(SOURCE, (HDX, DOT))));
+	}
+
+	remove_oracle {
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries - 1);
+
+		assert_ok!(EmaOracle::<T>::add_oracle(RawOrigin::Root.into(), SOURCE, (HDX, DOT)));
+
+		assert_eq!(WhitelistedAssets::<T>::get().len(), max_entries as usize);
+
+	}: _(RawOrigin::Root, SOURCE, (HDX, DOT))
+	verify {
+		assert!(!WhitelistedAssets::<T>::get().contains(&(SOURCE, (HDX, DOT))));
+	}
+
 	on_finalize_no_entry {
 		let block_num: u32 = 5;
 	}: { EmaOracle::<T>::on_finalize(block_num.into()); }
@@ -42,6 +71,9 @@ benchmarks! {
 
 	#[extra]
 	on_finalize_insert_one_token {
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries);
+
 		let block_num: BlockNumberFor<T> = 5u32.into();
 		let prev_block = block_num.saturating_sub(One::one());
 
@@ -78,6 +110,9 @@ benchmarks! {
 
 	#[extra]
 	on_finalize_update_one_token {
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries);
+
 		let initial_data_block: BlockNumberFor<T> = 5u32.into();
 		// higher update time difference might make exponentiation more expensive
 		let block_num = initial_data_block.saturating_add(1_000_000u32.into());
@@ -119,6 +154,9 @@ benchmarks! {
 	on_finalize_multiple_tokens {
 		let b in 1 .. (T::MaxUniqueEntries::get() - 1);
 
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries);
+
 		let initial_data_block: BlockNumberFor<T> = 5u32.into();
 		let block_num = initial_data_block.saturating_add(1_000_000u32.into());
 
@@ -167,6 +205,9 @@ benchmarks! {
 	on_trade_multiple_tokens {
 		let b in 1 .. (T::MaxUniqueEntries::get() - 1);
 
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries);
+
 		let initial_data_block: BlockNumberFor<T> = 5u32.into();
 		let block_num = initial_data_block.saturating_add(1_000_000u32.into());
 
@@ -229,6 +270,9 @@ benchmarks! {
 	on_liquidity_changed_multiple_tokens {
 		let b in 1 .. (T::MaxUniqueEntries::get() - 1);
 
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries);
+
 		let initial_data_block: BlockNumberFor<T> = 5u32.into();
 		let block_num = initial_data_block.saturating_add(1_000_000u32.into());
 
@@ -295,6 +339,9 @@ benchmarks! {
 	}
 
 	get_entry {
+		let max_entries = <<T as Config>::MaxUniqueEntries as Get<u32>>::get();
+		fill_whitelist_storage::<T>(max_entries);
+
 		let initial_data_block: BlockNumberFor<T> = 5u32.into();
 		let oracle_age: BlockNumberFor<T> = 999_999u32.into();
 		let block_num = initial_data_block.saturating_add(oracle_age.saturating_add(One::one()));

pallets/ema-oracle/src/lib.rs

@@ -115,8 +115,8 @@ impl BenchmarkHelper<AssetId> for () {
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-	use frame_support::BoundedBTreeMap;
-	use frame_system::pallet_prelude::BlockNumberFor;
+	use frame_support::{BoundedBTreeMap, BoundedBTreeSet};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
 
 	#[pallet::pallet]
 	pub struct Pallet<T>(_);
@@ -128,6 +128,9 @@ pub mod pallet {
 		/// Weight information for the extrinsics.
 		type WeightInfo: WeightInfo;
 
+		/// Origin that can enable oracle for assets that would be rejected by `OracleWhitelist` otherwise.
+		type AuthorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
 		/// Provider for the current block number.
 		type BlockNumberProvider: BlockNumberProvider<BlockNumber = BlockNumberFor<Self>>;
 
@@ -149,10 +152,17 @@ pub mod pallet {
 	pub enum Error<T> {
 		TooManyUniqueEntries,
 		OnTradeValueZero,
+		OracleNotFound,
 	}
 
 	#[pallet::event]
-	pub enum Event<T: Config> {}
+	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Oracle was added to the whitelist.
+		AddedToWhitelist { source: Source, assets: (AssetId, AssetId) },
+		/// Oracle was removed from the whitelist.
+		RemovedFromWhitelist { source: Source, assets: (AssetId, AssetId) },
+	}
 
 	/// Accumulator for oracle data in current block that will be recorded at the end of the block.
 	#[pallet::storage]
@@ -163,7 +173,7 @@ pub mod pallet {
 		ValueQuery,
 	>;
 
-	/// Orace storage keyed by data source, involved asset ids and the period length of the oracle.
+	/// Oracle storage keyed by data source, involved asset ids and the period length of the oracle.
 	///
 	/// Stores the data entry as well as the block number when the oracle was first initialized.
 	#[pallet::storage]
@@ -179,6 +189,11 @@ pub mod pallet {
 		OptionQuery,
 	>;
 
+	/// Assets that are whitelisted and tracked by the pallet.
+	#[pallet::storage]
+	pub type WhitelistedAssets<T: Config> =
+		StorageValue<_, BoundedBTreeSet<(Source, (AssetId, AssetId)), T::MaxUniqueEntries>, ValueQuery>;
+
 	#[pallet::genesis_config]
 	#[derive(frame_support::DefaultNoBound)]
 	pub struct GenesisConfig<T: Config> {
@@ -232,7 +247,51 @@ pub mod pallet {
 	}
 
 	#[pallet::call]
-	impl<T: Config> Pallet<T> {}
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config>::WeightInfo::add_oracle())]
+		pub fn add_oracle(origin: OriginFor<T>, source: Source, assets: (AssetId, AssetId)) -> DispatchResult {
+			T::AuthorityOrigin::ensure_origin(origin)?;
+
+			let assets = ordered_pair(assets.0, assets.1);
+
+			WhitelistedAssets::<T>::mutate(|list| {
+				list.try_insert((source, (assets)))
+					.map_err(|_| Error::<T>::TooManyUniqueEntries)
+			})?;
+
+			Self::deposit_event(Event::AddedToWhitelist { source, assets });
+
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config>::WeightInfo::remove_oracle())]
+		pub fn remove_oracle(origin: OriginFor<T>, source: Source, assets: (AssetId, AssetId)) -> DispatchResult {
+			T::AuthorityOrigin::ensure_origin(origin)?;
+
+			let assets = ordered_pair(assets.0, assets.1);
+
+			WhitelistedAssets::<T>::mutate(|list| {
+				ensure!(list.remove(&(source, (assets))), Error::<T>::OracleNotFound);
+
+				Ok::<(), DispatchError>(())
+			})?;
+
+			// remove oracle from the storage
+			for period in T::SupportedPeriods::get().into_iter() {
+				let _ = Accumulator::<T>::mutate(|accumulator| {
+					accumulator.remove(&(source, assets));
+					Ok::<(), ()>(())
+				});
+				Oracles::<T>::remove((source, assets, period));
+			}
+
+			Self::deposit_event(Event::RemovedFromWhitelist { source, assets });
+
+			Ok(())
+		}
+	}
 }
 
 impl<T: Config> Pallet<T> {
@@ -244,6 +303,7 @@ impl<T: Config> Pallet<T> {
 		oracle_entry: OracleEntry<BlockNumberFor<T>>,
 	) -> Result<(), ()> {
 		if !T::OracleWhitelist::contains(&(src, assets.0, assets.1)) {
+			// if we don't track oracle for given asset pair, don't throw error
 			return Ok(());
 		}
 
@@ -592,3 +652,11 @@ impl<T: Config> AggregatedPriceOracle<AssetId, BlockNumberFor<T>, Price> for Pal
 		Self::get_entry_weight()
 	}
 }
+
+/// Oracle whitelist based on the pallet's storage.
+pub struct OracleWhitelist<T>(PhantomData<T>);
+impl<T: Config> Contains<(Source, AssetId, AssetId)> for OracleWhitelist<T> {
+	fn contains(t: &(Source, AssetId, AssetId)) -> bool {
+		WhitelistedAssets::<T>::get().contains(&(t.0, (t.1, t.2)))
+	}
+}