Update market after order is created or comfirmed

modules/dispatch/src/lib.rs

@@ -166,7 +166,10 @@ impl<T: Config<I>, I: 'static> MessageDispatch<T::AccountId, T::BridgeMessageId>
 		match message {
 			Ok(raw_message) =>
 				if let Ok(call) = raw_message.clone().call.into() {
-					return T::CallValidator::check_receiving_before_dispatch(relayer_account, &call)
+					return T::CallValidator::check_receiving_before_dispatch(
+						relayer_account,
+						&call,
+					);
 				},
 			Err(_) => {
 				log::trace!(

modules/fee-market/src/lib.rs

@@ -462,11 +462,6 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		Self::assigned_relayers().and_then(|relayers| relayers.last().map(|r| r.fee))
 	}
 
-	/// Get order indexes in the storage
-	pub fn in_process_orders() -> Vec<(LaneId, MessageNonce)> {
-		Orders::<T, I>::iter().map(|(k, _v)| k).collect()
-	}
-
 	/// Get the relayer locked collateral value
 	pub fn relayer_locked_collateral(who: &T::AccountId) -> BalanceOf<T, I> {
 		RelayersMap::<T, I>::get(who).map_or(BalanceOf::<T, I>::zero(), |r| r.collateral)

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

@@ -40,8 +40,12 @@ impl<T: Config<I>, I: 'static> OnMessageAccepted for FeeMarketMessageAcceptedHan
 				assigned_relayers.clone(),
 				T::Slot::get(),
 			);
+
 			// Store the create order
 			<Orders<T, I>>::insert((order.lane, order.message), order.clone());
+			// Once order is created, the assigned relayers's order capacity should reduce by one.
+			// Thus, the whole market needs to re-sort to generate new assigned relayers set.
+			let _ = Pallet::<T, I>::update_market(|| Ok(()), None);
 
 			let ids: Vec<T::AccountId> = assigned_relayers.iter().map(|r| r.id.clone()).collect();
 			Pallet::<T, I>::deposit_event(Event::OrderCreated(
@@ -72,6 +76,11 @@ impl<T: Config<I>, I: 'static> OnDeliveryConfirmed for FeeMarketMessageConfirmed
 						Some(order) => order.set_confirm_time(Some(now)),
 						None => {},
 					});
+
+					// Once order is confirmed, the assigned relayers's order capacity should
+					// increase by one. Thus, the whole market needs to re-sort to generate new
+					// assigned relayers set.
+					let _ = Pallet::<T, I>::update_market(|| Ok(()), None);
 				}
 			}
 		}

modules/fee-market/src/tests.rs

@@ -739,9 +739,9 @@ fn receive_messages_delivery_proof() {
 #[test]
 fn test_callback_order_creation() {
 	new_test_ext().execute_with(|| {
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, Some(30));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 110, Some(50));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(3), 120, Some(100));
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 200, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(3), 210, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(4), 220, None);
 		System::set_block_number(2);
 
 		let assigned_relayers = FeeMarket::assigned_relayers().unwrap();
