pallet-election-provider-multi-phase

frame/contracts/src/gas.rs

@@ -107,7 +107,7 @@ where
 	///
 	/// Passing `0` as amount is interpreted as "all remaining gas".
 	pub fn nested(&mut self, amount: Weight) -> Result<Self, DispatchError> {
-		let amount = if amount == 0 { self.gas_left } else { amount };
+		let amount = if amount == Weight::zero() { self.gas_left } else { amount };
 
 		// NOTE that it is ok to allocate all available gas since it still ensured
 		// by `charge` that it doesn't reach zero.

frame/democracy/src/lib.rs

@@ -1778,11 +1778,13 @@ impl<T: Config> Pallet<T> {
 			if Self::launch_next(now).is_ok() {
 				weight = max_block_weight;
 			} else {
-				weight =
-					weight.saturating_add(T::WeightInfo::on_initialize_base_with_launch_period(r));
+				weight = weight.saturating_add(Weight::from_ref_time(
+					T::WeightInfo::on_initialize_base_with_launch_period(r),
+				));
 			}
 		} else {
-			weight = weight.saturating_add(T::WeightInfo::on_initialize_base(r));
+			weight =
+				weight.saturating_add(Weight::from_ref_time(T::WeightInfo::on_initialize_base(r)));
 		}
 
 		// tally up votes for any expiring referenda.

frame/democracy/src/tests.rs

@@ -78,7 +78,7 @@ impl Contains<Call> for BaseFilter {
 
 parameter_types! {
 	pub BlockWeights: frame_system::limits::BlockWeights =
-		frame_system::limits::BlockWeights::simple_max(1_000_000);
+		frame_system::limits::BlockWeights::simple_max(Weight::from_ref_time(1_000_000));
 }
 impl frame_system::Config for Test {
 	type BaseCallFilter = BaseFilter;
@@ -107,7 +107,7 @@ impl frame_system::Config for Test {
 	type MaxConsumers = frame_support::traits::ConstU32<16>;
 }
 parameter_types! {
-	pub MaximumSchedulerWeight: Weight = Weight::from_ref_time(Perbill::from_percent(80) * BlockWeights::get().max_block);
+	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * BlockWeights::get().max_block;
 }
 impl pallet_scheduler::Config for Test {
 	type Event = Event;

frame/election-provider-multi-phase/src/lib.rs

@@ -234,7 +234,6 @@ use frame_election_provider_support::{
 	ElectionDataProvider, ElectionProvider, InstantElectionProvider, NposSolution,
 };
 use frame_support::{
-	dispatch::DispatchResultWithPostInfo,
 	ensure,
 	traits::{Currency, Get, OnUnbalanced, ReservableCurrency},
 	weights::{DispatchClass, Weight},
@@ -731,12 +730,12 @@ pub mod pallet {
 					match Self::create_snapshot() {
 						Ok(_) => {
 							Self::on_initialize_open_signed();
-							T::WeightInfo::on_initialize_open_signed()
+							Weight::from_ref_time(T::WeightInfo::on_initialize_open_signed())
 						},
 						Err(why) => {
 							// Not much we can do about this at this point.
 							log!(warn, "failed to open signed phase due to {:?}", why);
-							T::WeightInfo::on_initialize_nothing()
+							Weight::from_ref_time(T::WeightInfo::on_initialize_nothing())
 						},
 					}
 				},
@@ -770,19 +769,19 @@ pub mod pallet {
 						match Self::create_snapshot() {
 							Ok(_) => {
 								Self::on_initialize_open_unsigned(enabled, now);
-								T::WeightInfo::on_initialize_open_unsigned()
+								Weight::from_ref_time(T::WeightInfo::on_initialize_open_unsigned())
 							},
 							Err(why) => {
 								log!(warn, "failed to open unsigned phase due to {:?}", why);
-								T::WeightInfo::on_initialize_nothing()
+								Weight::from_ref_time(T::WeightInfo::on_initialize_nothing())
 							},
 						}
 					} else {
 						Self::on_initialize_open_unsigned(enabled, now);
-						T::WeightInfo::on_initialize_open_unsigned()
+						Weight::from_ref_time(T::WeightInfo::on_initialize_open_unsigned())
 					}
 				},
-				_ => T::WeightInfo::on_initialize_nothing(),
+				_ => Weight::from_ref_time(T::WeightInfo::on_initialize_nothing()),
 			}
 		}
 
@@ -877,7 +876,7 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			raw_solution: Box<RawSolution<SolutionOf<T::MinerConfig>>>,
 			witness: SolutionOrSnapshotSize,
-		) -> DispatchResultWithPostInfo {
+		) -> DispatchResult {
 			ensure_none(origin)?;
 			let error_message = "Invalid unsigned submission must produce invalid block and \
 				 deprive validator from their authoring reward.";
@@ -905,7 +904,7 @@ pub mod pallet {
 				prev_ejected: ejected_a_solution,
 			});
 
-			Ok(None.into())
+			Ok(())
 		}
 
 		/// Set a new value for `MinimumUntrustedScore`.
