Companions fee market

modules/fee-market/src/benchmarking.rs

@@ -21,14 +21,14 @@
 
 use super::*;
 use crate::Pallet as FeeMarket;
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::{account, benchmarks_instance_pallet};
 use frame_support::assert_ok;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Saturating;
 
 const SEED: u32 = 0;
 
-fn fee_market_ready<T: Config>() {
+fn fee_market_ready<T: Config<I>, I: 'static>() {
 	let caller0: T::AccountId = account("source", 0, SEED);
 	let caller1: T::AccountId = account("source", 1, SEED);
 	let caller2: T::AccountId = account("source", 2, SEED);
@@ -41,78 +41,78 @@ fn fee_market_ready<T: Config>() {
 	assert_ne!(caller0, caller1);
 	assert_ne!(caller1, caller2);
 
-	assert_ok!(<FeeMarket<T>>::enroll_and_lock_collateral(
+	assert_ok!(<FeeMarket<T, I>>::enroll_and_lock_collateral(
 		RawOrigin::Signed(caller0).into(),
 		collateral,
 		None
 	));
-	assert_ok!(<FeeMarket<T>>::enroll_and_lock_collateral(
+	assert_ok!(<FeeMarket<T, I>>::enroll_and_lock_collateral(
 		RawOrigin::Signed(caller1).into(),
 		collateral,
 		None
 	));
-	assert_ok!(<FeeMarket<T>>::enroll_and_lock_collateral(
+	assert_ok!(<FeeMarket<T, I>>::enroll_and_lock_collateral(
 		RawOrigin::Signed(caller2).into(),
 		collateral,
 		None
 	));
-	assert_ok!(<FeeMarket<T>>::enroll_and_lock_collateral(
+	assert_ok!(<FeeMarket<T, I>>::enroll_and_lock_collateral(
 		RawOrigin::Signed(caller3).into(),
 		collateral,
 		None
 	));
-	assert!(<FeeMarket<T>>::market_fee().is_some());
-	assert_eq!(<FeeMarket<T>>::relayers().len(), 4);
+	assert!(<FeeMarket<T, I>>::market_fee().is_some());
+	assert_eq!(<FeeMarket<T, I>>::relayers().len(), 4);
 }
 
-benchmarks! {
+benchmarks_instance_pallet! {
 	enroll_and_lock_collateral {
-		fee_market_ready::<T>();
+		fee_market_ready::<T, I>();
 		let relayer: T::AccountId = account("source", 100, SEED);
 		T::Currency::make_free_balance_be(&relayer, T::CollateralPerOrder::get().saturating_mul(10u32.into()));
 		let lock_collateral = T::CollateralPerOrder::get().saturating_mul(5u32.into());
 	}: enroll_and_lock_collateral(RawOrigin::Signed(relayer.clone()), lock_collateral, None)
 	verify {
-		assert!(<FeeMarket<T>>::is_enrolled(&relayer));
-		assert_eq!(<FeeMarket<T>>::relayers().len(), 5);
+		assert!(<FeeMarket<T, I>>::is_enrolled(&relayer));
+		assert_eq!(<FeeMarket<T, I>>::relayers().len(), 5);
 	}
 
 	update_locked_collateral {
-		fee_market_ready::<T>();
+		fee_market_ready::<T, I>();
 		let caller3: T::AccountId = account("source", 3, SEED);
 		let new_collateral = T::CollateralPerOrder::get().saturating_mul(5u32.into());
 	}: update_locked_collateral(RawOrigin::Signed(caller3.clone()), new_collateral)
 	verify {
-		let relayer = <FeeMarket<T>>::relayer(&caller3);
+		let relayer = <FeeMarket<T, I>>::relayer(&caller3);
 		assert_eq!(relayer.collateral,  T::CollateralPerOrder::get().saturating_mul(5u32.into()));
 	}
 
 	update_relay_fee {
-		fee_market_ready::<T>();
+		fee_market_ready::<T, I>();
 		let caller3: T::AccountId = account("source", 3, SEED);
 		let new_fee = T::CollateralPerOrder::get().saturating_mul(10u32.into());
 	}: update_relay_fee(RawOrigin::Signed(caller3.clone()), new_fee)
 	verify {
-		let relayer = <FeeMarket<T>>::relayer(&caller3);
+		let relayer = <FeeMarket<T, I>>::relayer(&caller3);
 		assert_eq!(relayer.fee,  T::CollateralPerOrder::get().saturating_mul(10u32.into()));
 	}
 
 	cancel_enrollment {
-		fee_market_ready::<T>();
+		fee_market_ready::<T, I>();
 		let caller1: T::AccountId = account("source", 1, SEED);
 	}: cancel_enrollment(RawOrigin::Signed(caller1.clone()))
 	verify {
-		assert!(!<FeeMarket<T>>::is_enrolled(&caller1));
-		assert_eq!(<FeeMarket<T>>::relayers().len(), 3);
+		assert!(!<FeeMarket<T, I>>::is_enrolled(&caller1));
+		assert_eq!(<FeeMarket<T, I>>::relayers().len(), 3);
 	}
 
 	set_slash_protect {
 	}:set_slash_protect(RawOrigin::Root, T::CollateralPerOrder::get().saturating_mul(1u32.into()))
 
 	set_assigned_relayers_number{
-		fee_market_ready::<T>();
+		fee_market_ready::<T, I>();
 	}: set_assigned_relayers_number(RawOrigin::Root, 1)
 	verify {
-		assert_eq!(<FeeMarket<T>>::assigned_relayers().unwrap().len(), 1);
+		assert_eq!(<FeeMarket<T, I>>::assigned_relayers().unwrap().len(), 1);
 	}
 }

modules/fee-market/src/lib.rs

@@ -47,6 +47,7 @@ use sp_runtime::{
 };
 use sp_std::vec::Vec;
 // --- darwinia-network ---
+use s2s::RewardItem;
 use types::{Order, Relayer, SlashReport};
 
 pub type AccountId<T> = <T as frame_system::Config>::AccountId;
@@ -107,6 +108,17 @@ pub mod pallet {
 		UpdateAssignedRelayersNumber(u32),
 		/// Slash report
 		FeeMarketSlash(SlashReport<T::AccountId, T::BlockNumber, BalanceOf<T, I>>),
+		/// Create new order. \[lane_id, message_nonce, order_fee, assigned_relayers,
+		/// out_of_slots_time\]
+		OrderCreated(
+			LaneId,
+			MessageNonce,
+			BalanceOf<T, I>,
+			Vec<T::AccountId>,
+			Option<T::BlockNumber>,
+		),
+		/// Reward distribute of the order. \[lane_id, message_nonce, rewards\]
+		OrderReward(LaneId, MessageNonce, RewardItem<T::AccountId, BalanceOf<T, I>>),
 	}
 
 	#[pallet::error]
@@ -117,6 +129,8 @@ pub mod pallet {
 		AlreadyEnrolled,
 		/// This relayer doesn't enroll ever.
 		NotEnrolled,
+		/// Locked collateral is too low to cover one order.
+		CollateralTooLow,
 		/// Update locked collateral is not allow since some orders are not confirm.
 		StillHasOrdersNotConfirmed,
 		/// The fee is lower than MinimumRelayFee.
@@ -206,6 +220,12 @@ pub mod pallet {
 				T::Currency::free_balance(&who) >= lock_collateral,
 				<Error<T, I>>::InsufficientBalance
 			);
+
+			ensure!(
+				Self::collateral_to_order_capacity(lock_collateral) > 0,
+				<Error<T, I>>::CollateralTooLow
+			);
+
 			if let Some(fee) = relay_fee {
 				ensure!(fee >= T::MinimumRelayFee::get(), <Error<T, I>>::RelayFeeTooLow);
 			}

modules/fee-market/src/s2s/callbacks.rs

@@ -37,15 +37,25 @@ impl<T: Config<I>, I: 'static> OnMessageAccepted for FeeMarketMessageAcceptedHan
 				*message,
 				now,
 				T::CollateralPerOrder::get(),
-				assigned_relayers,
+				assigned_relayers.clone(),
 				T::Slot::get(),
 			);
 			// Store the create order
 			<Orders<T, I>>::insert((order.lane, order.message), order.clone());
+
+			let ids: Vec<T::AccountId> = assigned_relayers.iter().map(|r| r.id.clone()).collect();
+			Pallet::<T, I>::deposit_event(Event::OrderCreated(
+				order.lane,
+				order.message,
+				order.fee(),
+				ids,
+				order.range_end(),
+			));
 		}
 
-		// one read for assigned relayers
-		// one write for store order
+		// Storage: FeeMarket AssignedRelayers (r:1 w:0)
+		// Storage: FeeMarket Orders (r:0 w:1)
+		// Storage: System Events (r:0 w:1)
 		<T as frame_system::Config>::DbWeight::get().reads_writes(1, 1)
 	}
 }
@@ -66,8 +76,7 @@ impl<T: Config<I>, I: 'static> OnDeliveryConfirmed for FeeMarketMessageConfirmed
 			}
 		}
 
-		// one db read for get order
-		// one db write for update order confirm time
+		// Storage: FeeMarket Orders (r:1 w:1)
 		<T as frame_system::Config>::DbWeight::get().reads_writes(1, 1)
 	}
 }

modules/fee-market/src/s2s/mod.rs

@@ -17,7 +17,7 @@
 // along with Darwinia. If not, see <https://www.gnu.org/licenses/>.
 
 pub mod payment;
-pub use payment::FeeMarketPayment;
+pub use payment::{FeeMarketPayment, RewardItem};
 
 pub mod callbacks;
 pub use callbacks::{FeeMarketMessageAcceptedHandler, FeeMarketMessageConfirmedHandler};