min_price -> end_price

substrate/frame/broker/src/adapt_price.rs

@@ -30,7 +30,7 @@ pub struct SalePerformance<Balance> {
 	pub sellout_price: Option<Balance>,
 
 	/// The minimum price that was achieved in this sale.
-	pub min_price: Balance,
+	pub end_price: Balance,
 
 	/// The number of cores we want to sell, ideally.
 	pub ideal_cores_sold: CoreIndex,
@@ -46,7 +46,7 @@ pub struct SalePerformance<Balance> {
 #[derive(Copy, Clone)]
 pub struct AdaptedPrices<Balance> {
 	/// New minimum price to use.
-	pub min_price: Balance,
+	pub end_price: Balance,
 	/// Price we optimize for.
 	pub target_price: Balance,
 }
@@ -56,16 +56,16 @@ impl<Balance: Copy> SalePerformance<Balance> {
 	pub fn from_sale<BlockNumber>(record: &SaleInfoRecord<Balance, BlockNumber>) -> Self {
 		Self {
 			sellout_price: record.sellout_price,
-			min_price: record.min_price,
+			end_price: record.end_price,
 			ideal_cores_sold: record.ideal_cores_sold,
 			cores_offered: record.cores_offered,
 			cores_sold: record.cores_sold,
 		}
 	}
 
 	#[cfg(test)]
-	fn new(sellout_price: Option<Balance>, min_price: Balance) -> Self {
-		Self { sellout_price, min_price, ideal_cores_sold: 0, cores_offered: 0, cores_sold: 0 }
+	fn new(sellout_price: Option<Balance>, end_price: Balance) -> Self {
+		Self { sellout_price, end_price, ideal_cores_sold: 0, cores_offered: 0, cores_sold: 0 }
 	}
 }
 
@@ -87,8 +87,8 @@ impl<Balance: Copy> AdaptPrice<Balance> for () {
 		FixedU64::one()
 	}
 	fn adapt_price(performance: SalePerformance<Balance>) -> AdaptedPrices<Balance> {
-		let price = performance.sellout_price.unwrap_or(performance.min_price);
-		AdaptedPrices { min_price: price, target_price: price }
+		let price = performance.sellout_price.unwrap_or(performance.end_price);
+		AdaptedPrices { end_price: price, target_price: price }
 	}
 }
 
@@ -110,8 +110,8 @@ impl<Balance: FixedPointOperand> AdaptPrice<Balance> for CenterTargetPrice<Balan
 	fn adapt_price(performance: SalePerformance<Balance>) -> AdaptedPrices<Balance> {
 		let Some(sellout_price) = performance.sellout_price else {
 			return AdaptedPrices {
-				min_price: performance.min_price,
-				target_price: FixedU64::from(10).saturating_mul_int(performance.min_price),
+				end_price: performance.end_price,
+				target_price: FixedU64::from(10).saturating_mul_int(performance.end_price),
 			}
 		};
 
@@ -123,7 +123,7 @@ impl<Balance: FixedPointOperand> AdaptPrice<Balance> for CenterTargetPrice<Balan
 			price
 		};
 
-		AdaptedPrices { min_price: price, target_price: sellout_price }
+		AdaptedPrices { end_price: price, target_price: sellout_price }
 	}
 }
 
