Merge branch 'olympia_dev' of https://github.com/Joystream/joystream into forum_thread_tags_runtime

runtime-modules/bounty/src/lib.rs

@@ -85,7 +85,7 @@ use codec::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
 use frame_support::dispatch::{DispatchError, DispatchResult};
-use frame_support::traits::{Currency, ExistenceRequirement, Get};
+use frame_support::traits::{Currency, ExistenceRequirement, Get, LockIdentifier};
 use frame_support::weights::Weight;
 use frame_support::{decl_error, decl_event, decl_module, decl_storage, ensure, Parameter};
 use frame_system::ensure_root;
@@ -128,7 +128,12 @@ pub trait Trait:
     type CouncilBudgetManager: CouncilBudgetManager<BalanceOf<Self>>;
 
     /// Provides stake logic implementation.
-    type StakingHandler: StakingHandler<Self::AccountId, BalanceOf<Self>, MemberId<Self>>;
+    type StakingHandler: StakingHandler<
+        Self::AccountId,
+        BalanceOf<Self>,
+        MemberId<Self>,
+        LockIdentifier,
+    >;
 
     /// Work entry Id type
     type EntryId: From<u32> + Parameter + Default + Copy + Ord + One;
@@ -705,6 +710,9 @@ decl_module! {
         /// Exports const - min work entrant stake for a bounty.
         const MinWorkEntrantStake: BalanceOf<T> = T::MinWorkEntrantStake::get();
 
+        /// Exports const - bounty lock id.
+        const BountyLockId: LockIdentifier = T::StakingHandler::lock_id();
+
         /// Creates a bounty. Metadata stored in the transaction log but discarded after that.
         /// <weight>
         ///

runtime-modules/council/src/lib.rs

@@ -43,7 +43,7 @@
 
 // used dependencies
 use codec::{Decode, Encode};
-use frame_support::traits::{Currency, Get};
+use frame_support::traits::{Currency, Get, LockIdentifier};
 use frame_support::weights::Weight;
 use frame_support::{decl_error, decl_event, decl_module, decl_storage, ensure, error::BadOrigin};
 
@@ -234,21 +234,35 @@ pub trait Trait:
     /// Minimum number of extra candidates needed for the valid election.
     /// Number of total candidates is equal to council size plus extra candidates.
     type MinNumberOfExtraCandidates: Get<u64>;
+
     /// Council member count
     type CouncilSize: Get<u64>;
+
     /// Minimum stake candidate has to lock
     type MinCandidateStake: Get<Balance<Self>>;
 
     /// Identifier for currency lock used for candidacy staking.
-    type CandidacyLock: StakingHandler<Self::AccountId, Balance<Self>, Self::MemberId>;
+    type CandidacyLock: StakingHandler<
+        Self::AccountId,
+        Balance<Self>,
+        Self::MemberId,
+        LockIdentifier,
+    >;
+
     /// Identifier for currency lock used for candidacy staking.
-    type CouncilorLock: StakingHandler<Self::AccountId, Balance<Self>, Self::MemberId>;
+    type CouncilorLock: StakingHandler<
+        Self::AccountId,
+        Balance<Self>,
+        Self::MemberId,
+        LockIdentifier,
+    >;
 
     /// Validates staking account ownership for a member.
     type StakingAccountValidator: common::StakingAccountValidator<Self>;
 
     /// Duration of annoncing period
     type AnnouncingPeriodDuration: Get<Self::BlockNumber>;
+
     /// Duration of idle period
     type IdlePeriodDuration: Get<Self::BlockNumber>;
 
@@ -479,19 +493,31 @@ decl_module! {
         /// Minimum number of extra candidates needed for the valid election.
         /// Number of total candidates is equal to council size plus extra candidates.
         const MinNumberOfExtraCandidates: u64 = T::MinNumberOfExtraCandidates::get();
+
         /// Council member count
         const CouncilSize: u64 = T::CouncilSize::get();
+
         /// Minimum stake candidate has to lock
         const MinCandidateStake: Balance<T> = T::MinCandidateStake::get();
+
         /// Duration of annoncing period
         const AnnouncingPeriodDuration: T::BlockNumber = T::AnnouncingPeriodDuration::get();
+
         /// Duration of idle period
         const IdlePeriodDuration: T::BlockNumber = T::IdlePeriodDuration::get();
+
         /// Interval for automatic reward payments.
         const ElectedMemberRewardPeriod: T::BlockNumber = T::ElectedMemberRewardPeriod::get();
+
         /// Interval between automatic budget refills.
         const BudgetRefillPeriod: T::BlockNumber = T::BudgetRefillPeriod::get();
 
+        /// Exports const - candidacy lock id.
+        const CandidacyLockId: LockIdentifier = T::CandidacyLock::lock_id();
+
+        /// Exports const - councilor lock id.
+        const CouncilorLockId: LockIdentifier = T::CouncilorLock::lock_id();
+
         /////////////////// Lifetime ///////////////////////////////////////////
 
         // No origin so this is a priviledged call

runtime-modules/membership/src/lib.rs

@@ -51,7 +51,7 @@ mod tests;
 
 use codec::{Decode, Encode};
 use frame_support::dispatch::DispatchError;
-use frame_support::traits::{Currency, Get, WithdrawReason, WithdrawReasons};
+use frame_support::traits::{Currency, Get, LockIdentifier, WithdrawReason, WithdrawReasons};
 pub use frame_support::weights::Weight;
 use frame_support::{decl_error, decl_event, decl_module, decl_storage, ensure};
 use frame_system::{ensure_root, ensure_signed};
@@ -123,6 +123,7 @@ pub trait Trait:
         Self::AccountId,
         BalanceOf<Self>,
         Self::MemberId,
+        LockIdentifier,
     >;
 
     /// Staking handler used for staking candidate.
@@ -130,6 +131,7 @@ pub trait Trait:
         Self::AccountId,
         BalanceOf<Self>,
         Self::MemberId,
+        LockIdentifier,
     >;
 
     /// Weight information for extrinsics in this pallet.
@@ -392,6 +394,12 @@ decl_module! {
         /// Exports const - Stake needed to candidate as staking account.
         const CandidateStake: BalanceOf<T> = T::CandidateStake::get();
 
+        /// Exports const - invited member lock id.
+        const InvitedMemberLockId: LockIdentifier = T::InvitedMemberStakingHandler::lock_id();
+
+        /// Exports const - staking candidate lock id.
+        const StakingCandidateLockId: LockIdentifier = T::StakingCandidateStakingHandler::lock_id();
+
         /// Non-members can buy membership.
         ///
         /// <weight>

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

@@ -159,7 +159,9 @@ fn create_proposal_verify<T: Trait>(
         "Active proposal count not updated"
     );
 
-    assert_last_event::<T>(RawEvent::ProposalCreated(proposal_parameters, proposal_details).into());
+    assert_last_event::<T>(
+        RawEvent::ProposalCreated(proposal_id, proposal_parameters, proposal_details).into(),
+    );
 
     assert!(
         ThreadIdByProposalId::<T>::contains_key(proposal_id),

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

@@ -259,12 +259,14 @@ decl_event! {
     pub enum Event<T> where
         GeneralProposalParameters = GeneralProposalParameters<T>,
         ProposalDetailsOf = ProposalDetailsOf<T>,
+        <T as proposals_engine::Trait>::ProposalId,
     {
         /// A proposal was created
         /// Params:
+        /// - Id of a newly created proposal after it was saved in storage.
         /// - General proposal parameter. Parameters shared by all proposals
         /// - Proposal Details. Parameter of proposal with a variant for each kind of proposal
-        ProposalCreated(GeneralProposalParameters, ProposalDetailsOf),
+        ProposalCreated(ProposalId, GeneralProposalParameters, ProposalDetailsOf),
     }
 }
 
@@ -513,7 +515,7 @@ decl_module! {
 
             <ThreadIdByProposalId<T>>::insert(proposal_id, discussion_thread_id);
 
-            Self::deposit_event(RawEvent::ProposalCreated(general_proposal_parameters, proposal_details));
+            Self::deposit_event(RawEvent::ProposalCreated(proposal_id, general_proposal_parameters, proposal_details));
         }
     }
 }

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

@@ -123,6 +123,7 @@ where
         assert_eq!(proposal.parameters, self.proposal_parameters);
         assert_last_event(
             RawEvent::ProposalCreated(
+                proposal_id,
                 self.general_proposal_parameters.clone(),
                 self.proposal_details.clone(),
             )

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

@@ -143,7 +143,7 @@ mod tests;
 use codec::Decode;
 use frame_support::dispatch::{DispatchError, DispatchResult, UnfilteredDispatchable};
 use frame_support::storage::IterableStorageMap;
-use frame_support::traits::Get;
+use frame_support::traits::{Get, LockIdentifier};
 use frame_support::weights::{GetDispatchInfo, Weight};
 use frame_support::{
     decl_error, decl_event, decl_module, decl_storage, ensure, Parameter, StorageDoubleMap,
@@ -204,7 +204,12 @@ pub trait Trait:
     type ProposalId: From<u32> + Parameter + Default + Copy;
 
     /// Provides stake logic implementation.
-    type StakingHandler: StakingHandler<Self::AccountId, BalanceOf<Self>, MemberId<Self>>;
+    type StakingHandler: StakingHandler<
+        Self::AccountId,
+        BalanceOf<Self>,
+        MemberId<Self>,
+        LockIdentifier,
+    >;
 
     /// The fee is applied when cancel the proposal. A fee would be slashed (burned).
     type CancellationFee: Get<BalanceOf<Self>>;
@@ -259,11 +264,6 @@ decl_event!(
         MemberId = MemberId<T>,
         <T as frame_system::Trait>::BlockNumber,
     {
-        /// Emits on proposal creation.
-        /// Params:
-        /// - Member id of a proposer.
-        /// - Id of a newly created proposal after it was saved in storage.
-        ProposalCreated(MemberId, ProposalId),
 
         /// Emits on proposal creation.
         /// Params:
@@ -415,6 +415,9 @@ decl_module! {
         /// Exports const -  max simultaneous active proposals number.
         const MaxActiveProposalLimit: u32 = T::MaxActiveProposalLimit::get();
 
+        /// Exports const - staking handler lock id.
+        const StakingHandlerLockId: LockIdentifier = T::StakingHandler::lock_id();
+
         /// Block Initialization. Perform voting period check, vote result tally, approved proposals
         /// grace period checks, and proposal execution.
         /// # <weight>
@@ -604,11 +607,6 @@ impl<T: Trait> Module<T> {
         ProposalCount::put(next_proposal_count_value);
         Self::increase_active_proposal_counter();
 
-        Self::deposit_event(RawEvent::ProposalCreated(
-            creation_params.proposer_id,
-            proposal_id,
-        ));
-
         Ok(proposal_id)
     }
 

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

@@ -406,7 +406,6 @@ fn proposal_execution_succeeds() {
         run_to_block(2);
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::Voted(1, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(2, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(3, proposal_id, VoteKind::Approve, Vec::new()),
@@ -458,7 +457,6 @@ fn proposal_execution_failed() {
         assert!(!<crate::Proposals<Test>>::contains_key(proposal_id));
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::Voted(1, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(2, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(3, proposal_id, VoteKind::Approve, Vec::new()),
@@ -509,7 +507,6 @@ fn voting_results_calculation_succeeds() {
         run_to_block(block_number);
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::Voted(1, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(2, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(3, proposal_id, VoteKind::Reject, Vec::new()),
@@ -871,15 +868,13 @@ fn veto_proposal_fails_with_insufficient_rights() {
 }
 
 #[test]
-fn create_proposal_event_emitted() {
+fn create_proposal() {
     initial_test_ext().execute_with(|| {
         // Events start only from 1 first block. No events on block zero.
         run_to_block_and_finalize(1);
 
         let dummy_proposal = DummyProposalFixture::default();
         dummy_proposal.create_proposal_and_assert(Ok(1));
-
-        EventFixture::assert_events(vec![RawEvent::ProposalCreated(1, 1)]);
     });
 }
 
@@ -896,7 +891,6 @@ fn veto_proposal_event_emitted() {
         veto_proposal.veto_and_assert(Ok(()));
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::ProposalDecisionMade(proposal_id, ProposalDecision::Vetoed),
         ]);
     });
@@ -918,7 +912,6 @@ fn cancel_proposal_event_emitted() {
         cancel_proposal.cancel_and_assert(Ok(()));
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::ProposalDecisionMade(proposal_id, ProposalDecision::Canceled),
             RawEvent::ProposalCancelled(dummy_proposal.account_id, proposal_id),
         ]);
@@ -938,7 +931,6 @@ fn vote_proposal_event_emitted() {
         vote_generator.vote_and_assert_ok(VoteKind::Approve);
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, 1),
             RawEvent::Voted(1, 1, VoteKind::Approve, Vec::new()),
         ]);
     });
@@ -961,13 +953,11 @@ fn create_proposal_and_expire_it() {
         run_to_block_and_finalize(expected_expriration_block - 1);
 
         assert!(<crate::Proposals<Test>>::contains_key(proposal_id));
-        EventFixture::assert_last_crate_event(RawEvent::ProposalCreated(1, proposal_id));
 
         run_to_block_and_finalize(expected_expriration_block);
 
         assert!(!<crate::Proposals<Test>>::contains_key(proposal_id));
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::ProposalDecisionMade(proposal_id, ProposalDecision::Expired),
         ]);
     });
@@ -1091,8 +1081,6 @@ fn cancel_active_and_pending_execution_proposal_by_runtime() {
         ProposalsEngine::cancel_active_and_pending_proposals();
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, pending_execution_proposal_id),
-            RawEvent::ProposalCreated(1, active_proposal_id),
             RawEvent::Voted(
                 1,
                 pending_execution_proposal_id,
@@ -1186,7 +1174,6 @@ fn cancel_pending_constitutionality_proposal_by_runtime() {
         ProposalsEngine::cancel_active_and_pending_proposals();
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::Voted(1, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(2, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(3, proposal_id, VoteKind::Approve, Vec::new()),
@@ -1849,7 +1836,6 @@ fn proposal_with_pending_constitutionality_succeeds() {
         run_to_block_and_finalize(2);
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::Voted(1, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(2, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(3, proposal_id, VoteKind::Approve, Vec::new()),
@@ -1912,7 +1898,6 @@ fn proposal_with_pending_constitutionality_reactivation_succeeds() {
         run_to_block_and_finalize(2);
 
         EventFixture::assert_events(vec![
-            RawEvent::ProposalCreated(1, proposal_id),
             RawEvent::Voted(1, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(2, proposal_id, VoteKind::Approve, Vec::new()),
             RawEvent::Voted(3, proposal_id, VoteKind::Approve, Vec::new()),
@@ -2010,7 +1995,6 @@ fn proposal_with_pending_constitutionality_execution_succeeds() {
         EventFixture::assert_global_events(vec![
             TestEvent::frame_system(frame_system::RawEvent::NewAccount(1)), // because of token transfer
             TestEvent::balances(balances::RawEvent::Endowed(1, total_balance)), // because of token transfer
-            TestEvent::engine(RawEvent::ProposalCreated(1, proposal_id)),
             TestEvent::engine(RawEvent::Voted(
                 1,
                 proposal_id,
@@ -2109,7 +2093,6 @@ fn proposal_with_pending_constitutionality_execution_succeeds() {
             // first chain of event from the creation to the approval
             TestEvent::frame_system(frame_system::RawEvent::NewAccount(1)), // because of token transfer
             TestEvent::balances(balances::RawEvent::Endowed(1, total_balance)), // because of token transfer
-            TestEvent::engine(RawEvent::ProposalCreated(1, proposal_id)),
             TestEvent::engine(RawEvent::Voted(
                 1,
                 proposal_id,

runtime-modules/referendum/src/lib.rs

@@ -33,7 +33,7 @@
 // used dependencies
 use codec::{Codec, Decode, Encode};
 use core::marker::PhantomData;
-use frame_support::traits::{EnsureOrigin, Get};
+use frame_support::traits::{EnsureOrigin, Get, LockIdentifier};
 use frame_support::weights::Weight;
 use frame_support::{
     decl_error, decl_event, decl_module, decl_storage, ensure, error::BadOrigin, Parameter,
@@ -222,7 +222,12 @@ pub trait Trait<I: Instance = DefaultInstance>:
     type MaxSaltLength: Get<u64>;
 
     /// Stakes and balance locks handler.
-    type StakingHandler: StakingHandler<Self::AccountId, BalanceOf<Self>, Self::MemberId>;
+    type StakingHandler: StakingHandler<
+        Self::AccountId,
+        BalanceOf<Self>,
+        Self::MemberId,
+        LockIdentifier,
+    >;
 
     /// Origin from which the referendum can be started.
     type ManagerOrigin: EnsureOrigin<Self::Origin>;
@@ -395,13 +400,19 @@ decl_module! {
         /// Maximum length of vote commitment salt. Use length that ensures uniqueness for hashing
         /// e.g. std::u64::MAX.
         const MaxSaltLength: u64 = T::MaxSaltLength::get();
+
         /// Duration of voting stage (number of blocks)
         const VoteStageDuration: T::BlockNumber = T::VoteStageDuration::get();
+
         /// Duration of revealing stage (number of blocks)
         const RevealStageDuration: T::BlockNumber = T::RevealStageDuration::get();
+
         /// Minimum stake needed for voting
         const MinimumStake: BalanceOf<T> = T::MinimumStake::get();
 
+        /// Exports const - staking handler lock id.
+        const StakingHandlerLockId: LockIdentifier = T::StakingHandler::lock_id();
+
         /////////////////// Lifetime ///////////////////////////////////////////
 
         // No origin so this is a priviledged call

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

@@ -26,7 +26,7 @@ pub trait LockComparator<Balance> {
 /// Defines abstract staking handler to manage user stakes for different activities
 /// like adding a proposal. Implementation should use built-in LockableCurrency
 /// and LockIdentifier to lock balance consistently with pallet_staking.
-pub trait StakingHandler<AccountId, Balance, MemberId> {
+pub trait StakingHandler<AccountId, Balance, MemberId, LockIdentifier> {
     /// Locks the specified balance on the account using specific lock identifier.
     /// It locks for all withdraw reasons.
     fn lock(account_id: &AccountId, amount: Balance);
@@ -54,6 +54,9 @@ pub trait StakingHandler<AccountId, Balance, MemberId> {
     /// is 'already locked funds' + 'usable funds'.
     fn is_enough_balance_for_stake(account_id: &AccountId, amount: Balance) -> bool;
 
+    /// Returns lock identifier
+    fn lock_id() -> LockIdentifier;
+
     /// Returns the current stake on the account.
     fn current_stake(account_id: &AccountId) -> Balance;
 }
@@ -81,6 +84,7 @@ impl<
         <T as frame_system::Trait>::AccountId,
         <T as pallet_balances::Trait>::Balance,
         <T as common::membership::MembershipTypes>::MemberId,
+        LockIdentifier,
     > for StakingManager<T, LockId>
 {
     fn lock(
@@ -174,6 +178,10 @@ impl<
         <pallet_balances::Module<T>>::usable_balance(account_id) >= amount
     }
 
+    fn lock_id() -> LockIdentifier {
+        LockId::get()
+    }
+
     fn current_stake(
         account_id: &<T as frame_system::Trait>::AccountId,
     ) -> <T as pallet_balances::Trait>::Balance {

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

@@ -42,7 +42,7 @@ mod errors;
 mod tests;
 mod types;
 
-use frame_support::traits::{Currency, Get};
+use frame_support::traits::{Currency, Get, LockIdentifier};
 use frame_support::weights::Weight;
 use frame_support::IterableStorageMap;
 use frame_support::{decl_event, decl_module, decl_storage, ensure, StorageValue};
@@ -104,7 +104,12 @@ pub trait Trait<I: Instance = DefaultInstance>:
     type MaxWorkerNumberLimit: Get<u32>;
 
     /// Stakes and balance locks handler.
-    type StakingHandler: StakingHandler<Self::AccountId, BalanceOf<Self>, MemberId<Self>>;
+    type StakingHandler: StakingHandler<
+        Self::AccountId,
+        BalanceOf<Self>,
+        MemberId<Self>,
+        LockIdentifier,
+    >;
 
     /// Validates staking account ownership for a member.
     type StakingAccountValidator: common::StakingAccountValidator<Self>;
@@ -356,6 +361,9 @@ decl_module! {
         /// Defines the period every worker gets paid in blocks.
         const RewardPeriod: u32 = T::RewardPeriod::get();
 
+        /// Staking handler lock id.
+        const StakingHandlerLockId: LockIdentifier = T::StakingHandler::lock_id();
+
         /// # <weight>
         ///
         /// ## Weight

runtime/src/tests/proposals_integration/working_group_proposals.rs

@@ -5,6 +5,7 @@ use super::*;
 
 use common::working_group::WorkingGroup;
 use common::BalanceKind;
+use frame_support::traits::LockIdentifier;
 use frame_system::RawOrigin;
 use proposals_codex::CreateOpeningParameters;
 use sp_runtime::SaturatedConversion;
@@ -646,6 +647,7 @@ fn run_create_decrease_group_leader_stake_proposal_execution_succeeds<
         <T as frame_system::Trait>::AccountId,
         <T as pallet_balances::Trait>::Balance,
         <T as common::membership::MembershipTypes>::MemberId,
+        LockIdentifier,
     >,
 >(
     working_group: WorkingGroup,
@@ -806,6 +808,7 @@ fn run_create_slash_group_leader_stake_proposal_execution_succeeds<
         <T as frame_system::Trait>::AccountId,
         <T as pallet_balances::Trait>::Balance,
         <T as common::membership::MembershipTypes>::MemberId,
+        LockIdentifier,
     >,
 >(
     working_group: WorkingGroup,
@@ -1323,6 +1326,7 @@ fn run_create_terminate_group_leader_role_proposal_execution_succeeds<
         <T as frame_system::Trait>::AccountId,
         <T as pallet_balances::Trait>::Balance,
         <T as common::membership::MembershipTypes>::MemberId,
+        LockIdentifier,
     >,
 >(
     working_group: WorkingGroup,
@@ -1479,6 +1483,7 @@ fn run_create_terminate_group_leader_role_proposal_with_slashing_execution_succe
         <T as frame_system::Trait>::AccountId,
         <T as pallet_balances::Trait>::Balance,
         <T as common::membership::MembershipTypes>::MemberId,
+        LockIdentifier,
     >,
 >(
     working_group: WorkingGroup,