use super::*;
use frame_support::{
pallet_prelude::*,
traits::{
fungible::Balanced,
tokens::{Fortitude::Polite, Precision::Exact, Preservation::Expendable},
OnUnbalanced,
},
};
use frame_system::pallet_prelude::BlockNumberFor;
use sp_arithmetic::{
traits::{SaturatedConversion, Saturating},
FixedPointNumber, FixedU64,
};
use sp_runtime::traits::{AccountIdConversion, BlockNumberProvider};
impl<T: Config> Pallet<T> {
pub fn current_timeslice() -> Timeslice {
let latest = RCBlockNumberProviderOf::<T::Coretime>::current_block_number();
let timeslice_period = T::TimeslicePeriod::get();
(latest / timeslice_period).saturated_into()
}
pub fn latest_timeslice_ready_to_commit(config: &ConfigRecordOf<T>) -> Timeslice {
let latest = RCBlockNumberProviderOf::<T::Coretime>::current_block_number();
let advanced = latest.saturating_add(config.advance_notice);
let timeslice_period = T::TimeslicePeriod::get();
(advanced / timeslice_period).saturated_into()
}
pub fn next_timeslice_to_commit(
config: &ConfigRecordOf<T>,
status: &StatusRecord,
) -> Option<Timeslice> {
if status.last_committed_timeslice < Self::latest_timeslice_ready_to_commit(config) {
Some(status.last_committed_timeslice + 1)
} else {
None
}
}
pub fn account_id() -> T::AccountId {
T::PalletId::get().into_account_truncating()
}
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.end_price)
}
pub(crate) fn charge(who: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
let credit = T::Currency::withdraw(&who, amount, Exact, Expendable, Polite)?;
T::OnRevenue::on_unbalanced(credit);
Ok(())
}
pub(crate) fn purchase_core(
who: &T::AccountId,
price: BalanceOf<T>,
sale: &mut SaleInfoRecordOf<T>,
) -> Result<CoreIndex, DispatchError> {
Self::charge(who, price)?;
log::debug!("Purchased core at: {:?}", price);
let core = sale.first_core.saturating_add(sale.cores_sold);
sale.cores_sold.saturating_inc();
if sale.cores_sold <= sale.ideal_cores_sold || sale.sellout_price.is_none() {
sale.sellout_price = Some(price);
}
Ok(core)
}
pub fn issue(
core: CoreIndex,
begin: Timeslice,
mask: CoreMask,
end: Timeslice,
owner: Option<T::AccountId>,
paid: Option<BalanceOf<T>>,
) -> RegionId {
let id = RegionId { begin, core, mask };
let record = RegionRecord { end, owner, paid };
Regions::<T>::insert(&id, &record);
id
}
pub(crate) fn utilize(
mut region_id: RegionId,
maybe_check_owner: Option<T::AccountId>,
finality: Finality,
) -> Result<Option<(RegionId, RegionRecordOf<T>)>, Error<T>> {
let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
let region = Regions::<T>::get(®ion_id).ok_or(Error::<T>::UnknownRegion)?;
if let Some(check_owner) = maybe_check_owner {
ensure!(Some(check_owner) == region.owner, Error::<T>::NotOwner);
}
Regions::<T>::remove(®ion_id);
let last_committed_timeslice = status.last_committed_timeslice;
if region_id.begin <= last_committed_timeslice {
let duration = region.end.saturating_sub(region_id.begin);
region_id.begin = last_committed_timeslice + 1;
if region_id.begin >= region.end {
Self::deposit_event(Event::RegionDropped { region_id, duration });
return Ok(None)
}
} else {
Workplan::<T>::mutate_extant((region_id.begin, region_id.core), |p| {
p.retain(|i| (i.mask & region_id.mask).is_void())
});
}
if finality == Finality::Provisional {
Regions::<T>::insert(®ion_id, ®ion);
}
Ok(Some((region_id, region)))
}
}