@@ -770,8 +770,8 @@ fn test_callback_order_creation() {
 #[test]
 fn test_callback_no_order_created_when_fee_market_not_ready() {
 	new_test_ext().execute_with(|| {
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, Some(30));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 110, Some(50));
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 100, None);
 		System::set_block_number(2);
 
 		assert!(FeeMarket::assigned_relayers().is_none());
@@ -790,9 +790,9 @@ fn test_callback_no_order_created_when_fee_market_not_ready() {
 fn test_callback_order_confirm() {
 	new_test_ext().execute_with(|| {
 		System::set_block_number(2);
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, Some(30));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 110, Some(50));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(3), 120, Some(100));
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 110, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(3), 120, None);
 		let market_fee = FeeMarket::market_fee().unwrap();
 		let (lane, message_nonce) = send_regular_message(market_fee);
 		let order = FeeMarket::order((&lane, &message_nonce)).unwrap();
@@ -1148,9 +1148,9 @@ fn test_payment_cal_slash_with_multiple_message() {
 fn test_clean_order_state_at_the_end_of_block() {
 	new_test_ext().execute_with(|| {
 		System::set_block_number(2);
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(6), 400, Some(300));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(7), 400, Some(500));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(8), 400, Some(1000));
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(6), 400, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(7), 400, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(8), 400, None);
 		let market_fee = FeeMarket::market_fee().unwrap();
 		let (lane1, nonce1) = send_regular_message(market_fee);
 		let (lane2, nonce2) = send_regular_message(market_fee);
@@ -1197,8 +1197,8 @@ fn test_clean_order_state_at_the_end_of_block() {
 #[test]
 fn test_fee_verification_when_send_message() {
 	new_test_ext().execute_with(|| {
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, Some(30));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 100, Some(40));
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(1), 100, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(2), 100, None);
 		assert!(FeeMarket::market_fee().is_none());
 
 		// Case 1: When fee market are not ready, but somebody send messages
@@ -1228,12 +1228,12 @@ fn test_fee_verification_when_send_message() {
 }
 
 #[test]
-fn test_relayer_is_occupied() {
+fn test_relayer_occupied_result() {
 	new_test_ext().execute_with(|| {
 		System::set_block_number(2);
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(5), 300, Some(30));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(6), 300, Some(50));
-		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(7), 300, Some(100));
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(5), 300, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(6), 300, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(7), 300, None);
 
 		// Send message
 		let market_fee = FeeMarket::market_fee().unwrap();
@@ -1243,9 +1243,59 @@ fn test_relayer_is_occupied() {
 		assert_eq!(FeeMarket::occupied(&5), Some((2, 200)));
 		assert_eq!(FeeMarket::occupied(&6), Some((2, 200)));
 		assert_eq!(FeeMarket::occupied(&7), Some((2, 200)));
+		assert_eq!(FeeMarket::usable_order_capacity(&5), 1);
+		assert_eq!(FeeMarket::usable_order_capacity(&6), 1);
+		assert_eq!(FeeMarket::usable_order_capacity(&7), 1);
 		receive_messages_delivery_proof();
 		assert_eq!(FeeMarket::occupied(&5), Some((1, 100)));
 		assert_eq!(FeeMarket::occupied(&6), Some((1, 100)));
 		assert_eq!(FeeMarket::occupied(&7), Some((1, 100)));
+		assert_eq!(FeeMarket::usable_order_capacity(&5), 2);
+		assert_eq!(FeeMarket::usable_order_capacity(&6), 2);
+		assert_eq!(FeeMarket::usable_order_capacity(&7), 2);
+	});
+}
+
+#[test]
+fn test_relayer_update_order_capacity() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(2);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(5), 300, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(6), 300, None);
+		let _ = FeeMarket::enroll_and_lock_collateral(Origin::signed(7), 300, None);
+
+		let market_fee = FeeMarket::market_fee().unwrap();
+		let _ = send_regular_message(market_fee);
+		let _ = send_regular_message(market_fee);
+		let _ = send_regular_message(market_fee);
+
+		assert_eq!(FeeMarket::occupied(&5), Some((3, 300)));
+		assert_eq!(FeeMarket::usable_order_capacity(&5), 0);
+		assert_eq!(FeeMarket::usable_order_capacity(&6), 0);
+		assert_eq!(FeeMarket::usable_order_capacity(&7), 0);
+		assert!(FeeMarket::market_fee().is_none());
+
+		System::set_block_number(10);
+		assert_ok!(Messages::receive_messages_delivery_proof(
+			Origin::signed(5),
+			TestMessagesDeliveryProof(Ok((
+				TEST_LANE_ID,
+				InboundLaneData {
+					relayers: vec![unrewarded_relayer(1, 3, TEST_RELAYER_A),].into_iter().collect(),
+					..Default::default()
+				}
+			))),
+			UnrewardedRelayersState {
+				unrewarded_relayer_entries: 1,
+				total_messages: 3,
+				..Default::default()
+			},
+		));
+
+		assert_eq!(FeeMarket::occupied(&5), None);
+		assert_eq!(FeeMarket::usable_order_capacity(&5), 3);
+		assert_eq!(FeeMarket::usable_order_capacity(&6), 3);
+		assert_eq!(FeeMarket::usable_order_capacity(&7), 3);
+		assert!(FeeMarket::market_fee().is_some());
 	});
 }

modules/messages/src/inbound_lane.rs

@@ -149,7 +149,7 @@ impl<S: InboundLaneStorage> InboundLane<S> {
 		};
 		// if there are some extra pre-dispatch validation errors, reject this message.
 		if P::pre_dispatch(relayer_at_this_chain, &dispatch_message).is_err() {
-			return ReceivalResult::PreDispatchValidateFailed
+			return ReceivalResult::PreDispatchValidateFailed;
 		}
 
 		// then, dispatch message

modules/messages/src/lib.rs

@@ -466,10 +466,10 @@ pub mod pallet {
 								!dispatch_result.dispatch_fee_paid_during_dispatch,
 							)
 						},
-						ReceivalResult::InvalidNonce |
-						ReceivalResult::TooManyUnrewardedRelayers |
-						ReceivalResult::PreDispatchValidateFailed |
-						ReceivalResult::TooManyUnconfirmedMessages => (dispatch_weight, true),
+						ReceivalResult::InvalidNonce
+						| ReceivalResult::TooManyUnrewardedRelayers
+						| ReceivalResult::PreDispatchValidateFailed
+						| ReceivalResult::TooManyUnconfirmedMessages => (dispatch_weight, true),
 					};
 
 					let unspent_weight = sp_std::cmp::min(unspent_weight, dispatch_weight);

primitives/message-dispatch/src/lib.rs

@@ -167,7 +167,10 @@ pub trait CallValidate<AccountId, Origin, Call> {
 	///
 	/// This will be called before the call enter dispatch phase. If failed, the message(call) will
 	/// be not be processed by this relayer, latter relayers can still continue process it.
-	fn check_receiving_before_dispatch(relayer_account: &AccountId, call: &Call) -> Result<(), &'static str>;
+	fn check_receiving_before_dispatch(
+		relayer_account: &AccountId,
+		call: &Call,
+	) -> Result<(), &'static str>;
 	/// In-dispatch call validation
 	///
 	/// This will be called in the dispatch process, If failed, return message dispatch errors.
@@ -189,4 +192,4 @@ impl<AccountId, Origin, Call> CallValidate<AccountId, Origin, Call> for Everythi
 	fn call_validate(_: &AccountId, _: &Origin, _: &Call) -> Result<(), TransactionValidityError> {
 		Ok(())
 	}
-}
+}