Add ensure_storage_role_parameters_valid() to the codex

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

@@ -141,6 +141,30 @@ decl_error! {
 
         /// Require root origin in extrinsics
         RequireRootOrigin,
+
+        /// Invalid storage role parameter - min_actors
+        InvalidStorageRoleParameterMinActors,
+
+        /// Invalid storage role parameter - max_actors
+        InvalidStorageRoleParameterMaxActors,
+
+        /// Invalid storage role parameter - reward_period
+        InvalidStorageRoleParameterRewardPeriod,
+
+        /// Invalid storage role parameter - bonding_period
+        InvalidStorageRoleParameterBondingPeriod,
+
+        /// Invalid storage role parameter - unbonding_period
+        InvalidStorageRoleParameterUnbondingPeriod,
+
+        /// Invalid storage role parameter - min_service_period
+        InvalidStorageRoleParameterMinServicePeriod,
+
+        /// Invalid storage role parameter - min_service_period
+        InvalidStorageRoleParameterMinServicePeriod,
+
+        /// Invalid storage role parameter - startup_grace_period
+        InvalidStorageRoleParameterStartupGracePeriod,
     }
 }
 
@@ -485,6 +509,8 @@ decl_module! {
             stake_balance: Option<BalanceOf<T>>,
             role_parameters: RoleParameters<BalanceOfGovernanceCurrency<T>, T::BlockNumber>
         ) {
+            Self::ensure_storage_role_parameters_valid(&role_parameters)?;
+
             let proposal_code = <roles::actors::Call<T>>::set_role_parameters(
                 Role::StorageProvider,
                 role_parameters.clone()
@@ -611,4 +637,46 @@ impl<T: Trait> Module<T> {
 
         Ok(())
     }
+
+    // validates storage role parameters for the 'Set storage role parameters' proposal
+    fn ensure_storage_role_parameters_valid(
+        role_parameters: &RoleParameters<BalanceOfGovernanceCurrency<T>, T::BlockNumber>,
+    ) -> Result<(), Error> {
+        ensure!(
+            role_parameters.min_actors > 0,
+            Error::InvalidStorageRoleParameterMinActors
+        );
+
+        ensure!(
+            role_parameters.max_actors > 0,
+            Error::InvalidStorageRoleParameterMaxActors
+        );
+
+        ensure!(
+            role_parameters.reward_period == T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterRewardPeriod
+        );
+
+        ensure!(
+            role_parameters.bonding_period == T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterBondingPeriod
+        );
+
+        ensure!(
+            role_parameters.unbonding_period == T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterUnbondingPeriod
+        );
+
+        ensure!(
+            role_parameters.min_service_period == T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterMinServicePeriod
+        );
+
+        ensure!(
+            role_parameters.startup_grace_period >= T::BlockNumber::from(600),
+            Error::InvalidStorageRoleParameterStartupGracePeriod
+        );
+
+        Ok(())
+    }
 }

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

@@ -740,3 +740,74 @@ fn create_set_storage_role_parameters_proposal_common_checks_succeed() {
         proposal_fixture.check_all();
     });
 }
+
+fn assert_failed_set_storage_parameters_call(
+    role_parameters: RoleParameters<u64, u64>,
+    error: Error,
+) {
+    assert_eq!(
+        ProposalCodex::create_set_storage_role_parameters_proposal(
+            RawOrigin::Signed(1).into(),
+            1,
+            b"title".to_vec(),
+            b"body".to_vec(),
+            Some(<BalanceOf<Test>>::from(500u32)),
+            role_parameters,
+        ),
+        Err(error)
+    );
+}
+
+#[test]
+fn create_set_storage_role_parameters_proposal_fails_with_invalid_parameters() {
+    initial_test_ext().execute_with(|| {
+        let mut role_parameters = RoleParameters::default();
+        role_parameters.min_actors = 0;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMinActors,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.max_actors = 0;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMaxActors,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.reward_period = 700;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterRewardPeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.bonding_period = 700;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterBondingPeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.unbonding_period = 700;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterUnbondingPeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.min_service_period = 700;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterMinServicePeriod,
+        );
+
+        role_parameters = RoleParameters::default();
+        role_parameters.startup_grace_period = 500;
+        assert_failed_set_storage_parameters_call(
+            role_parameters,
+            Error::InvalidStorageRoleParameterStartupGracePeriod,
+        );
+    });
+}