@@ -145,7 +145,7 @@ mod tests {
 	fn no_op_sale_is_good() {
 		let prices = CenterTargetPrice::adapt_price(SalePerformance::new(None, 1));
 		assert_eq!(prices.target_price, 10);
-		assert_eq!(prices.min_price, 1);
+		assert_eq!(prices.end_price, 1);
 	}
 
 	#[test]
@@ -155,10 +155,10 @@ mod tests {
 		for _ in 0..10 {
 			let prices = CenterTargetPrice::adapt_price(performance);
 			performance.sellout_price = Some(1000);
-			performance.min_price = prices.min_price;
+			performance.end_price = prices.end_price;
 
-			assert!(prices.min_price <= 101);
-			assert!(prices.min_price >= 99);
+			assert!(prices.end_price <= 101);
+			assert!(prices.end_price >= 99);
 			assert!(prices.target_price <= 1001);
 			assert!(prices.target_price >= 999);
 		}
@@ -169,15 +169,15 @@ mod tests {
 		let performance = SalePerformance::new(Some(10_000), 100);
 		let prices = CenterTargetPrice::adapt_price(performance);
 		assert_eq!(prices.target_price, 10_000);
-		assert_eq!(prices.min_price, 1000);
+		assert_eq!(prices.end_price, 1000);
 	}
 
 	#[test]
 	fn price_adjusts_correctly_downwards() {
 		let performance = SalePerformance::new(Some(100), 100);
 		let prices = CenterTargetPrice::adapt_price(performance);
 		assert_eq!(prices.target_price, 100);
-		assert_eq!(prices.min_price, 10);
+		assert_eq!(prices.end_price, 10);
 	}
 
 	#[test]
@@ -188,10 +188,10 @@ mod tests {
 		for _ in 0..11 {
 			let prices = CenterTargetPrice::adapt_price(performance);
 			performance.sellout_price = Some(sellout_price);
-			performance.min_price = prices.min_price;
+			performance.end_price = prices.end_price;
 
-			assert!(prices.min_price <= sellout_price);
-			assert!(prices.min_price > 0);
+			assert!(prices.end_price <= sellout_price);
+			assert!(prices.end_price > 0);
 		}
 	}
 
@@ -200,7 +200,7 @@ mod tests {
 		let performance = SalePerformance::new(None, 100);
 		let prices = CenterTargetPrice::adapt_price(performance);
 		assert_eq!(prices.target_price, 1000);
-		assert_eq!(prices.min_price, 100);
+		assert_eq!(prices.end_price, 100);
 	}
 
 	#[test]

substrate/frame/broker/src/benchmarking.rs

@@ -776,12 +776,12 @@ mod benches {
 		let config = new_config_record::<T>();
 
 		let now = frame_system::Pallet::<T>::block_number();
-		let min_price = 10u32.into();
+		let end_price = 10u32.into();
 		let commit_timeslice = Broker::<T>::latest_timeslice_ready_to_commit(&config);
 		let sale = SaleInfoRecordOf::<T> {
 			sale_start: now,
 			leadin_length: Zero::zero(),
-			min_price,
+			end_price,
 			sellout_price: None,
 			region_begin: commit_timeslice,
 			region_end: commit_timeslice.saturating_add(config.region_length),

substrate/frame/broker/src/dispatchable_impls.rs

@@ -71,7 +71,7 @@ impl<T: Config> Pallet<T> {
 	}
 
 	pub(crate) fn do_start_sales(
-		min_price: BalanceOf<T>,
+		end_price: BalanceOf<T>,
 		extra_cores: CoreIndex,
 	) -> DispatchResult {
 		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
@@ -96,7 +96,7 @@ impl<T: Config> Pallet<T> {
 		let old_sale = SaleInfoRecord {
 			sale_start: now,
 			leadin_length: Zero::zero(),
-			min_price,
+			end_price,
 			sellout_price: None,
 			region_begin: commit_timeslice,
 			region_end: commit_timeslice.saturating_add(config.region_length),
@@ -105,7 +105,7 @@ impl<T: Config> Pallet<T> {
 			cores_offered: 0,
 			cores_sold: 0,
 		};
-		Self::deposit_event(Event::<T>::SalesStarted { price: min_price, core_count });
+		Self::deposit_event(Event::<T>::SalesStarted { price: end_price, core_count });
 		Self::rotate_sale(old_sale, &config, &status);
 		Status::<T>::put(&status);
 		Ok(())

substrate/frame/broker/src/lib.rs

@@ -559,7 +559,7 @@ pub mod pallet {
 		/// Begin the Bulk Coretime sales rotation.
 		///
 		/// - `origin`: Must be Root or pass `AdminOrigin`.
-		/// - `min_price`: The price after the leadin period of Bulk Coretime in the first sale.
+		/// - `end_price`: The price after the leadin period of Bulk Coretime in the first sale.
 		/// - `extra_cores`: Number of extra cores that should be requested on top of the cores
 		///   required for `Reservations` and `Leases`.
 		///
@@ -571,11 +571,11 @@ pub mod pallet {
 		))]
 		pub fn start_sales(
 			origin: OriginFor<T>,
-			min_price: BalanceOf<T>,
+			end_price: BalanceOf<T>,
 			extra_cores: CoreIndex,
 		) -> DispatchResultWithPostInfo {
 			T::AdminOrigin::ensure_origin_or_root(origin)?;
-			Self::do_start_sales(min_price, extra_cores)?;
+			Self::do_start_sales(end_price, extra_cores)?;
 			Ok(Pays::No.into())
 		}
 

substrate/frame/broker/src/tests.rs

@@ -1172,7 +1172,7 @@ fn purchase_requires_valid_status_and_sale_info() {
 		let mut dummy_sale = SaleInfoRecord {
 			sale_start: 0,
 			leadin_length: 0,
-			min_price: 200,
+			end_price: 200,
 			sellout_price: None,
 			region_begin: 0,
 			region_end: 3,
@@ -1214,7 +1214,7 @@ fn renewal_requires_valid_status_and_sale_info() {
 		let mut dummy_sale = SaleInfoRecord {
 			sale_start: 0,
 			leadin_length: 0,
-			min_price: 200,
+			end_price: 200,
 			sellout_price: None,
 			region_begin: 0,
 			region_end: 3,

substrate/frame/broker/src/tick_impls.rs

@@ -164,7 +164,7 @@ impl<T: Config> Pallet<T> {
 
 		log::debug!(
 			"Rotated sale, new prices: {:?}, {:?}",
-			new_prices.min_price,
+			new_prices.end_price,
 			new_prices.target_price
 		);
 
@@ -228,7 +228,7 @@ impl<T: Config> Pallet<T> {
 		let ideal_cores_sold = (config.ideal_bulk_proportion * cores_offered as u32) as u16;
 		let sellout_price = if cores_offered > 0 {
 			// No core sold -> price was too high -> we have to adjust downwards.
-			Some(new_prices.min_price)
+			Some(new_prices.end_price)
 		} else {
 			None
 		};
@@ -237,7 +237,7 @@ impl<T: Config> Pallet<T> {
 		let new_sale = SaleInfoRecord {
 			sale_start,
 			leadin_length,
-			min_price: new_prices.min_price,
+			end_price: new_prices.end_price,
 			sellout_price,
 			region_begin,
 			region_end,
@@ -252,7 +252,7 @@ impl<T: Config> Pallet<T> {
 			sale_start,
 			leadin_length,
 			start_price: Self::sale_price(&new_sale, now),
-			end_price: new_prices.min_price,
+			end_price: new_prices.end_price,
 			region_begin,
 			region_end,
 			ideal_cores_sold,

substrate/frame/broker/src/types.rs

@@ -214,7 +214,7 @@ pub struct SaleInfoRecord<Balance, BlockNumber> {
 	/// The length in blocks of the Leadin Period (where the price is decreasing).
 	pub leadin_length: BlockNumber,
 	/// The price of Bulk Coretime after the Leadin Period.
-	pub min_price: Balance,
+	pub end_price: Balance,
 	/// The first timeslice of the Regions which are being sold in this sale.
 	pub region_begin: Timeslice,
 	/// The timeslice on which the Regions which are being sold in the sale terminate. (i.e. One

substrate/frame/broker/src/utility_impls.rs

@@ -63,7 +63,7 @@ impl<T: Config> Pallet<T> {
 	pub fn sale_price(sale: &SaleInfoRecordOf<T>, now: BlockNumberFor<T>) -> BalanceOf<T> {
 		let num = now.saturating_sub(sale.sale_start).min(sale.leadin_length).saturated_into();
 		let through = FixedU64::from_rational(num, sale.leadin_length.saturated_into());
-		T::PriceAdapter::leadin_factor_at(through).saturating_mul_int(sale.min_price)
+		T::PriceAdapter::leadin_factor_at(through).saturating_mul_int(sale.end_price)
 	}
 
 	pub(crate) fn charge(who: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {