Enable certain dispatchable calls in smart contracts

runtime/battery-station/src/lib.rs

@@ -46,6 +46,7 @@ use frame_support::{
     weights::{constants::RocksDbWeight, ConstantMultiplier, IdentityFee, Weight},
 };
 use frame_system::EnsureRoot;
+use orml_currencies::Call::transfer;
 use pallet_collective::{EnsureProportionAtLeast, PrimeDefaultVote};
 use pallet_transaction_payment::ChargeTransactionPayment;
 use sp_runtime::{
@@ -56,7 +57,17 @@ use sp_runtime::{
 use sp_version::NativeVersion;
 use substrate_fixed::{types::extra::U33, FixedI128, FixedU128};
 use zeitgeist_primitives::{constants::*, types::*};
+use zrml_prediction_markets::Call::{
+    buy_complete_set, create_cpmm_market_and_deploy_assets, create_market,
+    deploy_swap_pool_and_additional_liquidity, deploy_swap_pool_for_market, dispute, edit_market,
+    redeem_shares, report, sell_complete_set, start_global_dispute,
+};
 use zrml_rikiddo::types::{EmaMarketVolume, FeeSigmoid, RikiddoSigmoidMV};
+use zrml_swaps::Call::{
+    pool_exit, pool_exit_subsidy, pool_exit_with_exact_asset_amount,
+    pool_exit_with_exact_pool_amount, pool_join, pool_join_with_exact_asset_amount,
+    pool_join_with_exact_pool_amount, swap_exact_amount_in, swap_exact_amount_out,
+};
 #[cfg(feature = "parachain")]
 use {
     frame_support::traits::{AsEnsureOriginWithArg, Everything, Nothing},
@@ -101,32 +112,88 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     state_version: 1,
 };
 
+#[derive(scale_info::TypeInfo)]
+pub struct ContractsCallfilter;
+
+impl Contains<RuntimeCall> for ContractsCallfilter {
+    fn contains(runtime_call: &RuntimeCall) -> bool {
+        #[allow(clippy::match_like_matches_macro)]
+        match runtime_call {
+            RuntimeCall::AssetManager(transfer { .. }) => true,
+            RuntimeCall::PredictionMarkets(inner_call) => {
+                match inner_call {
+                    buy_complete_set { .. } => true,
+                    deploy_swap_pool_and_additional_liquidity { .. } => true,
+                    deploy_swap_pool_for_market { .. } => true,
+                    dispute { .. } => true,
+                    // Only allow CPMM markets using Authorized or SimpleDisputes dispute mechanism
+                    create_market {
+                        dispute_mechanism:
+                            MarketDisputeMechanism::Authorized | MarketDisputeMechanism::SimpleDisputes,
+                        scoring_rule: ScoringRule::CPMM,
+                        ..
+                    } => true,
+                    create_cpmm_market_and_deploy_assets {
+                        dispute_mechanism:
+                            MarketDisputeMechanism::Authorized | MarketDisputeMechanism::SimpleDisputes,
+                        ..
+                    } => true,
+                    edit_market {
+                        dispute_mechanism:
+                            MarketDisputeMechanism::Authorized | MarketDisputeMechanism::SimpleDisputes,
+                        scoring_rule: ScoringRule::CPMM,
+                        ..
+                    } => true,
+                    redeem_shares { .. } => true,
+                    report { .. } => true,
+                    sell_complete_set { .. } => true,
+                    start_global_dispute { .. } => true,
+                    _ => false,
+                }
+            }
+            RuntimeCall::Swaps(inner_call) => match inner_call {
+                pool_exit { .. } => true,
+                pool_exit_subsidy { .. } => true,
+                pool_exit_with_exact_asset_amount { .. } => true,
+                pool_exit_with_exact_pool_amount { .. } => true,
+                pool_join { .. } => true,
+                pool_join_with_exact_asset_amount { .. } => true,
+                pool_join_with_exact_pool_amount { .. } => true,
+                swap_exact_amount_in { .. } => true,
+                swap_exact_amount_out { .. } => true,
+                _ => false,
+            },
+            _ => false,
+        }
+    }
+}
+
 #[derive(scale_info::TypeInfo)]
 pub struct IsCallable;
 
 // Currently disables Court, Rikiddo and creation of markets using Court.
 impl Contains<RuntimeCall> for IsCallable {
     fn contains(call: &RuntimeCall) -> bool {
-        use zeitgeist_primitives::types::{
-            MarketDisputeMechanism::Court, ScoringRule::RikiddoSigmoidFeeMarketEma,
-        };
-        use zrml_prediction_markets::Call::{
-            create_cpmm_market_and_deploy_assets, create_market, edit_market,
-        };
-
         #[allow(clippy::match_like_matches_macro)]
         match call {
             RuntimeCall::Court(_) => false,
             RuntimeCall::LiquidityMining(_) => false,
             RuntimeCall::PredictionMarkets(inner_call) => {
                 match inner_call {
                     // Disable Rikiddo markets
-                    create_market { scoring_rule: RikiddoSigmoidFeeMarketEma, .. } => false,
-                    edit_market { scoring_rule: RikiddoSigmoidFeeMarketEma, .. } => false,
+                    create_market {
+                        scoring_rule: ScoringRule::RikiddoSigmoidFeeMarketEma, ..
+                    } => false,
+                    edit_market {
+                        scoring_rule: ScoringRule::RikiddoSigmoidFeeMarketEma, ..
+                    } => false,
                     // Disable Court dispute resolution mechanism
-                    create_market { dispute_mechanism: Court, .. } => false,
-                    create_cpmm_market_and_deploy_assets { dispute_mechanism: Court, .. } => false,
-                    edit_market { dispute_mechanism: Court, .. } => false,
+                    create_market { dispute_mechanism: MarketDisputeMechanism::Court, .. } => false,
+                    create_cpmm_market_and_deploy_assets {
+                        dispute_mechanism: MarketDisputeMechanism::Court,
+                        ..
+                    } => false,
+                    edit_market { dispute_mechanism: MarketDisputeMechanism::Court, .. } => false,
                     _ => true,
                 }
             }

runtime/common/src/lib.rs

@@ -651,7 +651,7 @@ macro_rules! impl_config_traits {
 
         impl pallet_contracts::Config for Runtime {
             type AddressGenerator = pallet_contracts::DefaultAddressGenerator;
-            type CallFilter = frame_support::traits::Nothing;
+            type CallFilter = ContractsCallfilter;
             type CallStack = [pallet_contracts::Frame::<Runtime>; 5];
             type ChainExtension = ();
             type Currency = Balances;

runtime/zeitgeist/src/lib.rs

@@ -41,7 +41,9 @@ pub use crate::parachain_params::*;
 pub use crate::parameters::*;
 use alloc::vec;
 use frame_support::{
-    traits::{ConstU16, ConstU32, Contains, EitherOfDiverse, EqualPrivilegeOnly, InstanceFilter},
+    traits::{
+        ConstU16, ConstU32, Contains, EitherOfDiverse, EqualPrivilegeOnly, InstanceFilter, Nothing,
+    },
     weights::{constants::RocksDbWeight, ConstantMultiplier, IdentityFee, Weight},
 };
 use frame_system::EnsureRoot;
@@ -58,7 +60,7 @@ use zeitgeist_primitives::{constants::*, types::*};
 use zrml_rikiddo::types::{EmaMarketVolume, FeeSigmoid, RikiddoSigmoidMV};
 #[cfg(feature = "parachain")]
 use {
-    frame_support::traits::{AsEnsureOriginWithArg, Everything, Nothing},
+    frame_support::traits::{AsEnsureOriginWithArg, Everything},
     xcm_builder::{EnsureXcmOrigin, FixedWeightBounds, LocationInverter},
     xcm_config::{
         asset_registry::CustomAssetProcessor,
@@ -100,6 +102,8 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     state_version: 1,
 };
 
+pub type ContractsCallfilter = Nothing;
+
 #[derive(scale_info::TypeInfo)]
 pub struct IsCallable;