runtime: Fix tests after working-group update.

Cargo.lock

@@ -4145,6 +4145,7 @@ dependencies = [
  "pallet-working-group",
  "parity-scale-codec",
  "serde",
+ "sp-arithmetic",
  "sp-core",
  "sp-io",
  "sp-runtime",

runtime-modules/proposals/codex/src/lib.rs

@@ -25,7 +25,7 @@
 //! - [create_add_working_group_leader_opening_proposal](./struct.Module.html#method.create_add_working_group_leader_opening_proposal)
 //! - [create_begin_review_working_group_leader_applications_proposal](./struct.Module.html#method.create_begin_review_working_group_leader_applications_proposal)
 //! - [create_fill_working_group_leader_opening_proposal](./struct.Module.html#method.create_fill_working_group_leader_opening_proposal)
-//! - [create_set_working_group_mint_capacity_proposal](./struct.Module.html#method.create_set_working_group_mint_capacity_proposal)
+//! - [create_set_working_group_budget_capacity_proposal](./struct.Module.html#method.create_set_working_group_budget_capacity_proposal)
 //! - [create_decrease_working_group_leader_stake_proposal](./struct.Module.html#method.create_decrease_working_group_leader_stake_proposal)
 //! - [create_slash_working_group_leader_stake_proposal](./struct.Module.html#method.create_slash_working_group_leader_stake_proposal)
 //! - [create_set_working_group_leader_reward_proposal](./struct.Module.html#method.create_set_working_group_leader_reward_proposal)
@@ -80,8 +80,8 @@ use proposals_engine::{
 };
 use working_group::Penalty;
 
-// 'Set working group mint capacity' proposal limit
-const WORKING_GROUP_MINT_CAPACITY_MAX_VALUE: u32 = 5_000_000;
+// 'Set working group budget capacity' proposal limit
+const WORKING_GROUP_BUDGET_CAPACITY_MAX_VALUE: u32 = 5_000_000;
 // Max allowed value for 'spending' proposal
 const MAX_SPENDING_PROPOSAL_VALUE: u32 = 5_000_000_u32;
 // Max validator count for the 'set validator count' proposal
@@ -158,8 +158,8 @@ pub trait Trait:
         ProposalParameters<Self::BlockNumber, BalanceOf<Self>>,
     >;
 
-    /// 'Set working group mint capacity' proposal parameters.
-    type SetWorkingGroupMintCapacityProposalParameters: Get<
+    /// 'Set working group budget capacity' proposal parameters.
+    type SetWorkingGroupBudgetCapacityProposalParameters: Get<
         ProposalParameters<Self::BlockNumber, BalanceOf<Self>>,
     >;
 
@@ -249,11 +249,8 @@ decl_error! {
         /// Invalid council election parameter - announcing_period
         InvalidCouncilElectionParameterAnnouncingPeriod,
 
-        /// Invalid content working group mint capacity parameter
-        InvalidContentWorkingGroupMintCapacity,
-
-        /// Invalid working group mint capacity parameter
-        InvalidWorkingGroupMintCapacity,
+        /// Invalid working group budget capacity parameter
+        InvalidWorkingGroupBudgetCapacity,
 
         /// Invalid 'set lead proposal' parameter - proposed lead cannot be a councilor
         InvalidSetLeadParameterCannotBeCouncilor,
@@ -312,9 +309,9 @@ decl_module! {
         const FillWorkingGroupOpeningProposalParameters: ProposalParameters<T::BlockNumber, BalanceOf<T>>
             = T::FillWorkingGroupOpeningProposalParameters::get();
 
-        /// Exports 'Set working group mint capacity' proposal parameters.
-        const SetWorkingGroupMintCapacityProposalParameters: ProposalParameters<T::BlockNumber, BalanceOf<T>>
-            = T::SetWorkingGroupMintCapacityProposalParameters::get();
+        /// Exports 'Set working group budget capacity' proposal parameters.
+        const SetWorkingGroupBudgetCapacityProposalParameters: ProposalParameters<T::BlockNumber, BalanceOf<T>>
+            = T::SetWorkingGroupBudgetCapacityProposalParameters::get();
 
         /// Exports 'Decrease working group leader stake' proposal parameters.
         const DecreaseWorkingGroupLeaderStakeProposalParameters: ProposalParameters<T::BlockNumber, BalanceOf<T>>
@@ -534,10 +531,10 @@ decl_module! {
             Self::create_proposal(params)?;
         }
 
-        /// Create 'Set working group mint capacity' proposal type.
+        /// Create 'Set working group budget capacity' proposal type.
         /// This proposal uses `set_mint_capacity()` extrinsic from the `working-group`  module.
         #[weight = 10_000_000] // TODO: adjust weight
-        pub fn create_set_working_group_mint_capacity_proposal(
+        pub fn create_set_working_group_budget_capacity_proposal(
             origin,
             member_id: MemberId<T>,
             title: Vec<u8>,
@@ -548,8 +545,8 @@ decl_module! {
             exact_execution_block: Option<T::BlockNumber>,
         ) {
             ensure!(
-                mint_balance <= <BalanceOfMint<T>>::from(WORKING_GROUP_MINT_CAPACITY_MAX_VALUE),
-                Error::<T>::InvalidWorkingGroupMintCapacity
+                mint_balance <= <BalanceOfMint<T>>::from(WORKING_GROUP_BUDGET_CAPACITY_MAX_VALUE),
+                Error::<T>::InvalidWorkingGroupBudgetCapacity
             );
 
             let proposal_details = ProposalDetails::SetWorkingGroupBudgetCapacity(mint_balance, working_group);
@@ -560,7 +557,7 @@ decl_module! {
                 description,
                 staking_account_id,
                 proposal_details: proposal_details.clone(),
-                proposal_parameters: T::SetWorkingGroupMintCapacityProposalParameters::get(),
+                proposal_parameters: T::SetWorkingGroupBudgetCapacityProposalParameters::get(),
                 proposal_code: T::ProposalEncoder::encode_proposal(proposal_details),
                 exact_execution_block,
             };

runtime-modules/proposals/codex/src/proposal_types/mod.rs

@@ -62,7 +62,7 @@ pub enum ProposalDetails<
 
     /// ********** Deprecated during the Babylon release.
     /// It is kept only for backward compatibility in the Pioneer. **********
-    /// Balance for the `set content working group mint capacity` proposal
+    /// Balance for the `set content working group budget capacity` proposal
     DeprecatedSetContentWorkingGroupMintCapacity(MintedBalance),
 
     /// ********** Deprecated during the Nicaea release.

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

@@ -166,16 +166,26 @@ pub type StorageWorkingGroupInstance = working_group::Instance2;
 
 parameter_types! {
     pub const MaxWorkerNumberLimit: u32 = 100;
+    pub const LockId1: [u8; 8] = [1; 8];
+    pub const LockId2: [u8; 8] = [2; 8];
 }
 
 impl working_group::Trait<ContentDirectoryWorkingGroupInstance> for Test {
     type Event = ();
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
+    type StakingHandler = staking_handler::StakingManager<Self, LockId1>;
+    type MemberOriginValidator = ();
+    type MinUnstakingPeriodLimit = ();
+    type RewardPeriod = ();
 }
 
 impl working_group::Trait<StorageWorkingGroupInstance> for Test {
     type Event = ();
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
+    type StakingHandler = staking_handler::StakingManager<Self, LockId2>;
+    type MemberOriginValidator = ();
+    type MinUnstakingPeriodLimit = ();
+    type RewardPeriod = ();
 }
 
 impl recurring_rewards::Trait for Test {
@@ -284,7 +294,7 @@ impl crate::Trait for Test {
     type AddWorkingGroupOpeningProposalParameters = DefaultProposalParameters;
     type BeginReviewWorkingGroupApplicationsProposalParameters = DefaultProposalParameters;
     type FillWorkingGroupOpeningProposalParameters = DefaultProposalParameters;
-    type SetWorkingGroupMintCapacityProposalParameters = DefaultProposalParameters;
+    type SetWorkingGroupBudgetCapacityProposalParameters = DefaultProposalParameters;
     type DecreaseWorkingGroupLeaderStakeProposalParameters = DefaultProposalParameters;
     type SlashWorkingGroupLeaderStakeProposalParameters = DefaultProposalParameters;
     type SetWorkingGroupLeaderRewardProposalParameters = DefaultProposalParameters;

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

@@ -6,9 +6,7 @@ use frame_support::traits::Currency;
 use frame_system::RawOrigin;
 
 use common::working_group::WorkingGroup;
-use hiring::ActivateOpeningAt;
 use proposals_engine::ProposalParameters;
-use working_group::OpeningPolicyCommitment;
 
 use crate::*;
 use crate::{Error, ProposalDetails};
@@ -38,7 +36,7 @@ where
     empty_stake_call: EmptyStakeCall,
     successful_call: SuccessfulCall,
     proposal_parameters: ProposalParameters<u64, u64>,
-    proposal_details: ProposalDetails<u64, u64, u64, u64, u64, u64, u64, u64, u64>,
+    proposal_details: ProposalDetails<u64, u64, u64, u64, u64, u64, u64, u64>,
 }
 
 impl<InsufficientRightsCall, EmptyStakeCall, SuccessfulCall>
@@ -412,9 +410,9 @@ fn run_create_add_working_group_leader_opening_proposal_common_checks_succeed(
 ) {
     initial_test_ext().execute_with(|| {
         let add_opening_parameters = AddOpeningParameters {
-            activate_at: ActivateOpeningAt::CurrentBlock,
-            commitment: OpeningPolicyCommitment::default(),
-            human_readable_text: b"some text".to_vec(),
+            description: b"some text".to_vec(),
+            stake_policy: None,
+            reward_policy: None,
             working_group,
         };
 
@@ -464,69 +462,6 @@ fn run_create_add_working_group_leader_opening_proposal_common_checks_succeed(
     });
 }
 
-#[test]
-fn create_begin_review_working_group_leader_applications_proposal_common_checks_succeed() {
-    // This uses strum crate for enum iteration
-    for group in WorkingGroup::iter() {
-        run_create_begin_review_working_group_leader_applications_proposal_common_checks_succeed(
-            group,
-        );
-    }
-}
-
-fn run_create_begin_review_working_group_leader_applications_proposal_common_checks_succeed(
-    working_group: WorkingGroup,
-) {
-    initial_test_ext().execute_with(|| {
-        let opening_id = 1; // random opening id.
-
-        increase_total_balance_issuance_using_account_id(1, 500000);
-
-        let proposal_fixture = ProposalTestFixture {
-            insufficient_rights_call: || {
-                ProposalCodex::create_begin_review_working_group_leader_applications_proposal(
-                    RawOrigin::None.into(),
-                    1,
-                    b"title".to_vec(),
-                    b"body".to_vec(),
-                    None,
-                    opening_id,
-                    working_group,
- 					None,
-                )
-            },
-            empty_stake_call: || {
-                ProposalCodex::create_begin_review_working_group_leader_applications_proposal(
-                    RawOrigin::Signed(1).into(),
-                    1,
-                    b"title".to_vec(),
-                    b"body".to_vec(),
-                    None,
-                    opening_id,
-                    working_group,
- 					None,
-                )
-            },
-            successful_call: || {
-                ProposalCodex::create_begin_review_working_group_leader_applications_proposal(
-                    RawOrigin::Signed(1).into(),
-                    1,
-                    b"title".to_vec(),
-                    b"body".to_vec(),
-                    Some(1),
-                    opening_id,
-                    working_group,
- 					None,
-                )
-            },
-            proposal_parameters: <Test as crate::Trait>::BeginReviewWorkingGroupApplicationsProposalParameters::get(),
-            proposal_details: ProposalDetails::BeginReviewWorkingGroupLeaderApplications(opening_id,
-                working_group),
-        };
-        proposal_fixture.check_all();
-    });
-}
-
 #[test]
 fn create_fill_working_group_leader_opening_proposal_common_checks_succeed() {
     // This uses strum crate for enum iteration
@@ -544,7 +479,6 @@ fn run_create_fill_working_group_leader_opening_proposal_common_checks_succeed(
         let fill_opening_parameters = FillOpeningParameters {
             opening_id,
             successful_application_id: 1,
-            reward_policy: None,
             working_group,
         };
 
@@ -609,17 +543,17 @@ fn run_create_working_group_mint_capacity_proposal_fails_with_invalid_parameters
         increase_total_balance_issuance_using_account_id(1, 500000);
 
         assert_eq!(
-            ProposalCodex::create_set_working_group_mint_capacity_proposal(
+            ProposalCodex::create_set_working_group_budget_capacity_proposal(
                 RawOrigin::Signed(1).into(),
                 1,
                 b"title".to_vec(),
                 b"body".to_vec(),
                 Some(1),
-                (crate::WORKING_GROUP_MINT_CAPACITY_MAX_VALUE + 1) as u64,
+                (crate::WORKING_GROUP_BUDGET_CAPACITY_MAX_VALUE + 1) as u64,
                 working_group,
                 None,
             ),
-            Err(Error::<Test>::InvalidWorkingGroupMintCapacity.into())
+            Err(Error::<Test>::InvalidWorkingGroupBudgetCapacity.into())
         );
     });
 }
@@ -640,7 +574,7 @@ fn run_create_set_working_group_mint_capacity_proposal_common_checks_succeed(
 
         let proposal_fixture = ProposalTestFixture {
             insufficient_rights_call: || {
-                ProposalCodex::create_set_working_group_mint_capacity_proposal(
+                ProposalCodex::create_set_working_group_budget_capacity_proposal(
                     RawOrigin::None.into(),
                     1,
                     b"title".to_vec(),
@@ -652,7 +586,7 @@ fn run_create_set_working_group_mint_capacity_proposal_common_checks_succeed(
                 )
             },
             empty_stake_call: || {
-                ProposalCodex::create_set_working_group_mint_capacity_proposal(
+                ProposalCodex::create_set_working_group_budget_capacity_proposal(
                     RawOrigin::Signed(1).into(),
                     1,
                     b"title".to_vec(),
@@ -664,7 +598,7 @@ fn run_create_set_working_group_mint_capacity_proposal_common_checks_succeed(
                 )
             },
             successful_call: || {
-                ProposalCodex::create_set_working_group_mint_capacity_proposal(
+                ProposalCodex::create_set_working_group_budget_capacity_proposal(
                     RawOrigin::Signed(1).into(),
                     1,
                     b"title".to_vec(),
@@ -676,8 +610,8 @@ fn run_create_set_working_group_mint_capacity_proposal_common_checks_succeed(
                 )
             },
             proposal_parameters:
-                <Test as crate::Trait>::SetWorkingGroupMintCapacityProposalParameters::get(),
-            proposal_details: ProposalDetails::SetWorkingGroupMintCapacity(10, working_group),
+                <Test as crate::Trait>::SetWorkingGroupBudgetCapacityProposalParameters::get(),
+            proposal_details: ProposalDetails::SetWorkingGroupBudgetCapacity(10, working_group),
         };
         proposal_fixture.check_all();
     });
@@ -772,7 +706,10 @@ fn run_create_slash_working_group_leader_stake_proposal_common_checks_succeed(
                     b"body".to_vec(),
                     None,
                     0,
-                    10,
+                    Penalty {
+                        slashing_amount: 10,
+                        slashing_text: Vec::new(),
+                    },
                     working_group,
                     None,
                 )
@@ -785,7 +722,10 @@ fn run_create_slash_working_group_leader_stake_proposal_common_checks_succeed(
                     b"body".to_vec(),
                     None,
                     0,
-                    10,
+                    Penalty {
+                        slashing_amount: 10,
+                        slashing_text: Vec::new(),
+                    },
                     working_group,
                     None,
                 )
@@ -798,14 +738,24 @@ fn run_create_slash_working_group_leader_stake_proposal_common_checks_succeed(
                     b"body".to_vec(),
                     Some(1),
                     10,
-                    10,
+                    Penalty {
+                        slashing_amount: 10,
+                        slashing_text: Vec::new(),
+                    },
                     working_group,
                     None,
                 )
             },
             proposal_parameters:
                 <Test as crate::Trait>::SlashWorkingGroupLeaderStakeProposalParameters::get(),
-            proposal_details: ProposalDetails::SlashWorkingGroupLeaderStake(10, 10, working_group),
+            proposal_details: ProposalDetails::SlashWorkingGroupLeaderStake(
+                10,
+                Penalty {
+                    slashing_amount: 10,
+                    slashing_text: Vec::new(),
+                },
+                working_group,
+            ),
         };
         proposal_fixture.check_all();
     });
@@ -838,7 +788,10 @@ fn run_slash_stake_with_zero_staking_balance_fails(working_group: WorkingGroup)
                 b"body".to_vec(),
                 Some(1),
                 10,
-                0,
+                Penalty {
+                    slashing_amount: 0,
+                    slashing_text: Vec::new()
+                },
                 working_group,
                 None,
             ),
@@ -904,7 +857,7 @@ fn run_create_set_working_group_leader_reward_proposal_common_checks_succeed(
                     b"body".to_vec(),
                     None,
                     0,
-                    10,
+                    Some(10),
                     working_group,
                     None,
                 )
@@ -917,7 +870,7 @@ fn run_create_set_working_group_leader_reward_proposal_common_checks_succeed(
                     b"body".to_vec(),
                     None,
                     0,
-                    10,
+                    Some(10),
                     working_group,
                     None,
                 )
@@ -930,14 +883,18 @@ fn run_create_set_working_group_leader_reward_proposal_common_checks_succeed(
                     b"body".to_vec(),
                     Some(1),
                     10,
-                    10,
+                    Some(10),
                     working_group,
                     None,
                 )
             },
             proposal_parameters:
                 <Test as crate::Trait>::SlashWorkingGroupLeaderStakeProposalParameters::get(),
-            proposal_details: ProposalDetails::SetWorkingGroupLeaderReward(10, 10, working_group),
+            proposal_details: ProposalDetails::SetWorkingGroupLeaderReward(
+                10,
+                Some(10),
+                working_group,
+            ),
         };
         proposal_fixture.check_all();
     });
@@ -959,8 +916,7 @@ fn run_create_terminate_working_group_leader_role_proposal_common_checks_succeed
 
         let terminate_role_parameters = TerminateRoleParameters {
             worker_id: 10,
-            rationale: Vec::new(),
-            slash: false,
+            penalty: None,
             working_group,
         };
 

runtime-modules/service-discovery/Cargo.toml

@@ -8,6 +8,7 @@ edition = '2018'
 serde = { version = "1.0.101", optional = true, features = ["derive"] }
 codec = { package = 'parity-scale-codec', version = '1.3.4', default-features = false, features = ['derive'] }
 sp-std = { package = 'sp-std', default-features = false, git = 'https://github.com/paritytech/substrate.git', rev = 'a200cdb93c6af5763b9c7bf313fa708764ac88ca'}
+sp-arithmetic = { package = 'sp-arithmetic', default-features = false, git = 'https://github.com/paritytech/substrate.git', rev = 'a200cdb93c6af5763b9c7bf313fa708764ac88ca'}
 frame-support = { package = 'frame-support', default-features = false, git = 'https://github.com/paritytech/substrate.git', rev = 'a200cdb93c6af5763b9c7bf313fa708764ac88ca'}
 frame-system = { package = 'frame-system', default-features = false, git = 'https://github.com/paritytech/substrate.git', rev = 'a200cdb93c6af5763b9c7bf313fa708764ac88ca'}
 sp-runtime = { package = 'sp-runtime', default-features = false, git = 'https://github.com/paritytech/substrate.git', rev = 'a200cdb93c6af5763b9c7bf313fa708764ac88ca'}
@@ -31,6 +32,7 @@ std = [
 	'serde',
 	'codec/std',
 	'sp-std/std',
+	'sp-arithmetic/std',
 	'frame-support/std',
 	'frame-system/std',
 	'sp-runtime/std',

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

@@ -13,6 +13,8 @@ use sp_runtime::{
 // The storage working group instance alias.
 pub type StorageWorkingGroupInstance = working_group::Instance2;
 
+mod staking_handler;
+
 mod working_group_mod {
     pub use super::StorageWorkingGroupInstance;
     pub use working_group::Event;
@@ -136,11 +138,24 @@ impl recurringrewards::Trait for Test {
 
 parameter_types! {
     pub const MaxWorkerNumberLimit: u32 = 3;
+    pub const LockId1: [u8; 8] = [1; 8];
 }
 
 impl working_group::Trait<StorageWorkingGroupInstance> for Test {
     type Event = MetaEvent;
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
+    type StakingHandler = staking_handler::StakingManager<Self, LockId1>;
+    type MemberOriginValidator = ();
+    type MinUnstakingPeriodLimit = ();
+    type RewardPeriod = ();
+}
+
+impl common::origin::ActorOriginValidator<Origin, u64, u64> for () {
+    fn ensure_actor_origin(origin: Origin, _: u64) -> Result<u64, &'static str> {
+        let account_id = frame_system::ensure_signed(origin)?;
+
+        Ok(account_id)
+    }
 }
 
 impl pallet_timestamp::Trait for Test {
@@ -163,14 +178,19 @@ pub type System = frame_system::Module<Test>;
 pub type Discovery = Module<Test>;
 
 pub(crate) fn hire_storage_provider() -> (u64, u64) {
-    let storage_provider_id = 1;
-    let role_account_id = 1;
+    let storage_provider_id = 1u64;
+    let role_account_id = 1u64;
 
-    let storage_provider = working_group::Worker {
+    let storage_provider = working_group::Worker::<Test> {
         member_id: 1,
         role_account_id,
-        reward_relationship: None,
-        role_stake_profile: None,
+        staking_account_id: None,
+        reward_account_id: role_account_id,
+        started_leaving_at: None,
+        job_unstaking_period: 0,
+        reward_per_block: None,
+        missed_reward: None,
+        created_at: 1,
     };
 
     <working_group::WorkerById<Test, StorageWorkingGroupInstance>>::insert(

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

@@ -0,0 +1,98 @@
+use frame_support::dispatch::{DispatchError, DispatchResult};
+use frame_support::traits::{Currency, Get, LockIdentifier, LockableCurrency, WithdrawReasons};
+use membership::staking_handler::{BalanceOf, MemberId, StakingHandler};
+use sp_arithmetic::traits::Zero;
+use sp_std::marker::PhantomData;
+
+/// Implementation of the StakingHandler.
+pub struct StakingManager<
+    T: frame_system::Trait + membership::Trait + balances::Trait,
+    LockId: Get<LockIdentifier>,
+> {
+    trait_marker: PhantomData<T>,
+    lock_id_marker: PhantomData<LockId>,
+}
+
+impl<T: frame_system::Trait + membership::Trait + balances::Trait, LockId: Get<LockIdentifier>>
+    StakingHandler<T> for StakingManager<T, LockId>
+{
+    fn lock(account_id: &T::AccountId, amount: BalanceOf<T>) {
+        <balances::Module<T>>::set_lock(LockId::get(), &account_id, amount, WithdrawReasons::all())
+    }
+
+    fn unlock(account_id: &T::AccountId) {
+        T::Currency::remove_lock(LockId::get(), &account_id);
+    }
+
+    fn slash(account_id: &T::AccountId, amount: Option<BalanceOf<T>>) -> BalanceOf<T> {
+        let locks = <balances::Module<T>>::locks(&account_id);
+
+        let existing_lock = locks.iter().find(|lock| lock.id == LockId::get());
+
+        let mut actually_slashed_balance = Default::default();
+        if let Some(existing_lock) = existing_lock {
+            Self::unlock(&account_id);
+
+            let mut slashable_amount = existing_lock.amount;
+            if let Some(amount) = amount {
+                if existing_lock.amount > amount {
+                    let new_amount = existing_lock.amount - amount;
+                    Self::lock(&account_id, new_amount);
+
+                    slashable_amount = amount;
+                }
+            }
+
+            let _ = <balances::Module<T>>::slash(&account_id, slashable_amount);
+
+            actually_slashed_balance = slashable_amount
+        }
+
+        actually_slashed_balance
+    }
+
+    fn set_stake(account_id: &T::AccountId, new_stake: BalanceOf<T>) -> DispatchResult {
+        let current_stake = Self::current_stake(account_id);
+
+        //Unlock previous stake if its not zero.
+        if current_stake > Zero::zero() {
+            Self::unlock(account_id);
+        }
+
+        if !Self::is_enough_balance_for_stake(account_id, new_stake) {
+            //Restore previous stake if its not zero.
+            if current_stake > Zero::zero() {
+                Self::lock(account_id, current_stake);
+            }
+            return Err(DispatchError::Other("Not enough balance for a new stake."));
+        }
+
+        Self::lock(account_id, new_stake);
+
+        Ok(())
+    }
+
+    fn is_member_staking_account(_member_id: &MemberId<T>, _account_id: &T::AccountId) -> bool {
+        true
+    }
+
+    fn is_account_free_of_conflicting_stakes(account_id: &T::AccountId) -> bool {
+        let locks = <balances::Module<T>>::locks(&account_id);
+
+        let existing_lock = locks.iter().find(|lock| lock.id == LockId::get());
+
+        existing_lock.is_none()
+    }
+
+    fn is_enough_balance_for_stake(account_id: &T::AccountId, amount: BalanceOf<T>) -> bool {
+        <balances::Module<T>>::usable_balance(account_id) >= amount
+    }
+
+    fn current_stake(account_id: &T::AccountId) -> BalanceOf<T> {
+        let locks = <balances::Module<T>>::locks(&account_id);
+
+        let existing_lock = locks.iter().find(|lock| lock.id == LockId::get());
+
+        existing_lock.map_or(Zero::zero(), |lock| lock.amount)
+    }
+}

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

@@ -12,11 +12,16 @@ const DEFAULT_LEADER_WORKER_ID: u32 = 1;
 struct SetLeadFixture;
 impl SetLeadFixture {
     fn set_default_lead() {
-        let worker = working_group::Worker {
+        let worker = working_group::Worker::<Test> {
             member_id: DEFAULT_LEADER_MEMBER_ID,
             role_account_id: DEFAULT_LEADER_ACCOUNT_ID,
-            reward_relationship: None,
-            role_stake_profile: None,
+            staking_account_id: None,
+            reward_account_id: DEFAULT_LEADER_ACCOUNT_ID,
+            started_leaving_at: None,
+            job_unstaking_period: 0,
+            reward_per_block: None,
+            missed_reward: None,
+            created_at: 1,
         };
 
         // Create the worker.

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

@@ -1,7 +1,7 @@
 #![cfg(test)]
 
 use frame_support::storage::StorageMap;
-use frame_support::traits::{OnFinalize, OnInitialize};
+use frame_support::traits::{LockIdentifier, OnFinalize, OnInitialize};
 use frame_support::{impl_outer_event, impl_outer_origin, parameter_types};
 use sp_core::H256;
 use sp_runtime::{
@@ -17,6 +17,8 @@ pub use crate::{data_directory, data_object_storage_registry, data_object_type_r
 use common::currency::GovernanceCurrency;
 use membership;
 
+mod staking_handler;
+
 mod working_group_mod {
     pub use super::StorageWorkingGroupInstance;
     pub use working_group::Event;
@@ -152,11 +154,24 @@ impl GovernanceCurrency for Test {
 
 parameter_types! {
     pub const MaxWorkerNumberLimit: u32 = 3;
+    pub const LockId: LockIdentifier = [2; 8];
 }
 
 impl working_group::Trait<StorageWorkingGroupInstance> for Test {
     type Event = MetaEvent;
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
+    type StakingHandler = staking_handler::StakingManager<Self, LockId>;
+    type MemberOriginValidator = ();
+    type MinUnstakingPeriodLimit = ();
+    type RewardPeriod = ();
+}
+
+impl common::origin::ActorOriginValidator<Origin, u64, u64> for () {
+    fn ensure_actor_origin(origin: Origin, _: u64) -> Result<u64, &'static str> {
+        let account_id = frame_system::ensure_signed(origin)?;
+
+        Ok(account_id)
+    }
 }
 
 impl data_object_type_registry::Trait for Test {
@@ -179,14 +194,6 @@ impl crate::data_directory::StorageProviderHelper<Test> for () {
     }
 }
 
-impl common::origin::ActorOriginValidator<Origin, u64, u64> for () {
-    fn ensure_actor_origin(origin: Origin, _account_id: u64) -> Result<u64, &'static str> {
-        let signed_account_id = frame_system::ensure_signed(origin)?;
-
-        Ok(signed_account_id)
-    }
-}
-
 impl data_object_storage_registry::Trait for Test {
     type Event = MetaEvent;
     type DataObjectStorageRelationshipId = u64;
@@ -320,11 +327,16 @@ pub(crate) fn hire_storage_provider() -> (u64, u32) {
     let storage_provider_id = 1;
     let role_account_id = 1;
 
-    let storage_provider = working_group::Worker {
+    let storage_provider = working_group::Worker::<Test> {
         member_id: 1,
         role_account_id,
-        reward_relationship: None,
-        role_stake_profile: None,
+        staking_account_id: None,
+        reward_account_id: role_account_id,
+        started_leaving_at: None,
+        job_unstaking_period: 0,
+        reward_per_block: None,
+        missed_reward: None,
+        created_at: 1,
     };
 
     <working_group::WorkerById<Test, StorageWorkingGroupInstance>>::insert(

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

@@ -0,0 +1,98 @@
+use frame_support::dispatch::{DispatchError, DispatchResult};
+use frame_support::traits::{Currency, Get, LockIdentifier, LockableCurrency, WithdrawReasons};
+use membership::staking_handler::{BalanceOf, MemberId, StakingHandler};
+use sp_arithmetic::traits::Zero;
+use sp_std::marker::PhantomData;
+
+/// Implementation of the StakingHandler.
+pub struct StakingManager<
+    T: frame_system::Trait + membership::Trait + balances::Trait,
+    LockId: Get<LockIdentifier>,
+> {
+    trait_marker: PhantomData<T>,
+    lock_id_marker: PhantomData<LockId>,
+}
+
+impl<T: frame_system::Trait + membership::Trait + balances::Trait, LockId: Get<LockIdentifier>>
+    StakingHandler<T> for StakingManager<T, LockId>
+{
+    fn lock(account_id: &T::AccountId, amount: BalanceOf<T>) {
+        <balances::Module<T>>::set_lock(LockId::get(), &account_id, amount, WithdrawReasons::all())
+    }
+
+    fn unlock(account_id: &T::AccountId) {
+        T::Currency::remove_lock(LockId::get(), &account_id);
+    }
+
+    fn slash(account_id: &T::AccountId, amount: Option<BalanceOf<T>>) -> BalanceOf<T> {
+        let locks = <balances::Module<T>>::locks(&account_id);
+
+        let existing_lock = locks.iter().find(|lock| lock.id == LockId::get());
+
+        let mut actually_slashed_balance = Default::default();
+        if let Some(existing_lock) = existing_lock {
+            Self::unlock(&account_id);
+
+            let mut slashable_amount = existing_lock.amount;
+            if let Some(amount) = amount {
+                if existing_lock.amount > amount {
+                    let new_amount = existing_lock.amount - amount;
+                    Self::lock(&account_id, new_amount);
+
+                    slashable_amount = amount;
+                }
+            }
+
+            let _ = <balances::Module<T>>::slash(&account_id, slashable_amount);
+
+            actually_slashed_balance = slashable_amount
+        }
+
+        actually_slashed_balance
+    }
+
+    fn set_stake(account_id: &T::AccountId, new_stake: BalanceOf<T>) -> DispatchResult {
+        let current_stake = Self::current_stake(account_id);
+
+        //Unlock previous stake if its not zero.
+        if current_stake > Zero::zero() {
+            Self::unlock(account_id);
+        }
+
+        if !Self::is_enough_balance_for_stake(account_id, new_stake) {
+            //Restore previous stake if its not zero.
+            if current_stake > Zero::zero() {
+                Self::lock(account_id, current_stake);
+            }
+            return Err(DispatchError::Other("Not enough balance for a new stake."));
+        }
+
+        Self::lock(account_id, new_stake);
+
+        Ok(())
+    }
+
+    fn is_member_staking_account(_member_id: &MemberId<T>, _account_id: &T::AccountId) -> bool {
+        true
+    }
+
+    fn is_account_free_of_conflicting_stakes(account_id: &T::AccountId) -> bool {
+        let locks = <balances::Module<T>>::locks(&account_id);
+
+        let existing_lock = locks.iter().find(|lock| lock.id == LockId::get());
+
+        existing_lock.is_none()
+    }
+
+    fn is_enough_balance_for_stake(account_id: &T::AccountId, amount: BalanceOf<T>) -> bool {
+        <balances::Module<T>>::usable_balance(account_id) >= amount
+    }
+
+    fn current_stake(account_id: &T::AccountId) -> BalanceOf<T> {
+        let locks = <balances::Module<T>>::locks(&account_id);
+
+        let existing_lock = locks.iter().find(|lock| lock.id == LockId::get());
+
+        existing_lock.map_or(Zero::zero(), |lock| lock.amount)
+    }
+}

runtime-modules/working-group/src/checks.rs

@@ -1,6 +1,6 @@
 use crate::{
-    ApplicationId, BalanceOf, GroupWorker, Instance, JobOpening, MemberId, OpeningId, OpeningType,
-    RewardPolicy, StakePolicy, Trait, WorkerId,
+    ApplicationId, BalanceOf, Instance, JobOpening, MemberId, OpeningId, OpeningType, RewardPolicy,
+    StakePolicy, Trait, Worker, WorkerId,
 };
 
 use super::Error;
@@ -137,7 +137,7 @@ pub fn ensure_origin_is_active_leader<T: Trait<I>, I: Instance>(
 /// Check worker: ensures the worker was already created.
 pub fn ensure_worker_exists<T: Trait<I>, I: Instance>(
     worker_id: &WorkerId<T>,
-) -> Result<GroupWorker<T>, Error<T, I>> {
+) -> Result<Worker<T>, Error<T, I>> {
     ensure!(
         <crate::WorkerById::<T, I>>::contains_key(worker_id),
         Error::<T, I>::WorkerDoesNotExist
@@ -163,7 +163,7 @@ pub(crate) fn ensure_origin_signed_by_member<T: Trait<I>, I: Instance>(
 pub fn ensure_worker_signed<T: Trait<I>, I: Instance>(
     origin: T::Origin,
     worker_id: &WorkerId<T>,
-) -> Result<GroupWorker<T>, DispatchError> {
+) -> Result<Worker<T>, DispatchError> {
     // Ensure that it is signed
     let signer_account = ensure_signed(origin)?;
 
@@ -252,7 +252,7 @@ pub(crate) fn ensure_application_stake_match_opening<T: Trait<I>, I: Instance>(
 
 // Check worker: verifies that worker has recurring rewards.
 pub(crate) fn ensure_worker_has_recurring_reward<T: Trait<I>, I: Instance>(
-    worker: &GroupWorker<T>,
+    worker: &Worker<T>,
 ) -> DispatchResult {
     worker
         .reward_per_block

runtime-modules/working-group/src/lib.rs

@@ -48,10 +48,10 @@ use sp_std::vec::Vec;
 
 pub use errors::Error;
 pub use types::{
-    ApplicationId, ApplyOnOpeningParameters, BalanceOf, JobApplication, JobOpening, OpeningId,
-    OpeningType, Penalty, RewardPolicy, StakePolicy, WorkerId,
+    ApplicationId, ApplyOnOpeningParameters, BalanceOf, JobApplication, JobOpening, MemberId,
+    OpeningId, OpeningType, Penalty, RewardPolicy, StakePolicy, Worker, WorkerId,
 };
-use types::{ApplicationInfo, GroupWorker, MemberId, WorkerInfo};
+use types::{ApplicationInfo, WorkerInfo};
 
 pub use checks::{ensure_origin_is_active_leader, ensure_worker_exists, ensure_worker_signed};
 
@@ -219,7 +219,7 @@ decl_storage! {
 
         /// Maps identifier to corresponding worker.
         pub WorkerById get(fn worker_by_id) : map hasher(blake2_128_concat)
-            WorkerId<T> => GroupWorker<T>;
+            WorkerId<T> => Worker<T>;
 
         /// Current group lead.
         pub CurrentLead get(fn current_lead) : Option<WorkerId<T>>;
@@ -877,7 +877,7 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
         let new_worker_id = <NextWorkerId<T, I>>::get();
 
         // Construct a worker.
-        let worker = GroupWorker::<T>::new(
+        let worker = Worker::<T>::new(
             &application_info.application.member_id,
             &application_info.application.role_account_id,
             &application_info.application.reward_account_id,
@@ -924,7 +924,7 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
 
     // Fires the worker. Unsets the leader if necessary. Decreases active worker counter.
     // Deposits an event.
-    fn remove_worker(worker_id: &WorkerId<T>, worker: &GroupWorker<T>, event: Event<T, I>) {
+    fn remove_worker(worker_id: &WorkerId<T>, worker: &Worker<T>, event: Event<T, I>) {
         // Unset lead if the leader is leaving.
         let leader_worker_id = <CurrentLead<T, I>>::get();
         if let Some(leader_worker_id) = leader_worker_id {
@@ -957,7 +957,7 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
     }
 
     // Reward a worker using reward presets and working group budget.
-    fn reward_worker(worker_id: &WorkerId<T>, worker: &GroupWorker<T>) {
+    fn reward_worker(worker_id: &WorkerId<T>, worker: &Worker<T>) {
         // If reward period is not set.
         let mut rewarding_period: u32 = T::RewardPeriod::get();
         if rewarding_period == 0u32 {
@@ -1002,7 +1002,7 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
     }
 
     // Tries to pay missed reward if the reward is enabled for worker and there is enough of group budget.
-    fn try_to_pay_missed_reward(worker_id: &WorkerId<T>, worker: &GroupWorker<T>) {
+    fn try_to_pay_missed_reward(worker_id: &WorkerId<T>, worker: &Worker<T>) {
         if let Some(missed_reward) = worker.missed_reward {
             let (could_be_paid_reward, insufficient_amount) =
                 Self::calculate_possible_payment(missed_reward);
@@ -1026,7 +1026,7 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
     }
 
     // Saves missed reward for a worker.
-    fn save_missed_reward(worker_id: &WorkerId<T>, worker: &GroupWorker<T>, reward: BalanceOf<T>) {
+    fn save_missed_reward(worker_id: &WorkerId<T>, worker: &Worker<T>, reward: BalanceOf<T>) {
         // Save unpaid reward.
         let missed_reward_so_far = worker.missed_reward.map_or(Zero::zero(), |val| val);
 
@@ -1085,7 +1085,7 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
     }
 
     // Defines whether the worker staking parameters allow to leave without unstaking period.
-    fn can_leave_immediately(worker: &GroupWorker<T>) -> bool {
+    fn can_leave_immediately(worker: &Worker<T>) -> bool {
         if worker.job_unstaking_period == Zero::zero() {
             return true;
         }

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

@@ -9,8 +9,8 @@ use super::hiring_workflow::HiringWorkflow;
 use super::mock::{Balances, LockId, Membership, System, Test, TestEvent, TestWorkingGroup};
 use crate::types::StakeParameters;
 use crate::{
-    ApplyOnOpeningParameters, DefaultInstance, GroupWorker, JobApplication, JobOpening,
-    OpeningType, Penalty, RawEvent, RewardPolicy, StakePolicy,
+    ApplyOnOpeningParameters, DefaultInstance, JobApplication, JobOpening, OpeningType, Penalty,
+    RawEvent, RewardPolicy, StakePolicy, Worker,
 };
 
 pub struct EventFixture;
@@ -185,7 +185,7 @@ impl ApplyOnOpeningFixture {
         let saved_application_next_id = TestWorkingGroup::next_application_id();
         TestWorkingGroup::apply_on_opening(
             self.origin.clone().into(),
-            ApplyOnOpeningParameters::<Test, DefaultInstance> {
+            ApplyOnOpeningParameters::<Test> {
                 member_id: self.member_id,
                 opening_id: self.opening_id,
                 role_account_id: self.role_account_id,
@@ -338,7 +338,7 @@ impl FillOpeningFixture {
                 );
             }
 
-            let expected_worker = GroupWorker::<Test> {
+            let expected_worker = Worker::<Test> {
                 member_id: 1,
                 role_account_id: self.role_account_id,
                 reward_account_id: self.reward_account_id,

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

@@ -116,8 +116,6 @@ parameter_types! {
 }
 
 impl Trait for Test {
-    type OpeningId = u64;
-    type ApplicationId = u64;
     type Event = TestEvent;
     type MaxWorkerNumberLimit = MaxWorkerNumberLimit;
     type StakingHandler = staking_handler::StakingManager<Self, LockId>;

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

@@ -18,7 +18,7 @@ use crate::tests::mock::{
 };
 use crate::types::StakeParameters;
 use crate::{
-    DefaultInstance, Error, GroupWorker, OpeningType, Penalty, RawEvent, RewardPolicy, StakePolicy,
+    DefaultInstance, Error, OpeningType, Penalty, RawEvent, RewardPolicy, StakePolicy, Worker,
 };
 use fixtures::{
     increase_total_balance_issuance_using_account_id, setup_members, AddOpeningFixture,
@@ -460,7 +460,7 @@ fn update_worker_role_account_by_leader_succeeds() {
 
         assert_eq!(
             new_lead,
-            GroupWorker::<Test> {
+            Worker::<Test> {
                 role_account_id: new_account_id,
                 ..old_lead
             }

runtime-modules/working-group/src/types.rs

@@ -29,22 +29,22 @@ pub(crate) struct ApplicationInfo<T: crate::Trait<I>, I: crate::Instance> {
     pub marker: PhantomData<I>,
 }
 
-// WorkerId - GroupWorker - helper struct.
+// WorkerId - Worker - helper struct.
 pub(crate) struct WorkerInfo<T: membership::Trait + frame_system::Trait + balances::Trait> {
     pub worker_id: WorkerId<T>,
-    pub worker: GroupWorker<T>,
+    pub worker: Worker<T>,
 }
 
-impl<T: membership::Trait + frame_system::Trait + balances::Trait>
-    From<(WorkerId<T>, GroupWorker<T>)> for WorkerInfo<T>
+impl<T: membership::Trait + frame_system::Trait + balances::Trait> From<(WorkerId<T>, Worker<T>)>
+    for WorkerInfo<T>
 {
-    fn from((worker_id, worker): (WorkerId<T>, GroupWorker<T>)) -> Self {
+    fn from((worker_id, worker): (WorkerId<T>, Worker<T>)) -> Self {
         WorkerInfo { worker_id, worker }
     }
 }
 
 /// Group worker type alias.
-pub type GroupWorker<T> = Worker<
+pub type Worker<T> = GroupWorker<
     <T as frame_system::Trait>::AccountId,
     MemberId<T>,
     <T as frame_system::Trait>::BlockNumber,
@@ -136,7 +136,7 @@ impl<AccountId: Clone, MemberId: Clone> Application<AccountId, MemberId> {
 /// Working group participant: regular worker or lead.
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
-pub struct Worker<AccountId, MemberId, BlockNumber, Balance> {
+pub struct GroupWorker<AccountId, MemberId, BlockNumber, Balance> {
     /// Member id related to the worker/lead.
     pub member_id: MemberId,
 
@@ -167,7 +167,7 @@ pub struct Worker<AccountId, MemberId, BlockNumber, Balance> {
 }
 
 impl<AccountId: Clone, MemberId: Clone, BlockNumber, Balance>
-    Worker<AccountId, MemberId, BlockNumber, Balance>
+    GroupWorker<AccountId, MemberId, BlockNumber, Balance>
 {
     /// Creates a new _GroupWorker_ using parameters.
     pub fn new(
@@ -179,7 +179,7 @@ impl<AccountId: Clone, MemberId: Clone, BlockNumber, Balance>
         reward_per_block: Option<Balance>,
         created_at: BlockNumber,
     ) -> Self {
-        Worker {
+        GroupWorker {
             member_id: member_id.clone(),
             role_account_id: role_account_id.clone(),
             reward_account_id: reward_account_id.clone(),

runtime/src/lib.rs

@@ -657,8 +657,8 @@ impl proposals_codex::Trait for Runtime {
     type BeginReviewWorkingGroupApplicationsProposalParameters =
         BeginReviewWorkingGroupApplicationsProposalParameters;
     type FillWorkingGroupOpeningProposalParameters = FillWorkingGroupOpeningProposalParameters;
-    type SetWorkingGroupMintCapacityProposalParameters =
-        SetWorkingGroupMintCapacityProposalParameters;
+    type SetWorkingGroupBudgetCapacityProposalParameters =
+        SetWorkingGroupBudgetCapacityProposalParameters;
     type DecreaseWorkingGroupLeaderStakeProposalParameters =
         DecreaseWorkingGroupLeaderStakeProposalParameters;
     type SlashWorkingGroupLeaderStakeProposalParameters =

runtime/src/proposals_configuration/defaults.rs

@@ -100,9 +100,9 @@ pub(crate) fn fill_working_group_opening_proposal() -> ProposalParameters<BlockN
     }
 }
 
-// Proposal parameters for the 'Set working group mint capacity' proposal
-pub(crate) fn set_working_group_mint_capacity_proposal() -> ProposalParameters<BlockNumber, Balance>
-{
+// Proposal parameters for the 'Set working group budget capacity' proposal
+pub(crate) fn set_working_group_budget_capacity_proposal(
+) -> ProposalParameters<BlockNumber, Balance> {
     ProposalParameters {
         voting_period: 43200,
         grace_period: 0,

runtime/src/proposals_configuration/mod.rs

@@ -29,7 +29,7 @@ parameter_types! {
     pub AddWorkingGroupOpeningProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.add_working_group_opening_proposal;
     pub BeginReviewWorkingGroupApplicationsProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.begin_review_working_group_applications_proposal;
     pub FillWorkingGroupOpeningProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.fill_working_group_opening_proposal;
-    pub SetWorkingGroupMintCapacityProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.set_working_group_mint_capacity_proposal;
+    pub SetWorkingGroupBudgetCapacityProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.set_working_group_budget_capacity_proposal;
     pub DecreaseWorkingGroupLeaderStakeProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.decrease_working_group_leader_stake_proposal;
     pub SlashWorkingGroupLeaderStakeProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.slash_working_group_leader_stake_proposal;
     pub SetWorkingGroupLeaderRewardProposalParameters: ProposalParameters<BlockNumber, Balance> = ALL_PROPOSALS_PARAMETERS.set_working_group_leader_reward_proposal;
@@ -47,7 +47,7 @@ struct AllProposalsParameters {
     pub add_working_group_opening_proposal: ProposalParameters<BlockNumber, Balance>,
     pub begin_review_working_group_applications_proposal: ProposalParameters<BlockNumber, Balance>,
     pub fill_working_group_opening_proposal: ProposalParameters<BlockNumber, Balance>,
-    pub set_working_group_mint_capacity_proposal: ProposalParameters<BlockNumber, Balance>,
+    pub set_working_group_budget_capacity_proposal: ProposalParameters<BlockNumber, Balance>,
     pub decrease_working_group_leader_stake_proposal: ProposalParameters<BlockNumber, Balance>,
     pub slash_working_group_leader_stake_proposal: ProposalParameters<BlockNumber, Balance>,
     pub set_working_group_leader_reward_proposal: ProposalParameters<BlockNumber, Balance>,
@@ -119,7 +119,7 @@ fn convert_json_object_to_proposal_parameters(
         init_proposal_parameter_object!(
             params,
             jo.clone(),
-            set_working_group_mint_capacity_proposal
+            set_working_group_budget_capacity_proposal
         );
         init_proposal_parameter_object!(
             params,
@@ -254,8 +254,8 @@ fn default_parameters() -> AllProposalsParameters {
         begin_review_working_group_applications_proposal:
             defaults::begin_review_working_group_applications_proposal(),
         fill_working_group_opening_proposal: defaults::fill_working_group_opening_proposal(),
-        set_working_group_mint_capacity_proposal:
-            defaults::set_working_group_mint_capacity_proposal(),
+        set_working_group_budget_capacity_proposal:
+            defaults::set_working_group_budget_capacity_proposal(),
         decrease_working_group_leader_stake_proposal:
             defaults::decrease_working_group_leader_stake_proposal(),
         slash_working_group_leader_stake_proposal:

runtime/src/proposals_configuration/sample_proposal_parameters.json

@@ -16,7 +16,7 @@
   "add_working_group_opening_proposal": {},
   "begin_review_working_group_applications_proposal": {},
   "fill_working_group_opening_proposal": {},
-  "set_working_group_mint_capacity_proposal": {},
+  "set_working_group_budget_capacity_proposal": {},
   "decrease_working_group_leader_stake_proposal": {},
   "slash_working_group_leader_stake_proposal": {},
   "set_working_group_leader_reward_proposal": {},

runtime/src/tests/proposals_integration/working_group_proposals.rs

@@ -6,17 +6,14 @@ use super::*;
 use frame_system::RawOrigin;
 
 use common::working_group::WorkingGroup;
-use hiring::ActivateOpeningAt;
 use proposals_codex::AddOpeningParameters;
-use working_group::{OpeningPolicyCommitment, RewardPolicy};
+use working_group::Penalty;
 
+use crate::primitives::{ActorId, MemberId};
 use crate::{
     Balance, BlockNumber, ContentDirectoryWorkingGroup, ContentDirectoryWorkingGroupInstance,
     StorageWorkingGroup, StorageWorkingGroupInstance,
 };
-use sp_std::collections::btree_set::BTreeSet;
-
-use crate::primitives::{ActorId, MemberId};
 use frame_support::traits;
 use strum::IntoEnumIterator;
 
@@ -27,8 +24,7 @@ type Hiring = hiring::Module<Runtime>;
 fn add_opening(
     member_id: MemberId,
     account_id: [u8; 32],
-    activate_at: hiring::ActivateOpeningAt<BlockNumber>,
-    opening_policy_commitment: Option<OpeningPolicyCommitment<BlockNumber, u128>>,
+    stake_policy: Option<working_group::StakePolicy<BlockNumber, Balance>>,
     sequence_number: u32, // action sequence number to align with other actions
     working_group: WorkingGroup,
 ) -> u64 {
@@ -62,11 +58,9 @@ fn add_opening(
             b"body".to_vec(),
             Some(account_id.into()),
             AddOpeningParameters {
-                activate_at: activate_at.clone(),
-                commitment: opening_policy_commitment
-                    .clone()
-                    .unwrap_or(OpeningPolicyCommitment::default()),
-                human_readable_text: Vec::new(),
+                description: Vec::new(),
+                stake_policy: stake_policy.clone(),
+                reward_policy: None,
                 working_group,
             },
             None,
@@ -80,41 +74,11 @@ fn add_opening(
     opening_id
 }
 
-fn begin_review_applications(
-    member_id: MemberId,
-    account_id: [u8; 32],
-    opening_id: u64,
-    sequence_number: u32, // action sequence number to align with other actions
-    working_group: WorkingGroup,
-) {
-    let expected_proposal_id = sequence_number;
-    let run_to_block = sequence_number * 2;
-
-    let codex_extrinsic_test_fixture = CodexProposalTestFixture::default_for_call(|| {
-        ProposalCodex::create_begin_review_working_group_leader_applications_proposal(
-            RawOrigin::Signed(account_id.into()).into(),
-            member_id,
-            b"title".to_vec(),
-            b"body".to_vec(),
-            Some(account_id.into()),
-            opening_id,
-            working_group,
-            None,
-        )
-    })
-    .disable_setup_enviroment()
-    .with_expected_proposal_id(expected_proposal_id)
-    .with_run_to_block(run_to_block);
-
-    codex_extrinsic_test_fixture.call_extrinsic_and_assert();
-}
-
 fn fill_opening(
     member_id: MemberId,
     account_id: [u8; 32],
     opening_id: u64,
     successful_application_id: u64,
-    reward_policy: Option<RewardPolicy<Balance, BlockNumber>>,
     sequence_number: u32, // action sequence number to align with other actions
     working_group: WorkingGroup,
 ) {
@@ -131,7 +95,6 @@ fn fill_opening(
             proposals_codex::FillOpeningParameters {
                 opening_id,
                 successful_application_id,
-                reward_policy: reward_policy.clone(),
                 working_group,
             },
             None,
@@ -202,7 +165,10 @@ fn slash_stake(
             b"body".to_vec(),
             Some(account_id.into()),
             leader_worker_id,
-            stake_amount,
+            Penalty {
+                slashing_amount: stake_amount,
+                slashing_text: Vec::new(),
+            },
             working_group,
             None,
         )
@@ -233,7 +199,7 @@ fn set_reward(
             b"body".to_vec(),
             Some(account_id.into()),
             leader_worker_id,
-            reward_amount,
+            Some(reward_amount),
             working_group,
             None,
         )
@@ -246,7 +212,7 @@ fn set_reward(
 }
 
 fn set_mint_capacity<
-    T: working_group::Trait<I> + frame_system::Trait + minting::Trait,
+    T: working_group::Trait<I> + frame_system::Trait,
     I: frame_support::traits::Instance,
 >(
     member_id: MemberId,
@@ -255,21 +221,12 @@ fn set_mint_capacity<
     sequence_number: u32, // action sequence number to align with other actions
     setup_environment: bool,
     working_group: WorkingGroup,
-) where
-    <T as minting::Trait>::MintId: From<u64>,
-{
+) {
     let expected_proposal_id = sequence_number;
     let run_to_block = sequence_number * 2;
 
-    let mint_id_result = <minting::Module<Runtime>>::add_mint(0, None);
-
-    if let Ok(mint_id) = mint_id_result {
-        let mint_id: <T as minting::Trait>::MintId = mint_id.into();
-        <working_group::Mint<T, I>>::put(mint_id);
-    }
-
     let codex_extrinsic_test_fixture = CodexProposalTestFixture::default_for_call(|| {
-        ProposalCodex::create_set_working_group_mint_capacity_proposal(
+        ProposalCodex::create_set_working_group_budget_capacity_proposal(
             RawOrigin::Signed(account_id.into()).into(),
             member_id,
             b"title".to_vec(),
@@ -291,7 +248,6 @@ fn terminate_role(
     member_id: MemberId,
     account_id: [u8; 32],
     leader_worker_id: u64,
-    slash: bool,
     sequence_number: u32, // action sequence number to align with other actions
     working_group: WorkingGroup,
 ) {
@@ -307,8 +263,10 @@ fn terminate_role(
             Some(account_id.into()),
             proposals_codex::TerminateRoleParameters {
                 worker_id: leader_worker_id,
-                rationale: Vec::new(),
-                slash,
+                penalty: Some(Penalty {
+                    slashing_amount: 100,
+                    slashing_text: Vec::new(),
+                }),
                 working_group,
             },
             None,
@@ -349,7 +307,6 @@ fn run_create_add_working_group_leader_opening_proposal_execution_succeeds<
     working_group: WorkingGroup,
 ) where
     <T as membership::Trait>::MemberId: From<u64>,
-    <T as hiring::Trait>::OpeningId: From<u64>,
 {
     initial_test_ext().execute_with(|| {
         let member_id: MemberId = 1;
@@ -361,15 +318,8 @@ fn run_create_add_working_group_leader_opening_proposal_execution_succeeds<
             next_opening_id
         ));
 
-        let opening_id: <T as hiring::Trait>::OpeningId = add_opening(
-            member_id,
-            account_id,
-            ActivateOpeningAt::CurrentBlock,
-            None,
-            1,
-            working_group,
-        )
-        .into();
+        let opening_id: working_group::OpeningId =
+            add_opening(member_id, account_id, None, 1, working_group).into();
 
         // Check for expected opening id.
         assert_eq!(opening_id, next_opening_id);
@@ -379,88 +329,6 @@ fn run_create_add_working_group_leader_opening_proposal_execution_succeeds<
     });
 }
 
-#[test]
-fn create_begin_review_working_group_leader_applications_proposal_execution_succeeds() {
-    // This uses strum crate for enum iteration
-    for group in WorkingGroup::iter() {
-        match group {
-            WorkingGroup::Content => {
-                run_create_begin_review_working_group_leader_applications_proposal_execution_succeeds::<
-                Runtime,
-                ContentDirectoryWorkingGroupInstance,
-            >(group);
-            }
-            WorkingGroup::Storage => {
-                run_create_begin_review_working_group_leader_applications_proposal_execution_succeeds::<
-                Runtime,
-                StorageWorkingGroupInstance,
-            >(group);
-            }
-        }
-    }
-}
-
-fn run_create_begin_review_working_group_leader_applications_proposal_execution_succeeds<
-    T: working_group::Trait<I> + frame_system::Trait + stake::Trait,
-    I: frame_support::traits::Instance,
->(
-    working_group: WorkingGroup,
-) where
-    <T as hiring::Trait>::OpeningId: From<u64> + Into<u64>,
-{
-    initial_test_ext().execute_with(|| {
-        let member_id: MemberId = 1;
-        let account_id: [u8; 32] = [member_id as u8; 32];
-
-        let opening_id = add_opening(
-            member_id,
-            account_id,
-            ActivateOpeningAt::CurrentBlock,
-            None,
-            1,
-            working_group,
-        );
-
-        let opening = WorkingGroupInstance::<T, I>::opening_by_id(
-            <T as hiring::Trait>::OpeningId::from(opening_id),
-        );
-
-        let hiring_opening_id: u64 = opening.hiring_opening_id.into();
-        let hiring_opening = Hiring::opening_by_id(hiring_opening_id);
-        assert_eq!(
-            hiring_opening.stage,
-            hiring::OpeningStage::Active {
-                stage: hiring::ActiveOpeningStage::AcceptingApplications {
-                    started_accepting_applicants_at_block: 0
-                },
-                applications_added: BTreeSet::new(),
-                active_application_count: 0,
-                unstaking_application_count: 0,
-                deactivated_application_count: 0
-            }
-        );
-
-        begin_review_applications(member_id, account_id, opening_id, 2, working_group);
-        let grace_period = 14400;
-        run_to_block(grace_period + 10);
-
-        let hiring_opening = Hiring::opening_by_id(hiring_opening_id);
-        assert_eq!(
-            hiring_opening.stage,
-            hiring::OpeningStage::Active {
-                stage: hiring::ActiveOpeningStage::ReviewPeriod {
-                    started_accepting_applicants_at_block: 0,
-                    started_review_period_at_block: grace_period + 2,
-                },
-                applications_added: BTreeSet::new(),
-                active_application_count: 0,
-                unstaking_application_count: 0,
-                deactivated_application_count: 0
-            }
-        );
-    });
-}
-
 #[test]
 fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
     // This uses strum crate for enum iteration
@@ -489,54 +357,43 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
     ) where
         <T as frame_system::Trait>::AccountId: From<[u8; 32]>,
         <T as membership::Trait>::MemberId: From<u64>,
-        <T as hiring::Trait>::OpeningId: From<u64>,
+        working_group::MemberId<T>: From<u64>,
     {
         initial_test_ext().execute_with(|| {
-            let member_id: MemberId = 1;
+            let member_id: u64 = 1;
             let account_id: [u8; 32] = [member_id as u8; 32];
 
-            let opening_id = add_opening(
-                member_id,
-                account_id,
-                ActivateOpeningAt::CurrentBlock,
-                None,
-                1,
-                working_group,
-            );
+            let opening_id = add_opening(member_id, account_id, None, 1, working_group);
 
             let apply_result = WorkingGroupInstance::<T, I>::apply_on_opening(
                 RawOrigin::Signed(account_id.into()).into(),
-                member_id.into(),
-                opening_id.into(),
-                account_id.into(),
-                None,
-                None,
-                Vec::new(),
+                working_group::ApplyOnOpeningParameters::<T> {
+                    member_id: member_id.into(),
+                    opening_id,
+                    role_account_id: account_id.into(),
+                    reward_account_id: account_id.into(),
+                    description: Vec::new(),
+                    stake_parameters: None,
+                },
             );
 
             assert_eq!(apply_result, Ok(()));
 
             let expected_application_id = 0;
 
-            begin_review_applications(member_id, account_id, opening_id, 2, working_group);
-
             let lead = WorkingGroupInstance::<T, I>::current_lead();
             assert!(lead.is_none());
 
-            let grace_period_for_begin_application_proposal = 14400;
-            run_to_block(grace_period_for_begin_application_proposal + 20);
-
             fill_opening(
                 member_id,
                 account_id,
                 opening_id,
                 expected_application_id,
-                None,
-                3,
+                2,
                 working_group,
             );
 
-            run_to_block(grace_period_for_begin_application_proposal + 30);
+            run_to_block(30);
 
             let lead = WorkingGroupInstance::<T, I>::current_lead();
             assert!(lead.is_some());
@@ -571,7 +428,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
         working_group: WorkingGroup,
     ) where
         <T as frame_system::Trait>::AccountId: From<[u8; 32]>,
-        <T as hiring::Trait>::OpeningId: From<u64>,
         <T as membership::Trait>::MemberId: From<u64>,
         <T as membership::Trait>::ActorId: Into<u64>,
         <<T as stake::Trait>::Currency as traits::Currency<
@@ -583,41 +439,29 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
             let account_id: [u8; 32] = [member_id as u8; 32];
             let stake_amount: Balance = 100;
 
-            let opening_policy_commitment = OpeningPolicyCommitment {
-                role_staking_policy: Some(hiring::StakingPolicy {
-                    amount: 100,
-                    amount_mode: hiring::StakingAmountLimitMode::AtLeast,
-                    crowded_out_unstaking_period_length: None,
-                    review_period_expired_unstaking_period_length: None,
-                }),
-                ..OpeningPolicyCommitment::default()
-            };
+            let stake_policy = Some(working_group::StakePolicy {
+                stake_amount: 100,
+                leaving_unstaking_period: 0,
+            });
 
-            let opening_id = add_opening(
-                member_id,
-                account_id,
-                ActivateOpeningAt::CurrentBlock,
-                Some(opening_policy_commitment),
-                1,
-                working_group,
-            );
+            let opening_id = add_opening(member_id, account_id, stake_policy, 1, working_group);
 
             let apply_result = WorkingGroupInstance::<T, I>::apply_on_opening(
                 RawOrigin::Signed(account_id.into()).into(),
-                member_id.into(),
-                opening_id.into(),
-                account_id.into(),
-                Some(stake_amount.into()),
-                None,
-                Vec::new(),
+                working_group::ApplyOnOpeningParameters::<T> {
+                    member_id: member_id.into(),
+                    opening_id,
+                    role_account_id: account_id.into(),
+                    reward_account_id: account_id.into(),
+                    description: Vec::new(),
+                    stake_parameters: None,
+                },
             );
 
             assert_eq!(apply_result, Ok(()));
 
             let expected_application_id = 0;
 
-            begin_review_applications(member_id, account_id, opening_id, 2, working_group);
-
             let lead = WorkingGroupInstance::<T, I>::current_lead();
             assert!(lead.is_none());
 
@@ -626,7 +470,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                 account_id,
                 opening_id,
                 expected_application_id,
-                None,
                 3,
                 working_group,
             );
@@ -688,7 +531,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
         working_group: WorkingGroup,
     ) where
         <T as frame_system::Trait>::AccountId: From<[u8; 32]>,
-        <T as hiring::Trait>::OpeningId: From<u64>,
         <T as membership::Trait>::MemberId: From<u64>,
         <T as membership::Trait>::ActorId: Into<u64>,
         <<T as stake::Trait>::Currency as traits::Currency<
@@ -700,41 +542,29 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
             let account_id: [u8; 32] = [member_id as u8; 32];
             let stake_amount: Balance = 100;
 
-            let opening_policy_commitment = OpeningPolicyCommitment {
-                role_staking_policy: Some(hiring::StakingPolicy {
-                    amount: 100,
-                    amount_mode: hiring::StakingAmountLimitMode::AtLeast,
-                    crowded_out_unstaking_period_length: None,
-                    review_period_expired_unstaking_period_length: None,
-                }),
-                ..OpeningPolicyCommitment::default()
-            };
+            let stake_policy = Some(working_group::StakePolicy {
+                stake_amount: 100,
+                leaving_unstaking_period: 0,
+            });
 
-            let opening_id = add_opening(
-                member_id,
-                account_id,
-                ActivateOpeningAt::CurrentBlock,
-                Some(opening_policy_commitment),
-                1,
-                working_group,
-            );
+            let opening_id = add_opening(member_id, account_id, stake_policy, 1, working_group);
 
             let apply_result = WorkingGroupInstance::<T, I>::apply_on_opening(
                 RawOrigin::Signed(account_id.into()).into(),
-                member_id.into(),
-                opening_id.into(),
-                account_id.into(),
-                Some(stake_amount.into()),
-                None,
-                Vec::new(),
+                working_group::ApplyOnOpeningParameters::<T> {
+                    member_id: member_id.into(),
+                    opening_id,
+                    role_account_id: account_id.into(),
+                    reward_account_id: account_id.into(),
+                    description: Vec::new(),
+                    stake_parameters: None,
+                },
             );
 
             assert_eq!(apply_result, Ok(()));
 
             let expected_application_id = 0;
 
-            begin_review_applications(member_id, account_id, opening_id, 2, working_group);
-
             let lead = WorkingGroupInstance::<T, I>::current_lead();
 
             assert!(lead.is_none());
@@ -744,7 +574,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                 account_id,
                 opening_id,
                 expected_application_id,
-                None,
                 3,
                 working_group,
             );
@@ -807,16 +636,12 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
             <T as frame_system::Trait>::AccountId: From<[u8; 32]>,
             <T as membership::Trait>::MemberId: From<u64>,
             <T as minting::Trait>::MintId: From<u64>,
-            <<T as minting::Trait>::Currency as traits::Currency<
-                <T as frame_system::Trait>::AccountId,
-            >>::Balance: From<u128>,
+            working_group::BalanceOf<T>: From<u128>,
         {
             initial_test_ext().execute_with(|| {
                 let member_id: MemberId = 1;
                 let account_id: [u8; 32] = [member_id as u8; 32];
 
-                assert_eq!(WorkingGroupInstance::<T, I>::mint(), 0.into());
-
                 let mint_capacity = 999999;
                 set_mint_capacity::<T, I>(
                     member_id,
@@ -827,10 +652,10 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     working_group,
                 );
 
-                let mint_id = WorkingGroupInstance::<T, I>::mint();
-                let mint = <minting::Module<T>>::mints(mint_id);
-
-                assert_eq!(mint.capacity(), mint_capacity.into());
+                assert_eq!(
+                    working_group::Module::<T, I>::budget(),
+                    mint_capacity.into()
+                );
             });
         }
 
@@ -865,61 +690,38 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
             <T as membership::Trait>::MemberId: From<u64>,
             <T as membership::Trait>::ActorId: Into<u64>,
             <T as minting::Trait>::MintId: From<u64>,
-            <T as hiring::Trait>::OpeningId: From<u64>,
-            <<T as minting::Trait>::Currency as traits::Currency<
-                <T as frame_system::Trait>::AccountId,
-            >>::Balance: From<u128>,
+            working_group::BalanceOf<T>: From<u128>,
         {
             initial_test_ext().execute_with(|| {
                 let member_id: MemberId = 1;
                 let account_id: [u8; 32] = [member_id as u8; 32];
-                let stake_amount = 100;
-
-                let opening_policy_commitment = OpeningPolicyCommitment {
-                    role_staking_policy: Some(hiring::StakingPolicy {
-                        amount: 100,
-                        amount_mode: hiring::StakingAmountLimitMode::AtLeast,
-                        crowded_out_unstaking_period_length: None,
-                        review_period_expired_unstaking_period_length: None,
-                    }),
-                    ..OpeningPolicyCommitment::default()
-                };
 
-                let opening_id = add_opening(
-                    member_id,
-                    account_id,
-                    ActivateOpeningAt::CurrentBlock,
-                    Some(opening_policy_commitment),
-                    1,
-                    working_group,
-                );
+                let stake_policy = Some(working_group::StakePolicy {
+                    stake_amount: 100,
+                    leaving_unstaking_period: 0,
+                });
+
+                let opening_id = add_opening(member_id, account_id, stake_policy, 1, working_group);
 
                 let apply_result = WorkingGroupInstance::<T, I>::apply_on_opening(
                     RawOrigin::Signed(account_id.into()).into(),
-                    member_id.into(),
-                    opening_id.into(),
-                    account_id.into(),
-                    Some(stake_amount.into()),
-                    None,
-                    Vec::new(),
+                    working_group::ApplyOnOpeningParameters::<T> {
+                        member_id: member_id.into(),
+                        opening_id,
+                        role_account_id: account_id.into(),
+                        reward_account_id: account_id.into(),
+                        description: Vec::new(),
+                        stake_parameters: None,
+                    },
                 );
 
                 assert_eq!(apply_result, Ok(()));
 
                 let expected_application_id = 0;
 
-                begin_review_applications(member_id, account_id, opening_id, 2, working_group);
-
                 let lead = WorkingGroupInstance::<T, I>::current_lead();
                 assert!(lead.is_none());
 
-                let old_reward_amount = 100;
-                let reward_policy = Some(RewardPolicy {
-                    amount_per_payout: old_reward_amount,
-                    next_payment_at_block: 9999,
-                    payout_interval: None,
-                });
-
                 set_mint_capacity::<T, I>(member_id, account_id, 999999, 3, false, working_group);
 
                 fill_opening(
@@ -927,20 +729,12 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     account_id,
                     opening_id,
                     expected_application_id,
-                    reward_policy,
                     4,
                     working_group,
                 );
 
                 let leader_worker_id = WorkingGroupInstance::<T, I>::current_lead().unwrap();
 
-                let worker = WorkingGroupInstance::<T, I>::worker_by_id(leader_worker_id);
-                let relationship_id = worker.reward_relationship.unwrap();
-
-                let relationship =
-                    recurring_rewards::RewardRelationships::<T>::get(relationship_id);
-                assert_eq!(relationship.amount_per_payout, old_reward_amount.into());
-
                 let new_reward_amount = 999;
                 set_reward(
                     member_id,
@@ -951,9 +745,9 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     working_group,
                 );
 
-                let relationship =
-                    recurring_rewards::RewardRelationships::<T>::get(relationship_id);
-                assert_eq!(relationship.amount_per_payout, new_reward_amount.into());
+                let worker = WorkingGroupInstance::<T, I>::worker_by_id(leader_worker_id);
+
+                assert_eq!(worker.reward_per_block, Some(new_reward_amount.into()));
             });
         }
 
@@ -986,63 +780,41 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
         ) where
             <T as frame_system::Trait>::AccountId: From<[u8; 32]>,
             <T as membership::Trait>::MemberId: From<u64>,
+            working_group::MemberId<T>: From<u64>,
             <T as membership::Trait>::ActorId: Into<u64>,
             <T as minting::Trait>::MintId: From<u64>,
-            <T as hiring::Trait>::OpeningId: From<u64>,
-            <<T as stake::Trait>::Currency as traits::Currency<
-                <T as frame_system::Trait>::AccountId,
-            >>::Balance: From<u128>,
         {
             initial_test_ext().execute_with(|| {
                 let member_id: MemberId = 1;
                 let account_id: [u8; 32] = [0; 32];
                 let stake_amount = 100_u128;
 
-                let opening_policy_commitment = OpeningPolicyCommitment {
-                    role_staking_policy: Some(hiring::StakingPolicy {
-                        amount: 100,
-                        amount_mode: hiring::StakingAmountLimitMode::AtLeast,
-                        crowded_out_unstaking_period_length: None,
-                        review_period_expired_unstaking_period_length: None,
-                    }),
-                    ..OpeningPolicyCommitment::default()
-                };
+                let stake_policy = Some(working_group::StakePolicy {
+                    stake_amount: 100,
+                    leaving_unstaking_period: 0,
+                });
 
-                let opening_id = add_opening(
-                    member_id.into(),
-                    account_id,
-                    ActivateOpeningAt::CurrentBlock,
-                    Some(opening_policy_commitment),
-                    1,
-                    working_group,
-                );
+                let opening_id = add_opening(member_id, account_id, stake_policy, 1, working_group);
 
                 let apply_result = WorkingGroupInstance::<T, I>::apply_on_opening(
                     RawOrigin::Signed(account_id.into()).into(),
-                    member_id.into(),
-                    opening_id.into(),
-                    account_id.into(),
-                    Some(stake_amount.into()),
-                    None,
-                    Vec::new(),
+                    working_group::ApplyOnOpeningParameters::<T> {
+                        member_id: member_id.into(),
+                        opening_id,
+                        role_account_id: account_id.into(),
+                        reward_account_id: account_id.into(),
+                        description: Vec::new(),
+                        stake_parameters: None,
+                    },
                 );
 
                 assert_eq!(apply_result, Ok(()));
 
                 let expected_application_id = 0;
 
-                begin_review_applications(member_id, account_id, opening_id, 2, working_group);
-
                 let lead = WorkingGroupInstance::<T, I>::current_lead();
                 assert!(lead.is_none());
 
-                let old_reward_amount = 100;
-                let reward_policy = Some(RewardPolicy {
-                    amount_per_payout: old_reward_amount,
-                    next_payment_at_block: 9999,
-                    payout_interval: None,
-                });
-
                 set_mint_capacity::<T, I>(member_id, account_id, 999999, 3, false, working_group);
 
                 fill_opening(
@@ -1050,7 +822,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     account_id,
                     opening_id,
                     expected_application_id,
-                    reward_policy,
                     4,
                     working_group,
                 );
@@ -1067,7 +838,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     member_id,
                     account_id,
                     leader_worker_id.into(),
-                    false,
                     5,
                     working_group,
                 );
@@ -1106,68 +876,44 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
             <T as frame_system::Trait>::AccountId: From<[u8; 32]>,
             <T as membership::Trait>::MemberId: From<u64>,
             <T as membership::Trait>::ActorId: Into<u64>,
-            <T as minting::Trait>::MintId: From<u64>,
-            <T as hiring::Trait>::OpeningId: From<u64>,
-            <<T as stake::Trait>::Currency as traits::Currency<
-                <T as frame_system::Trait>::AccountId,
-            >>::Balance: From<u128>,
         {
             initial_test_ext().execute_with(|| {
                 let member_id: MemberId = 1;
                 let account_id: [u8; 32] = [0; 32];
                 let stake_amount = 100_u128;
 
-                let opening_policy_commitment = OpeningPolicyCommitment {
-                    role_staking_policy: Some(hiring::StakingPolicy {
-                        amount: 100,
-                        amount_mode: hiring::StakingAmountLimitMode::AtLeast,
-                        crowded_out_unstaking_period_length: None,
-                        review_period_expired_unstaking_period_length: None,
-                    }),
-                    ..OpeningPolicyCommitment::default()
+                let staking_policy = working_group::StakePolicy {
+                    stake_amount: 100,
+                    leaving_unstaking_period: 0,
                 };
 
                 let opening_id = add_opening(
                     member_id,
                     account_id,
-                    ActivateOpeningAt::CurrentBlock,
-                    Some(opening_policy_commitment),
+                    Some(staking_policy),
                     1,
                     working_group,
                 );
 
                 let apply_result = WorkingGroupInstance::<T, I>::apply_on_opening(
                     RawOrigin::Signed(account_id.into()).into(),
-                    member_id.into(),
-                    opening_id.into(),
-                    account_id.into(),
-                    Some(stake_amount.into()),
-                    None,
-                    Vec::new(),
+                    working_group::ApplyOnOpeningParameters::<T> {
+                        member_id: member_id.into(),
+                        opening_id,
+                        role_account_id: account_id.into(),
+                        reward_account_id: account_id.into(),
+                        description: Vec::new(),
+                        stake_parameters: None,
+                    },
                 );
 
                 assert_eq!(apply_result, Ok(()));
 
                 let expected_application_id = 0;
 
-                begin_review_applications(
-                    member_id,
-                    account_id,
-                    opening_id.into(),
-                    2,
-                    working_group,
-                );
-
                 let lead = WorkingGroupInstance::<T, I>::current_lead();
                 assert!(lead.is_none());
 
-                let old_reward_amount = 100;
-                let reward_policy = Some(RewardPolicy {
-                    amount_per_payout: old_reward_amount,
-                    next_payment_at_block: 9999,
-                    payout_interval: None,
-                });
-
                 set_mint_capacity::<T, I>(member_id, account_id, 999999, 3, false, working_group);
 
                 fill_opening(
@@ -1175,7 +921,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     account_id,
                     opening_id,
                     expected_application_id,
-                    reward_policy,
                     4,
                     working_group,
                 );
@@ -1192,7 +937,6 @@ fn create_fill_working_group_leader_opening_proposal_execution_succeeds() {
                     member_id,
                     account_id,
                     leader_worker_id.into(),
-                    true,
                     5,
                     working_group,
                 );

runtime/src/tests/storage_integration.rs

@@ -20,9 +20,9 @@ fn storage_provider_helper_succeeds() {
 		let worker_id2 = 7;
 		let worker_id3 = 19;
 
-		<working_group::WorkerById<Runtime, Instance2>>::insert(worker_id1, Worker::default());
-		<working_group::WorkerById<Runtime, Instance2>>::insert(worker_id2, Worker::default());
-		<working_group::WorkerById<Runtime, Instance2>>::insert(worker_id3, Worker::default());
+		<working_group::WorkerById<Runtime, Instance2>>::insert(worker_id1, Worker::<Runtime>::default());
+		<working_group::WorkerById<Runtime, Instance2>>::insert(worker_id2, Worker::<Runtime>::default());
+		<working_group::WorkerById<Runtime, Instance2>>::insert(worker_id3, Worker::<Runtime>::default());
 
 		// Still error - not registered in the service discovery.
 		let random_provider_result = <StorageProviderHelper as storage::data_directory::StorageProviderHelper<Runtime>>::get_random_storage_provider();