Merge pull request #161 from bifrost-platform/hotfix-04

hotfix

Author: dnjscksdn98

pallets/bfc-staking/src/lib.rs

@@ -739,7 +739,12 @@ impl<
 		self.commission = commission;
 	}
 
-	pub fn reset_commission<T: Config>(&mut self) {
+	pub fn reset_commission<T: Config>(&mut self, who: &T::AccountId) {
+		let round = <Round<T>>::get();
+		let mut commission_sets = <DelayedCommissionSets<T>>::get(round.current_round_index);
+		commission_sets.retain(|c| c.who != *who);
+		<DelayedCommissionSets<T>>::insert(round.current_round_index, commission_sets);
+
 		if self.tier == TierType::Full {
 			self.commission = <DefaultFullValidatorCommission<T>>::get();
 		} else {

pallets/bfc-staking/src/pallet/impls.rs

@@ -444,6 +444,8 @@ impl<T: Config> Pallet<T> {
 				// replace `SelectedCandidates`
 				if candidate.is_selected {
 					Self::replace_from_selected_candidates(&c.old, &c.new, candidate.tier);
+				}
+				if candidate.tier == TierType::Full {
 					T::RelayManager::replace_bonded_controller(c.old.clone(), c.new.clone());
 				}
 				// replace `TopNominations`
@@ -465,8 +467,10 @@ impl<T: Config> Pallet<T> {
 					<BottomNominations<T>>::insert(&c.new, bottom_nominations);
 				}
 				// replace `AwardedPts`
-				let points = <AwardedPts<T>>::take(now, &c.old);
-				<AwardedPts<T>>::insert(now, &c.new, points);
+				let current_points = <AwardedPts<T>>::take(now, &c.old);
+				<AwardedPts<T>>::insert(now, &c.new, current_points);
+				let previous_points = <AwardedPts<T>>::take(delayed_round, &c.old);
+				<AwardedPts<T>>::insert(delayed_round, &c.new, previous_points);
 				// replace `AtStake`
 				let at_stake = <AtStake<T>>::take(now, &c.old);
 				<AtStake<T>>::insert(now, &c.new, at_stake);
@@ -951,9 +955,10 @@ impl<T: Config> Pallet<T> {
 		// snapshot total stake and storage state
 		<Staked<T>>::insert(now, Total::<T>::get());
 		<TotalAtStake<T>>::remove(now - 1);
+		// handle delayed commission update requests
+		Self::handle_delayed_commission_sets(now);
 		// handle delayed controller update requests
 		Self::handle_delayed_controller_sets(now);
-		Self::handle_delayed_commission_sets(now);
 
 		Self::deposit_event(Event::NewRound {
 			starting_block: round.first_round_block,

pallets/bfc-staking/src/pallet/mod.rs

@@ -1085,7 +1085,7 @@ pub mod pallet {
 				T::RelayManager::leave_relayers(&controller);
 			}
 			state.tier = new;
-			state.reset_commission::<T>();
+			state.reset_commission::<T>(&controller);
 			<CandidateInfo<T>>::insert(&controller, state.clone());
 			Self::update_active(&controller, state.voting_power)?;
 			Ok(().into())
@@ -1167,6 +1167,14 @@ pub mod pallet {
 			ensure!(!<BondedStash<T>>::contains_key(&stash), Error::<T>::AlreadyBonded);
 			ensure!(!<CandidateInfo<T>>::contains_key(&controller), Error::<T>::AlreadyPaired);
 
+			// check if the controller account is already scheduled for update
+			let round = Round::<T>::get();
+			let controller_sets = DelayedControllerSets::<T>::get(round.current_round_index);
+			ensure!(
+				!controller_sets.into_iter().any(|c| c.new == controller),
+				Error::<T>::AlreadyControllerSetRequested
+			);
+
 			ensure!(!Self::is_nominator(&controller), Error::<T>::NominatorExists);
 			let mut candidates = <CandidatePool<T>>::get();
 			let old_count = candidates.len() as u32;

pallets/btc-socket-queue/src/pallet/impls.rs

@@ -106,13 +106,15 @@ impl<T: Config> SocketQueueManager<T::AccountId> for Pallet<T> {
 
 	fn replace_authority(old: &T::AccountId, new: &T::AccountId) {
 		// replace authority in pending requests
-		<PendingRequests<T>>::iter().for_each(|(_, mut request)| {
+		<PendingRequests<T>>::iter().for_each(|(txid, mut request)| {
 			request.replace_authority(old, new);
+			<PendingRequests<T>>::insert(&txid, request);
 		});
 		// replace authority in rollback requests (if not approved yet)
-		<RollbackRequests<T>>::iter().for_each(|(_, mut request)| {
+		<RollbackRequests<T>>::iter().for_each(|(txid, mut request)| {
 			if !request.is_approved {
 				request.replace_authority(old, new);
+				<RollbackRequests<T>>::insert(&txid, request);
 			}
 		});
 	}

pallets/relay-manager/src/pallet/impls.rs

@@ -214,23 +214,24 @@ where
 		let delayed_round = now - 1;
 		let relayer_sets = <DelayedRelayerSets<T>>::take(delayed_round);
 		relayer_sets.into_iter().for_each(|r| {
-			Self::replace_bonded_relayer(&r.old, &r.new).expect("Replacement must success");
-			T::SocketQueue::replace_authority(&r.old, &r.new);
-			T::RegistrationPool::replace_authority(&r.old, &r.new);
-
-			// replace member of RelayExecutive (only if it's the old member)
-			let mut members = Members::<T, Instance3>::get();
-			if let Some(location) = members.binary_search(&r.old).ok() {
-				if members.binary_search(&r.new).is_err() {
-					members[location] = r.new.clone();
-					members.sort();
-
-					Members::<T, Instance3>::put(members.clone());
-					T::MembershipChanged::change_members_sorted(&[r.new.clone()], &[r.old.clone()], &members[..]);
-
-					if Prime::<T, Instance3>::get() == Some(r.old) {
-						Prime::<T, Instance3>::put(&r.new);
-						T::MembershipChanged::set_prime(Some(r.new));
+			if Self::replace_bonded_relayer(&r.old, &r.new).expect("Replacement must success") {
+				T::SocketQueue::replace_authority(&r.old, &r.new);
+				T::RegistrationPool::replace_authority(&r.old, &r.new);
+
+				// replace member of RelayExecutive (only if it's the old member)
+				let mut members = Members::<T, Instance3>::get();
+				if let Some(location) = members.binary_search(&r.old).ok() {
+					if members.binary_search(&r.new).is_err() {
+						members[location] = r.new.clone();
+						members.sort();
+
+						Members::<T, Instance3>::put(members.clone());
+						T::MembershipChanged::change_members_sorted(&[r.new.clone()], &[r.old.clone()], &members[..]);
+
+						if Prime::<T, Instance3>::get() == Some(r.old) {
+							Prime::<T, Instance3>::put(&r.new);
+							T::MembershipChanged::set_prime(Some(r.new));
+						}
 					}
 				}
 			}
@@ -277,6 +278,14 @@ impl<T: Config> Pallet<T> {
 	) -> Result<(), DispatchError> {
 		ensure!(!Self::is_relayer(relayer), Error::<T>::RelayerAlreadyJoined);
 		ensure!(!<BondedController<T>>::contains_key(controller), Error::<T>::RelayerAlreadyBonded);
+
+		let round = Round::<T>::get();
+		let relayer_sets = DelayedRelayerSets::<T>::get(round);
+		ensure!(
+			!relayer_sets.into_iter().any(|r| r.new == *relayer),
+			Error::<T>::AlreadyRelayerSetRequested
+		);
+
 		Ok(().into())
 	}