Use defaultConfig for pallet_contracts

substrate/frame/contracts/mock-network/src/parachain/contracts_config.rs

@@ -15,87 +15,19 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::{Balances, Runtime, RuntimeCall, RuntimeEvent};
-use crate::{
-	parachain,
-	parachain::RuntimeHoldReason,
-	primitives::{Balance, CENTS},
-};
-use frame_support::{
-	parameter_types,
-	traits::{ConstBool, ConstU32, Contains, Randomness},
-	weights::Weight,
-};
-use frame_system::{pallet_prelude::BlockNumberFor, EnsureSigned};
-use pallet_xcm::BalanceOf;
-use sp_runtime::{traits::Convert, Perbill};
-
-pub const fn deposit(items: u32, bytes: u32) -> Balance {
-	items as Balance * 1 * CENTS + (bytes as Balance) * 1 * CENTS
-}
+use crate::parachain::RuntimeHoldReason;
+use frame_support::{derive_impl, parameter_types};
 
 parameter_types! {
-	pub const DepositPerItem: Balance = deposit(1, 0);
-	pub const DepositPerByte: Balance = deposit(0, 1);
-	pub const DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024);
 	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();
-	pub const CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(0);
-	pub const MaxDelegateDependencies: u32 = 32;
-}
-
-pub struct DummyRandomness<T: pallet_contracts::Config>(sp_std::marker::PhantomData<T>);
-
-impl<T: pallet_contracts::Config> Randomness<T::Hash, BlockNumberFor<T>> for DummyRandomness<T> {
-	fn random(_subject: &[u8]) -> (T::Hash, BlockNumberFor<T>) {
-		(Default::default(), Default::default())
-	}
-}
-
-impl Convert<Weight, BalanceOf<Self>> for Runtime {
-	fn convert(w: Weight) -> BalanceOf<Self> {
-		w.ref_time().into()
-	}
-}
-
-#[derive(Clone, Default)]
-pub struct Filters;
-
-impl Contains<RuntimeCall> for Filters {
-	fn contains(call: &RuntimeCall) -> bool {
-		match call {
-			parachain::RuntimeCall::Contracts(_) => true,
-			_ => false,
-		}
-	}
 }
 
+#[derive_impl(pallet_contracts::config_preludes::TestDefaultConfig)]
 impl pallet_contracts::Config for Runtime {
 	type AddressGenerator = pallet_contracts::DefaultAddressGenerator;
-	type CallFilter = Filters;
 	type CallStack = [pallet_contracts::Frame<Self>; 5];
-	type ChainExtension = ();
-	type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
 	type Currency = Balances;
-	type DefaultDepositLimit = DefaultDepositLimit;
-	type DepositPerByte = DepositPerByte;
-	type DepositPerItem = DepositPerItem;
-	type MaxCodeLen = ConstU32<{ 123 * 1024 }>;
-	type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>;
-	type MaxDelegateDependencies = MaxDelegateDependencies;
-	type MaxStorageKeyLen = ConstU32<128>;
-	type Migrations = ();
-	type Randomness = DummyRandomness<Self>;
-	type RuntimeCall = RuntimeCall;
-	type RuntimeEvent = RuntimeEvent;
-	type RuntimeHoldReason = RuntimeHoldReason;
 	type Schedule = Schedule;
 	type Time = super::Timestamp;
-	type UnsafeUnstableInterface = ConstBool<true>;
-	type UploadOrigin = EnsureSigned<Self::AccountId>;
-	type InstantiateOrigin = EnsureSigned<Self::AccountId>;
-	type WeightInfo = ();
-	type WeightPrice = Self;
-	type Debug = ();
-	type Environment = ();
-	type ApiVersion = ();
 	type Xcm = pallet_xcm::Pallet<Self>;
 }

substrate/frame/contracts/src/lib.rs

