price -> base_price

substrate/frame/broker/src/adapt_price.rs

@@ -30,22 +30,22 @@ pub struct SalePerformance<Balance> {
 	pub sellout_price: Option<Balance>,
 
 	/// The base price (lowest possible price) that was used in this sale.
-	pub price: Balance,
+	pub base_price: Balance,
 }
 
 /// Result of `AdaptPrice::adapt_price`.
 #[derive(Copy, Clone)]
 pub struct AdaptedPrices<Balance> {
 	/// New base price to use.
-	pub price: Balance,
+	pub base_price: Balance,
 	/// Price we optimize for.
-	pub renewal_price: Balance,
+	pub target_price: Balance,
 }
 
 impl<Balance: Copy> SalePerformance<Balance> {
 	/// Construct performance via data from a `SaleInfoRecord`.
 	pub fn from_sale<BlockNumber>(record: &SaleInfoRecord<Balance, BlockNumber>) -> Self {
-		Self { sellout_price: record.sellout_price, price: record.price }
+		Self { sellout_price: record.sellout_price, base_price: record.base_price }
 	}
 }
 
@@ -67,8 +67,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.price);
-		AdaptedPrices { price, renewal_price: price }
+		let price = performance.sellout_price.unwrap_or(performance.base_price);
+		AdaptedPrices { base_price: price, target_price: price }
 	}
 }
 
@@ -88,8 +88,8 @@ impl<Balance: FixedPointOperand> AdaptPrice<Balance> for Linear<Balance> {
 	fn adapt_price(performance: SalePerformance<Balance>) -> AdaptedPrices<Balance> {
 		let Some(sellout_price) = performance.sellout_price else {
 			return AdaptedPrices {
-				price: performance.price,
-				renewal_price: FixedU64::from(10).saturating_mul_int(performance.price),
+				base_price: performance.base_price,
+				target_price: FixedU64::from(10).saturating_mul_int(performance.base_price),
 			}
 		};
 
@@ -101,7 +101,7 @@ impl<Balance: FixedPointOperand> AdaptPrice<Balance> for Linear<Balance> {
 			price
 		};
 
-		AdaptedPrices { price, renewal_price: sellout_price }
+		AdaptedPrices { base_price: price, target_price: sellout_price }
 	}
 }
 
@@ -114,77 +114,77 @@ mod tests {
 		for sellout in 0..11 {
 			for price in 0..10 {
 				let sellout_price = if sellout == 11 { None } else { Some(sellout) };
-				Linear::adapt_price(SalePerformance { sellout_price, price });
+				Linear::adapt_price(SalePerformance { sellout_price, base_price: price });
 			}
 		}
 	}
 
 	#[test]
 	fn no_op_sale_is_good() {
-		let prices = Linear::adapt_price(SalePerformance { sellout_price: None, price: 1 });
-		assert_eq!(prices.renewal_price, 10);
-		assert_eq!(prices.price, 1);
+		let prices = Linear::adapt_price(SalePerformance { sellout_price: None, base_price: 1 });
+		assert_eq!(prices.target_price, 10);
+		assert_eq!(prices.base_price, 1);
 	}
 
 	#[test]
 	fn price_stays_stable_on_optimal_sale() {
 		// Check price stays stable if sold at the optimal price:
-		let mut performance = SalePerformance { sellout_price: Some(1000), price: 100 };
+		let mut performance = SalePerformance { sellout_price: Some(1000), base_price: 100 };
 		for _ in 0..10 {
 			let prices = Linear::adapt_price(performance);
 			performance.sellout_price = Some(1000);
-			performance.price = prices.price;
+			performance.base_price = prices.base_price;
 
-			assert!(prices.price <= 101);
-			assert!(prices.price >= 99);
-			assert!(prices.renewal_price <= 1001);
-			assert!(prices.renewal_price >= 999);
+			assert!(prices.base_price <= 101);
+			assert!(prices.base_price >= 99);
+			assert!(prices.target_price <= 1001);
+			assert!(prices.target_price >= 999);
 		}
 	}
 
 	#[test]
 	fn price_adjusts_correctly_upwards() {
-		let performance = SalePerformance { sellout_price: Some(10_000), price: 100 };
+		let performance = SalePerformance { sellout_price: Some(10_000), base_price: 100 };
 		let prices = Linear::adapt_price(performance);
-		assert_eq!(prices.renewal_price, 10_000);
-		assert_eq!(prices.price, 1000);
+		assert_eq!(prices.target_price, 10_000);
+		assert_eq!(prices.base_price, 1000);
 	}
 
 	#[test]
 	fn price_adjusts_correctly_downwards() {
-		let performance = SalePerformance { sellout_price: Some(100), price: 100 };
+		let performance = SalePerformance { sellout_price: Some(100), base_price: 100 };
 		let prices = Linear::adapt_price(performance);
-		assert_eq!(prices.renewal_price, 100);
-		assert_eq!(prices.price, 10);
+		assert_eq!(prices.target_price, 100);
+		assert_eq!(prices.base_price, 10);
 	}
 
 	#[test]
 	fn price_never_goes_to_zero_and_recovers() {
 		// Check price stays stable if sold at the optimal price:
 		let sellout_price = 1;
-		let mut performance = SalePerformance { sellout_price: Some(sellout_price), price: 1 };
+		let mut performance = SalePerformance { sellout_price: Some(sellout_price), base_price: 1 };
 		for _ in 0..11 {
 			let prices = Linear::adapt_price(performance);
 			performance.sellout_price = Some(sellout_price);
-			performance.price = prices.price;
+			performance.base_price = prices.base_price;
 
-			assert!(prices.price <= sellout_price);
-			assert!(prices.price > 0);
+			assert!(prices.base_price <= sellout_price);
+			assert!(prices.base_price > 0);
 		}
 	}
 
 	#[test]
 	fn renewal_price_is_correct_on_no_sale() {
-		let performance = SalePerformance { sellout_price: None, price: 100 };
+		let performance = SalePerformance { sellout_price: None, base_price: 100 };
 		let prices = Linear::adapt_price(performance);
-		assert_eq!(prices.renewal_price, 1000);
-		assert_eq!(prices.price, 100);
+		assert_eq!(prices.target_price, 1000);
+		assert_eq!(prices.base_price, 100);
 	}
 
 	#[test]
 	fn renewal_price_is_sell_out() {
-		let performance = SalePerformance { sellout_price: Some(1000), price: 100 };
+		let performance = SalePerformance { sellout_price: Some(1000), base_price: 100 };
 		let prices = Linear::adapt_price(performance);
-		assert_eq!(prices.renewal_price, 1000);
+		assert_eq!(prices.target_price, 1000);
 	}
 }

