Set proposal parameters

- set proposal limits and introduce errors
- update spending proposal parameters
- introduce total issuance token percentage

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

@@ -52,11 +52,14 @@ use governance::election_params::ElectionParameters;
 use proposal_engine::ProposalParameters;
 use roles::actors::{Role, RoleParameters};
 use rstd::clone::Clone;
+use rstd::convert::TryInto;
 use rstd::prelude::*;
 use rstd::str::from_utf8;
 use rstd::vec::Vec;
 use runtime_io::blake2_256;
+use sr_primitives::traits::SaturatedConversion;
 use sr_primitives::traits::{One, Zero};
+pub use sr_primitives::Perbill;
 use srml_support::dispatch::DispatchResult;
 use srml_support::traits::{Currency, Get};
 use srml_support::{decl_error, decl_module, decl_storage, ensure, print};
@@ -64,6 +67,10 @@ use system::{ensure_root, RawOrigin};
 
 pub use proposal_types::ProposalDetails;
 
+// Percentage of the total token issue as max mint balance value. Shared with spending
+// proposal max balance percentage.
+const COUNCIL_MINT_MAX_BALANCE_PERCENT: u32 = 2;
+
 /// 'Proposals codex' substrate module Trait
 pub trait Trait:
     system::Trait
@@ -134,10 +141,10 @@ decl_error! {
         RuntimeProposalProposerNotInTheAllowedProposersList,
 
         /// Invalid balance value for the spending proposal
-        SpendingProposalZeroBalance,
+        InvalidSpendingProposalBalance,
 
         /// Invalid validator count for the 'set validator count' proposal
-        LessThanMinValidatorCount,
+        InvalidValidatorCount,
 
         /// Require root origin in extrinsics
         RequireRootOrigin,
@@ -187,6 +194,23 @@ decl_error! {
         /// Invalid council election parameter - announcing_period
         InvalidCouncilElectionParameterAnnouncingPeriod,
 
+        /// Invalid council election parameter - min_stake
+        InvalidStorageRoleParameterMinStake,
+
+        /// Invalid council election parameter - reward
+        InvalidStorageRoleParameterReward,
+
+        /// Invalid council election parameter - entry_request_fee
+        InvalidStorageRoleParameterEntryRequestFee,
+
+        /// Invalid working group mint capacity parameter
+        InvalidStorageWorkingGroupMintCapacity,
+
+        /// Invalid council mint capacity parameter
+        InvalidStorageCouncilMintCapacity,
+
+        /// Invalid 'set lead proposal' parameter - proposed lead cannot be a councilor
+        InvalidSetLeadParameterCannotBeCouncilor
     }
 }
 