@@ -992,7 +991,7 @@ pub mod pallet {
 			let deposit = Self::deposit_for(&raw_solution, size);
 			let call_fee = {
 				let call = Call::submit { raw_solution: raw_solution.clone() };
-				T::EstimateCallFee::estimate_call_fee(&call, None.into())
+				T::EstimateCallFee::estimate_call_fee(&call, None::<Weight>.into())
 			};
 
 			let submission = SignedSubmission {
@@ -1401,8 +1400,10 @@ impl<T: Config> Pallet<T> {
 		let (targets, voters, desired_targets) = Self::create_snapshot_external()?;
 
 		// ..therefore we only measure the weight of this and add it.
-		let internal_weight =
-			T::WeightInfo::create_snapshot_internal(voters.len() as u32, targets.len() as u32);
+		let internal_weight = Weight::from_ref_time(T::WeightInfo::create_snapshot_internal(
+			voters.len() as u32,
+			targets.len() as u32,
+		));
 		Self::create_snapshot_internal(targets, voters, desired_targets);
 		Self::register_weight(internal_weight);
 		Ok(())
@@ -1562,7 +1563,10 @@ impl<T: Config> Pallet<T> {
 			.map(|(_, x)| x)
 			.fold(Zero::zero(), |acc, next| acc + next.voters.len() as u32);
 		let desired_targets = supports.len() as u32;
-		Self::register_weight(T::WeightInfo::elect_queued(active_voters, desired_targets));
+		Self::register_weight(Weight::from_ref_time(T::WeightInfo::elect_queued(
+			active_voters,
+			desired_targets,
+		)));
 	}
 }
 
@@ -2195,12 +2199,12 @@ mod tests {
 		let all_targets: u32 = 5_000;
 		let desired: u32 = 1_000;
 		let weight_with = |active| {
-			<Runtime as Config>::WeightInfo::submit_unsigned(
+			Weight::from_ref_time(<Runtime as Config>::WeightInfo::submit_unsigned(
 				all_voters,
 				all_targets,
 				active,
 				desired,
-			)
+			))
 		};
 
 		let mut active = 1;

frame/election-provider-multi-phase/src/mock.rs

@@ -226,7 +226,7 @@ const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
 parameter_types! {
 	pub const ExistentialDeposit: u64 = 1;
 	pub BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights
-		::with_sensible_defaults(2 * frame_support::weights::constants::WEIGHT_PER_SECOND, NORMAL_DISPATCH_RATIO);
+		::with_sensible_defaults(Weight::from_ref_time(2 * frame_support::weights::constants::WEIGHT_PER_SECOND), NORMAL_DISPATCH_RATIO);
 }
 
 impl pallet_balances::Config for Runtime {
@@ -271,12 +271,12 @@ parameter_types! {
 	pub static SignedDepositByte: Balance = 0;
 	pub static SignedDepositWeight: Balance = 0;
 	pub static SignedRewardBase: Balance = 7;
-	pub static SignedMaxWeight: Weight = Weight::from_ref_time(BlockWeights::get().max_block);
+	pub static SignedMaxWeight: Weight = BlockWeights::get().max_block;
 	pub static MinerTxPriority: u64 = 100;
 	pub static BetterSignedThreshold: Perbill = Perbill::zero();
 	pub static BetterUnsignedThreshold: Perbill = Perbill::zero();
 	pub static OffchainRepeat: BlockNumber = 5;
-	pub static MinerMaxWeight: Weight = Weight::from_ref_time(BlockWeights::get().max_block);
+	pub static MinerMaxWeight: Weight = BlockWeights::get().max_block;
 	pub static MinerMaxLength: u32 = 256;
 	pub static MockWeightInfo: MockedWeightInfo = MockedWeightInfo::Real;
 	pub static MaxElectingVoters: VoterIndex = u32::max_value();
@@ -348,13 +348,15 @@ impl MinerConfig for Runtime {
 	type Solution = TestNposSolution;
 
 	fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight {
-		match MockWeightInfo::get() {
+		let ref_time_weight = match MockWeightInfo::get() {
 			MockedWeightInfo::Basic =>
-				(10 as Weight).saturating_add((5 as Weight).saturating_mul(a as Weight)),
-			MockedWeightInfo::Complex => (0 * v + 0 * t + 1000 * a + 0 * d) as Weight,
+				(10 as u64).saturating_add((5 as u64).saturating_mul(a as u64)),
+			MockedWeightInfo::Complex => (0 * v + 0 * t + 1000 * a + 0 * d) as u64,
 			MockedWeightInfo::Real =>
 				<() as multi_phase::weights::WeightInfo>::feasibility_check(v, t, a, d),
-		}
+		};
+
+		Weight::from_ref_time(ref_time_weight)
 	}
 }
 

frame/election-provider-multi-phase/src/signed.rs

@@ -443,7 +443,7 @@ impl<T: Config> Pallet<T> {
 			discarded
 		);
 
-		(weight, found_solution)
+		(Weight::from_ref_time(weight), found_solution)
 	}
 	/// Helper function for the case where a solution is accepted in the signed phase.
 	///
@@ -514,8 +514,8 @@ impl<T: Config> Pallet<T> {
 		let feasibility_weight = Self::solution_weight_of(raw_solution, size);
 
 		let len_deposit = T::SignedDepositByte::get().saturating_mul(encoded_len);
-		let weight_deposit =
-			T::SignedDepositWeight::get().saturating_mul(feasibility_weight.saturated_into());
+		let weight_deposit = T::SignedDepositWeight::get()
+			.saturating_mul(feasibility_weight.ref_time().saturated_into());
 
 		T::SignedDepositBase::get()
 			.saturating_add(len_deposit)
@@ -957,7 +957,7 @@ mod tests {
 	#[test]
 	fn cannot_consume_too_much_future_weight() {
 		ExtBuilder::default()
-			.signed_weight(40)
+			.signed_weight(Weight::from_ref_time(40))
 			.mock_weight_info(MockedWeightInfo::Basic)
 			.build_and_execute(|| {
 				roll_to(15);
@@ -971,13 +971,13 @@ mod tests {
 					raw.solution.unique_targets().len() as u32,
 				);
 				// default solution will have 5 edges (5 * 5 + 10)
-				assert_eq!(solution_weight, 35);
+				assert_eq!(solution_weight, Weight::from_ref_time(35));
 				assert_eq!(raw.solution.voter_count(), 5);
-				assert_eq!(<Runtime as Config>::SignedMaxWeight::get(), 40);
+				assert_eq!(<Runtime as Config>::SignedMaxWeight::get(), Weight::from_ref_time(40));
 
 				assert_ok!(MultiPhase::submit(Origin::signed(99), Box::new(raw.clone())));
 
-				<SignedMaxWeight>::set(30);
+				<SignedMaxWeight>::set(Weight::from_ref_time(30));
 
 				// note: resubmitting the same solution is technically okay as long as the queue has
 				// space.