substrate/frame/broker/src/dispatchable_impls.rs

@@ -70,7 +70,7 @@ impl<T: Config> Pallet<T> {
 		Ok(())
 	}
 
-	pub(crate) fn do_start_sales(price: BalanceOf<T>, extra_cores: CoreIndex) -> DispatchResult {
+	pub(crate) fn do_start_sales(base_price: BalanceOf<T>, extra_cores: CoreIndex) -> DispatchResult {
 		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
 
 		// Determine the core count
@@ -93,7 +93,7 @@ impl<T: Config> Pallet<T> {
 		let old_sale = SaleInfoRecord {
 			sale_start: now,
 			leadin_length: Zero::zero(),
-			price,
+			base_price,
 			sellout_price: None,
 			region_begin: commit_timeslice,
 			region_end: commit_timeslice.saturating_add(config.region_length),
@@ -102,7 +102,7 @@ impl<T: Config> Pallet<T> {
 			cores_offered: 0,
 			cores_sold: 0,
 		};
-		Self::deposit_event(Event::<T>::SalesStarted { price, core_count });
+		Self::deposit_event(Event::<T>::SalesStarted { price: base_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`.
-		/// - `initial_price`: The price of Bulk Coretime in the first sale.
+		/// - `base_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>,
-			initial_price: BalanceOf<T>,
+			base_price: BalanceOf<T>,
 			extra_cores: CoreIndex,
 		) -> DispatchResultWithPostInfo {
 			T::AdminOrigin::ensure_origin_or_root(origin)?;
-			Self::do_start_sales(initial_price, extra_cores)?;
+			Self::do_start_sales(base_price, extra_cores)?;
 			Ok(Pays::No.into())
 		}
 

substrate/frame/broker/src/tests.rs

@@ -1104,7 +1104,7 @@ fn purchase_requires_valid_status_and_sale_info() {
 		let mut dummy_sale = SaleInfoRecord {
 			sale_start: 0,
 			leadin_length: 0,
-			price: 200,
+			base_price: 200,
 			sellout_price: None,
 			region_begin: 0,
 			region_end: 3,
@@ -1146,7 +1146,7 @@ fn renewal_requires_valid_status_and_sale_info() {
 		let mut dummy_sale = SaleInfoRecord {
 			sale_start: 0,
 			leadin_length: 0,
-			price: 200,
+			base_price: 200,
 			sellout_price: None,
 			region_begin: 0,
 			region_end: 3,

substrate/frame/broker/src/tick_impls.rs

@@ -195,13 +195,13 @@ impl<T: Config> Pallet<T> {
 				// last time for this one - make it renewable in the next sale.
 				let renewal_id = PotentialRenewalId { core: first_core, when: region_end };
 				let record = PotentialRenewalRecord {
-					price: new_prices.renewal_price,
+					price: new_prices.target_price,
 					completion: Complete(schedule),
 				};
 				PotentialRenewals::<T>::insert(renewal_id, &record);
 				Self::deposit_event(Event::Renewable {
 					core: first_core,
-					price: new_prices.renewal_price,
+					price: new_prices.target_price,
 					begin: region_end,
 					workload: record.completion.drain_complete().unwrap_or_default(),
 				});
@@ -222,7 +222,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.price)
+			Some(new_prices.base_price)
 		} else {
 			None
 		};
@@ -231,7 +231,7 @@ impl<T: Config> Pallet<T> {
 		let new_sale = SaleInfoRecord {
 			sale_start,
 			leadin_length,
-			price: new_prices.price,
+			base_price: new_prices.base_price,
 			sellout_price,
 			region_begin,
 			region_end,
@@ -246,7 +246,7 @@ impl<T: Config> Pallet<T> {
 			sale_start,
 			leadin_length,
 			start_price: Self::sale_price(&new_sale, now),
-			regular_price: new_prices.price,
+			regular_price: new_prices.base_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 price: Balance,
+	pub base_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.price)
+		T::PriceAdapter::leadin_factor_at(through).saturating_mul_int(sale.base_price)
 	}
 
 	pub(crate) fn charge(who: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {