TRN-808 Sylo Data Pallet

Cargo.toml

@@ -132,6 +132,7 @@ pallet-nft-peg = { path = "pallet/nft-peg", default-features = false }
 pallet-sft = { path = "pallet/sft", default-features = false }
 pallet-sft-rpc = { path = "pallet/sft/rpc", default-features = false }
 pallet-sft-rpc-runtime-api = { path = "pallet/sft/rpc/runtime-api", default-features = false }
+pallet-sylo = { path = "pallet/sylo", default-features = false }
 pallet-token-approvals = { path = "pallet/token-approvals", default-features = false }
 pallet-tx-fee-pot = { path = "pallet/tx-fee-pot", default-features = false }
 pallet-vortex-distribution = { path = "pallet/vortex-distribution", default-features = false }

pallet/common/src/test_utils.rs

@@ -723,3 +723,27 @@ macro_rules! impl_pallet_scheduler_config {
 		}
 	};
 }
+
+#[macro_export]
+macro_rules! impl_pallet_sylo_config {
+	($test:ident) => {
+		parameter_types! {
+			pub const MaxResolvers: u32 = 10;
+			pub const MaxTags: u32 = 10;
+			pub const MaxEntries: u32 = 100;
+			pub const MaxServiceEndpoints: u32 = 10;
+			pub const StringLimit: u32 = 500;
+		}
+		impl pallet_sylo::Config for Test {
+			type RuntimeCall = RuntimeCall;
+			type RuntimeEvent = RuntimeEvent;
+			type ApproveOrigin = EnsureRoot<AccountId>;
+			type MaxResolvers = MaxResolvers;
+			type MaxTags = MaxTags;
+			type MaxEntries = MaxEntries;
+			type MaxServiceEndpoints = MaxServiceEndpoints;
+			type StringLimit = StringLimit;
+			type WeightInfo = ();
+		}
+	};
+}

pallet/fee-control/Cargo.toml

@@ -38,6 +38,7 @@ pallet-fee-proxy = { workspace = true, default-features = true }
 pallet-dex = { workspace = true }
 pallet-assets-ext = { workspace = true }
 pallet-futurepass = { workspace = true }
+pallet-sylo = { workspace = true }
 seed-pallet-common= { workspace = true, default-features = true }
 
 [features]

pallet/fee-control/src/mock.rs

@@ -39,6 +39,7 @@ construct_runtime!(
 		Evm: pallet_evm,
 		Timestamp: pallet_timestamp,
 		Futurepass: pallet_futurepass,
+		Sylo: pallet_sylo,
 		MockPallet: mock_pallet::pallet,
 		FeeControl: pallet_fee_control,
 	}
@@ -54,6 +55,7 @@ impl_pallet_dex_config!(Test);
 impl_pallet_timestamp_config!(Test);
 impl_pallet_evm_config!(Test);
 impl_pallet_futurepass_config!(Test);
+impl_pallet_sylo_config!(Test);
 impl_pallet_fee_control_config!(Test);
 
 impl mock_pallet::pallet::Config for Test {}

pallet/fee-proxy/Cargo.toml

@@ -23,6 +23,7 @@ pallet-evm = { workspace = true }
 pallet-assets-ext = { workspace = true }
 pallet-dex = { workspace = true }
 pallet-futurepass = { workspace = true }
+pallet-sylo = { workspace = true }
 pallet-transaction-payment = { workspace = true }
 precompile-utils = { workspace = true }
 
@@ -45,6 +46,7 @@ std = [
     "pallet-assets-ext/std",
     "pallet-futurepass/std",
     "pallet-evm/std",
+    "pallet-sylo/std",
     "pallet-transaction-payment/std",
     "scale-info/std",
     "seed-primitives/std",

pallet/fee-proxy/src/impls.rs

@@ -30,12 +30,16 @@ where
 		+ pallet_dex::Config
 		+ pallet_evm::Config
 		+ pallet_assets_ext::Config
-		+ pallet_futurepass::Config,
+		+ pallet_futurepass::Config
+		+ pallet_sylo::Config,
 	<T as frame_system::Config>::RuntimeCall: IsSubType<crate::Call<T>>,
 	<T as frame_system::Config>::RuntimeCall: IsSubType<pallet_futurepass::Call<T>>,
+	<T as frame_system::Config>::RuntimeCall: IsSubType<pallet_sylo::Call<T>>,
 	<T as Config>::RuntimeCall: IsSubType<pallet_evm::Call<T>>,
 	<T as Config>::RuntimeCall: IsSubType<pallet_futurepass::Call<T>>,
+	<T as Config>::RuntimeCall: IsSubType<pallet_sylo::Call<T>>,
 	<T as pallet_futurepass::Config>::RuntimeCall: IsSubType<pallet_evm::Call<T>>,
+	<T as pallet_futurepass::Config>::RuntimeCall: IsSubType<pallet_sylo::Call<T>>,
 	<T as Config>::OnChargeTransaction: OnChargeTransaction<T>,
 	<T as Config>::ErcIdConversion: ErcIdConversion<AssetId, EvmId = Address>,
 	Balance: From<<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::Balance>,
@@ -45,7 +49,10 @@ where
 		<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::LiquidityInfo;
 
 	/// Intercept the withdraw fee, and swap any tokens to gas tokens if the call is
-	/// pallet_fee_proxy.call_with_fee_preferences()
+	/// pallet_fee_proxy.call_with_fee_preferences().
+	///
+	/// This also additionally will force the Sylo token as the gas token if the call
+	/// is detected as  a extrinsic for the sylo pallet.
 	fn withdraw_fee(
 		who: &T::AccountId,
 		call: &<T as frame_system::Config>::RuntimeCall,
@@ -65,12 +72,61 @@ where
 			}
 		}
 
+		let do_fee_swap = |who: &T::AccountId,
+		                   payment_asset: &AssetId,
+		                   mut total_fee: Balance,
+		                   max_payment: Balance|
+		 -> Result<(), TransactionValidityError> {
+			let native_asset = <T as Config>::FeeAssetId::get();
+
+			// If the account has less balance than the minimum_deposit, we need to add
+			// the minimum deposit onto the total_fee.
+			// This is due to the preservation rules of the withdraw call made within
+			// <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::withdraw_fee
+			let account_balance = pallet_assets_ext::Pallet::<T>::balance(native_asset, who);
+			// Minium balance is hardcoded to 1
+			let minimum_balance = pallet_assets_ext::Pallet::<T>::minimum_balance(native_asset);
+			if account_balance < minimum_balance {
+				total_fee = total_fee.saturating_add(minimum_balance);
+			}
+			let path: &[AssetId] = &[*payment_asset, native_asset];
+			pallet_dex::Pallet::<T>::do_swap_with_exact_target(
+				who,
+				total_fee,
+				max_payment,
+				path,
+				*who,
+				None,
+			)
+			.map_err(|_| InvalidTransaction::Stale)?;
+
+			Ok(())
+		};
+
+		let is_sylo_call = is_sylo_call::<T>(call);
+
+		// if the call is a sylo pallet call, then we always force a fee swap with the
+		// sylo token
+		if is_sylo_call {
+			// let payment_asset =
+			// 	pallet_sylo::Pallet::<T>::payment_asset().ok_or(InvalidTransaction::Payment)?;
+
+			let payment_asset =
+				pallet_sylo::SyloAssetId::<T>::get().ok_or(InvalidTransaction::Payment)?;
+
+			do_fee_swap(who, &payment_asset, Balance::from(fee), u128::MAX)?;
+		}
+
 		// Check whether this call has specified fee preferences
 		if let Some(call_with_fee_preferences { payment_asset, max_payment, call }) =
 			call.is_sub_type()
 		{
+			// prevent using the fee proxy if the inner call is a sylo call
+			if is_sylo_call {
+				Err(InvalidTransaction::Payment)?;
+			}
+
 			let mut total_fee: Balance = Balance::from(fee);
-			let native_asset = <T as Config>::FeeAssetId::get();
 
 			let mut add_evm_gas_cost =
 				|gas_limit: &u64,
@@ -127,27 +183,7 @@ where
 				add_evm_gas_cost(gas_limit, max_fee_per_gas, max_priority_fee_per_gas);
 			}
 
-			// If the account has less balance than the minimum_deposit, we need to add
-			// the minimum deposit onto the total_fee.
-			// This is due to the preservation rules of the withdraw call made within
-			// <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::withdraw_fee
-			let account_balance = pallet_assets_ext::Pallet::<T>::balance(native_asset, who);
-			// Minium balance is hardcoded to 1
-			// pallet_assets_ext::Pallet::<T>::minimum_balance(native_asset);
-			let minimum_balance = pallet_assets_ext::Pallet::<T>::minimum_balance(native_asset);
-			if account_balance < minimum_balance {
-				total_fee = total_fee.saturating_add(minimum_balance);
-			}
-			let path: &[AssetId] = &[*payment_asset, native_asset];
-			pallet_dex::Pallet::<T>::do_swap_with_exact_target(
-				who,
-				total_fee,
-				*max_payment,
-				path,
-				*who,
-				None,
-			)
-			.map_err(|_| InvalidTransaction::Payment)?;
+			do_fee_swap(who, payment_asset, total_fee, *max_payment)?;
 		};
 
 		<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::withdraw_fee(
@@ -182,3 +218,45 @@ where
 		)
 	}
 }
