feat: Oracle pallet and precompile

Cargo.toml

@@ -123,6 +123,7 @@ pallet-services-rpc-runtime-api = { path = "pallets/services/rpc/runtime-api", d
 pallet-services-rpc = { path = "pallets/services/rpc" }
 pallet-multi-asset-delegation = { path = "pallets/multi-asset-delegation", default-features = false }
 pallet-tangle-lst-benchmarking = { path = "pallets/tangle-lst/benchmarking", default-features = false }
+pallet-oracle = { path = "pallets/oracle", default-features = false }
 
 k256 = { version = "0.13.3", default-features = false }
 p256 = { version = "0.13.2", default-features = false }

client/evm-tracing/Cargo.toml

@@ -11,8 +11,6 @@ ethereum-types = { workspace = true, features = [ "std" ] }
 hex = { workspace = true, features = [ "serde" ] }
 serde = { workspace = true, features = [ "derive", "std" ] }
 serde_json = { workspace = true }
-
-# Moonbeam
 evm-tracing-events = { workspace = true, features = [ "std" ] }
 rpc-primitives-debug = { workspace = true, features = [ "std" ] }
 

client/rpc/debug/Cargo.toml

@@ -12,7 +12,7 @@ hex-literal = { workspace = true }
 jsonrpsee = { workspace = true, features = ["macros", "server"] }
 tokio = { workspace = true, features = ["sync", "time"] }
 
-# Moonbeam
+
 client-evm-tracing = { workspace = true }
 rpc-core-debug = { workspace = true }
 rpc-core-types = { workspace = true }

client/rpc/trace/Cargo.toml

@@ -15,7 +15,7 @@ substrate-prometheus-endpoint = { workspace = true }
 tokio = { workspace = true, features = ["sync", "time"] }
 tracing = { workspace = true }
 
-# Moonbeam
+
 client-evm-tracing = { workspace = true }
 rpc-core-trace = { workspace = true }
 rpc-core-types = { workspace = true }

client/rpc/txpool/Cargo.toml

@@ -11,7 +11,7 @@ jsonrpsee = { workspace = true, features = ["macros", "server"] }
 serde = { workspace = true, features = ["derive"] }
 sha3 = { workspace = true }
 
-# Moonbeam
+
 rpc-core-txpool = { workspace = true }
 rpc-primitives-txpool = { workspace = true, features = ["std"] }
 

evm-tracer/Cargo.toml

@@ -7,7 +7,7 @@ license = "GPL-3.0-only"
 repository = { workspace = true }
 
 [dependencies]
-# Moonbeam
+
 evm-tracing-events = { workspace = true, features = ["evm-tracing"] }
 primitives-ext = { workspace = true }
 

pallets/claims/src/lib.rs

@@ -48,6 +48,7 @@ use sp_io::{
 	crypto::{secp256k1_ecdsa_recover, sr25519_verify},
 	hashing::keccak_256,
 };
+use sp_runtime::Saturating;
 use sp_runtime::{
 	traits::{CheckedSub, Zero},
 	transaction_validity::{InvalidTransaction, TransactionValidity, ValidTransaction},
@@ -334,7 +335,7 @@ pub mod pallet {
 		) -> DispatchResult {
 			ensure_root(origin)?;
 
-			<Total<T>>::mutate(|t| *t += value);
+			<Total<T>>::mutate(|t| *t = t.saturating_add(value));
 			<Claims<T>>::insert(who.clone(), value);
 			if let Some(vs) = vesting_schedule {
 				<Vesting<T>>::insert(who.clone(), vs);

pallets/oracle/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "pallet-oracle"
+description = "Oracle module that makes off-chain data available on-chain."
+repository = "https://github.com/open-web3-stack/open-runtime-module-library/tree/master/oracle"
+license = "Apache-2.0"
+version = "1.1.0"
+authors = ["Laminar Developers <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+parity-scale-codec = { workspace = true }
+scale-info = { workspace = true }
+serde = { workspace = true, optional = true }
+
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-application-crypto = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+frame-benchmarking = { workspace = true, optional = true }
+tangle-primitives = { workspace = true }
+
+[dev-dependencies]
+sp-core = { workspace = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"tangle-primitives/std",
+	"parity-scale-codec/std",
+	"scale-info/std",
+	"serde",
+	"sp-application-crypto/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]

pallets/oracle/README.md

@@ -0,0 +1,8 @@
+# Oracle module
+
+### Overview
+
+This module exposes capabilities for oracle operators to feed external offchain data.
+The raw values can be combined to provide an aggregated value.
+
+The data is valid only if feeded by an authorized operator. This module implements `frame_support::traits::InitializeMembers` and `frame_support::traits::ChangeMembers`, to provide a way to manage operators membership. Typically it could be leveraged to `pallet_membership` in FRAME.

pallets/oracle/runtime-api/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "pallet-oracle-runtime-api"
+version = "1.1.0"
+authors = ["Laminar Developers <[email protected]>"]
+edition = "2021"
+license = "Apache-2.0"
+description = "Runtime API module for pallet-oracle."
+repository = "https://github.com/open-web3-stack/open-runtime-module-library"
+
+[dependencies]
+parity-scale-codec = {  version = "3.0.0", default-features = false, features = ["derive"] }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
+
+[features]
+default = [ "std" ]
+std = [ "parity-scale-codec/std", "sp-api/std", "sp-std/std" ]

pallets/oracle/runtime-api/src/lib.rs

@@ -0,0 +1,21 @@
+//! Runtime API definition for oracle module.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// The `too_many_arguments` warning originates from `decl_runtime_apis` macro.
+#![allow(clippy::too_many_arguments)]
+// The `unnecessary_mut_passed` warning originates from `decl_runtime_apis` macro.
+#![allow(clippy::unnecessary_mut_passed)]
+
+use parity_scale_codec::Codec;
+use sp_std::prelude::Vec;
+
+sp_api::decl_runtime_apis! {
+	pub trait OracleApi<ProviderId, Key, Value> where
+		ProviderId: Codec,
+		Key: Codec,
+		Value: Codec,
+	{
+		fn get_value(provider_id: ProviderId, key: Key) -> Option<Value>;
+		fn get_all_values(provider_id: ProviderId) -> Vec<(Key, Option<Value>)>;
+	}
+}

pallets/oracle/src/benchmarking.rs

@@ -0,0 +1,56 @@
+use super::*;
+use crate::Pallet as Oracle;
+
+use frame_benchmarking::v2::*;
+
+use frame_support::assert_ok;
+use frame_system::{Pallet as System, RawOrigin};
+
+#[instance_benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn feed_values(
+		x: Linear<0, { T::BenchmarkHelper::get_currency_id_value_pairs().len() as u32 }>,
+	) {
+		// Register the caller
+		let caller: T::AccountId = whitelisted_caller();
+		T::Members::add(&caller);
+
+		let values = T::BenchmarkHelper::get_currency_id_value_pairs()[..x as usize]
+			.to_vec()
+			.try_into()
+			.expect("Must succeed since at worst the length remained the same.");
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), values);
+
+		assert!(HasDispatched::<T, I>::get().contains(&caller));
+	}
+
+	#[benchmark]
+	fn on_finalize() {
+		// Register the caller
+		let caller: T::AccountId = whitelisted_caller();
+		T::Members::add(&caller);
+
+		// Feed some values before running `on_finalize` hook
+		System::<T>::set_block_number(1u32.into());
+		let values = T::BenchmarkHelper::get_currency_id_value_pairs();
+		assert_ok!(Oracle::<T, I>::feed_values(RawOrigin::Signed(caller).into(), values));
+
+		#[block]
+		{
+			Oracle::<T, I>::on_finalize(System::<T>::block_number());
+		}
+
+		assert!(!HasDispatched::<T, I>::exists());
+	}
+
+	impl_benchmark_test_suite! {
+		Oracle,
+		crate::mock::new_test_ext(),
+		crate::mock::Test,
+	}
+}

pallets/oracle/src/default_combine_data.rs

@@ -0,0 +1,44 @@
+use crate::{Config, MomentOf, TimestampedValueOf};
+use frame_support::traits::{Get, Time};
+use sp_runtime::traits::Saturating;
+use sp_std::{marker, prelude::*};
+use tangle_primitives::CombineData;
+
+/// Sort by value and returns median timestamped value.
+/// Returns prev_value if not enough valid values.
+pub struct DefaultCombineData<T, MinimumCount, ExpiresIn, I = ()>(
+	marker::PhantomData<(T, I, MinimumCount, ExpiresIn)>,
+);
+
+impl<T, I, MinimumCount, ExpiresIn>
+	CombineData<<T as Config<I>>::OracleKey, TimestampedValueOf<T, I>>
+	for DefaultCombineData<T, MinimumCount, ExpiresIn, I>
+where
+	T: Config<I>,
+	I: 'static,
+	MinimumCount: Get<u32>,
+	ExpiresIn: Get<MomentOf<T, I>>,
+{
+	fn combine_data(
+		_key: &<T as Config<I>>::OracleKey,
+		mut values: Vec<TimestampedValueOf<T, I>>,
+		prev_value: Option<TimestampedValueOf<T, I>>,
+	) -> Option<TimestampedValueOf<T, I>> {
+		let expires_in = ExpiresIn::get();
+		let now = T::Time::now();
+
+		values.retain(|x| x.timestamp.saturating_add(expires_in) > now);
+
+		let count = values.len() as u32;
+		let minimum_count = MinimumCount::get();
+		if count < minimum_count || count == 0 {
+			return prev_value;
+		}
+
+		let mid_index = count / 2;
+		// Won't panic as `values` ensured not empty.
+		let (_, value, _) =
+			values.select_nth_unstable_by(mid_index as usize, |a, b| a.value.cmp(&b.value));
+		Some(value.clone())
+	}
+}