@@ -322,6 +346,8 @@ decl_module! {
             stake_balance: Option<BalanceOf<T>>,
             election_parameters: ElectionParameters<BalanceOfGovernanceCurrency<T>, T::BlockNumber>,
         ) {
+            election_parameters.ensure_valid()?;
+
             Self::ensure_council_election_parameters_valid(&election_parameters)?;
 
             let proposal_code =
@@ -352,6 +378,19 @@ decl_module! {
             stake_balance: Option<BalanceOf<T>>,
             mint_balance: BalanceOfMint<T>,
         ) {
+
+            let max_mint_capacity: u32 = get_required_stake_by_fraction::<T>(
+                COUNCIL_MINT_MAX_BALANCE_PERCENT,
+                100
+            )
+            .try_into()
+            .unwrap_or_default() as u32;
+
+            ensure!(
+                mint_balance < <BalanceOfMint<T>>::from(max_mint_capacity),
+                Error::InvalidStorageCouncilMintCapacity
+            );
+
             let proposal_code =
                 <governance::council::Call<T>>::set_council_mint_capacity(mint_balance.clone());
 
@@ -380,6 +419,15 @@ decl_module! {
             stake_balance: Option<BalanceOf<T>>,
             mint_balance: BalanceOfMint<T>,
         ) {
+
+            let max_mint_capacity: u32 = get_required_stake_by_fraction::<T>(1, 100)
+                .try_into()
+                .unwrap_or_default() as u32;
+            ensure!(
+                mint_balance < <BalanceOfMint<T>>::from(max_mint_capacity),
+                Error::InvalidStorageWorkingGroupMintCapacity
+            );
+
             let proposal_code =
                 <content_working_group::Call<T>>::set_mint_capacity(mint_balance.clone());
 
@@ -409,7 +457,19 @@ decl_module! {
             balance: BalanceOfMint<T>,
             destination: T::AccountId,
         ) {
-            ensure!(balance != BalanceOfMint::<T>::zero(), Error::SpendingProposalZeroBalance);
+            ensure!(balance != BalanceOfMint::<T>::zero(), Error::InvalidSpendingProposalBalance);
+
+            let max_balance: u32 = get_required_stake_by_fraction::<T>(
+                COUNCIL_MINT_MAX_BALANCE_PERCENT,
+                100
+            )
+            .try_into()
+            .unwrap_or_default() as u32;
+
+            ensure!(
+                balance < <BalanceOfMint<T>>::from(max_balance),
+                Error::InvalidSpendingProposalBalance
+            );
 
             let proposal_code = <governance::council::Call<T>>::spend_from_council_mint(
                 balance.clone(),
@@ -442,6 +502,14 @@ decl_module! {
             stake_balance: Option<BalanceOf<T>>,
             new_lead: Option<(T::MemberId, T::AccountId)>
         ) {
+            if let Some(lead) = new_lead.clone() {
+                let account_id = lead.1;
+                ensure!(
+                    !<governance::council::Module<T>>::is_councilor(&account_id),
+                    Error::InvalidSetLeadParameterCannotBeCouncilor
+                );
+            }
+
             let proposal_code =
                 <content_working_group::Call<T>>::replace_lead(new_lead.clone());
 
@@ -500,7 +568,12 @@ decl_module! {
         ) {
             ensure!(
                 new_validator_count >= <staking::Module<T>>::minimum_validator_count(),
-                Error::LessThanMinValidatorCount
+                Error::InvalidValidatorCount
+            );
+
+            ensure!(
+                new_validator_count <= 1000, // max validator count
+                Error::InvalidValidatorCount
             );
 
             let proposal_code =
@@ -665,32 +738,57 @@ impl<T: Trait> Module<T> {
         role_parameters: &RoleParameters<BalanceOfGovernanceCurrency<T>, T::BlockNumber>,
     ) -> Result<(), Error> {
         ensure!(
-            role_parameters.min_actors > 0,
+            role_parameters.min_actors <= 5,
             Error::InvalidStorageRoleParameterMinActors
         );
 
         ensure!(
-            role_parameters.max_actors > 0,
+            role_parameters.max_actors >= 5,
+            Error::InvalidStorageRoleParameterMaxActors
+        );
+
+        ensure!(
+            role_parameters.max_actors < 100,
             Error::InvalidStorageRoleParameterMaxActors
         );
 
         ensure!(
-            role_parameters.reward_period == T::BlockNumber::from(600),
+            role_parameters.reward_period >= T::BlockNumber::from(600),
             Error::InvalidStorageRoleParameterRewardPeriod
         );
 
         ensure!(
-            role_parameters.bonding_period == T::BlockNumber::from(600),
+            role_parameters.reward_period <= T::BlockNumber::from(3600),
+            Error::InvalidStorageRoleParameterRewardPeriod
+        );
+
+        ensure!(
+            role_parameters.bonding_period >= T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterBondingPeriod
+        );
+
+        ensure!(
+            role_parameters.bonding_period <= T::BlockNumber::from(28800),
             Error::InvalidStorageRoleParameterBondingPeriod
         );
 
         ensure!(
-            role_parameters.unbonding_period == T::BlockNumber::from(600),
+            role_parameters.unbonding_period >= T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterUnbondingPeriod
+        );
+
+        ensure!(
+            role_parameters.unbonding_period <= T::BlockNumber::from(28800),
             Error::InvalidStorageRoleParameterUnbondingPeriod
         );
 
         ensure!(
-            role_parameters.min_service_period == T::BlockNumber::from(600),
+            role_parameters.min_service_period >= T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterMinServicePeriod
+        );
+
+        ensure!(
+            role_parameters.min_service_period <= T::BlockNumber::from(28800),
             Error::InvalidStorageRoleParameterMinServicePeriod
         );
 
@@ -699,15 +797,74 @@ impl<T: Trait> Module<T> {
             Error::InvalidStorageRoleParameterStartupGracePeriod
         );
 
+        ensure!(
+            role_parameters.startup_grace_period <= T::BlockNumber::from(28800),
+            Error::InvalidStorageRoleParameterStartupGracePeriod
+        );
+
+        ensure!(
+            role_parameters.min_stake > <BalanceOfGovernanceCurrency<T>>::from(0u32),
+            Error::InvalidStorageRoleParameterMinStake
+        );
+
+        let max_min_stake: u32 = get_required_stake_by_fraction::<T>(1, 100)
+            .try_into()
+            .unwrap_or_default() as u32;
+
+        ensure!(
+            role_parameters.min_stake < <BalanceOfGovernanceCurrency<T>>::from(max_min_stake),
+            Error::InvalidStorageRoleParameterMinStake
+        );
+
+        ensure!(
+            role_parameters.entry_request_fee > <BalanceOfGovernanceCurrency<T>>::from(0u32),
+            Error::InvalidStorageRoleParameterEntryRequestFee
+        );
+
+        let max_entry_request_fee: u32 = get_required_stake_by_fraction::<T>(1, 100)
+            .try_into()
+            .unwrap_or_default() as u32;
+
+        ensure!(
+            role_parameters.entry_request_fee
+                < <BalanceOfGovernanceCurrency<T>>::from(max_entry_request_fee),
+            Error::InvalidStorageRoleParameterEntryRequestFee
+        );
+
+        ensure!(
+            role_parameters.reward > <BalanceOfGovernanceCurrency<T>>::from(0u32),
+            Error::InvalidStorageRoleParameterReward
+        );
+
+        let max_reward: u32 = get_required_stake_by_fraction::<T>(1, 1000)
+            .try_into()
+            .unwrap_or_default() as u32;
+
+        ensure!(
+            role_parameters.reward < <BalanceOfGovernanceCurrency<T>>::from(max_reward),
+            Error::InvalidStorageRoleParameterReward
+        );
+
         Ok(())
     }
 
+    /*
+    entry_request_fee [tJOY]	>0	<1%	NA
+    * Not enforced by runtime. Should not be displayed in the UI, or at least grayed out.
+    ** Should not be displayed in the UI, or at least grayed out.
+        */
+
     // validates council election parameters for the 'Set election parameters' proposal
-    fn ensure_council_election_parameters_valid(
+    pub(crate) fn ensure_council_election_parameters_valid(
         election_parameters: &ElectionParameters<BalanceOfGovernanceCurrency<T>, T::BlockNumber>,
     ) -> Result<(), Error> {
         ensure!(
-            election_parameters.council_size >= 3,
+            election_parameters.council_size >= 4,
+            Error::InvalidCouncilElectionParameterCouncilSize
+        );
+
+        ensure!(
+            election_parameters.council_size <= 20,
             Error::InvalidCouncilElectionParameterCouncilSize
         );
 
@@ -716,36 +873,88 @@ impl<T: Trait> Module<T> {
             Error::InvalidCouncilElectionParameterCandidacyLimit
         );
 
+        ensure!(
+            election_parameters.candidacy_limit <= 100,
+            Error::InvalidCouncilElectionParameterCandidacyLimit
+        );
+
         ensure!(
             election_parameters.min_voting_stake >= <BalanceOfGovernanceCurrency<T>>::one(),
             Error::InvalidCouncilElectionParameterMinVotingStake
         );
 
+        ensure!(
+            election_parameters.min_voting_stake
+                <= <BalanceOfGovernanceCurrency<T>>::from(100000u32),
+            Error::InvalidCouncilElectionParameterMinVotingStake
+        );
+
         ensure!(
             election_parameters.new_term_duration >= T::BlockNumber::from(14400),
             Error::InvalidCouncilElectionParameterNewTermDuration
         );
 
+        ensure!(
+            election_parameters.new_term_duration <= T::BlockNumber::from(432000),
+            Error::InvalidCouncilElectionParameterNewTermDuration
+        );
+
         ensure!(
             election_parameters.revealing_period >= T::BlockNumber::from(14400),
             Error::InvalidCouncilElectionParameterRevealingPeriod
         );
 
+        ensure!(
+            election_parameters.revealing_period <= T::BlockNumber::from(43200),
+            Error::InvalidCouncilElectionParameterRevealingPeriod
+        );
+
         ensure!(
             election_parameters.voting_period >= T::BlockNumber::from(14400),
             Error::InvalidCouncilElectionParameterVotingPeriod
         );
 
+        ensure!(
+            election_parameters.voting_period <= T::BlockNumber::from(43200),
+            Error::InvalidCouncilElectionParameterVotingPeriod
+        );
+
         ensure!(
             election_parameters.announcing_period >= T::BlockNumber::from(14400),
             Error::InvalidCouncilElectionParameterAnnouncingPeriod
         );
 
+        ensure!(
+            election_parameters.announcing_period <= T::BlockNumber::from(43200),
+            Error::InvalidCouncilElectionParameterAnnouncingPeriod
+        );
+
         ensure!(
             election_parameters.min_council_stake >= <BalanceOfGovernanceCurrency<T>>::one(),
             Error::InvalidCouncilElectionParameterMinCouncilStake
         );
 
+        ensure!(
+            election_parameters.min_council_stake
+                <= <BalanceOfGovernanceCurrency<T>>::from(100000u32),
+            Error::InvalidCouncilElectionParameterMinCouncilStake
+        );
+
         Ok(())
     }
 }
+
+// calculates required stake value using total issuance value and stake percentage. Truncates to
+// lowest integer value. Value fraction is defined by numerator and denominator.
+pub(crate) fn get_required_stake_by_fraction<T: crate::Trait>(
+    numerator: u32,
+    denominator: u32,
+) -> BalanceOf<T> {
+    let total_issuance: u128 = <CurrencyOf<T>>::total_issuance().try_into().unwrap_or(0) as u128;
+    let required_stake =
+        Perbill::from_rational_approximation(numerator, denominator) * total_issuance;
+
+    let balance: BalanceOf<T> = required_stake.saturated_into();
+
+    balance
+}

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

@@ -1,23 +1,4 @@
-use crate::{BalanceOf, CurrencyOf, ProposalParameters};
-use rstd::convert::TryInto;
-use sr_primitives::traits::SaturatedConversion;
-pub use sr_primitives::Perbill;
-use srml_support::traits::Currency;
-
-// calculates required stake value using total issuance value and stake percentage. Truncates to
-// lowest integer value.
-fn get_required_stake_by_fraction<T: crate::Trait>(
-    numerator: u32,
-    denominator: u32,
-) -> BalanceOf<T> {
-    let total_issuance: u128 = <CurrencyOf<T>>::total_issuance().try_into().unwrap_or(0) as u128;
-    let required_stake =
-        Perbill::from_rational_approximation(numerator, denominator) * total_issuance;
-
-    let balance: BalanceOf<T> = required_stake.saturated_into();
-
-    balance
-}
+use crate::{get_required_stake_by_fraction, BalanceOf, ProposalParameters};
 
 // Proposal parameters for the 'Set validator count' proposal
 pub(crate) fn set_validator_count_proposal<T: crate::Trait>(
@@ -106,8 +87,8 @@ pub(crate) fn set_content_working_group_mint_capacity_proposal<T: crate::Trait>(
 pub(crate) fn spending_proposal<T: crate::Trait>(
 ) -> ProposalParameters<T::BlockNumber, BalanceOf<T>> {
     ProposalParameters {
-        voting_period: T::BlockNumber::from(43200u32),
-        grace_period: T::BlockNumber::from(0u32),
+        voting_period: T::BlockNumber::from(72000u32),
+        grace_period: T::BlockNumber::from(14400u32),
         approval_quorum_percentage: 66,
         approval_threshold_percentage: 80,
         slashing_quorum_percentage: 60,

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

@@ -14,9 +14,13 @@ use srml_support::dispatch::DispatchResult;
 pub use mock::*;
 
 pub(crate) fn increase_total_balance_issuance(balance: u64) {
+    increase_total_balance_issuance_using_account_id(balance, 999);
+}
+
+pub(crate) fn increase_total_balance_issuance_using_account_id(balance: u64, account_id: u64) {
     let initial_balance = Balances::total_issuance();
     {
-        let _ = <Test as stake::Trait>::Currency::deposit_creating(&999, balance);
+        let _ = <Test as stake::Trait>::Currency::deposit_creating(&account_id, balance);
     }
     assert_eq!(Balances::total_issuance(), initial_balance + balance);
 }
@@ -340,7 +344,7 @@ fn assert_failed_election_parameters_call(
             1,
             b"title".to_vec(),
             b"body".to_vec(),
-            Some(<BalanceOf<Test>>::from(500u32)),
+            Some(<BalanceOf<Test>>::from(3750u32)),
             election_parameters,
         ),
         Err(error)
@@ -352,7 +356,7 @@ fn get_valid_election_parameters() -> ElectionParameters<u64, u64> {
         announcing_period: 14400,
         voting_period: 14400,
         revealing_period: 14400,
-        council_size: 3,
+        council_size: 4,
         candidacy_limit: 25,
         new_term_duration: 14400,
         min_council_stake: 1,
@@ -363,7 +367,7 @@ fn get_valid_election_parameters() -> ElectionParameters<u64, u64> {
 #[test]
 fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
     initial_test_ext().execute_with(|| {
-        let _imbalance = <Test as stake::Trait>::Currency::deposit_creating(&1, 50000);
+        increase_total_balance_issuance_using_account_id(500000, 1);
 
         let mut election_parameters = get_valid_election_parameters();
         election_parameters.council_size = 2;
@@ -372,6 +376,12 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterCouncilSize,
         );
 
+        election_parameters.council_size = 21;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterCouncilSize,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.candidacy_limit = 22;
         assert_failed_election_parameters_call(
@@ -379,6 +389,13 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterCandidacyLimit,
         );
 
+        election_parameters = get_valid_election_parameters();
+        election_parameters.candidacy_limit = 122;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterCandidacyLimit,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.min_voting_stake = 0;
         assert_failed_election_parameters_call(
@@ -386,6 +403,13 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterMinVotingStake,
         );
 
+        election_parameters = get_valid_election_parameters();
+        election_parameters.min_voting_stake = 200000;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterMinVotingStake,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.new_term_duration = 10000;
         assert_failed_election_parameters_call(
@@ -393,6 +417,13 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterNewTermDuration,
         );
 
+        election_parameters = get_valid_election_parameters();
+        election_parameters.new_term_duration = 500000;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterNewTermDuration,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.min_council_stake = 0;
         assert_failed_election_parameters_call(
@@ -400,6 +431,13 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterMinCouncilStake,
         );
 
+        election_parameters = get_valid_election_parameters();
+        election_parameters.min_council_stake = 200000;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterMinCouncilStake,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.voting_period = 10000;
         assert_failed_election_parameters_call(
@@ -407,6 +445,13 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterVotingPeriod,
         );
 
+        election_parameters = get_valid_election_parameters();
+        election_parameters.voting_period = 50000;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterVotingPeriod,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.revealing_period = 10000;
         assert_failed_election_parameters_call(
@@ -414,12 +459,45 @@ fn create_set_election_parameters_call_fails_with_incorrect_parameters() {
             Error::InvalidCouncilElectionParameterRevealingPeriod,
         );
 
+        election_parameters = get_valid_election_parameters();
+        election_parameters.revealing_period = 50000;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterRevealingPeriod,
+        );
+
         election_parameters = get_valid_election_parameters();
         election_parameters.announcing_period = 10000;
         assert_failed_election_parameters_call(
             election_parameters,
             Error::InvalidCouncilElectionParameterAnnouncingPeriod,
         );
+
+        election_parameters = get_valid_election_parameters();
+        election_parameters.announcing_period = 50000;
+        assert_failed_election_parameters_call(
+            election_parameters,
+            Error::InvalidCouncilElectionParameterAnnouncingPeriod,
+        );
+    });
+}
+
+#[test]
+fn create_set_council_mint_capacity_proposal_fails_with_invalid_parameters() {
+    initial_test_ext().execute_with(|| {
+        increase_total_balance_issuance(500000);
+
+        assert_eq!(
+            ProposalCodex::create_set_council_mint_capacity_proposal(
+                RawOrigin::Signed(1).into(),
+                1,
+                b"title".to_vec(),
+                b"body".to_vec(),
+                Some(<BalanceOf<Test>>::from(1250u32)),
+                10001,
+            ),
+            Err(Error::InvalidStorageCouncilMintCapacity)
+        );
     });
 }
 
@@ -477,6 +555,25 @@ fn create_set_council_mint_capacity_proposal_common_checks_succeed() {
     });
 }
 
+#[test]
+fn create_working_groupd_mint_capacity_proposal_fails_with_invalid_parameters() {
+    initial_test_ext().execute_with(|| {
+        increase_total_balance_issuance(500000);
+
+        assert_eq!(
+            ProposalCodex::create_set_content_working_group_mint_capacity_proposal(
+                RawOrigin::Signed(1).into(),
+                1,
+                b"title".to_vec(),
+                b"body".to_vec(),
+                Some(<BalanceOf<Test>>::from(1250u32)),
+                5001,
+            ),
+            Err(Error::InvalidStorageWorkingGroupMintCapacity)
+        );
+    });
+}
+
 #[test]
 fn create_set_content_working_group_mint_capacity_proposal_common_checks_succeed() {
     initial_test_ext().execute_with(|| {
@@ -590,17 +687,58 @@ fn create_spending_proposal_common_checks_succeed() {
 #[test]
 fn create_spending_proposal_call_fails_with_incorrect_balance() {
     initial_test_ext().execute_with(|| {
+        increase_total_balance_issuance_using_account_id(1, 500000);
+
         assert_eq!(
             ProposalCodex::create_spending_proposal(
                 RawOrigin::Signed(1).into(),
                 1,
                 b"title".to_vec(),
                 b"body".to_vec(),
-                Some(<BalanceOf<Test>>::from(500u32)),
+                Some(<BalanceOf<Test>>::from(1250u32)),
                 0,
                 2,
             ),
-            Err(Error::SpendingProposalZeroBalance)
+            Err(Error::InvalidSpendingProposalBalance)
+        );
+
+        assert_eq!(
+            ProposalCodex::create_spending_proposal(
+                RawOrigin::Signed(1).into(),
+                1,
+                b"title".to_vec(),
+                b"body".to_vec(),
+                Some(<BalanceOf<Test>>::from(1250u32)),
+                1001,
+                2,
+            ),
+            Err(Error::InvalidSpendingProposalBalance)
+        );
+    });
+}
+
+#[test]
+fn create_set_lead_proposal_fails_with_proposed_councilor() {
+    initial_test_ext().execute_with(|| {
+        increase_total_balance_issuance_using_account_id(500000, 1);
+
+        let lead_account_id = 20;
+        <governance::council::Module<Test>>::set_council(
+            RawOrigin::Root.into(),
+            vec![lead_account_id],
+        )
+        .unwrap();
+
+        assert_eq!(
+            ProposalCodex::create_set_lead_proposal(
+                RawOrigin::Signed(1).into(),
+                1,
+                b"title".to_vec(),
+                b"body".to_vec(),
+                Some(<BalanceOf<Test>>::from(1250u32)),
+                Some((20, lead_account_id)),
+            ),
+            Err(Error::InvalidSetLeadParameterCannotBeCouncilor)
         );
     });
 }
@@ -778,7 +916,19 @@ fn create_set_validator_count_proposal_failed_with_invalid_validator_count() {
                 Some(<BalanceOf<Test>>::from(500u32)),
                 3,
             ),
-            Err(Error::LessThanMinValidatorCount)
+            Err(Error::InvalidValidatorCount)
+        );
+
+        assert_eq!(
+            ProposalCodex::create_set_validator_count_proposal(
+                RawOrigin::Signed(1).into(),
+                1,
+                b"title".to_vec(),
+                b"body".to_vec(),
+                Some(<BalanceOf<Test>>::from(1001u32)),
+                3,
+            ),
+            Err(Error::InvalidValidatorCount)
         );
     });
 }
@@ -857,53 +1007,138 @@ fn assert_failed_set_storage_parameters_call(
 #[test]
 fn create_set_storage_role_parameters_proposal_fails_with_invalid_parameters() {
     initial_test_ext().execute_with(|| {
+        increase_total_balance_issuance(500000);
+
         let mut role_parameters = RoleParameters::default();
-        role_parameters.min_actors = 0;
+        role_parameters.min_actors = 6;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterMinActors,
         );
 
         role_parameters = RoleParameters::default();
-        role_parameters.max_actors = 0;
+        role_parameters.max_actors = 4;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterMaxActors,
         );
 
         role_parameters = RoleParameters::default();
-        role_parameters.reward_period = 700;
+        role_parameters.max_actors = 100;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMaxActors,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.reward_period = 599;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterRewardPeriod,
+        );
+
+        role_parameters.reward_period = 28801;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterRewardPeriod,
         );
 
         role_parameters = RoleParameters::default();
-        role_parameters.bonding_period = 700;
+        role_parameters.bonding_period = 599;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterBondingPeriod,
         );
 
         role_parameters = RoleParameters::default();
-        role_parameters.unbonding_period = 700;
+        role_parameters.bonding_period = 28801;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterBondingPeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.unbonding_period = 599;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterUnbondingPeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.unbonding_period = 28801;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterUnbondingPeriod,
         );
 
         role_parameters = RoleParameters::default();
-        role_parameters.min_service_period = 700;
+        role_parameters.min_service_period = 599;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMinServicePeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.min_service_period = 28801;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterMinServicePeriod,
         );
 
         role_parameters = RoleParameters::default();
-        role_parameters.startup_grace_period = 500;
+        role_parameters.startup_grace_period = 599;
         assert_failed_set_storage_parameters_call(
             role_parameters,
             Error::InvalidStorageRoleParameterStartupGracePeriod,
         );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.startup_grace_period = 28801;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterStartupGracePeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.min_stake = 0;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMinStake,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.min_stake = 5001;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMinStake,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.entry_request_fee = 0;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterEntryRequestFee,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.entry_request_fee = 5001;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterEntryRequestFee,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.reward = 0;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterReward,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.reward = 501;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterReward,
+        );
     });
 }