Coretime auto-renew

substrate/frame/broker/src/lib.rs

@@ -99,6 +99,12 @@ pub mod pallet {
 		type ConvertBalance: Convert<BalanceOf<Self>, RelayBalanceOf<Self>>
 			+ ConvertBack<BalanceOf<Self>, RelayBalanceOf<Self>>;
 
+		/// Type used for getting the associated account of a task. This account is controlled by
+		/// the task itself.
+		//
+		// TODO: maybe rename this?
+		type SovereignAccountOf: Convert<TaskId, Self::AccountId>;
+
 		/// Identifier from which the internal Pot is generated.
 		#[pallet::constant]
 		type PalletId: Get<PalletId>;
@@ -114,6 +120,9 @@ pub mod pallet {
 		/// Maximum number of system cores.
 		#[pallet::constant]
 		type MaxReservedCores: Get<u32>;
+
+		#[pallet::constant]
+		type MaxAutoRenewals: Get<u32>;
 	}
 
 	/// The current configuration of this pallet.
@@ -172,6 +181,11 @@ pub mod pallet {
 	#[pallet::storage]
 	pub type CoreCountInbox<T> = StorageValue<_, CoreIndex, OptionQuery>;
 
+	/// Keeping track of cores which have auto-renewal enabled.
+	#[pallet::storage]
+	pub type AutoRenewals<T: Config> =
+		StorageValue<_, BoundedVec<(CoreIndex, TaskId), T::MaxAutoRenewals>, ValueQuery>;
+
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
@@ -803,6 +817,57 @@ pub mod pallet {
 			Ok(())
 		}
 
+		/// Extrinsic for enabling auto renewal.
+		///
+		/// Callable by the account associated with the task on the specified core. This account
+		/// will be charged at the start of every bulk period for renewing core time.
+		#[pallet::call_index(20)]
+		#[pallet::weight(T::WeightInfo::notify_core_count())]
+		pub fn enable_auto_renew(origin: OriginFor<T>, core: CoreIndex) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			// TODO: ensure origin is the parachain's sovereign account.
+
+			let sale = SaleInfo::<T>::get().ok_or(Error::<T>::NoSales)?;
+
+			// If the core hasn't been renewed yet we will renew it now.
+			let record = if let Some(record) =
+				AllowedRenewals::<T>::get(AllowedRenewalId { core, when: sale.region_begin })
+			{
+				Self::do_renew(who, core)?;
+				record
+			} else {
+				// If we couldn't find the renewal record for the current bulk period we should be
+				// able to find it for the upcoming bulk period.
+				//
+				// If not the core is not eligable for renewal.
+				AllowedRenewals::<T>::get(AllowedRenewalId { core, when: sale.region_end })
+					.ok_or(Error::<T>::NotAllowed)?
+			};
+
+			let workload =
+				record.completion.drain_complete().ok_or(Error::<T>::IncompleteAssignment)?;
+			// Given that only non-interlaced cores can be renewed, there should be only one
+			// assignment in the core's workload.
+			ensure!(workload.len() == 1, Error::<T>::IncompleteAssignment);
+			let schedule_item = &workload[0];
+			let CoreAssignment::Task(task_id) = schedule_item.assignment else {
+				// return an error.
+				todo!();
+			};
+
+			AutoRenewals::<T>::try_mutate(|renewals| {
+				let pos = renewals
+					.binary_search_by(|r: &(CoreIndex, TaskId)| r.0.cmp(&core))
+					.unwrap_or_else(|e| e);
+				renewals.try_insert(pos, (core, task_id))
+			})
+			.map_err(|_| Error::<T>::NotAllowed)?; // TODO: custom error
+
+			// The caller must pay for the transaction otherwise spamming would be possible by
+			// turning auto-renewal on and off.
+			Ok(())
+		}
+
 		#[pallet::call_index(99)]
 		#[pallet::weight(T::WeightInfo::swap_leases())]
 		pub fn swap_leases(origin: OriginFor<T>, id: TaskId, other: TaskId) -> DispatchResult {

substrate/frame/broker/src/mock.rs

@@ -31,7 +31,7 @@ use frame_system::{EnsureRoot, EnsureSignedBy};
 use sp_arithmetic::Perbill;
 use sp_core::{ConstU32, ConstU64, Get};
 use sp_runtime::{
-	traits::{BlockNumberProvider, Identity},
+	traits::{BlockNumberProvider, Convert, Identity},
 	BuildStorage, Saturating,
 };
 use sp_std::collections::btree_map::BTreeMap;
@@ -187,6 +187,14 @@ ord_parameter_types! {
 }
 type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<One, u64>>;
 
+pub struct TaskToAccountId;
+// TODO
+impl Convert<TaskId, u64> for TaskToAccountId {
+	fn convert(_task: TaskId) -> u64 {
+		0
+	}
+}
+
 impl crate::Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = ItemOf<TestFungibles<(), u64, (), ConstU64<0>, ()>, (), u64>;
@@ -200,6 +208,7 @@ impl crate::Config for Test {
 	type PalletId = TestBrokerId;
 	type AdminOrigin = EnsureOneOrRoot;
 	type PriceAdapter = Linear;
+	type SovereignAccountOf = TaskToAccountId;
 }
 
 pub fn advance_to(b: u64) {

substrate/frame/broker/src/tick_impls.rs

@@ -21,7 +21,7 @@ use sp_arithmetic::{
 	traits::{One, SaturatedConversion, Saturating, Zero},
 	FixedPointNumber,
 };
-use sp_runtime::traits::ConvertBack;
+use sp_runtime::traits::{Convert, ConvertBack};
 use sp_std::{vec, vec::Vec};
 use CompletionStatus::Complete;
 
@@ -238,6 +238,8 @@ impl<T: Config> Pallet<T> {
 		});
 		Leases::<T>::put(&leases);
 
+		Self::renew_cores();
+
 		let max_possible_sales = status.core_count.saturating_sub(first_core);
 		let limit_cores_offered = config.limit_cores_offered.unwrap_or(CoreIndex::max_value());
 		let cores_offered = limit_cores_offered.min(max_possible_sales);
@@ -329,4 +331,15 @@ impl<T: Config> Pallet<T> {
 		T::Coretime::assign_core(core, rc_begin, assignment.clone(), None);
 		Self::deposit_event(Event::<T>::CoreAssigned { core, when: rc_begin, assignment });
 	}
+
+	/// Renews all the cores which have auto-renewal enabled.
+	pub(crate) fn renew_cores() {
+		let renewals = AutoRenewals::<T>::get();
+		renewals.iter().for_each(|(core, task_id)| {
+			let payer = T::SovereignAccountOf::convert(*task_id);
+			if let Err(_) = Self::do_renew(payer, *core) {
+				// TODO: emit event
+			}
+		});
+	}
 }