@@ -250,9 +250,10 @@ pub mod pallet {
 	#[pallet::storage_version(STORAGE_VERSION)]
 	pub struct Pallet<T>(_);
 
-	#[pallet::config]
+	#[pallet::config(with_default)]
 	pub trait Config: frame_system::Config {
 		/// The time implementation used to supply timestamps to contracts through `seal_now`.
+		#[pallet::no_default]
 		type Time: Time;
 
 		/// The generator used to supply randomness to contracts through `seal_random`.
@@ -263,22 +264,30 @@ pub mod pallet {
 		/// be instantiated from existing codes that use this deprecated functionality. It will
 		/// be removed eventually. Hence for new `pallet-contracts` deployments it is okay
 		/// to supply a dummy implementation for this type (because it is never used).
+		#[pallet::no_default_bounds]
 		type Randomness: Randomness<Self::Hash, BlockNumberFor<Self>>;
 
 		/// The fungible in which fees are paid and contract balances are held.
+		#[pallet::no_default]
 		type Currency: Inspect<Self::AccountId>
 			+ Mutate<Self::AccountId>
 			+ MutateHold<Self::AccountId, Reason = Self::RuntimeHoldReason>;
 
 		/// The overarching event type.
+		#[pallet::no_default_bounds]
 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
 
 		/// The overarching call type.
+		#[pallet::no_default_bounds]
 		type RuntimeCall: Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
 			+ GetDispatchInfo
 			+ codec::Decode
 			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
 
+		/// Overarching hold reason.
+		#[pallet::no_default_bounds]
+		type RuntimeHoldReason: From<HoldReason>;
+
 		/// Filter that is applied to calls dispatched by contracts.
 		///
 		/// Use this filter to control which dispatchables are callable by contracts.
@@ -301,21 +310,25 @@ pub mod pallet {
 		///
 		/// This filter does not apply to XCM transact calls. To impose restrictions on XCM transact
 		/// calls, you must configure them separately within the XCM pallet itself.
+		#[pallet::no_default_bounds]
 		type CallFilter: Contains<<Self as frame_system::Config>::RuntimeCall>;
 
 		/// Used to answer contracts' queries regarding the current weight price. This is **not**
 		/// used to calculate the actual fee and is only for informational purposes.
+		#[pallet::no_default_bounds]
 		type WeightPrice: Convert<Weight, BalanceOf<Self>>;
 
 		/// Describes the weights of the dispatchables of this module and is also used to
 		/// construct a default cost schedule.
 		type WeightInfo: WeightInfo;
 
 		/// Type that allows the runtime authors to add new host functions for a contract to call.
+		#[pallet::no_default_bounds]
 		type ChainExtension: chain_extension::ChainExtension<Self> + Default;
 
 		/// Cost schedule and limits.
 		#[pallet::constant]
+		#[pallet::no_default]
 		type Schedule: Get<Schedule<Self>>;
 
 		/// The type of the call stack determines the maximum nesting depth of contract calls.
@@ -326,6 +339,7 @@ pub mod pallet {
 		///
 		/// This setting along with [`MaxCodeLen`](#associatedtype.MaxCodeLen) directly affects
 		/// memory usage of your runtime.
+		#[pallet::no_default]
 		type CallStack: Array<Item = Frame<Self>>;
 
 		/// The amount of balance a caller has to pay for each byte of storage.
@@ -334,10 +348,12 @@ pub mod pallet {
 		///
 		/// Changing this value for an existing chain might need a storage migration.
 		#[pallet::constant]
+		#[pallet::no_default_bounds]
 		type DepositPerByte: Get<BalanceOf<Self>>;
 
 		/// Fallback value to limit the storage deposit if it's not being set by the caller.
 		#[pallet::constant]
+		#[pallet::no_default_bounds]
 		type DefaultDepositLimit: Get<BalanceOf<Self>>;
 
 		/// The amount of balance a caller has to pay for each storage item.
@@ -346,6 +362,7 @@ pub mod pallet {
 		///
 		/// Changing this value for an existing chain might need a storage migration.
 		#[pallet::constant]
+		#[pallet::no_default_bounds]
 		type DepositPerItem: Get<BalanceOf<Self>>;
 
 		/// The percentage of the storage deposit that should be held for using a code hash.
@@ -356,6 +373,7 @@ pub mod pallet {
 		type CodeHashLockupDepositPercent: Get<Perbill>;
 
 		/// The address generator used to generate the addresses of contracts.
+		#[pallet::no_default_bounds]
 		type AddressGenerator: AddressGenerator<Self>;
 
 		/// The maximum length of a contract code in bytes.
@@ -395,6 +413,7 @@ pub mod pallet {
 		///
 		/// By default, it is safe to set this to `EnsureSigned`, allowing anyone to upload contract
 		/// code.
+		#[pallet::no_default_bounds]
 		type UploadOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
 
 		/// Origin allowed to instantiate code.
@@ -407,11 +426,9 @@ pub mod pallet {
 		///
 		/// By default, it is safe to set this to `EnsureSigned`, allowing anyone to instantiate
 		/// contract code.
+		#[pallet::no_default_bounds]
 		type InstantiateOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
 
-		/// Overarching hold reason.
-		type RuntimeHoldReason: From<HoldReason>;
-
 		/// The sequence of migration steps that will be applied during a migration.
 		///
 		/// # Examples
@@ -435,30 +452,117 @@ pub mod pallet {
 		/// For most production chains, it's recommended to use the `()` implementation of this
 		/// trait. This implementation offers additional logging when the log target
 		/// "runtime::contracts" is set to trace.
+		#[pallet::no_default_bounds]
 		type Debug: Debugger<Self>;
 
 		/// Type that bundles together all the runtime configurable interface types.
 		///
 		/// This is not a real config. We just mention the type here as constant so that
 		/// its type appears in the metadata. Only valid value is `()`.
 		#[pallet::constant]
+		#[pallet::no_default_bounds]
 		type Environment: Get<Environment<Self>>;
 
 		/// The version of the HostFn APIs that are available in the runtime.
 		///
 		/// Only valid value is `()`.
 		#[pallet::constant]
+		#[pallet::no_default_bounds]
 		type ApiVersion: Get<ApiVersion>;
 
 		/// A type that exposes XCM APIs, allowing contracts to interact with other parachains, and
 		/// execute XCM programs.
+		#[pallet::no_default_bounds]
 		type Xcm: xcm_builder::Controller<
 			OriginFor<Self>,
 			<Self as frame_system::Config>::RuntimeCall,
 			BlockNumberFor<Self>,
 		>;
 	}
 
+	/// Container for different types that implement [`DefaultConfig`]` of this pallet.
+	pub mod config_preludes {
+		use super::*;
+		use frame_support::{
+			derive_impl,
+			traits::{ConstBool, ConstU32},
+		};
+		use frame_system::EnsureSigned;
+		use sp_core::parameter_types;
+
+		type AccountId = sp_runtime::AccountId32;
+		type Balance = u64;
+		const UNITS: Balance = 10_000_000_000;
+		const CENTS: Balance = UNITS / 100;
+
+		const fn deposit(items: u32, bytes: u32) -> Balance {
+			items as Balance * 1 * CENTS + (bytes as Balance) * 1 * CENTS
+		}
+
+		parameter_types! {
+			pub const DepositPerItem: Balance = deposit(1, 0);
+			pub const DepositPerByte: Balance = deposit(0, 1);
+			pub const DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024);
+			pub const CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(0);
+			pub const MaxDelegateDependencies: u32 = 32;
+		}
+
+		/// A type providing default configurations for this pallet in testing environment.
+		pub struct TestDefaultConfig;
+
+		pub struct TestRandomness;
+		impl<Output, BlockNumber> Randomness<Output, BlockNumber> for TestRandomness {
+			fn random(_subject: &[u8]) -> (Output, BlockNumber) {
+				panic!("Randomness is not configured for this test environment")
+			}
+		}
+
+		pub struct TestWeightPrice;
+		impl<T: From<u64>> Convert<Weight, T> for TestWeightPrice {
+			fn convert(w: Weight) -> T {
+				w.ref_time().into()
+			}
+		}
+
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig, no_aggregated_types)]
+		impl frame_system::DefaultConfig for TestDefaultConfig {}
+
+		#[frame_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			#[inject_runtime_type]
+			type RuntimeEvent = ();
+
+			#[inject_runtime_type]
+			type RuntimeHoldReason = ();
+
+			#[inject_runtime_type]
+			type RuntimeCall = ();
+
+			type AddressGenerator = DefaultAddressGenerator;
+			type CallFilter = ();
+			type ChainExtension = ();
+			type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
+			type DefaultDepositLimit = DefaultDepositLimit;
+			type DepositPerByte = DepositPerByte;
+			type DepositPerItem = DepositPerItem;
+			type MaxCodeLen = ConstU32<{ 123 * 1024 }>;
+			type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>;
+			type MaxDelegateDependencies = MaxDelegateDependencies;
+			type MaxStorageKeyLen = ConstU32<128>;
+			type Migrations = ();
+			type Randomness = TestRandomness;
+			type UnsafeUnstableInterface = ConstBool<true>;
+			type UploadOrigin = EnsureSigned<AccountId>;
+			type InstantiateOrigin = EnsureSigned<AccountId>;
+			type WeightInfo = ();
+			type WeightPrice = TestWeightPrice;
+			type Debug = ();
+			type Environment = ();
+			type ApiVersion = ();
+			type Xcm = ();
+		}
+	}
+
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_idle(_block: BlockNumberFor<T>, limit: Weight) -> Weight {