staking handler - lock comparator decisions based on lock identifier only

runtime-modules/council/src/mock.rs

@@ -27,7 +27,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
     Perbill,
 };
-use staking_handler::{BalanceLock, LockComparator, StakingManager};
+use staking_handler::{LockComparator, StakingManager};
 use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::marker::PhantomData;
@@ -303,7 +303,7 @@ parameter_types! {
 impl LockComparator<<Runtime as balances::Trait>::Balance> for Runtime {
     fn are_locks_conflicting(
         _new_lock: &LockIdentifier,
-        _existing_locks: &[BalanceLock<<Runtime as balances::Trait>::Balance>],
+        _existing_locks: &[LockIdentifier],
     ) -> bool {
         true
     }

runtime-modules/proposals/codex/src/tests/mock.rs

@@ -11,7 +11,7 @@ use sp_runtime::{
     Perbill,
 };
 use sp_staking::SessionIndex;
-use staking_handler::{BalanceLock, LockComparator, StakingManager};
+use staking_handler::{LockComparator, StakingManager};
 
 use crate::{ProposalDetailsOf, ProposalEncoder, ProposalParameters};
 use proposals_engine::VotersParameters;
@@ -457,7 +457,7 @@ impl pallet_timestamp::Trait for Test {
 impl LockComparator<<Test as balances::Trait>::Balance> for Test {
     fn are_locks_conflicting(
         _new_lock: &LockIdentifier,
-        _existing_locks: &[BalanceLock<<Test as balances::Trait>::Balance>],
+        _existing_locks: &[LockIdentifier],
     ) -> bool {
         true
     }

runtime-modules/proposals/engine/src/tests/mock/mod.rs

@@ -20,7 +20,7 @@ pub(crate) mod proposals;
 
 use crate::ProposalObserver;
 pub use proposals::*;
-use staking_handler::{BalanceLock, LockComparator, StakingManager};
+use staking_handler::{LockComparator, StakingManager};
 
 // Workaround for https://github.com/rust-lang/rust/issues/26925 . Remove when sorted.
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -228,7 +228,7 @@ impl minting::Trait for Test {
 impl LockComparator<<Test as balances::Trait>::Balance> for Test {
     fn are_locks_conflicting(
         _new_lock: &LockIdentifier,
-        _existing_locks: &[BalanceLock<<Test as balances::Trait>::Balance>],
+        _existing_locks: &[LockIdentifier],
     ) -> bool {
         true
     }

runtime-modules/service-discovery/src/mock.rs

@@ -11,7 +11,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
     Perbill,
 };
-use staking_handler::{BalanceLock, LockComparator, StakingManager};
+use staking_handler::{LockComparator, StakingManager};
 
 // The storage working group instance alias.
 pub type StorageWorkingGroupInstance = working_group::Instance2;
@@ -227,7 +227,7 @@ impl pallet_timestamp::Trait for Test {
 impl LockComparator<<Test as balances::Trait>::Balance> for Test {
     fn are_locks_conflicting(
         _new_lock: &LockIdentifier,
-        _existing_locks: &[BalanceLock<<Test as balances::Trait>::Balance>],
+        _existing_locks: &[LockIdentifier],
     ) -> bool {
         true
     }

runtime-modules/staking-handler/src/lib.rs

@@ -10,9 +10,7 @@ use frame_support::dispatch::{DispatchError, DispatchResult};
 use frame_support::traits::{Currency, Get, LockIdentifier, LockableCurrency, WithdrawReasons};
 use sp_arithmetic::traits::Zero;
 use sp_std::marker::PhantomData;
-
-// re-export BalanceLock used in LockComparator so that modules using StakingHandler don't have to depend on pallet_balances
-pub use pallet_balances::BalanceLock;
+use sp_std::vec::Vec;
 
 #[cfg(test)]
 mod mock;
@@ -22,10 +20,7 @@ mod test;
 /// Trait for (dis)allowing certain stake locks combinations.
 pub trait LockComparator<Balance> {
     /// Checks if stake lock that is about to be used is conflicting with existing locks.
-    fn are_locks_conflicting(
-        new_lock: &LockIdentifier,
-        existing_locks: &[BalanceLock<Balance>],
-    ) -> bool;
+    fn are_locks_conflicting(new_lock: &LockIdentifier, existing_locks: &[LockIdentifier]) -> bool;
 }
 
 /// Defines abstract staking handler to manage user stakes for different activities
@@ -172,8 +167,10 @@ impl<
         account_id: &<T as frame_system::Trait>::AccountId,
     ) -> bool {
         let locks = <pallet_balances::Module<T>>::locks(&account_id);
+        let lock_ids: Vec<LockIdentifier> =
+            locks.iter().map(|balance_lock| balance_lock.id).collect();
 
-        T::are_locks_conflicting(&LockId::get(), locks.as_slice())
+        T::are_locks_conflicting(&LockId::get(), lock_ids.as_slice())
     }
 
     fn is_enough_balance_for_stake(

runtime-modules/staking-handler/src/mock.rs

@@ -1,4 +1,4 @@
-use crate::{BalanceLock, LockComparator};
+use crate::LockComparator;
 use frame_support::traits::LockIdentifier;
 use frame_support::{impl_outer_origin, parameter_types};
 use frame_system;
@@ -77,14 +77,11 @@ impl membership::Trait for Test {
 }
 
 impl LockComparator<<Test as pallet_balances::Trait>::Balance> for Test {
-    fn are_locks_conflicting(
-        new_lock: &LockIdentifier,
-        existing_locks: &[BalanceLock<<Test as pallet_balances::Trait>::Balance>],
-    ) -> bool {
+    fn are_locks_conflicting(new_lock: &LockIdentifier, existing_locks: &[LockIdentifier]) -> bool {
         // simple check preventing lock reuse
         existing_locks
             .iter()
-            .find(|lock| &lock.id == new_lock)
+            .find(|lock| *lock == new_lock)
             .is_none()
     }
 }

runtime-modules/storage/src/tests/mock.rs

@@ -10,7 +10,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
     Perbill,
 };
-use staking_handler::{BalanceLock, LockComparator, StakingManager};
+use staking_handler::{LockComparator, StakingManager};
 
 use crate::data_directory::ContentIdExists;
 use crate::data_object_type_registry::IsActiveDataObjectType;
@@ -295,7 +295,7 @@ impl recurringrewards::Trait for Test {
 impl LockComparator<<Test as balances::Trait>::Balance> for Test {
     fn are_locks_conflicting(
         _new_lock: &LockIdentifier,
-        _existing_locks: &[BalanceLock<<Test as balances::Trait>::Balance>],
+        _existing_locks: &[LockIdentifier],
     ) -> bool {
         true
     }

runtime-modules/working-group/src/tests/mock.rs

@@ -9,7 +9,7 @@ use sp_runtime::{
     traits::{BlakeTwo256, IdentityLookup},
     Perbill,
 };
-use staking_handler::{BalanceLock, LockComparator, StakingManager};
+use staking_handler::{LockComparator, StakingManager};
 
 use crate::{DefaultInstance, Module, Trait};
 
@@ -107,7 +107,7 @@ impl membership::Trait for Test {
 impl LockComparator<<Test as balances::Trait>::Balance> for Test {
     fn are_locks_conflicting(
         _new_lock: &LockIdentifier,
-        _existing_locks: &[BalanceLock<<Test as balances::Trait>::Balance>],
+        _existing_locks: &[LockIdentifier],
     ) -> bool {
         true
     }

runtime/src/lib.rs

@@ -55,7 +55,7 @@ pub use runtime_api::*;
 use integration::proposals::{CouncilManager, ExtrinsicProposalEncoder, MembershipOriginValidator};
 
 use governance::{council, election};
-use staking_handler::{BalanceLock, LockComparator};
+use staking_handler::LockComparator;
 use storage::data_object_storage_registry;
 
 // Node dependencies
@@ -588,12 +588,9 @@ impl forum::Trait for Runtime {
 }
 
 impl LockComparator<<Runtime as pallet_balances::Trait>::Balance> for Runtime {
-    fn are_locks_conflicting(
-        new_lock: &LockIdentifier,
-        existing_locks: &[BalanceLock<<Runtime as pallet_balances::Trait>::Balance>],
-    ) -> bool {
+    fn are_locks_conflicting(new_lock: &LockIdentifier, existing_locks: &[LockIdentifier]) -> bool {
         for lock in existing_locks {
-            if !ALLOWED_LOCK_COMBINATIONS.contains(&(*new_lock, lock.id)) {
+            if !ALLOWED_LOCK_COMBINATIONS.contains(&(*new_lock, *lock)) {
                 return false;
             }
         }