+
+/// Helper function to determine if a call is sylo pallet call that
+/// should be paid using sylo tokens.
+///
+/// Will also determine if the inner call of a futurepass or
+/// fee proxy call is a sylo call as well.
+fn is_sylo_call<T>(call: &<T as frame_system::Config>::RuntimeCall) -> bool
+where
+	T: Config
+		+ frame_system::Config<AccountId = AccountId>
+		+ pallet_futurepass::Config
+		+ pallet_sylo::Config,
+	<T as frame_system::Config>::RuntimeCall: IsSubType<crate::Call<T>>,
+	<T as frame_system::Config>::RuntimeCall: IsSubType<pallet_futurepass::Call<T>>,
+	<T as frame_system::Config>::RuntimeCall: IsSubType<pallet_sylo::Call<T>>,
+	<T as Config>::RuntimeCall: IsSubType<pallet_futurepass::Call<T>>,
+	<T as Config>::RuntimeCall: IsSubType<pallet_sylo::Call<T>>,
+	<T as pallet_futurepass::Config>::RuntimeCall: IsSubType<pallet_sylo::Call<T>>,
+{
+	if match call.is_sub_type() {
+		Some(pallet_sylo::Call::register_resolver { .. }) => true,
+		Some(pallet_sylo::Call::update_resolver { .. }) => true,
+		Some(pallet_sylo::Call::unregister_resolver { .. }) => true,
+		Some(pallet_sylo::Call::create_validation_record { .. }) => true,
+		Some(pallet_sylo::Call::add_validation_record_entry { .. }) => true,
+		Some(pallet_sylo::Call::update_validation_record { .. }) => true,
+		Some(pallet_sylo::Call::delete_validation_record { .. }) => true,
+		_ => false,
+	} {
+		return true;
+	}
+
+	if let Some(pallet_futurepass::Call::proxy_extrinsic { call, .. }) = call.is_sub_type() {
+		return is_sylo_call::<T>(call.as_ref().into_ref());
+	}
+
+	if let Some(call_with_fee_preferences { call, .. }) = call.is_sub_type() {
+		return is_sylo_call::<T>(call.as_ref().into_ref());
+	}
+
+	false
+}

pallet/fee-proxy/src/lib.rs

@@ -25,7 +25,7 @@ pub use pallet::*;
 use frame_support::{
 	dispatch::{Dispatchable, GetDispatchInfo, PostDispatchInfo},
 	pallet_prelude::*,
-	traits::IsSubType,
+	traits::{IsSubType, IsType},
 };
 use frame_system::pallet_prelude::*;
 use seed_pallet_common::{FeeConfig, MaintenanceCheckEVM};
@@ -63,7 +63,8 @@ pub mod pallet {
 			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
 			+ GetDispatchInfo
 			+ From<frame_system::Call<Self>>
-			+ IsSubType<Call<Self>>;
+			+ IsSubType<Call<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
 		/// The system event type
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 		/// The caller origin, overarching type of all pallets origins.

pallet/fee-proxy/src/mock.rs

@@ -40,6 +40,7 @@ construct_runtime!(
 		Timestamp: pallet_timestamp,
 		Futurepass: pallet_futurepass,
 		FeeControl: pallet_fee_control,
+		Sylo: pallet_sylo,
 	}
 );
 
@@ -53,6 +54,7 @@ impl_pallet_timestamp_config!(Test);
 impl_pallet_evm_config!(Test);
 impl_pallet_futurepass_config!(Test);
 impl_pallet_fee_control_config!(Test);
+impl_pallet_sylo_config!(Test);
 
 // Mock ErcIdConversion for testing purposes
 impl<RuntimeId> ErcIdConversion<RuntimeId> for Test

pallet/sylo/Cargo.toml

@@ -0,0 +1,48 @@
+[package]
+name = "pallet-sylo"
+version = "0.0.1"
+description = "Root Network Sylo Pallet"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+hex = { workspace = true }
+serde = { workspace = true }
+scale-info = { workspace = true }
+codec = { workspace = true }
+
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+frame-benchmarking = { workspace = true, optional = true }
+sp-core = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+sp-arithmetic = { workspace = true }
+sp-std = { workspace = true }
+
+seed-primitives = { workspace = true }
+seed-pallet-common = { workspace = true }
+
+[dev-dependencies]
+sp-io = { workspace = true }
+pallet-assets = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-assets-ext = { workspace = true, default-features = true }
+
+[features]
+default = ["std"]
+std = [
+    "codec/std",
+    "sp-runtime/std",
+    "frame-support/std",
+    "frame-system/std",
+    "sp-std/std",
+    "seed-primitives/std",
+    "seed-pallet-common/std",
+    "sp-io/std",
+    "frame-benchmarking?/std"
+]
+runtime-benchmarks = ["frame-benchmarking"]
+try-runtime = ["frame-support/try-runtime"]