Migrate away from SimpleDispatchInfo (#5686)

* Migrate away from SimpleDispatchInfo * Fix imports * Better doc * Update lib.rs Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
2026-06-13 02:21:14 +00:00 · 2020-04-22 09:20:28 +02:00
parent 25c3ab2c1e
commit 50a7e12b3f
40 changed files with 458 additions and 405 deletions
@@ -10,7 +10,7 @@
 /// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs

 use frame_support::{decl_module, decl_storage, decl_event, decl_error, dispatch};
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;
 use frame_system::{self as system, ensure_signed};

 #[cfg(test)]
@@ -76,7 +76,7 @@ decl_module! {
 		/// Just a dummy entry point.
 		/// function that can be called by the external world as an extrinsics call
 		/// takes a parameter of the type `AccountId`, stores it, and emits an event
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn do_something(origin, something: u32) -> dispatch::DispatchResult {
 			// Check it was signed and get the signer. See also: ensure_root and ensure_none
 			let who = ensure_signed(origin)?;
@@ -92,7 +92,7 @@ decl_module! {

 		/// Another dummy entry point.
 		/// takes no parameters, attempts to increment storage value, and possibly throws an error
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn cause_error(origin) -> dispatch::DispatchResult {
 			// Check it was signed and get the signer. See also: ensure_root and ensure_none
 			let _who = ensure_signed(origin)?;
@@ -133,7 +133,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]

 use frame_support::{Parameter, decl_module, decl_event, decl_storage, decl_error, ensure};
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;
 use sp_runtime::traits::{Member, AtLeast32Bit, Zero, StaticLookup};
 use frame_system::{self as system, ensure_signed};
 use sp_runtime::traits::One;
@@ -158,7 +158,7 @@ decl_module! {
 		/// Issue a new class of fungible assets. There are, and will only ever be, `total`
 		/// such assets and they'll all belong to the `origin` initially. It will have an
 		/// identifier `AssetId` instance: this will be specified in the `Issued` event.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn issue(origin, #[compact] total: T::Balance) {
 			let origin = ensure_signed(origin)?;

@@ -172,7 +172,7 @@ decl_module! {
 		}

 		/// Move some assets from one holder to another.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn transfer(origin,
 			#[compact] id: T::AssetId,
 			target: <T::Lookup as StaticLookup>::Source,
@@ -191,7 +191,7 @@ decl_module! {
 		}

 		/// Destroy any assets of `id` owned by `origin`.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn destroy(origin, #[compact] id: T::AssetId) {
 			let origin = ensure_signed(origin)?;
 			let balance = <Balances<T>>::take((id, &origin));
@@ -27,7 +27,7 @@ use frame_support::traits::{FindAuthor, VerifySeal, Get};
 use codec::{Encode, Decode};
 use frame_system::ensure_none;
 use sp_runtime::traits::{Header as HeaderT, One, Zero};
-use frame_support::weights::{Weight, MINIMUM_WEIGHT, SimpleDispatchInfo};
+use frame_support::weights::{Weight, MINIMUM_WEIGHT, DispatchClass};
 use sp_inherents::{InherentIdentifier, ProvideInherent, InherentData};
 use sp_authorship::{INHERENT_IDENTIFIER, UnclesInherentData, InherentError};

@@ -207,7 +207,7 @@ decl_module! {
 		}

 		/// Provide a set of uncles.
-		#[weight = SimpleDispatchInfo::FixedMandatory(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Mandatory)]
 		fn set_uncles(origin, new_uncles: Vec<T::Header>) -> dispatch::DispatchResult {
 			ensure_none(origin)?;
 			ensure!(new_uncles.len() <= MAX_UNCLES, Error::<T>::TooManyUncles);
@@ -21,7 +21,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]

 use frame_support::{decl_module, decl_storage, decl_event, decl_error};
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;
 use frame_support::traits::Currency;
 use frame_system::{self as system, ensure_signed};
 use codec::{Encode, Decode};
@@ -71,7 +71,7 @@ decl_module! {
 		fn deposit_event() = default;

 		/// Do nothing.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn do_nothing(_origin, input: u32) {
 			if input > 0 {
 				return Ok(());
@@ -83,7 +83,7 @@ decl_module! {
 		/// storage database, however, the `repeat` calls will all pull from the
 		/// storage overlay cache. You must consider this when analyzing the
 		/// results of the benchmark.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn read_value(_origin, repeat: u32) {
 			for _ in 0..repeat {
 				MyValue::get();
@@ -91,7 +91,7 @@ decl_module! {
 		}

 		/// Put a value into a storage value.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn put_value(_origin, repeat: u32) {
 			for r in 0..repeat {
 				MyValue::put(r);
@@ -103,7 +103,7 @@ decl_module! {
 		/// storage database, however, the `repeat` calls will all pull from the
 		/// storage overlay cache. You must consider this when analyzing the
 		/// results of the benchmark.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn exists_value(_origin, repeat: u32) {
 			for _ in 0..repeat {
 				MyValue::exists();
@@ -111,7 +111,7 @@ decl_module! {
 		}

 		/// Remove a value from storage `repeat` number of times.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn remove_value(_origin, repeat: u32) {
 			for r in 0..repeat {
 				MyMap::remove(r);
@@ -119,7 +119,7 @@ decl_module! {
 		}

 		/// Read a value from storage map `repeat` number of times.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn read_map(_origin, repeat: u32) {
 			for r in 0..repeat {
 				MyMap::get(r);
@@ -127,7 +127,7 @@ decl_module! {
 		}

 		/// Insert a value into a map.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn insert_map(_origin, repeat: u32) {
 			for r in 0..repeat {
 				MyMap::insert(r, r);
@@ -135,7 +135,7 @@ decl_module! {
 		}

 		/// Check is a map contains a value `repeat` number of times.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn contains_key_map(_origin, repeat: u32) {
 			for r in 0..repeat {
 				MyMap::contains_key(r);
@@ -143,7 +143,7 @@ decl_module! {
 		}

 		/// Read a value from storage `repeat` number of times.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn remove_prefix(_origin, repeat: u32) {
 			for r in 0..repeat {
 				MyDoubleMap::remove_prefix(r);
@@ -151,21 +151,21 @@ decl_module! {
 		}

 		/// Add user to the list.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn add_member_list(origin) {
 			let who = ensure_signed(origin)?;
 			MyMemberList::<T>::mutate(|x| x.push(who));
 		}

 		/// Append user to the list.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn append_member_list(origin) {
 			let who = ensure_signed(origin)?;
 			MyMemberList::<T>::append(&[who])?;
 		}

 		/// Encode a vector of accounts to bytes.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn encode_accounts(_origin, accounts: Vec<T::AccountId>) {
 			let bytes = accounts.encode();

@@ -177,7 +177,7 @@ decl_module! {
 		}

 		/// Decode bytes into a vector of accounts.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn decode_accounts(_origin, bytes: Vec<u8>) {
 			let accounts: Vec<T::AccountId> = Decode::decode(&mut bytes.as_slice()).map_err(|_| "Could not decode")?;

@@ -24,7 +24,7 @@ use sp_std::prelude::*;
 use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::{H256, Header}};
 use frame_support::{
 	dispatch::DispatchResult,
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::MINIMUM_WEIGHT,
 	decl_module, decl_storage, impl_outer_origin, assert_ok, assert_err, ensure
 };
 use frame_system::{RawOrigin, ensure_signed, ensure_none};
@@ -37,14 +37,14 @@ decl_storage! {

 decl_module! {
 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn set_value(origin, n: u32) -> DispatchResult {
 			let _sender = ensure_signed(origin)?;
 			Value::put(n);
 			Ok(())
 		}

-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn dummy(origin, _n: u32) -> DispatchResult {
 			let _sender = ensure_none(origin)?;
 			Ok(())
@@ -40,11 +40,11 @@ use sp_std::{prelude::*, result};
 use sp_core::u32_trait::Value as U32;
 use sp_runtime::RuntimeDebug;
 use sp_runtime::traits::Hash;
-use frame_support::weights::SimpleDispatchInfo;
 use frame_support::{
 	dispatch::{Dispatchable, Parameter}, codec::{Encode, Decode},
 	traits::{Get, ChangeMembers, InitializeMembers, EnsureOrigin}, decl_module, decl_event,
 	decl_storage, decl_error, ensure,
+	weights::DispatchClass,
 };
 use frame_system::{self as system, ensure_signed, ensure_root};

@@ -187,7 +187,7 @@ decl_module! {
 		/// - `prime`: The prime member whose vote sets the default.
 		///
 		/// Requires root origin.
-		#[weight = SimpleDispatchInfo::FixedOperational(100_000_000)]
+		#[weight = (100_000_000, DispatchClass::Operational)]
 		fn set_members(origin, new_members: Vec<T::AccountId>, prime: Option<T::AccountId>) {
 			ensure_root(origin)?;
 			let mut new_members = new_members;
@@ -200,7 +200,7 @@ decl_module! {
 		/// Dispatch a proposal from a member using the `Member` origin.
 		///
 		/// Origin must be a member of the collective.
-		#[weight = SimpleDispatchInfo::FixedOperational(100_000_000)]
+		#[weight = (100_000_000, DispatchClass::Operational)]
 		fn execute(origin, proposal: Box<<T as Trait<I>>::Proposal>) {
 			let who = ensure_signed(origin)?;
 			ensure!(Self::is_member(&who), Error::<T, I>::NotMember);
@@ -214,7 +214,7 @@ decl_module! {
 		/// - Bounded storage reads and writes.
 		/// - Argument `threshold` has bearing on weight.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(5_000_000_000)]
+		#[weight = (5_000_000_000, DispatchClass::Operational)]
 		fn propose(origin, #[compact] threshold: MemberCount, proposal: Box<<T as Trait<I>>::Proposal>) {
 			let who = ensure_signed(origin)?;
 			ensure!(Self::is_member(&who), Error::<T, I>::NotMember);
@@ -244,7 +244,7 @@ decl_module! {
 		/// - Bounded storage read and writes.
 		/// - Will be slightly heavier if the proposal is approved / disapproved after the vote.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(200_000_000)]
+		#[weight = (200_000_000, DispatchClass::Operational)]
 		fn vote(origin, proposal: T::Hash, #[compact] index: ProposalIndex, approve: bool) {
 			let who = ensure_signed(origin)?;
 			ensure!(Self::is_member(&who), Error::<T, I>::NotMember);
@@ -303,7 +303,7 @@ decl_module! {
 		///   - `M` is number of members,
 		///   - `P` is number of active proposals,
 		///   - `L` is the encoded length of `proposal` preimage.
-		#[weight = SimpleDispatchInfo::FixedOperational(200_000_000)]
+		#[weight = (200_000_000, DispatchClass::Operational)]
 		fn close(origin, proposal: T::Hash, #[compact] index: ProposalIndex) {
 			let _ = ensure_signed(origin)?;

@@ -123,7 +123,7 @@ use sp_runtime::{
 	RuntimeDebug,
 };
 use frame_support::dispatch::{DispatchResult, Dispatchable};
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;
 use frame_support::{
 	Parameter, decl_module, decl_event, decl_storage, decl_error,
 	parameter_types, IsSubType, storage::child::{self, ChildInfo},
@@ -539,7 +539,7 @@ decl_module! {
 		/// Updates the schedule for metering contracts.
 		///
 		/// The schedule must have a greater version than the stored schedule.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn update_schedule(origin, schedule: Schedule) -> DispatchResult {
 			ensure_root(origin)?;
 			if <Module<T>>::current_schedule().version >= schedule.version {
@@ -554,7 +554,7 @@ decl_module! {

 		/// Stores the given binary Wasm code into the chain's storage and returns its `codehash`.
 		/// You can instantiate contracts only with stored code.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn put_code(
 			origin,
 			#[compact] gas_limit: Gas,
@@ -582,7 +582,7 @@ decl_module! {
 		/// * If the account is a regular account, any value will be transferred.
 		/// * If no account exists and the call value is not less than `existential_deposit`,
 		/// a regular account will be created and any value will be transferred.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn call(
 			origin,
 			dest: <T::Lookup as StaticLookup>::Source,
@@ -608,7 +608,7 @@ decl_module! {
 		///   after the execution is saved as the `code` of the account. That code will be invoked
 		///   upon any call received by this account.
 		/// - The contract is initialized.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn instantiate(
 			origin,
 			#[compact] endowment: BalanceOf<T>,
@@ -631,7 +631,7 @@ decl_module! {
 		///
 		/// If contract is not evicted as a result of this call, no actions are taken and
 		/// the sender is not eligible for the reward.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn claim_surcharge(origin, dest: T::AccountId, aux_sender: Option<T::AccountId>) {
 			let origin = origin.into();
 			let (signed, rewarded) = match (origin, aux_sender) {
@@ -171,7 +171,7 @@ use sp_runtime::{
 use codec::{Ref, Encode, Decode};
 use frame_support::{
 	decl_module, decl_storage, decl_event, decl_error, ensure, Parameter,
-	weights::{SimpleDispatchInfo, Weight, MINIMUM_WEIGHT},
+	weights::{Weight, MINIMUM_WEIGHT, DispatchClass},
 	traits::{
 		Currency, ReservableCurrency, LockableCurrency, WithdrawReason, LockIdentifier, Get,
 		OnUnbalanced, BalanceStatus, schedule::Named as ScheduleNamed, EnsureOrigin
@@ -546,7 +546,7 @@ decl_module! {
 		/// - P is the number proposals in the `PublicProps` vec.
 		/// - Two DB changes, one DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000_000)]
+		#[weight = 5_000_000_000]
 		fn propose(origin,
 			proposal_hash: T::Hash,
 			#[compact] value: BalanceOf<T>
@@ -577,7 +577,7 @@ decl_module! {
 		/// - S is the number of seconds a proposal already has.
 		/// - One DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000_000)]
+		#[weight = 5_000_000_000]
 		fn second(origin, #[compact] proposal: PropIndex) {
 			let who = ensure_signed(origin)?;
 			let mut deposit = Self::deposit_of(proposal)
@@ -600,7 +600,7 @@ decl_module! {
 		/// - R is the number of referendums the voter has voted on.
 		/// - One DB change, one DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(200_000_000)]
+		#[weight = 200_000_000]
 		fn vote(origin,
 			#[compact] ref_index: ReferendumIndex,
 			vote: AccountVote<BalanceOf<T>>,
@@ -621,7 +621,7 @@ decl_module! {
 		/// - `O(1)`.
 		/// - One DB change, one DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(200_000_000)]
+		#[weight = 200_000_000]
 		fn proxy_vote(origin,
 			#[compact] ref_index: ReferendumIndex,
 			vote: AccountVote<BalanceOf<T>>,
@@ -641,7 +641,7 @@ decl_module! {
 		/// # <weight>
 		/// - `O(1)`.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(500_000_000)]
+		#[weight = (500_000_000, DispatchClass::Operational)]
 		fn emergency_cancel(origin, ref_index: ReferendumIndex) {
 			T::CancellationOrigin::ensure_origin(origin)?;

@@ -664,7 +664,7 @@ decl_module! {
 		/// - `O(1)`.
 		/// - One DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000_000)]
+		#[weight = 5_000_000_000]
 		fn external_propose(origin, proposal_hash: T::Hash) {
 			T::ExternalOrigin::ensure_origin(origin)?;
 			ensure!(!<NextExternal<T>>::exists(), Error::<T>::DuplicateProposal);
@@ -691,7 +691,7 @@ decl_module! {
 		/// - `O(1)`.
 		/// - One DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000_000)]
+		#[weight = 5_000_000_000]
 		fn external_propose_majority(origin, proposal_hash: T::Hash) {
 			T::ExternalMajorityOrigin::ensure_origin(origin)?;
 			<NextExternal<T>>::put((proposal_hash, VoteThreshold::SimpleMajority));
@@ -711,7 +711,7 @@ decl_module! {
 		/// - `O(1)`.
 		/// - One DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000_000)]
+		#[weight = 5_000_000_000]
 		fn external_propose_default(origin, proposal_hash: T::Hash) {
 			T::ExternalDefaultOrigin::ensure_origin(origin)?;
 			<NextExternal<T>>::put((proposal_hash, VoteThreshold::SuperMajorityAgainst));
@@ -736,7 +736,7 @@ decl_module! {
 		/// - One DB change.
 		/// - One extra DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(200_000_000)]
+		#[weight = 200_000_000]
 		fn fast_track(origin,
 			proposal_hash: T::Hash,
 			voting_period: T::BlockNumber,
@@ -787,7 +787,7 @@ decl_module! {
 		///   be very large.
 		/// - O(log v), v is number of `existing_vetoers`
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(200_000_000)]
+		#[weight = 200_000_000]
 		fn veto_external(origin, proposal_hash: T::Hash) {
 			let who = T::VetoOrigin::ensure_origin(origin)?;

@@ -820,7 +820,7 @@ decl_module! {
 		/// # <weight>
 		/// - `O(1)`.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn cancel_referendum(origin, #[compact] ref_index: ReferendumIndex) {
 			ensure_root(origin)?;
 			Self::internal_cancel_referendum(ref_index);
@@ -836,7 +836,7 @@ decl_module! {
 		/// - One DB change.
 		/// - O(d) where d is the items in the dispatch queue.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn cancel_queued(origin, which: ReferendumIndex) {
 			ensure_root(origin)?;
 			T::Scheduler::cancel_named((DEMOCRACY_ID, which))
@@ -862,7 +862,7 @@ decl_module! {
 		/// # <weight>
 		/// - One extra DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn activate_proxy(origin, proxy: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			Proxy::<T>::try_mutate(&proxy, |a| match a.take() {
@@ -885,7 +885,7 @@ decl_module! {
 		/// # <weight>
 		/// - One DB clear.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn close_proxy(origin) {
 			let who = ensure_signed(origin)?;
 			Proxy::<T>::mutate(&who, |a| {
@@ -909,7 +909,7 @@ decl_module! {
 		/// # <weight>
 		/// - One DB clear.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn deactivate_proxy(origin, proxy: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			Proxy::<T>::try_mutate(&proxy, |a| match a.take() {
@@ -942,7 +942,7 @@ decl_module! {
 		///
 		/// # <weight>
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		pub fn delegate(origin, to: T::AccountId, conviction: Conviction, balance: BalanceOf<T>) {
 			let who = ensure_signed(origin)?;
 			Self::try_delegate(who, to, conviction, balance)?;
@@ -961,7 +961,7 @@ decl_module! {
 		/// # <weight>
 		/// - O(1).
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn undelegate(origin) {
 			let who = ensure_signed(origin)?;
 			Self::try_undelegate(who)?;
@@ -975,7 +975,7 @@ decl_module! {
 		/// - `O(1)`.
 		/// - One DB clear.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn clear_public_proposals(origin) {
 			ensure_root(origin)?;

@@ -995,7 +995,7 @@ decl_module! {
 		/// - Dependent on the size of `encoded_proposal` but protected by a
 		///   required deposit.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn note_preimage(origin, encoded_proposal: Vec<u8>) {
 			let who = ensure_signed(origin)?;
 			let proposal_hash = T::Hashing::hash(&encoded_proposal[..]);
@@ -1030,7 +1030,7 @@ decl_module! {
 		/// # <weight>
 		/// - Dependent on the size of `encoded_proposal` and length of dispatch queue.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn note_imminent_preimage(origin, encoded_proposal: Vec<u8>) {
 			let who = ensure_signed(origin)?;
 			let proposal_hash = T::Hashing::hash(&encoded_proposal[..]);
@@ -1066,7 +1066,7 @@ decl_module! {
 		/// # <weight>
 		/// - One DB clear.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn reap_preimage(origin, proposal_hash: T::Hash) {
 			let who = ensure_signed(origin)?;
 			let (provider, deposit, since, expiry) = <Preimages<T>>::get(&proposal_hash)
@@ -1096,7 +1096,7 @@ decl_module! {
 		/// # <weight>
 		/// - `O(1)`.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn unlock(origin, target: T::AccountId) {
 			ensure_signed(origin)?;
 			Self::update_lock(&target);
@@ -1115,7 +1115,7 @@ decl_module! {
 		/// # <weight>
 		/// - One extra DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn open_proxy(origin, target: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			Proxy::<T>::mutate(&who, |a| {
@@ -1154,7 +1154,7 @@ decl_module! {
 		/// # <weight>
 		/// - `O(R + log R)` where R is the number of referenda that `target` has voted on.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn remove_vote(origin, index: ReferendumIndex) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Self::try_remove_vote(&who, index, UnvoteScope::Any)
@@ -1176,7 +1176,7 @@ decl_module! {
 		/// # <weight>
 		/// - `O(R + log R)` where R is the number of referenda that `target` has voted on.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn remove_other_vote(origin, target: T::AccountId, index: ReferendumIndex) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let scope = if target == who { UnvoteScope::Any } else { UnvoteScope::OnlyExpired };
@@ -1207,7 +1207,7 @@ decl_module! {
 		///
 		/// # <weight>
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		pub fn proxy_delegate(origin,
 			to: T::AccountId,
 			conviction: Conviction,
@@ -1231,7 +1231,7 @@ decl_module! {
 		/// # <weight>
 		/// - O(1).
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn proxy_undelegate(origin) {
 			let who = ensure_signed(origin)?;
 			let target = Self::proxy(who).and_then(|a| a.as_active()).ok_or(Error::<T>::NotProxy)?;
@@ -1251,7 +1251,7 @@ decl_module! {
 		/// # <weight>
 		/// - `O(R + log R)` where R is the number of referenda that `target` has voted on.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn proxy_remove_vote(origin, index: ReferendumIndex) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let target = Self::proxy(who).and_then(|a| a.as_active()).ok_or(Error::<T>::NotProxy)?;
@@ -1259,7 +1259,7 @@ decl_module! {
 		}

 		/// Enact a proposal from a referendum. For now we just make the weight be the maximum.
-		#[weight = SimpleDispatchInfo::MaxNormal]
+		#[weight = Weight::max_value()]
 		fn enact_proposal(origin, proposal_hash: T::Hash, index: ReferendumIndex) -> DispatchResult {
 			ensure_root(origin)?;
 			Self::do_enact_proposal(proposal_hash, index)
@@ -88,7 +88,8 @@ use sp_runtime::{
 };
 use frame_support::{
 	decl_storage, decl_event, ensure, decl_module, decl_error,
-	weights::{SimpleDispatchInfo, Weight, MINIMUM_WEIGHT}, storage::{StorageMap, IterableStorageMap},
+	weights::{Weight, MINIMUM_WEIGHT, DispatchClass},
+	storage::{StorageMap, IterableStorageMap},
 	traits::{
 		Currency, Get, LockableCurrency, LockIdentifier, ReservableCurrency, WithdrawReasons,
 		ChangeMembers, OnUnbalanced, WithdrawReason, Contains, BalanceStatus, InitializeMembers,
@@ -291,7 +292,7 @@ decl_module! {
 		/// Reads: O(1)
 		/// Writes: O(V) given `V` votes. V is bounded by 16.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn vote(origin, votes: Vec<T::AccountId>, #[compact] value: BalanceOf<T>) {
 			let who = ensure_signed(origin)?;

@@ -336,7 +337,7 @@ decl_module! {
 		/// Reads: O(1)
 		/// Writes: O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn remove_voter(origin) {
 			let who = ensure_signed(origin)?;

@@ -358,7 +359,7 @@ decl_module! {
 		/// Reads: O(NLogM) given M current candidates and N votes for `target`.
 		/// Writes: O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(1_000_000_000)]
+		#[weight = 1_000_000_000]
 		fn report_defunct_voter(origin, target: <T::Lookup as StaticLookup>::Source) {
 			let reporter = ensure_signed(origin)?;
 			let target = T::Lookup::lookup(target)?;
@@ -401,7 +402,7 @@ decl_module! {
 		/// Reads: O(LogN) Given N candidates.
 		/// Writes: O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn submit_candidacy(origin) {
 			let who = ensure_signed(origin)?;

@@ -428,7 +429,7 @@ decl_module! {
 		/// - `origin` is a current member. In this case, the bond is unreserved and origin is
 		///   removed as a member, consequently not being a candidate for the next round anymore.
 		///   Similar to [`remove_voter`], if replacement runners exists, they are immediately used.
-		#[weight = SimpleDispatchInfo::FixedOperational(2_000_000_000)]
+		#[weight = (2_000_000_000, DispatchClass::Operational)]
 		fn renounce_candidacy(origin) {
 			let who = ensure_signed(origin)?;

@@ -487,7 +488,7 @@ decl_module! {
 		/// Reads: O(do_phragmen)
 		/// Writes: O(do_phragmen)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(2_000_000_000)]
+		#[weight = (2_000_000_000, DispatchClass::Operational)]
 		fn remove_member(origin, who: <T::Lookup as StaticLookup>::Source) -> DispatchResult {
 			ensure_root(origin)?;
 			let who = T::Lookup::lookup(who)?;
@@ -30,7 +30,7 @@ use sp_runtime::{
 };
 use frame_support::{
 	decl_storage, decl_event, ensure, decl_module, decl_error,
-	weights::{Weight, MINIMUM_WEIGHT, SimpleDispatchInfo},
+	weights::{Weight, MINIMUM_WEIGHT, DispatchClass},
 	traits::{
 		Currency, ExistenceRequirement, Get, LockableCurrency, LockIdentifier, BalanceStatus,
 		OnUnbalanced, ReservableCurrency, WithdrawReason, WithdrawReasons, ChangeMembers
@@ -405,13 +405,13 @@ decl_module! {
 		/// - Two extra DB entries, one DB change.
 		/// - Argument `votes` is limited in length to number of candidates.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(2_500_000_000)]
+		#[weight = 2_500_000_000]
 		fn set_approvals(
 			origin,
 			votes: Vec<bool>,
 			#[compact] index: VoteIndex,
 			hint: SetIndex,
-			#[compact] value: BalanceOf<T>
+			#[compact] value: BalanceOf<T>,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Self::do_set_approvals(who, votes, index, hint, value)
@@ -423,12 +423,12 @@ decl_module! {
 		/// # <weight>
 		/// - Same as `set_approvals` with one additional storage read.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(2_500_000_000)]
+		#[weight = 2_500_000_000]
 		fn proxy_set_approvals(origin,
 			votes: Vec<bool>,
 			#[compact] index: VoteIndex,
 			hint: SetIndex,
-			#[compact] value: BalanceOf<T>
+			#[compact] value: BalanceOf<T>,
 		) -> DispatchResult {
 			let who = Self::proxy(ensure_signed(origin)?).ok_or(Error::<T>::NotProxy)?;
 			Self::do_set_approvals(who, votes, index, hint, value)
@@ -446,13 +446,13 @@ decl_module! {
 		/// - O(1).
 		/// - Two fewer DB entries, one DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(2_500_000_000)]
+		#[weight = 2_500_000_000]
 		fn reap_inactive_voter(
 			origin,
 			#[compact] reporter_index: u32,
 			who: <T::Lookup as StaticLookup>::Source,
 			#[compact] who_index: u32,
-			#[compact] assumed_vote_index: VoteIndex
+			#[compact] assumed_vote_index: VoteIndex,
 		) {
 			let reporter = ensure_signed(origin)?;
 			let who = T::Lookup::lookup(who)?;
@@ -520,7 +520,7 @@ decl_module! {
 		/// - O(1).
 		/// - Two fewer DB entries, one DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(1_250_000_000)]
+		#[weight = 1_250_000_000]
 		fn retract_voter(origin, #[compact] index: u32) {
 			let who = ensure_signed(origin)?;

@@ -548,7 +548,7 @@ decl_module! {
 		/// - Independent of input.
 		/// - Three DB changes.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(2_500_000_000)]
+		#[weight = 2_500_000_000]
 		fn submit_candidacy(origin, #[compact] slot: u32) {
 			let who = ensure_signed(origin)?;

@@ -585,12 +585,12 @@ decl_module! {
 		/// - O(voters) compute.
 		/// - One DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(10_000_000_000)]
+		#[weight = 10_000_000_000]
 		fn present_winner(
 			origin,
 			candidate: <T::Lookup as StaticLookup>::Source,
 			#[compact] total: BalanceOf<T>,
-			#[compact] index: VoteIndex
+			#[compact] index: VoteIndex,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			ensure!(
@@ -659,7 +659,7 @@ decl_module! {
 		/// Set the desired member count; if lower than the current count, then seats will not be up
 		/// election when they expire. If more, then a new vote will be started if one is not
 		/// already in progress.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn set_desired_seats(origin, #[compact] count: u32) {
 			ensure_root(origin)?;
 			DesiredSeats::put(count);
@@ -669,7 +669,7 @@ decl_module! {
 		///
 		/// Note: A tally should happen instantly (if not already in a presentation
 		/// period) to fill the seat if removal means that the desired members are not met.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn remove_member(origin, who: <T::Lookup as StaticLookup>::Source) {
 			ensure_root(origin)?;
 			let who = T::Lookup::lookup(who)?;
@@ -684,7 +684,7 @@ decl_module! {

 		/// Set the presentation duration. If there is currently a vote being presented for, will
 		/// invoke `finalize_vote`.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn set_presentation_duration(origin, #[compact] count: T::BlockNumber) {
 			ensure_root(origin)?;
 			<PresentationDuration<T>>::put(count);
@@ -692,7 +692,7 @@ decl_module! {

 		/// Set the presentation duration. If there is current a vote being presented for, will
 		/// invoke `finalize_vote`.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn set_term_duration(origin, #[compact] count: T::BlockNumber) {
 			ensure_root(origin)?;
 			<TermDuration<T>>::put(count);
@@ -29,7 +29,6 @@ use frame_support::weights::{Weight, MINIMUM_WEIGHT, DispatchClass, FunctionOf};
 use frame_support::traits::{Currency, WithdrawReason, ExistenceRequirement};
 use frame_system::{self as system, ensure_signed};
 use sp_runtime::ModuleId;
-use frame_support::weights::SimpleDispatchInfo;
 use sp_core::{U256, H256, H160, Hasher};
 use sp_runtime::{
 	DispatchResult, traits::{UniqueSaturatedInto, AccountIdConversion, SaturatedConversion},
@@ -191,7 +190,7 @@ decl_module! {
 		fn deposit_event() = default;

 		/// Deposit balance from currency/balances module into EVM.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn deposit_balance(origin, value: BalanceOf<T>) {
 			let sender = ensure_signed(origin)?;

@@ -212,7 +211,7 @@ decl_module! {
 		}

 		/// Withdraw balance from EVM into currency/balances module.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn withdraw_balance(origin, value: BalanceOf<T>) {
 			let sender = ensure_signed(origin)?;
 			let address = T::ConvertAccountId::convert_account_id(&sender);
@@ -53,7 +53,7 @@ use frame_support::{
 	debug,
 	dispatch::DispatchResult, decl_module, decl_storage, decl_event,
 	traits::Get,
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::MINIMUM_WEIGHT,
 };
 use sp_core::crypto::KeyTypeId;
 use sp_runtime::{
@@ -189,7 +189,7 @@ decl_module! {
 		/// working and receives (and provides) meaningful data.
 		/// This example is not focused on correctness of the oracle itself, but rather its
 		/// purpose is to showcase offchain worker capabilities.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn submit_price(origin, price: u32) -> DispatchResult {
 			// Retrieve sender of the transaction.
 			let who = ensure_signed(origin)?;
@@ -214,7 +214,7 @@ decl_module! {
 		///
 		/// This example is not focused on correctness of the oracle itself, but rather its
 		/// purpose is to showcase offchain worker capabilities.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn submit_price_unsigned(origin, _block_number: T::BlockNumber, price: u32)
 			-> DispatchResult
 		{
@@ -228,7 +228,7 @@ decl_module! {
 			Ok(())
 		}

-		#[weight = SimpleDispatchInfo::FixedNormal(10_000)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn submit_price_unsigned_with_signed_payload(
 			origin,
 			price_payload: PricePayload<T::Public, T::BlockNumber>,
@@ -256,10 +256,7 @@
 use sp_std::marker::PhantomData;
 use frame_support::{
 	dispatch::DispatchResult, decl_module, decl_storage, decl_event,
-	weights::{
-		SimpleDispatchInfo, DispatchClass, ClassifyDispatch, WeighData, Weight, PaysFee,
-		MINIMUM_WEIGHT,
-	},
+	weights::{DispatchClass, ClassifyDispatch, WeighData, Weight, PaysFee, MINIMUM_WEIGHT},
 };
 use sp_std::prelude::*;
 use frame_system::{self as system, ensure_signed, ensure_root};
@@ -469,7 +466,7 @@ decl_module! {
 		// weight (a numeric representation of pure execution time and difficulty) of the
 		// transaction and the latter demonstrates the [`DispatchClass`] of the call. A higher
 		// weight means a larger transaction (less of which can be placed in a single block).
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn accumulate_dummy(origin, increase_by: T::Balance) -> DispatchResult {
 			// This is a public call, so we ensure that the origin is some signed account.
 			let _sender = ensure_signed(origin)?;
@@ -518,8 +515,7 @@ decl_module! {

 		// The signature could also look like: `fn on_initialize()`.
 		// This function could also very well have a weight annotation, similar to any other. The
-		// only difference being that if it is not annotated, the default is
-		// `SimpleDispatchInfo::zero()`, which resolves into no weight.
+		// only difference is that it mut be returned, not annotated.
 		fn on_initialize(_n: T::BlockNumber) -> Weight {
 			// Anything that needs to be done at the start of the block.
 			// We don't do anything here.
@@ -411,22 +411,22 @@ mod tests {
 	use hex_literal::hex;

 	mod custom {
-		use frame_support::weights::{SimpleDispatchInfo, Weight};
+		use frame_support::weights::{Weight, DispatchClass};

 		pub trait Trait: frame_system::Trait {}

 		frame_support::decl_module! {
 			pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-				#[weight = SimpleDispatchInfo::FixedNormal(100)]
+				#[weight = 100]
 				fn some_function(origin) {
 					// NOTE: does not make any different.
 					let _ = frame_system::ensure_signed(origin);
 				}
-				#[weight = SimpleDispatchInfo::FixedOperational(200)]
+				#[weight = (200, DispatchClass::Operational)]
 				fn some_root_operation(origin) {
 					let _ = frame_system::ensure_root(origin);
 				}
-				#[weight = SimpleDispatchInfo::InsecureFreeNormal]
+				#[weight = 0]
 				fn some_unsigned_message(origin) {
 					let _ = frame_system::ensure_none(origin);
 				}
@@ -23,7 +23,7 @@ use sp_runtime::traits::{One, Zero, SaturatedConversion};
 use sp_std::{prelude::*, result, cmp, vec};
 use frame_support::{decl_module, decl_storage, decl_error, ensure};
 use frame_support::traits::Get;
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::{MINIMUM_WEIGHT, DispatchClass};
 use frame_system::{ensure_none, Trait as SystemTrait};
 use sp_finality_tracker::{INHERENT_IDENTIFIER, FinalizedInherentData};

@@ -77,7 +77,7 @@ decl_module! {

 		/// Hint that the author of this block thinks the best finalized
 		/// block is the given number.
-		#[weight = SimpleDispatchInfo::FixedMandatory(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Mandatory)]
 		fn final_hint(origin, #[compact] hint: T::BlockNumber) {
 			ensure_none(origin)?;
 			ensure!(!<Self as Store>::Update::exists(), Error::<T>::AlreadyUpdated);
@@ -212,7 +212,9 @@ mod tests {
 		traits::{BlakeTwo256, IdentityLookup, Header as HeaderT},
 	};
 	use frame_support::{
-		assert_ok, impl_outer_origin, parameter_types, weights::Weight, traits::OnFinalize
+		assert_ok, impl_outer_origin, parameter_types,
+		weights::Weight,
+		traits::OnFinalize,
 	};
 	use frame_system as system;
 	use std::cell::RefCell;
@@ -164,7 +164,7 @@ use sp_std::prelude::*;
 use sp_std::{cmp, result, fmt::Debug};
 use frame_support::{
 	decl_event, decl_module, decl_storage, ensure, decl_error,
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::MINIMUM_WEIGHT,
 	traits::{
 		Currency, ExistenceRequirement, Imbalance, LockIdentifier, LockableCurrency, ReservableCurrency,
 		SignedImbalance, WithdrawReason, WithdrawReasons, TryDrop, BalanceStatus,
@@ -361,14 +361,14 @@ decl_module! {
 		fn deposit_event() = default;

 		/// Create a new kind of asset.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn create(origin, options: AssetOptions<T::Balance, T::AccountId>) -> DispatchResult {
 			let origin = ensure_signed(origin)?;
 			Self::create_asset(None, Some(origin), options)
 		}

 		/// Transfer some liquid free balance to another account.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn transfer(origin, #[compact] asset_id: T::AssetId, to: T::AccountId, #[compact] amount: T::Balance) {
 			let origin = ensure_signed(origin)?;
 			ensure!(!amount.is_zero(), Error::<T>::ZeroAmount);
@@ -378,7 +378,7 @@ decl_module! {
 		/// Updates permission for a given `asset_id` and an account.
 		///
 		/// The `origin` must have `update` permission.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn update_permission(
 			origin,
 			#[compact] asset_id: T::AssetId,
@@ -401,7 +401,7 @@ decl_module! {

 		/// Mints an asset, increases its total issuance.
 		/// The origin must have `mint` permissions.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn mint(origin, #[compact] asset_id: T::AssetId, to: T::AccountId, amount: T::Balance) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Self::mint_free(&asset_id, &who, &to, &amount)?;
@@ -411,7 +411,7 @@ decl_module! {

 		/// Burns an asset, decreases its total issuance.
 		/// The `origin` must have `burn` permissions.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn burn(origin, #[compact] asset_id: T::AssetId, to: T::AccountId, amount: T::Balance) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Self::burn_free(&asset_id, &who, &to, &amount)?;
@@ -421,7 +421,7 @@ decl_module! {

 		/// Can be used to create reserved tokens.
 		/// Requires Root call.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn create_reserved(
 			origin,
 			asset_id: T::AssetId,
@@ -33,7 +33,7 @@ pub use sp_finality_grandpa as fg_primitives;
 use sp_std::prelude::*;
 use codec::{self as codec, Encode, Decode};
 use frame_support::{decl_event, decl_storage, decl_module, decl_error, storage};
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;
 use sp_runtime::{
 	DispatchResult, generic::{DigestItem, OpaqueDigestItemId}, traits::Zero, Perbill,
 };
@@ -185,7 +185,7 @@ decl_module! {
 		fn deposit_event() = default;

 		/// Report some misbehavior.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn report_misbehavior(origin, _report: Vec<u8>) {
 			ensure_signed(origin)?;
 			// FIXME: https://github.com/paritytech/substrate/issues/1112
@@ -74,7 +74,7 @@ use sp_runtime::traits::{StaticLookup, Zero, AppendZerosInput};
 use frame_support::{
 	decl_module, decl_event, decl_storage, ensure, decl_error,
 	traits::{Currency, ReservableCurrency, OnUnbalanced, Get, BalanceStatus, EnsureOrigin},
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::MINIMUM_WEIGHT,
 };
 use frame_system::{self as system, ensure_signed, ensure_root};

@@ -474,7 +474,7 @@ decl_module! {
 		/// - One storage mutation (codec `O(R)`).
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn add_registrar(origin, account: T::AccountId) {
 			T::RegistrarOrigin::try_origin(origin)
 				.map(|_| ())
@@ -506,7 +506,7 @@ decl_module! {
 		/// - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_identity(origin, info: IdentityInfo) {
 			let sender = ensure_signed(origin)?;
 			let extra_fields = info.additional.len() as u32;
@@ -552,7 +552,7 @@ decl_module! {
 		/// - At most O(2 * S + 1) storage mutations; codec complexity `O(1 * S + S * 1)`);
 		///   one storage-exists.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_subs(origin, subs: Vec<(T::AccountId, Data)>) {
 			let sender = ensure_signed(origin)?;
 			ensure!(<IdentityOf<T>>::contains_key(&sender), Error::<T>::NotFound);
@@ -599,7 +599,7 @@ decl_module! {
 		/// - `S + 2` storage deletions.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn clear_identity(origin) {
 			let sender = ensure_signed(origin)?;

@@ -638,7 +638,7 @@ decl_module! {
 		/// - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn request_judgement(origin,
 			#[compact] reg_index: RegistrarIndex,
 			#[compact] max_fee: BalanceOf<T>,
@@ -684,7 +684,7 @@ decl_module! {
 		/// - One storage mutation `O(R + X)`.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn cancel_request(origin, reg_index: RegistrarIndex) {
 			let sender = ensure_signed(origin)?;
 			let mut id = <IdentityOf<T>>::get(&sender).ok_or(Error::<T>::NoIdentity)?;
@@ -715,7 +715,7 @@ decl_module! {
 		/// - `O(R)`.
 		/// - One storage mutation `O(R)`.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_fee(origin,
 			#[compact] index: RegistrarIndex,
 			#[compact] fee: BalanceOf<T>,
@@ -742,7 +742,7 @@ decl_module! {
 		/// - `O(R)`.
 		/// - One storage mutation `O(R)`.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_account_id(origin,
 			#[compact] index: RegistrarIndex,
 			new: T::AccountId,
@@ -769,7 +769,7 @@ decl_module! {
 		/// - `O(R)`.
 		/// - One storage mutation `O(R)`.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_fields(origin,
 			#[compact] index: RegistrarIndex,
 			fields: IdentityFields,
@@ -803,7 +803,7 @@ decl_module! {
 		/// - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn provide_judgement(origin,
 			#[compact] reg_index: RegistrarIndex,
 			target: <T::Lookup as StaticLookup>::Source,
@@ -852,7 +852,7 @@ decl_module! {
 		/// - `S + 2` storage mutations.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn kill_identity(origin, target: <T::Lookup as StaticLookup>::Source) {
 			T::ForceOrigin::try_origin(origin)
 				.map(|_| ())
@@ -43,7 +43,7 @@
 //!
 //! ```
 //! use frame_support::{decl_module, dispatch};
-//! use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+//! use frame_support::weights::MINIMUM_WEIGHT;
 //! use frame_system::{self as system, ensure_signed};
 //! use pallet_im_online::{self as im_online};
 //!
@@ -51,7 +51,7 @@
 //!
 //! decl_module! {
 //! 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //! 		pub fn is_online(origin, authority_index: u32) -> dispatch::DispatchResult {
 //! 			let _sender = ensure_signed(origin)?;
 //! 			let _is_online = <im_online::Module<T>>::is_online(authority_index);
@@ -95,7 +95,7 @@ use sp_staking::{
 use frame_support::{
 	decl_module, decl_event, decl_storage, Parameter, debug, decl_error,
 	traits::Get,
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::MINIMUM_WEIGHT,
 };
 use frame_system::{self as system, ensure_none};
 use frame_system::offchain::{
@@ -315,7 +315,7 @@ decl_module! {

 		fn deposit_event() = default;

-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn heartbeat(
 			origin,
 			heartbeat: Heartbeat<T::BlockNumber>,
@@ -25,7 +25,7 @@ use sp_runtime::traits::{
 	StaticLookup, Member, LookupError, Zero, One, BlakeTwo256, Hash, Saturating, AtLeast32Bit
 };
 use frame_support::{Parameter, decl_module, decl_error, decl_event, decl_storage, ensure};
-use frame_support::weights::{Weight, MINIMUM_WEIGHT, SimpleDispatchInfo};
+use frame_support::weights::{Weight, MINIMUM_WEIGHT};
 use frame_support::dispatch::DispatchResult;
 use frame_support::traits::{Currency, ReservableCurrency, Get, BalanceStatus::Reserved};
 use frame_support::storage::migration::take_storage_value;
@@ -121,7 +121,7 @@ decl_module! {
 		/// - One reserve operation.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn claim(origin, index: T::AccountIndex) {
 			let who = ensure_signed(origin)?;

@@ -149,7 +149,7 @@ decl_module! {
 		/// - One transfer operation.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn transfer(origin, new: T::AccountId, index: T::AccountIndex) {
 			let who = ensure_signed(origin)?;
 			ensure!(who != new, Error::<T>::NotTransfer);
@@ -180,7 +180,7 @@ decl_module! {
 		/// - One reserve operation.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn free(origin, index: T::AccountIndex) {
 			let who = ensure_signed(origin)?;

@@ -209,7 +209,7 @@ decl_module! {
 		/// - Up to one reserve operation.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn force_transfer(origin, new: T::AccountId, index: T::AccountIndex) {
 			ensure_root(origin)?;

@@ -26,7 +26,6 @@ use sp_std::prelude::*;
 use frame_support::{
 	decl_module, decl_storage, decl_event, decl_error,
 	traits::{ChangeMembers, InitializeMembers, EnsureOrigin},
-	weights::SimpleDispatchInfo,
 };
 use frame_system::{self as system, ensure_root, ensure_signed};

@@ -118,7 +117,7 @@ decl_module! {
 		/// Add a member `who` to the set.
 		///
 		/// May only be called from `AddOrigin` or root.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn add_member(origin, who: T::AccountId) {
 			T::AddOrigin::try_origin(origin)
 				.map(|_| ())
@@ -137,7 +136,7 @@ decl_module! {
 		/// Remove a member `who` from the set.
 		///
 		/// May only be called from `RemoveOrigin` or root.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn remove_member(origin, who: T::AccountId) {
 			T::RemoveOrigin::try_origin(origin)
 				.map(|_| ())
@@ -159,7 +158,7 @@ decl_module! {
 		/// May only be called from `SwapOrigin` or root.
 		///
 		/// Prime membership is *not* passed from `remove` to `add`, if extant.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn swap_member(origin, remove: T::AccountId, add: T::AccountId) {
 			T::SwapOrigin::try_origin(origin)
 				.map(|_| ())
@@ -188,7 +187,7 @@ decl_module! {
 		/// pass `members` pre-sorted.
 		///
 		/// May only be called from `ResetOrigin` or root.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn reset_members(origin, members: Vec<T::AccountId>) {
 			T::ResetOrigin::try_origin(origin)
 				.map(|_| ())
@@ -211,7 +210,7 @@ decl_module! {
 		/// May only be called from `Signed` origin of a current member.
 		///
 		/// Prime membership is passed from the origin account to `new`, if extant.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn change_key(origin, new: T::AccountId) {
 			let remove = ensure_signed(origin)?;

@@ -239,7 +238,7 @@ decl_module! {
 		}

 		/// Set the prime member. Must be a current member.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_prime(origin, who: T::AccountId) {
 			T::PrimeOrigin::try_origin(origin)
 				.map(|_| ())
@@ -250,7 +249,7 @@ decl_module! {
 		}

 		/// Remove the prime member if it exists.
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn clear_prime(origin) {
 			T::PrimeOrigin::try_origin(origin)
 				.map(|_| ())
@@ -45,7 +45,6 @@ use sp_runtime::{
 use frame_support::{
 	decl_module, decl_event, decl_storage, ensure, decl_error,
 	traits::{Currency, EnsureOrigin, ReservableCurrency, OnUnbalanced, Get},
-	weights::SimpleDispatchInfo,
 };
 use frame_system::{self as system, ensure_signed, ensure_root};

@@ -141,7 +140,7 @@ decl_module! {
 		/// - One storage read/write.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn set_name(origin, name: Vec<u8>) {
 			let sender = ensure_signed(origin)?;

@@ -171,7 +170,7 @@ decl_module! {
 		/// - One storage read/write.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(70_000_000)]
+		#[weight = 70_000_000]
 		fn clear_name(origin) {
 			let sender = ensure_signed(origin)?;

@@ -195,7 +194,7 @@ decl_module! {
 		/// - One storage read/write.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(70_000_000)]
+		#[weight = 70_000_000]
 		fn kill_name(origin, target: <T::Lookup as StaticLookup>::Source) {
 			T::ForceOrigin::try_origin(origin)
 				.map(|_| ())
@@ -223,7 +222,7 @@ decl_module! {
 		/// - One storage read/write.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(70_000_000)]
+		#[weight = 70_000_000]
 		fn force_name(origin, target: <T::Lookup as StaticLookup>::Source, name: Vec<u8>) {
 			T::ForceOrigin::try_origin(origin)
 				.map(|_| ())
@@ -36,13 +36,13 @@
 //! ### Example - Get random seed for the current block
 //!
 //! ```
-//! use frame_support::{decl_module, dispatch, traits::Randomness, weights::{SimpleDispatchInfo, MINIMUM_WEIGHT}};
+//! use frame_support::{decl_module, dispatch, traits::Randomness, weights::MINIMUM_WEIGHT};
 //!
 //! pub trait Trait: frame_system::Trait {}
 //!
 //! decl_module! {
 //! 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //! 		pub fn random_module_example(origin) -> dispatch::DispatchResult {
 //! 			let _random_value = <pallet_randomness_collective_flip::Module<T>>::random(&b"my context"[..]);
 //! 			Ok(())
@@ -159,7 +159,7 @@ use codec::{Encode, Decode};

 use frame_support::{
 	decl_module, decl_event, decl_storage, decl_error, ensure,
-	Parameter, RuntimeDebug, weights::{MINIMUM_WEIGHT, GetDispatchInfo, SimpleDispatchInfo, FunctionOf},
+	Parameter, RuntimeDebug, weights::{MINIMUM_WEIGHT, GetDispatchInfo, FunctionOf},
 	traits::{Currency, ReservableCurrency, Get, BalanceStatus},
 	dispatch::PostDispatchInfo,
 };
@@ -365,7 +365,7 @@ decl_module! {
 		/// - One storage write O(1)
 		/// - One event
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn set_recovered(origin, lost: T::AccountId, rescuer: T::AccountId) {
 			ensure_root(origin)?;
 			// Create the recovery storage item.
@@ -400,7 +400,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(F + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn create_recovery(origin,
 			friends: Vec<T::AccountId>,
 			threshold: u16,
@@ -460,7 +460,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(F + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn initiate_recovery(origin, account: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			// Check that the account is recoverable
@@ -506,7 +506,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(F + logF + V + logV)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn vouch_recovery(origin, lost: T::AccountId, rescuer: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			// Get the recovery configuration for the lost account.
@@ -545,7 +545,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(F + V)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn claim_recovery(origin, account: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			// Get the recovery configuration for the lost account
@@ -590,7 +590,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(V + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(30_000_000)]
+		#[weight = 30_000_000]
 		fn close_recovery(origin, rescuer: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			// Take the active recovery process started by the rescuer for this account.
@@ -622,7 +622,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(F + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(30_000_000)]
+		#[weight = 30_000_000]
 		fn remove_recovery(origin) {
 			let who = ensure_signed(origin)?;
 			// Check there are no active recoveries
@@ -647,7 +647,7 @@ decl_module! {
 		/// # <weight>
 		/// - One storage mutation to check account is recovered by `who`. O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn cancel_recovered(origin, account: T::AccountId) {
 			let who = ensure_signed(origin)?;
 			// Check `who` is allowed to make a call on behalf of `account`
@@ -54,7 +54,7 @@
 //!
 //! ```
 //! use frame_support::{decl_module, dispatch};
-//! use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+//! use frame_support::weights::MINIMUM_WEIGHT;
 //! use frame_system::{self as system, ensure_signed};
 //! use pallet_scored_pool::{self as scored_pool};
 //!
@@ -62,7 +62,7 @@
 //!
 //! decl_module! {
 //! 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //! 		pub fn candidate(origin) -> dispatch::DispatchResult {
 //! 			let who = ensure_signed(origin)?;
 //!
@@ -98,7 +98,7 @@ use sp_std::{
 use frame_support::{
 	decl_module, decl_storage, decl_event, ensure, decl_error,
 	traits::{EnsureOrigin, ChangeMembers, InitializeMembers, Currency, Get, ReservableCurrency},
-	weights::{Weight, MINIMUM_WEIGHT, SimpleDispatchInfo},
+	weights::{Weight, MINIMUM_WEIGHT},
 };
 use frame_system::{self as system, ensure_root, ensure_signed};
 use sp_runtime::{
@@ -267,7 +267,7 @@ decl_module! {
 		///
 		/// The `index` parameter of this function must be set to
 		/// the index of the transactor in the `Pool`.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn submit_candidacy(origin) {
 			let who = ensure_signed(origin)?;
 			ensure!(!<CandidateExists<T, I>>::contains_key(&who), Error::<T, I>::AlreadyInPool);
@@ -297,7 +297,7 @@ decl_module! {
 		///
 		/// The `index` parameter of this function must be set to
 		/// the index of the transactor in the `Pool`.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn withdraw_candidacy(
 			origin,
 			index: u32
@@ -317,7 +317,7 @@ decl_module! {
 		///
 		/// The `index` parameter of this function must be set to
 		/// the index of `dest` in the `Pool`.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn kick(
 			origin,
 			dest: <T::Lookup as StaticLookup>::Source,
@@ -342,7 +342,7 @@ decl_module! {
 		///
 		/// The `index` parameter of this function must be set to
 		/// the index of the `dest` in the `Pool`.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn score(
 			origin,
 			dest: <T::Lookup as StaticLookup>::Source,
@@ -383,7 +383,7 @@ decl_module! {
 		/// (this happens each `Period`).
 		///
 		/// May only be called from root.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		pub fn change_member_count(origin, count: u32) {
 			ensure_root(origin)?;
 			<MemberCount<I>>::put(&count);
@@ -110,7 +110,7 @@ use frame_support::{
 		Get, FindAuthor, ValidatorRegistration, EstimateNextSessionRotation, EstimateNextNewSession,
 	},
 	dispatch::{self, DispatchResult, DispatchError},
-	weights::{Weight, MINIMUM_WEIGHT, SimpleDispatchInfo},
+	weights::{Weight, MINIMUM_WEIGHT},
 };
 use frame_system::{self as system, ensure_signed};

@@ -498,7 +498,7 @@ decl_module! {
 		/// - Increases system account refs by one on success iff there were previously no keys set.
 		///   In this case, purge_keys will need to be called before the account can be removed.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(150_000_000)]
+		#[weight = 150_000_000]
 		pub fn set_keys(origin, keys: T::Keys, proof: Vec<u8>) -> dispatch::DispatchResult {
 			let who = ensure_signed(origin)?;

@@ -519,7 +519,7 @@ decl_module! {
 		/// - Removes N + 1 DB entries.
 		/// - Reduces system account refs by one on success.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(150_000_000)]
+		#[weight = 150_000_000]
 		pub fn purge_keys(origin) {
 			let who = ensure_signed(origin)?;
 			Self::do_purge_keys(&who)?;
@@ -260,7 +260,7 @@ use sp_runtime::{Percent, ModuleId, RuntimeDebug,
 	}
 };
 use frame_support::{decl_error, decl_module, decl_storage, decl_event, ensure, dispatch::DispatchResult};
-use frame_support::weights::{SimpleDispatchInfo, Weight, MINIMUM_WEIGHT};
+use frame_support::weights::{Weight, MINIMUM_WEIGHT};
 use frame_support::traits::{
 	Currency, ReservableCurrency, Randomness, Get, ChangeMembers, BalanceStatus,
 	ExistenceRequirement::AllowDeath, EnsureOrigin
@@ -527,7 +527,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + B + C + logM + logB + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		pub fn bid(origin, value: BalanceOf<T, I>) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			ensure!(!<SuspendedCandidates<T, I>>::contains_key(&who), Error::<T, I>::Suspended);
@@ -566,7 +566,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(B + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(20_000_000)]
+		#[weight = 20_000_000]
 		pub fn unbid(origin, pos: u32) -> DispatchResult {
 			let who = ensure_signed(origin)?;

@@ -636,7 +636,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + B + C + logM + logB + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		pub fn vouch(origin, who: T::AccountId, value: BalanceOf<T, I>, tip: BalanceOf<T, I>) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
 			// Check user is not suspended.
@@ -677,7 +677,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(B)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(20_000_000)]
+		#[weight = 20_000_000]
 		pub fn unvouch(origin, pos: u32) -> DispatchResult {
 			let voucher = ensure_signed(origin)?;
 			ensure!(Self::vouching(&voucher) == Some(VouchingStatus::Vouching), Error::<T, I>::NotVouching);
@@ -715,7 +715,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + logM + C)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(30_000_000)]
+		#[weight = 30_000_000]
 		pub fn vote(origin, candidate: <T::Lookup as StaticLookup>::Source, approve: bool) {
 			let voter = ensure_signed(origin)?;
 			let candidate = T::Lookup::lookup(candidate)?;
@@ -746,7 +746,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + logM)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(20_000_000)]
+		#[weight = 20_000_000]
 		pub fn defender_vote(origin, approve: bool) {
 			let voter = ensure_signed(origin)?;
 			let members = <Members<T, I>>::get();
@@ -778,7 +778,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + logM + P + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(30_000_000)]
+		#[weight = 30_000_000]
 		pub fn payout(origin) {
 			let who = ensure_signed(origin)?;

@@ -820,7 +820,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn found(origin, founder: T::AccountId, max_members: u32, rules: Vec<u8>) {
 			T::FounderSetOrigin::ensure_origin(origin)?;
 			ensure!(!<Head<T, I>>::exists(), Error::<T, I>::AlreadyFounded);
@@ -847,7 +847,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(20_000_000)]
+		#[weight = 20_000_000]
 		fn unfound(origin) {
 			let founder = ensure_signed(origin)?;
 			ensure!(Founder::<T, I>::get() == Some(founder.clone()), Error::<T, I>::NotFounder);
@@ -889,7 +889,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + logM + B)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(30_000_000)]
+		#[weight = 30_000_000]
 		fn judge_suspended_member(origin, who: T::AccountId, forgive: bool) {
 			T::SuspensionJudgementOrigin::ensure_origin(origin)?;
 			ensure!(<SuspendedMembers<T, I>>::contains_key(&who), Error::<T, I>::NotSuspended);
@@ -960,7 +960,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(M + logM + B + X)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn judge_suspended_candidate(origin, who: T::AccountId, judgement: Judgement) {
 			T::SuspensionJudgementOrigin::ensure_origin(origin)?;
 			if let Some((value, kind)) = <SuspendedCandidates<T, I>>::get(&who) {
@@ -1020,7 +1020,7 @@ decl_module! {
 		///
 		/// Total Complexity: O(1)
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn set_max_members(origin, max: u32) {
 			ensure_root(origin)?;
 			ensure!(max > 1, Error::<T, I>::MaxMembers);
@@ -150,7 +150,7 @@
 //!
 //! ```
 //! use frame_support::{decl_module, dispatch};
-//! use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+//! use frame_support::weights::MINIMUM_WEIGHT;
 //! use frame_system::{self as system, ensure_signed};
 //! use pallet_staking::{self as staking};
 //!
@@ -159,7 +159,7 @@
 //! decl_module! {
 //! 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 //!			/// Reward a validator.
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //! 		pub fn reward_myself(origin) -> dispatch::DispatchResult {
 //! 			let reported = ensure_signed(origin)?;
 //! 			<staking::Module<T>>::reward_by_ids(vec![(reported, 10)]);
@@ -291,7 +291,7 @@ use sp_std::{
 use codec::{HasCompact, Encode, Decode};
 use frame_support::{
 	decl_module, decl_event, decl_storage, ensure, decl_error, debug,
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT, Weight},
+	weights::{MINIMUM_WEIGHT, Weight, DispatchClass},
 	storage::IterableStorageMap,
 	dispatch::{IsSubType, DispatchResult},
 	traits::{
@@ -1268,7 +1268,7 @@ decl_module! {
 		/// NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned
 		/// unless the `origin` falls below _existential deposit_ and gets removed as dust.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		pub fn bond(origin,
 			controller: <T::Lookup as StaticLookup>::Source,
 			#[compact] value: BalanceOf<T>,
@@ -1332,7 +1332,7 @@ decl_module! {
 		/// - O(1).
 		/// - One DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn bond_extra(origin, #[compact] max_additional: BalanceOf<T>) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let stash = ensure_signed(origin)?;
@@ -1378,7 +1378,7 @@ decl_module! {
 		///   `withdraw_unbonded`.
 		/// - One DB entry.
 		/// </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(400_000_000)]
+		#[weight = 400_000_000]
 		fn unbond(origin, #[compact] value: BalanceOf<T>) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let controller = ensure_signed(origin)?;
@@ -1426,7 +1426,7 @@ decl_module! {
 		/// - Contains a limited number of reads, yet the size of which could be large based on `ledger`.
 		/// - Writes are limited to the `origin` account key.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(400_000_000)]
+		#[weight = 400_000_000]
 		fn withdraw_unbonded(origin) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let controller = ensure_signed(origin)?;
@@ -1469,7 +1469,7 @@ decl_module! {
 		/// - Contains a limited number of reads.
 		/// - Writes are limited to the `origin` account key.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(750_000_000)]
+		#[weight = 750_000_000]
 		pub fn validate(origin, prefs: ValidatorPrefs) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let controller = ensure_signed(origin)?;
@@ -1492,7 +1492,7 @@ decl_module! {
 		/// which is capped at CompactAssignments::LIMIT.
 		/// - Both the reads and writes follow a similar pattern.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(750_000_000)]
+		#[weight = 750_000_000]
 		pub fn nominate(origin, targets: Vec<<T::Lookup as StaticLookup>::Source>) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let controller = ensure_signed(origin)?;
@@ -1527,7 +1527,7 @@ decl_module! {
 		/// - Contains one read.
 		/// - Writes are limited to the `origin` account key.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn chill(origin) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let controller = ensure_signed(origin)?;
@@ -1546,7 +1546,7 @@ decl_module! {
 		/// - Contains a limited number of reads.
 		/// - Writes are limited to the `origin` account key.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn set_payee(origin, payee: RewardDestination) {
 			let controller = ensure_signed(origin)?;
 			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
@@ -1565,7 +1565,7 @@ decl_module! {
 		/// - Contains a limited number of reads.
 		/// - Writes are limited to the `origin` account key.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(750_000_000)]
+		#[weight = 750_000_000]
 		fn set_controller(origin, controller: <T::Lookup as StaticLookup>::Source) {
 			let stash = ensure_signed(origin)?;
 			let old_controller = Self::bonded(&stash).ok_or(Error::<T>::NotStash)?;
@@ -1582,7 +1582,7 @@ decl_module! {
 		}

 		/// The ideal number of validators.
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000)]
+		#[weight = 5_000_000]
 		fn set_validator_count(origin, #[compact] new: u32) {
 			ensure_root(origin)?;
 			ValidatorCount::put(new);
@@ -1593,7 +1593,7 @@ decl_module! {
 		/// # <weight>
 		/// - No arguments.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000)]
+		#[weight = 5_000_000]
 		fn force_no_eras(origin) {
 			ensure_root(origin)?;
 			ForceEra::put(Forcing::ForceNone);
@@ -1605,21 +1605,21 @@ decl_module! {
 		/// # <weight>
 		/// - No arguments.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000)]
+		#[weight = 5_000_000]
 		fn force_new_era(origin) {
 			ensure_root(origin)?;
 			ForceEra::put(Forcing::ForceNew);
 		}

 		/// Set the validators who cannot be slashed (if any).
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000)]
+		#[weight = 5_000_000]
 		fn set_invulnerables(origin, validators: Vec<T::AccountId>) {
 			ensure_root(origin)?;
 			<Invulnerables<T>>::put(validators);
 		}

 		/// Force a current staker to become completely unstaked, immediately.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn force_unstake(origin, stash: T::AccountId) {
 			ensure_root(origin)?;

@@ -1635,7 +1635,7 @@ decl_module! {
 		/// # <weight>
 		/// - One storage write
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(5_000_000)]
+		#[weight = 5_000_000]
 		fn force_new_era_always(origin) {
 			ensure_root(origin)?;
 			ForceEra::put(Forcing::ForceAlways);
@@ -1648,7 +1648,7 @@ decl_module! {
 		/// # <weight>
 		/// - One storage write.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(1_000_000_000)]
+		#[weight = 1_000_000_000]
 		fn cancel_deferred_slash(origin, era: EraIndex, slash_indices: Vec<u32>) {
 			T::SlashCancelOrigin::try_origin(origin)
 				.map(|_| ())
@@ -1699,7 +1699,7 @@ decl_module! {
 		///   maximum number of validators that may be nominated by a single nominator, it is
 		///   bounded only economically (all nominators are required to place a minimum stake).
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn payout_nominator(origin, era: EraIndex, validators: Vec<(T::AccountId, u32)>)
 			-> DispatchResult
 		{
@@ -1726,7 +1726,7 @@ decl_module! {
 		/// - Time complexity: O(1).
 		/// - Contains a limited number of reads and writes.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn payout_validator(origin, era: EraIndex) -> DispatchResult {
 			let ctrl = ensure_signed(origin)?;
 			Self::do_payout_validator(ctrl, era)
@@ -1747,7 +1747,7 @@ decl_module! {
 		/// - Time complexity: at most O(MaxNominatorRewardedPerValidator).
 		/// - Contains a limited number of reads and writes.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn payout_stakers(origin, validator_stash: T::AccountId, era: EraIndex) -> DispatchResult {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			ensure_signed(origin)?;
@@ -1763,7 +1763,7 @@ decl_module! {
 		/// - Time complexity: O(1). Bounded by `MAX_UNLOCKING_CHUNKS`.
 		/// - Storage changes: Can't increase storage, only decrease it.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn rebond(origin, #[compact] value: BalanceOf<T>) {
 			ensure!(Self::era_election_status().is_closed(), Error::<T>::CallNotAllowed);
 			let controller = ensure_signed(origin)?;
@@ -1777,7 +1777,7 @@ decl_module! {
 		/// Set history_depth value.
 		///
 		/// Origin must be root.
-		#[weight = SimpleDispatchInfo::FixedOperational(500_000_000)]
+		#[weight = (500_000_000, DispatchClass::Operational)]
 		fn set_history_depth(origin, #[compact] new_history_depth: EraIndex) {
 			ensure_root(origin)?;
 			if let Some(current_era) = Self::current_era() {
@@ -1799,7 +1799,7 @@ decl_module! {
 		/// This can be called from any origin.
 		///
 		/// - `stash`: The stash account to reap. Its balance must be zero.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn reap_stash(_origin, stash: T::AccountId) {
 			ensure!(T::Currency::total_balance(&stash).is_zero(), Error::<T>::FundedTarget);
 			Self::kill_stash(&stash)?;
@@ -1880,7 +1880,7 @@ decl_module! {
 		///
 		/// The weight of this call is 1/10th of the blocks total weight.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000_000)]
+		#[weight = 100_000_000_000]
 		pub fn submit_election_solution(
 			origin,
 			winners: Vec<ValidatorIndex>,
@@ -1903,7 +1903,7 @@ decl_module! {
 		/// Note that this must pass the [`ValidateUnsigned`] check which only allows transactions
 		/// from the local node to be included. In other words, only the block author can include a
 		/// transaction in the block.
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000_000)]
+		#[weight = 100_000_000_000]
 		pub fn submit_election_solution_unsigned(
 			origin,
 			winners: Vec<ValidatorIndex>,
@@ -52,14 +52,14 @@
 //!
 //! ```
 //! use frame_support::{decl_module, dispatch};
-//! use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+//! use frame_support::weights::MINIMUM_WEIGHT;
 //! use frame_system::{self as system, ensure_root};
 //!
 //! pub trait Trait: frame_system::Trait {}
 //!
 //! decl_module! {
 //!     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //!         pub fn privileged_function(origin) -> dispatch::DispatchResult {
 //!             ensure_root(origin)?;
 //!
@@ -93,7 +93,7 @@ use sp_runtime::traits::{StaticLookup, Dispatchable};
 use frame_support::{
 	Parameter, decl_module, decl_event, decl_storage, decl_error, ensure,
 };
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT, GetDispatchInfo, FunctionOf};
+use frame_support::weights::{MINIMUM_WEIGHT, GetDispatchInfo, FunctionOf};
 use frame_system::{self as system, ensure_signed};

 pub trait Trait: frame_system::Trait {
@@ -151,7 +151,7 @@ decl_module! {
 		/// - Limited storage reads.
 		/// - One DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn set_key(origin, new: <T::Lookup as StaticLookup>::Source) {
 			// This is a public call, so we ensure that the origin is some signed account.
 			let sender = ensure_signed(origin)?;
@@ -24,8 +24,8 @@ pub use frame_metadata::{
 	ModuleConstantMetadata, DefaultByte, DefaultByteGetter, ModuleErrorMetadata, ErrorMetadata
 };
 pub use crate::weights::{
-	SimpleDispatchInfo, GetDispatchInfo, DispatchInfo, WeighData, ClassifyDispatch,
-	TransactionPriority, Weight, PaysFee, PostDispatchInfo, WithPostDispatchInfo,
+	GetDispatchInfo, DispatchInfo, WeighData, ClassifyDispatch, TransactionPriority, Weight,
+	PaysFee, PostDispatchInfo, WithPostDispatchInfo,
 };
 pub use sp_runtime::{traits::Dispatchable, DispatchError};
 pub use crate::traits::{CallMetadata, GetCallMetadata, GetCallName};
@@ -70,14 +70,14 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug {}
 /// # #[macro_use]
 /// # extern crate frame_support;
 /// # use frame_support::dispatch;
-/// # use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+/// # use frame_support::weights::MINIMUM_WEIGHT;
 /// # use frame_system::{self as system, Trait, ensure_signed};
 /// decl_module! {
 /// 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 ///
 /// 		// Private functions are dispatchable, but not available to other
 /// 		// FRAME pallets.
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+/// 		#[weight = MINIMUM_WEIGHT]
 /// 		fn my_function(origin, var: u64) -> dispatch::DispatchResult {
 ///				// Your implementation
 ///				Ok(())
@@ -85,7 +85,7 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug {}
 ///
 ///			// Public functions are both dispatchable and available to other
 /// 		// FRAME pallets.
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+/// 		#[weight = MINIMUM_WEIGHT]
 ///			pub fn my_public_function(origin) -> dispatch::DispatchResult {
 /// 			// Your implementation
 ///				Ok(())
@@ -113,17 +113,17 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug {}
 /// # #[macro_use]
 /// # extern crate frame_support;
 /// # use frame_support::dispatch;
-/// # use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+/// # use frame_support::weights::MINIMUM_WEIGHT;
 /// # use frame_system::{self as system, Trait, ensure_signed};
 /// decl_module! {
 /// 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+/// 		#[weight = MINIMUM_WEIGHT]
 /// 		fn my_long_function(origin) -> dispatch::DispatchResult {
 ///				// Your implementation
 /// 			Ok(())
 /// 		}
 ///
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+/// 		#[weight = MINIMUM_WEIGHT]
 /// 		fn my_short_function(origin) {
 ///				// Your implementation
 /// 		}
@@ -149,11 +149,10 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug {}
 /// # #[macro_use]
 /// # extern crate frame_support;
 /// # use frame_support::dispatch::{DispatchResultWithPostInfo, WithPostDispatchInfo};
-/// # use frame_support::weights::SimpleDispatchInfo;
 /// # use frame_system::{self as system, Trait, ensure_signed};
 /// decl_module! {
 /// 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(1_000_000)]
+/// 		#[weight = 1_000_000]
 /// 		fn my_long_function(origin, do_expensive_calc: bool) -> DispatchResultWithPostInfo {
 /// 			ensure_signed(origin).map_err(|e| e.with_weight(100_000))?;
 /// 			if do_expensive_calc {
@@ -178,11 +177,11 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug {}
 /// # #[macro_use]
 /// # extern crate frame_support;
 /// # use frame_support::dispatch;
-/// # use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+/// # use frame_support::weights::MINIMUM_WEIGHT;
 /// # use frame_system::{self as system, Trait, ensure_signed, ensure_root};
 /// decl_module! {
 /// 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+/// 		#[weight = MINIMUM_WEIGHT]
 ///			fn my_privileged_function(origin) -> dispatch::DispatchResult {
 /// 			ensure_root(origin)?;
 ///				// Your implementation
@@ -2072,25 +2071,25 @@ mod tests {
 	decl_module! {
 		pub struct Module<T: Trait> for enum Call where origin: T::Origin, T::AccountId: From<u32> {
 			/// Hi, this is a comment.
-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			fn aux_0(_origin) -> DispatchResult { unreachable!() }

-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			fn aux_1(_origin, #[compact] _data: u32,) -> DispatchResult { unreachable!() }

-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			fn aux_2(_origin, _data: i32, _data2: String) -> DispatchResult { unreachable!() }

-			#[weight = SimpleDispatchInfo::FixedNormal(3)]
+			#[weight = 3]
 			fn aux_3(_origin) -> DispatchResult { unreachable!() }

-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			fn aux_4(_origin, _data: i32) -> DispatchResult { unreachable!() }

-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			fn aux_5(_origin, _data: i32, #[compact] _data2: u32,) -> DispatchResult { unreachable!() }

-			#[weight = SimpleDispatchInfo::FixedOperational(5)]
+			#[weight = (5, DispatchClass::Operational)]
 			fn operational(_origin) { unreachable!() }

 			fn on_initialize(n: T::BlockNumber,) -> Weight { if n.into() == 42 { panic!("on_initialize") } 7 }
@@ -35,7 +35,7 @@ pub use frame_metadata::{ModuleErrorMetadata, ErrorMetadata, DecodeDifferent};
 ///
 /// ```
 /// # use frame_support::{decl_error, decl_module};
-/// # use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+/// # use frame_support::weights::MINIMUM_WEIGHT;
 /// decl_error! {
 ///     /// Errors that can occur in my module.
 ///     pub enum MyError for Module<T: Trait> {
@@ -55,7 +55,7 @@ pub use frame_metadata::{ModuleErrorMetadata, ErrorMetadata, DecodeDifferent};
 ///     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 ///         type Error = MyError<T>;
 ///
-/// 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+/// 		#[weight = MINIMUM_WEIGHT]
 ///         fn do_something(origin) -> frame_support::dispatch::DispatchResult {
 ///             Err(MyError::<T>::YouAreNotCoolEnough.into())
 ///         }
@@ -334,7 +334,7 @@ mod tests {

 	mod event_module {
 		use crate::dispatch::DispatchResult;
-		use crate::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+		use crate::weights::MINIMUM_WEIGHT;

 		pub trait Trait: super::system::Trait {
 			type Balance;
@@ -352,7 +352,7 @@ mod tests {
 			pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 				type Error = Error<T>;

-				#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+				#[weight = MINIMUM_WEIGHT]
 				fn aux_0(_origin) -> DispatchResult { unreachable!() }
 			}
 		}
@@ -16,29 +16,104 @@

 //! # Primitives for transaction weighting.
 //!
-//! All dispatchable functions defined in `decl_module!` must provide two trait implementations:
-//!   - [`WeightData`]: To determine the weight of the dispatch.
-//!   - [`ClassifyDispatch`]: To determine the class of the dispatch. See the enum definition for
-//!     more information on dispatch classes.
+//! Every dispatchable function is responsible for providing `#[weight = $x]` attribute. In this
+//! snipped, `$x` can be any user provided struct that implements the following traits:
 //!
-//! Every dispatchable function is responsible for providing this data via an optional `#[weight =
-//! $x]` attribute. In this snipped, `$x` can be any user provided struct that implements the
-//! two aforementioned traits.
+//! - [`WeighData`]: the weight amount.
+//! - [`ClassifyDispatch`]: class of the dispatch.
+//! - [`PaysFee`]: weather this weight should be translated to fee and deducted upon dispatch.
 //!
 //! Substrate then bundles then output information of the two traits into [`DispatchInfo`] struct
-//! and provides it by implementing the [`GetDispatchInfo`] for all `Call` variants, and opaque
-//! extrinsic types.
+//! and provides it by implementing the [`GetDispatchInfo`] for all `Call` both inner and outer call
+//! types.
 //!
-//! If no `#[weight]` is defined, the macro automatically injects the `Default` implementation of
-//! the [`SimpleDispatchInfo`].
+//! Substrate provides two pre-defined ways to annotate weight:
 //!
-//! Note that the decl_module macro _cannot_ enforce this and will simply fail if an invalid struct
-//! (something that does not  implement `Weighable`) is passed in.
+//! ### 1. Fixed values
+//!
+//! This can only be used when all 3 traits can be resolved statically. You have 3 degrees of
+//! configuration:
+//!
+//! 1. Define only weight, **in which case `ClassifyDispatch` will be `Normal` and `PaysFee` will be
+//!    `true`**.
+//!
+//! ```
+//! # use frame_system::{self as system, Trait};
+//! frame_support::decl_module! {
+//!     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+//!         #[weight = 1000]
+//!         fn dispatching(origin) { unimplemented!() }
+//!     }
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! 2. Define weight and class, **in which case `PaysFee` would be `true`**.
+//!
+//! ```
+//! # use frame_system::{self as system, Trait};
+//! # use frame_support::weights::DispatchClass;
+//! frame_support::decl_module! {
+//!     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+//!         #[weight = (1000, DispatchClass::Operational)]
+//!         fn dispatching(origin) { unimplemented!() }
+//!     }
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! 3. Define all 3 parameters.
+//!
+//! ```
+//! # use frame_system::{self as system, Trait};
+//! # use frame_support::weights::DispatchClass;
+//! frame_support::decl_module! {
+//!     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+//!         #[weight = (1000, DispatchClass::Operational, false)]
+//!         fn dispatching(origin) { unimplemented!() }
+//!     }
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! ### 2. Define weights as a function of input arguments using `FunctionOf` tuple struct. This struct works
+//! in a similar manner as above. 3 items must be provided and each can be either a fixed value or a
+//! function/closure with the same parameters list as the dispatchable function itself, wrapper in a
+//! tuple.
+//!
+//! Using this only makes sense if you want to use a function for at least one of the elements. If
+//! all 3 are static values, providing a raw tuple is easier.
+//!
+//! ```
+//! # use frame_system::{self as system, Trait};
+//! # use frame_support::weights::{DispatchClass, FunctionOf};
+//! frame_support::decl_module! {
+//!     pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+//!         #[weight = FunctionOf(
+//! 			// weight, function.
+//! 			|args: (&u32, &u64)| *args.0 as u64 + args.1,
+//! 			// class, fixed.
+//! 			DispatchClass::Operational,
+//! 			// pays fee, function.
+//! 			|args: (&u32, &u64)| *args.0 > 1000,
+//! 		)]
+//!         fn dispatching(origin, a: u32, b: u64) { unimplemented!() }
+//!     }
+//! }
+//! # fn main() {}
+//! ```
+//! FRAME assumes a weight of `1_000_000_000_000` equals 1 second of compute on a standard machine.
+//!
+//! Latest machine specification used to benchmark are:
+//! - Digital Ocean: ubuntu-s-2vcpu-4gb-ams3-01
+//! - 2x Intel(R) Xeon(R) CPU E5-2650 v4 @ 2.20GHz
+//! - 4GB RAM
+//! - Ubuntu 19.10 (GNU/Linux 5.3.0-18-generic x86_64)
+//! - rustc 1.42.0 (b8cedc004 2020-03-09)

 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
 use codec::{Encode, Decode};
-use sp_arithmetic::traits::Bounded;
 use sp_runtime::{
 	RuntimeDebug,
 	traits::SignedExtension,
@@ -50,9 +125,6 @@ use crate::dispatch::{DispatchErrorWithPostInfo, DispatchError};
 pub use sp_runtime::transaction_validity::TransactionPriority;

 /// Numeric range of a transaction weight.
-///
-/// FRAME assumes a weight of `1_000_000_000_000` equals 1 second of compute on a standard
-/// machine: (TODO: DEFINE STANDARD MACHINE SPECIFICATIONS)
 pub type Weight = u64;

 /// The smallest total weight an extrinsic should have.
@@ -81,8 +153,7 @@ pub trait PaysFee<T> {
 	}
 }

-/// A generalized group of dispatch types. This is only distinguishing normal, user-triggered transactions
-/// (`Normal`) and anything beyond which serves a higher purpose to the system (`Operational`).
+/// A generalized group of dispatch types.
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
 #[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug)]
@@ -108,41 +179,7 @@ pub enum DispatchClass {

 impl Default for DispatchClass {
 	fn default() -> Self {
-		DispatchClass::Normal
-	}
-}
-
-// Implement traits for raw Weight value
-impl<T> WeighData<T> for Weight {
-	fn weigh_data(&self, _: T) -> Weight {
-		return *self
-	}
-}
-
-impl<T> ClassifyDispatch<T> for Weight {
-	fn classify_dispatch(&self, _: T) -> DispatchClass {
-		DispatchClass::default()
-	}
-}
-
-impl<T> PaysFee<T> for Weight {
-	fn pays_fee(&self, _: T) -> bool {
-		true
-	}
-}
-
-impl From<SimpleDispatchInfo> for DispatchClass {
-	fn from(tx: SimpleDispatchInfo) -> Self {
-		match tx {
-			SimpleDispatchInfo::FixedOperational(_) => DispatchClass::Operational,
-			SimpleDispatchInfo::MaxOperational => DispatchClass::Operational,
-
-			SimpleDispatchInfo::FixedNormal(_) => DispatchClass::Normal,
-			SimpleDispatchInfo::MaxNormal => DispatchClass::Normal,
-			SimpleDispatchInfo::InsecureFreeNormal => DispatchClass::Normal,
-
-			SimpleDispatchInfo::FixedMandatory(_) => DispatchClass::Mandatory,
-		}
+		Self::Normal
 	}
 }

@@ -157,6 +194,15 @@ pub struct DispatchInfo {
 	pub pays_fee: bool,
 }

+/// A `Dispatchable` function (aka transaction) that can carry some static information along with
+/// it, using the `#[weight]` attribute.
+pub trait GetDispatchInfo {
+	/// Return a `DispatchInfo`, containing relevant information of this dispatch.
+	///
+	/// This is done independently of its encoded size.
+	fn get_dispatch_info(&self) -> DispatchInfo;
+}
+
 /// Weight information that is only available post dispatch.
 #[derive(Clone, Copy, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode)]
 pub struct PostDispatchInfo {
@@ -206,7 +252,7 @@ impl sp_runtime::traits::Printable for PostDispatchInfo {
 }

 /// Allows easy conversion from `DispatchError` to `DispatchErrorWithPostInfo` for dispatchables
-/// that want to return a custom a posteriori weight on error.
+/// that want to return a custom a posterior weight on error.
 pub trait WithPostDispatchInfo {
 	/// Call this on your modules custom errors type in order to return a custom weight on error.
 	///
@@ -230,86 +276,75 @@ impl<T> WithPostDispatchInfo for T where
 	}
 }

-/// A `Dispatchable` function (aka transaction) that can carry some static information along with
-/// it, using the `#[weight]` attribute.
-pub trait GetDispatchInfo {
-	/// Return a `DispatchInfo`, containing relevant information of this dispatch.
-	///
-	/// This is done independently of its encoded size.
-	fn get_dispatch_info(&self) -> DispatchInfo;
-}
-
-/// Default type used with the `#[weight = x]` attribute in a substrate chain.
-///
-/// A user may pass in any other type that implements the correct traits. If not, the `Default`
-/// implementation of [`SimpleDispatchInfo`] is used.
-///
-/// For each generalized group (`Normal` and `Operation`):
-///   - A `Fixed` variant means weight fee is charged normally and the weight is the number
-///      specified in the inner value of the variant.
-///   - A `Free` variant is equal to `::Fixed(0)`. Note that this does not guarantee inclusion.
-///   - A `Max` variant is equal to `::Fixed(Weight::max_value())`.
-///
-/// As for the generalized groups themselves:
-///   - `Normal` variants will be assigned a priority proportional to their weight. They can only
-///     consume a portion (defined in the system module) of the maximum block resource limits.
-///   - `Operational` variants will be assigned the maximum priority. They can potentially consume
-///     the entire block resource limit.
-#[derive(Clone, Copy)]
-pub enum SimpleDispatchInfo {
-	/// A normal dispatch with fixed weight.
-	FixedNormal(Weight),
-	/// A normal dispatch with the maximum weight.
-	MaxNormal,
-	/// A normal dispatch with no weight. Base and bytes fees still need to be paid.
-	InsecureFreeNormal,
-	/// An operational dispatch with fixed weight.
-	FixedOperational(Weight),
-	/// An operational dispatch with the maximum weight.
-	MaxOperational,
-	/// A mandatory dispatch with fixed weight.
-	///
-	/// NOTE: Signed transactions may not (directly) dispatch this kind of a call, so the other
-	/// attributes concerning transactability (e.g. priority, fee paying) are moot.
-	FixedMandatory(Weight),
-}
-
-impl<T> WeighData<T> for SimpleDispatchInfo {
+impl<T> WeighData<T> for Weight {
 	fn weigh_data(&self, _: T) -> Weight {
-		match self {
-			SimpleDispatchInfo::FixedNormal(w) => *w,
-			SimpleDispatchInfo::MaxNormal => Bounded::max_value(),
-			SimpleDispatchInfo::InsecureFreeNormal => Bounded::min_value(),
-			SimpleDispatchInfo::FixedOperational(w) => *w,
-			SimpleDispatchInfo::MaxOperational => Bounded::max_value(),
-			SimpleDispatchInfo::FixedMandatory(w) => *w,
-		}
+		return *self
 	}
 }

-impl<T> ClassifyDispatch<T> for SimpleDispatchInfo {
+impl<T> ClassifyDispatch<T> for Weight {
 	fn classify_dispatch(&self, _: T) -> DispatchClass {
-		DispatchClass::from(*self)
+		DispatchClass::Normal
 	}
 }

-impl<T> PaysFee<T> for SimpleDispatchInfo {
+impl<T> PaysFee<T> for Weight {
 	fn pays_fee(&self, _: T) -> bool {
-		match self {
-			SimpleDispatchInfo::FixedNormal(_) => true,
-			SimpleDispatchInfo::MaxNormal => true,
-			SimpleDispatchInfo::InsecureFreeNormal => true,
-			SimpleDispatchInfo::FixedOperational(_) => true,
-			SimpleDispatchInfo::MaxOperational => true,
-			SimpleDispatchInfo::FixedMandatory(_) => true,
-		}
+		true
 	}
 }

-impl SimpleDispatchInfo {
-	/// An _additive zero_ variant of SimpleDispatchInfo.
-	pub fn zero() -> Self {
-		Self::FixedNormal(0)
+impl<T> WeighData<T> for (Weight, DispatchClass, bool) {
+	fn weigh_data(&self, _: T) -> Weight {
+		return self.0
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (Weight, DispatchClass, bool) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		self.1
+	}
+}
+
+impl<T> PaysFee<T> for (Weight, DispatchClass, bool) {
+	fn pays_fee(&self, _: T) -> bool {
+		self.2
+	}
+}
+
+impl<T> WeighData<T> for (Weight, DispatchClass) {
+	fn weigh_data(&self, _: T) -> Weight {
+		return self.0
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (Weight, DispatchClass) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		self.1
+	}
+}
+
+impl<T> PaysFee<T> for (Weight, DispatchClass) {
+	fn pays_fee(&self, _: T) -> bool {
+		true
+	}
+}
+
+impl<T> WeighData<T> for (Weight, bool) {
+	fn weigh_data(&self, _: T) -> Weight {
+		return self.0
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (Weight, bool) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		DispatchClass::Normal
+	}
+}
+
+impl<T> PaysFee<T> for (Weight, bool) {
+	fn pays_fee(&self, _: T) -> bool {
+		self.1
 	}
 }

@@ -463,8 +498,14 @@ mod tests {
 	decl_module! {
 		pub struct Module<T: Trait> for enum Call where origin: T::Origin {
 			// no arguments, fixed weight
-			#[weight = SimpleDispatchInfo::FixedNormal(1000)]
-			fn f0(_origin) { unimplemented!(); }
+			#[weight = 1000]
+			fn f00(_origin) { unimplemented!(); }
+
+			#[weight = (1000, DispatchClass::Mandatory)]
+			fn f01(_origin) { unimplemented!(); }
+
+			#[weight = (1000, DispatchClass::Operational, false)]
+			fn f02(_origin) { unimplemented!(); }

 			// weight = a x 10 + b
 			#[weight = FunctionOf(|args: (&u32, &u32)| (args.0 * 10 + args.1) as Weight, DispatchClass::Normal, true)]
@@ -484,7 +525,24 @@ mod tests {

 	#[test]
 	fn weights_are_correct() {
-		assert_eq!(Call::<TraitImpl>::f0().get_dispatch_info().weight, 1000);
+		// #[weight = 1000]
+		let info = Call::<TraitImpl>::f00().get_dispatch_info();
+		assert_eq!(info.weight, 1000);
+		assert_eq!(info.class, DispatchClass::Normal);
+		assert_eq!(info.pays_fee, true);
+
+		// #[weight = (1000, DispatchClass::Mandatory)]
+		let info = Call::<TraitImpl>::f01().get_dispatch_info();
+		assert_eq!(info.weight, 1000);
+		assert_eq!(info.class, DispatchClass::Mandatory);
+		assert_eq!(info.pays_fee, true);
+
+		// #[weight = (1000, DispatchClass::Operational, false)]
+		let info = Call::<TraitImpl>::f02().get_dispatch_info();
+		assert_eq!(info.weight, 1000);
+		assert_eq!(info.class, DispatchClass::Operational);
+		assert_eq!(info.pays_fee, false);
+
 		assert_eq!(Call::<TraitImpl>::f11(10, 20).get_dispatch_info().weight, 120);
 		assert_eq!(Call::<TraitImpl>::f11(10, 20).get_dispatch_info().class, DispatchClass::Normal);
 		assert_eq!(Call::<TraitImpl>::f12(10, 20).get_dispatch_info().weight, 0);
@@ -18,7 +18,7 @@

 use sp_runtime::{generic, traits::{BlakeTwo256, Block as _, Verify}, DispatchError};
 use sp_core::{H256, sr25519};
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;

 mod system;

@@ -33,7 +33,7 @@ mod module1 {
 		pub struct Module<T: Trait<I>, I: Instance = DefaultInstance> for enum Call
 			where origin: <T as system::Trait>::Origin
 		{
-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			pub fn fail(_origin) -> frame_support::dispatch::DispatchResult {
 				Err(Error::<T, I>::Something.into())
 			}
@@ -60,7 +60,7 @@ mod module2 {
 		pub struct Module<T: Trait> for enum Call
 			where origin: <T as system::Trait>::Origin
 		{
-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			pub fn fail(_origin) -> frame_support::dispatch::DispatchResult {
 				Err(Error::<T>::Something.into())
 			}
@@ -23,7 +23,7 @@ use frame_support::{
 		DecodeDifferent, StorageMetadata, StorageEntryModifier, StorageEntryType, DefaultByteGetter,
 		StorageEntryMetadata, StorageHasher,
 	},
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::MINIMUM_WEIGHT,
 	StorageValue, StorageMap, StorageDoubleMap,
 };
 use sp_inherents::{ProvideInherent, InherentData, InherentIdentifier, MakeFatalError};
@@ -56,7 +56,7 @@ mod module1 {

 			fn deposit_event() = default;

-			#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+			#[weight = MINIMUM_WEIGHT]
 			fn one(origin) {
 				system::ensure_root(origin)?;
 				Self::deposit_event(RawEvent::AnotherVariant(3));
@@ -2,7 +2,7 @@ macro_rules! reserved {
 	($($reserved:ident)*) => {
 		$(
 			mod $reserved {
-				pub use frame_support::{dispatch, weights::{SimpleDispatchInfo, MINIMUM_WEIGHT}};
+				pub use frame_support::{dispatch, weights::MINIMUM_WEIGHT};

 				pub trait Trait {
 					type Origin;
@@ -19,7 +19,7 @@ macro_rules! reserved {

 				frame_support::decl_module! {
 					pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-						#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+						#[weight = MINIMUM_WEIGHT]
 						fn $reserved(_origin) -> dispatch::DispatchResult { unreachable!() }
 					}
 				}
@@ -68,14 +68,14 @@
 //! ### Example - Get extrinsic count and parent hash for the current block
 //!
 //! ```
-//! use frame_support::{decl_module, dispatch, weights::{SimpleDispatchInfo, MINIMUM_WEIGHT}};
+//! use frame_support::{decl_module, dispatch, weights::MINIMUM_WEIGHT};
 //! use frame_system::{self as system, ensure_signed};
 //!
 //! pub trait Trait: system::Trait {}
 //!
 //! decl_module! {
 //! 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //! 		pub fn system_module_example(origin) -> dispatch::DispatchResult {
 //! 			let _sender = ensure_signed(origin)?;
 //! 			let _extrinsic_count = <system::Module<T>>::extrinsic_count();
@@ -120,7 +120,7 @@ use frame_support::{
 		Contains, Get, ModuleToIndex, OnNewAccount, OnKilledAccount, IsDeadAccount, Happened,
 		StoredMap, EnsureOrigin,
 	},
-	weights::{Weight, MINIMUM_WEIGHT, RuntimeDbWeight, DispatchInfo, PostDispatchInfo, DispatchClass, SimpleDispatchInfo, FunctionOf}
+	weights::{Weight, MINIMUM_WEIGHT, RuntimeDbWeight, DispatchInfo, PostDispatchInfo, DispatchClass, FunctionOf}
 };
 use codec::{Encode, Decode, FullCodec, EncodeLike};

@@ -485,20 +485,20 @@ decl_module! {
 		}

 		/// Make some on-chain remark.
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn remark(origin, _remark: Vec<u8>) {
 			ensure_signed(origin)?;
 		}

 		/// Set the number of pages in the WebAssembly environment's heap.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn set_heap_pages(origin, pages: u64) {
 			ensure_root(origin)?;
 			storage::unhashed::put_raw(well_known_keys::HEAP_PAGES, &pages.encode());
 		}

 		/// Set the new runtime code.
-		#[weight = SimpleDispatchInfo::FixedOperational(200_000_000)]
+		#[weight = (200_000_000, DispatchClass::Operational)]
 		pub fn set_code(origin, code: Vec<u8>) {
 			Self::can_set_code(origin, &code)?;

@@ -507,7 +507,7 @@ decl_module! {
 		}

 		/// Set the new runtime code without doing any checks of the given `code`.
-		#[weight = SimpleDispatchInfo::FixedOperational(200_000_000)]
+		#[weight = (200_000_000, DispatchClass::Operational)]
 		pub fn set_code_without_checks(origin, code: Vec<u8>) {
 			ensure_root(origin)?;
 			storage::unhashed::put_raw(well_known_keys::CODE, &code);
@@ -515,7 +515,7 @@ decl_module! {
 		}

 		/// Set the new changes trie configuration.
-		#[weight = SimpleDispatchInfo::FixedOperational(20_000_000)]
+		#[weight = (20_000_000, DispatchClass::Operational)]
 		pub fn set_changes_trie_config(origin, changes_trie_config: Option<ChangesTrieConfiguration>) {
 			ensure_root(origin)?;
 			match changes_trie_config.clone() {
@@ -533,7 +533,7 @@ decl_module! {
 		}

 		/// Set some items of storage.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn set_storage(origin, items: Vec<KeyValue>) {
 			ensure_root(origin)?;
 			for i in &items {
@@ -542,7 +542,7 @@ decl_module! {
 		}

 		/// Kill some items from storage.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn kill_storage(origin, keys: Vec<Key>) {
 			ensure_root(origin)?;
 			for key in &keys {
@@ -551,7 +551,7 @@ decl_module! {
 		}

 		/// Kill all storage items with a key that starts with the given prefix.
-		#[weight = SimpleDispatchInfo::FixedOperational(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Operational)]
 		fn kill_prefix(origin, prefix: Key) {
 			ensure_root(origin)?;
 			storage::unhashed::kill_prefix(&prefix);
@@ -559,7 +559,7 @@ decl_module! {

 		/// Kill the sending account, assuming there are no references outstanding and the composite
 		/// data is equal to its default value.
-		#[weight = SimpleDispatchInfo::FixedOperational(25_000_000)]
+		#[weight = (25_000_000, DispatchClass::Operational)]
 		fn suicide(origin) {
 			let who = ensure_signed(origin)?;
 			let account = Account::<T>::get(&who);
@@ -62,7 +62,7 @@
 //!
 //! ```
 //! use frame_support::{decl_module, dispatch};
-//! use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+//! use frame_support::weights::MINIMUM_WEIGHT;
 //! # use pallet_timestamp as timestamp;
 //! use frame_system::{self as system, ensure_signed};
 //!
@@ -70,7 +70,7 @@
 //!
 //! decl_module! {
 //! 	pub struct Module<T: Trait> for enum Call where origin: T::Origin {
-//! 		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+//! 		#[weight = MINIMUM_WEIGHT]
 //! 		pub fn get_time(origin) -> dispatch::DispatchResult {
 //! 			let _sender = ensure_signed(origin)?;
 //! 			let _now = <timestamp::Module<T>>::get();
@@ -101,7 +101,7 @@ use frame_support::debug;
 use frame_support::{
 	Parameter, decl_storage, decl_module,
 	traits::{Time, UnixTime, Get},
-	weights::{SimpleDispatchInfo, MINIMUM_WEIGHT},
+	weights::{MINIMUM_WEIGHT, DispatchClass},
 };
 use sp_runtime::{
 	RuntimeString,
@@ -148,7 +148,7 @@ decl_module! {
 		/// `MinimumPeriod`.
 		///
 		/// The dispatch origin for this call must be `Inherent`.
-		#[weight = SimpleDispatchInfo::FixedMandatory(MINIMUM_WEIGHT)]
+		#[weight = (MINIMUM_WEIGHT, DispatchClass::Mandatory)]
 		fn set(origin, #[compact] now: T::Moment) {
 			ensure_none(origin)?;
 			assert!(!<Self as Store>::DidUpdate::exists(), "Timestamp must be updated only once in the block");
@@ -98,7 +98,7 @@ use frame_support::traits::{
 use sp_runtime::{Permill, ModuleId, Percent, RuntimeDebug, traits::{
 	Zero, StaticLookup, AccountIdConversion, Saturating, Hash, BadOrigin
 }};
-use frame_support::weights::{Weight, MINIMUM_WEIGHT, SimpleDispatchInfo};
+use frame_support::weights::{Weight, MINIMUM_WEIGHT, DispatchClass};
 use frame_support::traits::{Contains, EnsureOrigin};
 use codec::{Encode, Decode};
 use frame_system::{self as system, ensure_signed, ensure_root};
@@ -327,7 +327,7 @@ decl_module! {
 		/// - Limited storage reads.
 		/// - One DB change, one extra DB entry.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(500_000_000)]
+		#[weight = 500_000_000]
 		fn propose_spend(
 			origin,
 			#[compact] value: BalanceOf<T>,
@@ -354,7 +354,7 @@ decl_module! {
 		/// - Limited storage reads.
 		/// - One DB clear.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(100_000_000)]
+		#[weight = (100_000_000, DispatchClass::Operational)]
 		fn reject_proposal(origin, #[compact] proposal_id: ProposalIndex) {
 			T::RejectOrigin::try_origin(origin)
 				.map(|_| ())
@@ -376,7 +376,7 @@ decl_module! {
 		/// - Limited storage reads.
 		/// - One DB change.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedOperational(100_000_000)]
+		#[weight = (100_000_000, DispatchClass::Operational)]
 		fn approve_proposal(origin, #[compact] proposal_id: ProposalIndex) {
 			T::ApproveOrigin::try_origin(origin)
 				.map(|_| ())
@@ -405,7 +405,7 @@ decl_module! {
 		/// - One storage mutation (codec `O(R)`).
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(100_000_000)]
+		#[weight = 100_000_000]
 		fn report_awesome(origin, reason: Vec<u8>, who: T::AccountId) {
 			let finder = ensure_signed(origin)?;

@@ -447,7 +447,7 @@ decl_module! {
 		/// - Two storage removals (one read, codec `O(T)`).
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn retract_tip(origin, hash: T::Hash) {
 			let who = ensure_signed(origin)?;
 			let tip = Tips::<T>::get(&hash).ok_or(Error::<T>::UnknownTip)?;
@@ -479,7 +479,7 @@ decl_module! {
 		/// - Two storage insertions (codecs `O(R)`, `O(T)`), one read `O(1)`.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(150_000_000)]
+		#[weight = 150_000_000]
 		fn tip_new(origin, reason: Vec<u8>, who: T::AccountId, tip_value: BalanceOf<T>) {
 			let tipper = ensure_signed(origin)?;
 			ensure!(T::Tippers::contains(&tipper), BadOrigin);
@@ -513,7 +513,7 @@ decl_module! {
 		/// - One storage mutation (codec `O(T)`), one storage read `O(1)`.
 		/// - Up to one event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn tip(origin, hash: T::Hash, tip_value: BalanceOf<T>) {
 			let tipper = ensure_signed(origin)?;
 			ensure!(T::Tippers::contains(&tipper), BadOrigin);
@@ -539,7 +539,7 @@ decl_module! {
 		/// - One storage retrieval (codec `O(T)`) and two removals.
 		/// - Up to three balance operations.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(50_000_000)]
+		#[weight = 50_000_000]
 		fn close_tip(origin, hash: T::Hash) {
 			ensure_signed(origin)?;

@@ -57,7 +57,7 @@ use frame_support::traits::{
 	Currency, LockableCurrency, VestingSchedule, WithdrawReason, LockIdentifier,
 	ExistenceRequirement, Get
 };
-use frame_support::weights::{SimpleDispatchInfo, MINIMUM_WEIGHT};
+use frame_support::weights::MINIMUM_WEIGHT;
 use frame_system::{self as system, ensure_signed};

 mod benchmarking;
@@ -194,7 +194,7 @@ decl_module! {
 		/// - One storage read (codec `O(1)`) and up to one removal.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn vest(origin) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Self::update_lock(who)
@@ -216,7 +216,7 @@ decl_module! {
 		/// - One storage read (codec `O(1)`) and up to one removal.
 		/// - One event.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(MINIMUM_WEIGHT)]
+		#[weight = MINIMUM_WEIGHT]
 		fn vest_other(origin, target: <T::Lookup as StaticLookup>::Source) -> DispatchResult {
 			ensure_signed(origin)?;
 			Self::update_lock(T::Lookup::lookup(target)?)
@@ -236,7 +236,7 @@ decl_module! {
 		/// - Creates a new storage entry, but is protected by a minimum transfer
 		///	   amount needed to succeed.
 		/// # </weight>
-		#[weight = SimpleDispatchInfo::FixedNormal(1_000_000_000)]
+		#[weight = 1_000_000_000]
 		pub fn vested_transfer(
 			origin,
 			target: <T::Lookup as StaticLookup>::Source,