Merge pull request #157 from bifrost-platform/main

back-merge main to test

Author: dnjscksdn98

Cargo.lock

@@ -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/lib.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/impls.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/bfc-staking/src/pallet/mod.rs

@@ -36,6 +36,10 @@ pub mod pallet {
 	pub enum Error<T> {
 		/// The given amount is too low to process.
 		AmountTooLow,
+		/// The account is already blocked.
+		AccountAlreadyBlocked,
+		/// The account is not blocked.
+		AccountNotBlocked,
 	}
 
 	#[pallet::event]
@@ -56,6 +60,16 @@ pub mod pallet {
 	/// Storage for proposal index. Whenever proposal is accepted, index will be increased.
 	pub type ProposalIndex<T: Config> = StorageValue<_, PropIndex, ValueQuery>;
 
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type BlockedAccounts<T: Config> = StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+
+	impl<T: Config> Pallet<T> {
+		pub fn is_blocked_account(account: &T::AccountId) -> bool {
+			BlockedAccounts::<T>::get().contains(account)
+		}
+	}
+
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_runtime_upgrade() -> Weight {
@@ -124,5 +138,35 @@ pub mod pallet {
 
 			Ok(().into())
 		}
+
+		#[pallet::call_index(2)]
+		#[pallet::weight((T::DbWeight::get().writes(1), DispatchClass::Operational,))]
+		/// Add an account to the blocked accounts list.
+		pub fn add_blocked_account(
+			origin: OriginFor<T>,
+			account: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			ensure!(!Self::is_blocked_account(&account), Error::<T>::AccountAlreadyBlocked);
+			let mut blocked_accounts = BlockedAccounts::<T>::get();
+			blocked_accounts.push(account);
+			BlockedAccounts::<T>::put(blocked_accounts);
+			Ok(().into())
+		}
+
+		#[pallet::call_index(3)]
+		#[pallet::weight((T::DbWeight::get().writes(1), DispatchClass::Operational,))]
+		/// Remove an account from the blocked accounts list.
+		pub fn remove_blocked_account(
+			origin: OriginFor<T>,
+			account: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			ensure!(Self::is_blocked_account(&account), Error::<T>::AccountNotBlocked);
+			let mut blocked_accounts = BlockedAccounts::<T>::get();
+			blocked_accounts.retain(|a| a != &account);
+			BlockedAccounts::<T>::put(blocked_accounts);
+			Ok(().into())
+		}
 	}
 }

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

@@ -122,12 +122,17 @@ impl<T: Config> PoolManager<T::AccountId> for Pallet<T> {
 		if let Some(mut vault) = SystemVault::<T>::get(round) {
 			if vault.address == AddressState::Pending {
 				vault.replace_authority(old, new);
+				SystemVault::<T>::insert(round, vault);
 			}
 		}
 		// replace authority in all registration pools (if they are pending)
-		<RegistrationPool<T>>::iter_prefix(round).for_each(|(_, mut relay_target)| {
+		<RegistrationPool<T>>::iter_prefix(round).for_each(|(address, relay_target)| {
 			if relay_target.vault.address == AddressState::Pending {
-				relay_target.vault.replace_authority(old, new);
+				<RegistrationPool<T>>::mutate(round, &address, |relay_target| {
+					if let Some(relay_target) = relay_target {
+						relay_target.vault.replace_authority(old, new);
+					}
+				});
 			}
 		});
 	}

pallets/btc-registration-pool/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/btc-socket-queue/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())
 	}
 
@@ -316,6 +325,11 @@ impl<T: Config> Pallet<T> {
 	pub fn add_to_relayer_sets(old: T::AccountId, new: T::AccountId) -> DispatchResult {
 		let round = Round::<T>::get();
 		<DelayedRelayerSets<T>>::try_mutate(round, |relayer_sets| -> DispatchResult {
+			ensure!(
+				!relayer_sets.into_iter().any(|r| r.old == old || r.new == new),
+				Error::<T>::AlreadyRelayerSetRequested
+			);
+
 			Ok(relayer_sets
 				.try_push(DelayedRelayerSet::new(old, new))
 				.map_err(|_| <Error<T>>::TooManyDelayedRelayers)?)

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

@@ -10,6 +10,7 @@ repository = { workspace = true }
 
 [dependencies]
 parity-scale-codec = { workspace = true }
+scale-info = { workspace = true }
 ethereum = { workspace = true }
 
 # Substrate
@@ -18,16 +19,19 @@ frame-support = { workspace = true }
 sp-core = { workspace = true }
 sp-runtime = { workspace = true }
 sp-std = { workspace = true }
+pallet-bfc-utility = { workspace = true }
 
 [features]
 default = ["std"]
 std = [
+	"scale-info/std",
 	"ethereum/std",
 	"parity-scale-codec/std",
 	"frame-system/std",
 	"frame-support/std",
 	"sp-core/std",
 	"sp-runtime/std",
 	"sp-std/std",
+	"pallet-bfc-utility/std",
 ]
 try-runtime = ["frame-support/try-runtime"]

runtime/common/Cargo.toml

@@ -0,0 +1,94 @@
+use frame_support::pallet_prelude::{TransactionSource, TransactionValidityError};
+use parity_scale_codec::{Decode, DecodeWithMemTracking, Encode};
+use scale_info::TypeInfo;
+
+use sp_core::H160;
+use sp_runtime::{
+	traits::{AsSystemOriginSigner, DispatchInfoOf, Dispatchable, TransactionExtension},
+	Weight,
+};
+use sp_std::{
+	fmt::{Debug, Formatter},
+	marker::PhantomData,
+};
+
+/// Transaction extension that blocks extrinsics from specific origins
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo, DecodeWithMemTracking)]
+#[scale_info(skip_type_params(T))]
+#[codec(encode_bound())]
+#[codec(decode_bound())]
+pub struct CheckBlockedOrigin<T, Call>(PhantomData<(T, Call)>);
+
+impl<T, Call> Debug for CheckBlockedOrigin<T, Call> {
+	fn fmt(&self, f: &mut Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckBlockedOrigin")
+	}
+}
+
+impl<T, Call> Default for CheckBlockedOrigin<T, Call> {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl<T, Call> CheckBlockedOrigin<T, Call> {
+	pub fn new() -> Self {
+		Self(PhantomData)
+	}
+}
+
+impl<T, Call> TransactionExtension<Call> for CheckBlockedOrigin<T, Call>
+where
+	T: frame_system::Config + Send + Sync,
+	T::AccountId: From<H160>,
+	T: pallet_bfc_utility::Config,
+	Call: Dispatchable + Clone + Eq + TypeInfo + Send + Sync + 'static,
+	<Call as Dispatchable>::RuntimeOrigin: AsSystemOriginSigner<T::AccountId>,
+{
+	const IDENTIFIER: &'static str = "CheckBlockedOrigin";
+	type Implicit = ();
+	type Pre = ();
+	type Val = ();
+
+	fn weight(&self, _call: &Call) -> Weight {
+		Weight::zero()
+	}
+
+	fn validate(
+		&self,
+		origin: <Call as Dispatchable>::RuntimeOrigin,
+		_call: &Call,
+		_info: &DispatchInfoOf<Call>,
+		_len: usize,
+		_self_implicit: Self::Implicit,
+		_inherited_implication: &impl Encode,
+		_source: TransactionSource,
+	) -> Result<
+		(
+			sp_runtime::transaction_validity::ValidTransaction,
+			Self::Val,
+			<Call as Dispatchable>::RuntimeOrigin,
+		),
+		TransactionValidityError,
+	> {
+		if let Some(who) = origin.as_system_origin_signer() {
+			if pallet_bfc_utility::Pallet::<T>::is_blocked_account(who) {
+				return Err(TransactionValidityError::Invalid(
+					sp_runtime::transaction_validity::InvalidTransaction::BadSigner,
+				));
+			}
+		}
+		Ok((sp_runtime::transaction_validity::ValidTransaction::default(), (), origin))
+	}
+
+	fn prepare(
+		self,
+		_val: Self::Val,
+		_origin: &<Call as Dispatchable>::RuntimeOrigin,
+		_call: &Call,
+		_info: &DispatchInfoOf<Call>,
+		_len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		Ok(())
+	}
+}