Allow an Offset to Lease Periods (#3980)

* add slot offset for slots

* trying things out

* fix test

* improve api to return the first block of a new lease period

* add an integration test with offset

* de-duplicate test

* hide lease period_period_length from public api

* fix benchmarks

* Update runtime/common/src/slots.rs

* support the exact same range of crowdloans

* fix docs

* fix docs again

* introduce offset to runtimes

* fix and check edge case w/ offset and lease period first block

* remove newline

* turn into an option

* fix benchmarks

Co-authored-by: Robert Habermeier <rphmeier@gmail.com>

runtime/common/src/auctions.rs

@@ -34,8 +34,9 @@ use primitives::v1::Id as ParaId;
 use sp_runtime::traits::{CheckedSub, One, Saturating, Zero};
 use sp_std::{mem::swap, prelude::*};
 
-type CurrencyOf<T> = <<T as Config>::Leaser as Leaser>::Currency;
-type BalanceOf<T> = <<<T as Config>::Leaser as Leaser>::Currency as Currency<
+type CurrencyOf<T> =
+	<<T as Config>::Leaser as Leaser<<T as frame_system::Config>::BlockNumber>>::Currency;
+type BalanceOf<T> = <<<T as Config>::Leaser as Leaser<<T as frame_system::Config>::BlockNumber>>::Currency as Currency<
 	<T as frame_system::Config>::AccountId,
 >>::Balance;
 
@@ -65,7 +66,9 @@ impl WeightInfo for TestWeightInfo {
 /// An auction index. We count auctions in this type.
 pub type AuctionIndex = u32;
 
-type LeasePeriodOf<T> = <<T as Config>::Leaser as Leaser>::LeasePeriod;
+type LeasePeriodOf<T> =
+	<<T as Config>::Leaser as Leaser<<T as frame_system::Config>::BlockNumber>>::LeasePeriod;
+
 // Winning data type. This encodes the top bidders of each range together with their bid.
 type WinningData<T> = [Option<(<T as frame_system::Config>::AccountId, ParaId, BalanceOf<T>)>;
 	SlotRange::SLOT_RANGE_COUNT];
@@ -91,7 +94,11 @@ pub mod pallet {
 		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
 
 		/// The type representing the leasing system.
-		type Leaser: Leaser<AccountId = Self::AccountId, LeasePeriod = Self::BlockNumber>;
+		type Leaser: Leaser<
+			Self::BlockNumber,
+			AccountId = Self::AccountId,
+			LeasePeriod = Self::BlockNumber,
+		>;
 
 		/// The parachain registrar type.
 		type Registrar: Registrar<AccountId = Self::AccountId>;
@@ -299,9 +306,8 @@ pub mod pallet {
 	}
 }
 
-impl<T: Config> Auctioneer for Pallet<T> {
+impl<T: Config> Auctioneer<T::BlockNumber> for Pallet<T> {
 	type AccountId = T::AccountId;
-	type BlockNumber = T::BlockNumber;
 	type LeasePeriod = T::BlockNumber;
 	type Currency = CurrencyOf<T>;
 
@@ -313,7 +319,7 @@ impl<T: Config> Auctioneer for Pallet<T> {
 	}
 
 	// Returns the status of the auction given the current block number.
-	fn auction_status(now: Self::BlockNumber) -> AuctionStatus<Self::BlockNumber> {
+	fn auction_status(now: T::BlockNumber) -> AuctionStatus<T::BlockNumber> {
 		let early_end = match AuctionInfo::<T>::get() {
 			Some((_, early_end)) => early_end,
 			None => return AuctionStatus::NotStarted,
@@ -346,12 +352,13 @@ impl<T: Config> Auctioneer for Pallet<T> {
 		Self::handle_bid(bidder, para, AuctionCounter::<T>::get(), first_slot, last_slot, amount)
 	}
 
-	fn lease_period_index() -> Self::LeasePeriod {
-		T::Leaser::lease_period_index()
+	fn lease_period_index(b: T::BlockNumber) -> Option<(Self::LeasePeriod, bool)> {
+		T::Leaser::lease_period_index(b)
 	}
 
-	fn lease_period() -> Self::LeasePeriod {
-		T::Leaser::lease_period()
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	fn lease_period_length() -> (T::BlockNumber, T::BlockNumber) {
+		T::Leaser::lease_period_length()
 	}
 
 	fn has_won_an_auction(para: ParaId, bidder: &T::AccountId) -> bool {
@@ -374,10 +381,11 @@ impl<T: Config> Pallet<T> {
 	) -> DispatchResult {
 		let maybe_auction = AuctionInfo::<T>::get();
 		ensure!(maybe_auction.is_none(), Error::<T>::AuctionInProgress);
-		ensure!(
-			lease_period_index >= T::Leaser::lease_period_index(),
-			Error::<T>::LeasePeriodInPast
-		);
+		let now = frame_system::Pallet::<T>::block_number();
+		if let Some((current_lease_period, _)) = T::Leaser::lease_period_index(now) {
+			// If there is no active lease period, then we don't need to make this check.
+			ensure!(lease_period_index >= current_lease_period, Error::<T>::LeasePeriodInPast);
+		}
 
 		// Bump the counter.
 		let n = AuctionCounter::<T>::mutate(|n| {
@@ -567,7 +575,9 @@ impl<T: Config> Pallet<T> {
 			let period_count = LeasePeriodOf::<T>::from(range.len() as u32);
 
 			match T::Leaser::lease_out(para, &leaser, amount, period_begin, period_count) {
-				Err(LeaseError::ReserveFailed) | Err(LeaseError::AlreadyEnded) => {
+				Err(LeaseError::ReserveFailed) |
+				Err(LeaseError::AlreadyEnded) |
+				Err(LeaseError::NoLeasePeriod) => {
 					// Should never happen since we just unreserved this amount (and our offset is from the
 					// present period). But if it does, there's not much we can do.
 				},
@@ -735,7 +745,7 @@ mod tests {
 	}
 
 	pub struct TestLeaser;
-	impl Leaser for TestLeaser {
+	impl Leaser<BlockNumber> for TestLeaser {
 		type AccountId = u64;
 		type LeasePeriod = BlockNumber;
 		type Currency = Balances;
@@ -749,7 +759,10 @@ mod tests {
 		) -> Result<(), LeaseError> {
 			LEASES.with(|l| {
 				let mut leases = l.borrow_mut();
-				if period_begin < Self::lease_period_index() {
+				let now = System::block_number();
+				let (current_lease_period, _) =
+					Self::lease_period_index(now).ok_or(LeaseError::NoLeasePeriod)?;
+				if period_begin < current_lease_period {
 					return Err(LeaseError::AlreadyEnded)
 				}
 				for period in period_begin..(period_begin + period_count) {
@@ -779,12 +792,18 @@ mod tests {
 				.unwrap_or_default()
 		}
 
-		fn lease_period() -> Self::LeasePeriod {
-			10
+		fn lease_period_length() -> (BlockNumber, BlockNumber) {
+			(10, 0)
 		}
 
-		fn lease_period_index() -> Self::LeasePeriod {
-			(System::block_number() / Self::lease_period()).into()
+		fn lease_period_index(b: BlockNumber) -> Option<(Self::LeasePeriod, bool)> {
+			let (lease_period_length, offset) = Self::lease_period_length();
+			let b = b.checked_sub(offset)?;
+
+			let lease_period = b / lease_period_length;
+			let first_block = (b % lease_period_length).is_zero();
+
+			Some((lease_period, first_block))
 		}
 
 		fn already_leased(

runtime/common/src/crowdloan.rs

@@ -72,8 +72,11 @@ use sp_runtime::{
 };
 use sp_std::vec::Vec;
 
-type CurrencyOf<T> = <<T as Config>::Auctioneer as Auctioneer>::Currency;
-type LeasePeriodOf<T> = <<T as Config>::Auctioneer as Auctioneer>::LeasePeriod;
+type CurrencyOf<T> =
+	<<T as Config>::Auctioneer as Auctioneer<<T as frame_system::Config>::BlockNumber>>::Currency;
+type LeasePeriodOf<T> = <<T as Config>::Auctioneer as Auctioneer<
+	<T as frame_system::Config>::BlockNumber,
+>>::LeasePeriod;
 type BalanceOf<T> = <CurrencyOf<T> as Currency<<T as frame_system::Config>::AccountId>>::Balance;
 
 #[allow(dead_code)]
@@ -203,8 +206,8 @@ pub mod pallet {
 
 		/// The type representing the auctioning system.
 		type Auctioneer: Auctioneer<
+			Self::BlockNumber,
 			AccountId = Self::AccountId,
-			BlockNumber = Self::BlockNumber,
 			LeasePeriod = Self::BlockNumber,
 		>;
 
@@ -313,6 +316,8 @@ pub mod pallet {
 		AlreadyInNewRaise,
 		/// No contributions allowed during the VRF delay
 		VrfDelayInProgress,
+		/// A lease period has not started yet, due to an offset in the starting block.
+		NoLeasePeriod,
 	}
 
 	#[pallet::hooks]
@@ -365,20 +370,31 @@ pub mod pallet {
 			verifier: Option<MultiSigner>,
 		) -> DispatchResult {
 			let depositor = ensure_signed(origin)?;
+			let now = frame_system::Pallet::<T>::block_number();
 
 			ensure!(first_period <= last_period, Error::<T>::LastPeriodBeforeFirstPeriod);
 			let last_period_limit = first_period
 				.checked_add(&((SlotRange::LEASE_PERIODS_PER_SLOT as u32) - 1).into())
 				.ok_or(Error::<T>::FirstPeriodTooFarInFuture)?;
 			ensure!(last_period <= last_period_limit, Error::<T>::LastPeriodTooFarInFuture);
-			ensure!(end > <frame_system::Pallet<T>>::block_number(), Error::<T>::CannotEndInPast);
-			let last_possible_win_date = (first_period.saturating_add(One::one()))
-				.saturating_mul(T::Auctioneer::lease_period());
-			ensure!(end <= last_possible_win_date, Error::<T>::EndTooFarInFuture);
-			ensure!(
-				first_period >= T::Auctioneer::lease_period_index(),
-				Error::<T>::FirstPeriodInPast
-			);
+			ensure!(end > now, Error::<T>::CannotEndInPast);
+
+			// Here we check the lease period on the ending block is at most the first block of the
+			// period after `first_period`. If it would be larger, there is no way we could win an
+			// active auction, thus it would make no sense to have a crowdloan this long.
+			let (lease_period_at_end, is_first_block) =
+				T::Auctioneer::lease_period_index(end).ok_or(Error::<T>::NoLeasePeriod)?;
+			let adjusted_lease_period_at_end = if is_first_block {
+				lease_period_at_end.saturating_sub(One::one())
+			} else {
+				lease_period_at_end
+			};
+			ensure!(adjusted_lease_period_at_end <= first_period, Error::<T>::EndTooFarInFuture);
+
+			// Can't start a crowdloan for a lease period that already passed.
+			if let Some((current_lease_period, _)) = T::Auctioneer::lease_period_index(now) {
+				ensure!(first_period >= current_lease_period, Error::<T>::FirstPeriodInPast);
+			}
 
 			// There should not be an existing fund.
 			ensure!(!Funds::<T>::contains_key(index), Error::<T>::FundNotEnded);
@@ -439,7 +455,9 @@ pub mod pallet {
 			ensure!(now < fund.end, Error::<T>::ContributionPeriodOver);
 
 			// Make sure crowdloan is in a valid lease period
-			let current_lease_period = T::Auctioneer::lease_period_index();
+			let now = frame_system::Pallet::<T>::block_number();
+			let (current_lease_period, _) =
+				T::Auctioneer::lease_period_index(now).ok_or(Error::<T>::NoLeasePeriod)?;
 			ensure!(current_lease_period <= fund.first_period, Error::<T>::ContributionPeriodOver);
 
 			// Make sure crowdloan has not already won.
@@ -751,7 +769,8 @@ impl<T: Config> Pallet<T> {
 		// `fund.end` can represent the end of a failed crowdloan or the beginning of retirement
 		// If the current lease period is past the first period they are trying to bid for, then
 		// it is already too late to win the bid.
-		let current_lease_period = T::Auctioneer::lease_period_index();
+		let (current_lease_period, _) =
+			T::Auctioneer::lease_period_index(now).ok_or(Error::<T>::NoLeasePeriod)?;
 		ensure!(
 			now >= fund.end || current_lease_period > fund.first_period,
 			Error::<T>::FundNotEnded
@@ -931,14 +950,16 @@ mod tests {
 	}
 
 	pub struct TestAuctioneer;
-	impl Auctioneer for TestAuctioneer {
+	impl Auctioneer<u64> for TestAuctioneer {
 		type AccountId = u64;
-		type BlockNumber = BlockNumber;
 		type LeasePeriod = u64;
 		type Currency = Balances;
 
 		fn new_auction(duration: u64, lease_period_index: u64) -> DispatchResult {
-			assert!(lease_period_index >= Self::lease_period_index());
+			let now = System::block_number();
+			let (current_lease_period, _) =
+				Self::lease_period_index(now).ok_or("no lease period yet")?;
+			assert!(lease_period_index >= current_lease_period);
 
 			let ending = System::block_number().saturating_add(duration);
 			AUCTION.with(|p| *p.borrow_mut() = Some((lease_period_index, ending)));
@@ -991,12 +1012,17 @@ mod tests {
 			Ok(())
 		}
 
-		fn lease_period_index() -> u64 {
-			System::block_number() / Self::lease_period()
+		fn lease_period_index(b: BlockNumber) -> Option<(u64, bool)> {
+			let (lease_period_length, offset) = Self::lease_period_length();
+			let b = b.checked_sub(offset)?;
+
+			let lease_period = b / lease_period_length;
+			let first_block = (b % lease_period_length).is_zero();
+			Some((lease_period, first_block))
 		}
 
-		fn lease_period() -> u64 {
-			20
+		fn lease_period_length() -> (u64, u64) {
+			(20, 0)
 		}
 
 		fn has_won_an_auction(para: ParaId, bidder: &u64) -> bool {
@@ -1367,7 +1393,8 @@ mod tests {
 			let para_3 = new_para();
 			assert_ok!(Crowdloan::create(Origin::signed(1), para_3, 1000, 1, 4, 40, None));
 			run_to_block(40);
-			assert_eq!(TestAuctioneer::lease_period_index(), 2);
+			let now = System::block_number();
+			assert_eq!(TestAuctioneer::lease_period_index(now).unwrap().0, 2);
 			assert_noop!(
 				Crowdloan::contribute(Origin::signed(1), para_3, 49, None),
 				Error::<Test>::ContributionPeriodOver
@@ -1842,7 +1869,11 @@ mod benchmarking {
 
 	fn create_fund<T: Config>(id: u32, end: T::BlockNumber) -> ParaId {
 		let cap = BalanceOf::<T>::max_value();
-		let lease_period_index = T::Auctioneer::lease_period_index();
+		let (_, offset) = T::Auctioneer::lease_period_length();
+		// Set to the very beginning of lease period index 0.
+		frame_system::Pallet::<T>::set_block_number(offset);
+		let now = frame_system::Pallet::<T>::block_number();
+		let (lease_period_index, _) = T::Auctioneer::lease_period_index(now).unwrap_or_default();
 		let first_period = lease_period_index;
 		let last_period =
 			lease_period_index + ((SlotRange::LEASE_PERIODS_PER_SLOT as u32) - 1).into();
@@ -1894,7 +1925,8 @@ mod benchmarking {
 			let cap = BalanceOf::<T>::max_value();
 			let first_period = 0u32.into();
 			let last_period = 3u32.into();
-			let end = T::Auctioneer::lease_period();
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
 
 			let caller: T::AccountId = whitelisted_caller();
 			let head_data = T::Registrar::worst_head_data();
@@ -1913,7 +1945,9 @@ mod benchmarking {
 
 		// Contribute has two arms: PreEnding and Ending, but both are equal complexity.
 		contribute {
-			let fund_index = create_fund::<T>(1, 100u32.into());
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
+			let fund_index = create_fund::<T>(1, end);
 			let caller: T::AccountId = whitelisted_caller();
 			let contribution = T::MinContribution::get();
 			CurrencyOf::<T>::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
@@ -1931,7 +1965,9 @@ mod benchmarking {
 		}
 
 		withdraw {
-			let fund_index = create_fund::<T>(1337, 100u32.into());
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
+			let fund_index = create_fund::<T>(1337, end);
 			let caller: T::AccountId = whitelisted_caller();
 			let contributor = account("contributor", 0, 0);
 			contribute_fund::<T>(&contributor, fund_index);
@@ -1945,7 +1981,9 @@ mod benchmarking {
 		#[skip_meta]
 		refund {
 			let k in 0 .. T::RemoveKeysLimit::get();
-			let fund_index = create_fund::<T>(1337, 100u32.into());
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
+			let fund_index = create_fund::<T>(1337, end);
 
 			// Dissolve will remove at most `RemoveKeysLimit` at once.
 			for i in 0 .. k {
@@ -1960,7 +1998,9 @@ mod benchmarking {
 		}
 
 		dissolve {
-			let fund_index = create_fund::<T>(1337, 100u32.into());
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
+			let fund_index = create_fund::<T>(1337, end);
 			let caller: T::AccountId = whitelisted_caller();
 			frame_system::Pallet::<T>::set_block_number(T::BlockNumber::max_value());
 		}: _(RawOrigin::Signed(caller.clone()), fund_index)
@@ -1973,7 +2013,8 @@ mod benchmarking {
 			let cap = BalanceOf::<T>::max_value();
 			let first_period = 0u32.into();
 			let last_period = 3u32.into();
-			let end = T::Auctioneer::lease_period();
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
 
 			let caller: T::AccountId = whitelisted_caller();
 			let head_data = T::Registrar::worst_head_data();
@@ -1997,7 +2038,9 @@ mod benchmarking {
 		}
 
 		add_memo {
-			let fund_index = create_fund::<T>(1, 100u32.into());
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
+			let fund_index = create_fund::<T>(1, end);
 			let caller: T::AccountId = whitelisted_caller();
 			contribute_fund::<T>(&caller, fund_index);
 			let worst_memo = vec![42; T::MaxMemoLength::get().into()];
@@ -2011,7 +2054,9 @@ mod benchmarking {
 		}
 
 		poke {
-			let fund_index = create_fund::<T>(1, 100u32.into());
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end = lpl + offset;
+			let fund_index = create_fund::<T>(1, end);
 			let caller: T::AccountId = whitelisted_caller();
 			contribute_fund::<T>(&caller, fund_index);
 			NewRaise::<T>::kill();
@@ -2028,7 +2073,8 @@ mod benchmarking {
 		on_initialize {
 			// We test the complexity over different number of new raise
 			let n in 2 .. 100;
-			let end_block: T::BlockNumber = 100u32.into();
+			let (lpl, offset) = T::Auctioneer::lease_period_length();
+			let end_block = lpl + offset - 1u32.into();
 
 			let pubkey = crypto::create_ed25519_pubkey(b"//verifier".to_vec());
 
@@ -2043,7 +2089,8 @@ mod benchmarking {
 				Crowdloan::<T>::contribute(RawOrigin::Signed(contributor).into(), fund_index, contribution, Some(sig))?;
 			}
 
-			let lease_period_index = T::Auctioneer::lease_period_index();
+			let now = frame_system::Pallet::<T>::block_number();
+			let (lease_period_index, _) = T::Auctioneer::lease_period_index(now).unwrap_or_default();
 			let duration = end_block
 				.checked_sub(&frame_system::Pallet::<T>::block_number())
 				.ok_or("duration of auction less than zero")?;
@@ -2062,7 +2109,7 @@ mod benchmarking {
 
 	impl_benchmark_test_suite!(
 		Crowdloan,
-		crate::integration_tests::new_test_ext(),
+		crate::integration_tests::new_test_ext_with_offset(10),
 		crate::integration_tests::Test,
 	);
 }

runtime/common/src/integration_tests.rs

@@ -203,6 +203,7 @@ impl auctions::Config for Test {
 
 parameter_types! {
 	pub const LeasePeriod: BlockNumber = 100;
+	pub static LeaseOffset: BlockNumber = 0;
 }
 
 impl slots::Config for Test {
@@ -210,6 +211,7 @@ impl slots::Config for Test {
 	type Currency = Balances;
 	type Registrar = Registrar;
 	type LeasePeriod = LeasePeriod;
+	type LeaseOffset = LeaseOffset;
 	type WeightInfo = crate::slots::TestWeightInfo;
 }
 
@@ -254,6 +256,11 @@ pub fn new_test_ext() -> TestExternalities {
 	ext
 }
 
+pub fn new_test_ext_with_offset(n: BlockNumber) -> TestExternalities {
+	LeaseOffset::set(n);
+	new_test_ext()
+}
+
 const BLOCKS_PER_SESSION: u32 = 10;
 
 fn maybe_new_session(n: u32) {
@@ -298,8 +305,12 @@ fn last_event() -> Event {
 	System::events().pop().expect("Event expected").event
 }
 
+// Runs an end to end test of the auction, crowdloan, slots, and onboarding process over varying
+// lease period offsets.
 #[test]
 fn basic_end_to_end_works() {
+	for offset in [0u32, 50, 100, 200].iter() {
+		LeaseOffset::set(*offset);
 		new_test_ext().execute_with(|| {
 			let para_1 = LOWEST_PUBLIC_ID;
 			let para_2 = LOWEST_PUBLIC_ID + 1;
@@ -330,7 +341,7 @@ fn basic_end_to_end_works() {
 			assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Onboarding));
 
 			// Start a new auction in the future
-		let duration = 99u32;
+			let duration = 99u32 + offset;
 			let lease_period_index_start = 4u32;
 			assert_ok!(Auctions::new_auction(Origin::root(), duration, lease_period_index_start));
 
@@ -347,13 +358,13 @@ fn basic_end_to_end_works() {
 				1_000,                        // Cap
 				lease_period_index_start + 2, // First Slot
 				lease_period_index_start + 3, // Last Slot
-			200,                          // Block End
+				200 + offset,                 // Block End
 				None,
 			));
 			let crowdloan_account = Crowdloan::fund_account_id(ParaId::from(para_2));
 
-		// Auction ending begins on block 100, so we make a bid before then.
-		run_to_block(90);
+			// Auction ending begins on block 100 + offset, so we make a bid before then.
+			run_to_block(90 + offset);
 
 			Balances::make_free_balance_be(&10, 1_000_000_000);
 			Balances::make_free_balance_be(&20, 1_000_000_000);
@@ -372,13 +383,13 @@ fn basic_end_to_end_works() {
 			Balances::make_free_balance_be(&2, 1_000_000_000);
 			assert_ok!(Crowdloan::contribute(Origin::signed(2), ParaId::from(para_2), 920, None));
 
-		// Auction ends at block 110
-		run_to_block(109);
+			// Auction ends at block 110 + offset
+			run_to_block(109 + offset);
 			assert_eq!(
 				last_event(),
 				crowdloan::Event::<Test>::HandleBidResult(ParaId::from(para_2), Ok(())).into(),
 			);
-		run_to_block(110);
+			run_to_block(110 + offset);
 			assert_eq!(last_event(), auctions::Event::<Test>::AuctionClosed(1).into());
 
 			// Paras should have won slots
@@ -409,7 +420,7 @@ fn basic_end_to_end_works() {
 			);
 
 			// New leases will start on block 400
-		let lease_start_block = 400;
+			let lease_start_block = 400 + offset;
 			run_to_block(lease_start_block);
 
 			// First slot, Para 1 should be transitioning to Parachain
@@ -463,6 +474,7 @@ fn basic_end_to_end_works() {
 			assert_eq!(Paras::lifecycle(ParaId::from(para_1)), Some(ParaLifecycle::Parathread));
 			assert_eq!(Paras::lifecycle(ParaId::from(para_2)), Some(ParaLifecycle::Parathread));
 		});
+	}
 }
 
 #[test]

runtime/common/src/slots.rs

@@ -83,6 +83,10 @@ pub mod pallet {
 		#[pallet::constant]
 		type LeasePeriod: Get<Self::BlockNumber>;
 
+		/// The number of blocks to offset each lease period by.
+		#[pallet::constant]
+		type LeaseOffset: Get<Self::BlockNumber>;
+
 		/// Weight Information for the Extrinsics in the Pallet
 		type WeightInfo: WeightInfo;
 	}
@@ -138,15 +142,16 @@ pub mod pallet {
 	#[pallet::hooks]
 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
 		fn on_initialize(n: T::BlockNumber) -> Weight {
+			if let Some((lease_period, first_block)) = Self::lease_period_index(n) {
 				// If we're beginning a new lease period then handle that.
-			let lease_period = T::LeasePeriod::get();
-			if (n % lease_period).is_zero() {
-				let lease_period_index = n / lease_period;
-				Self::manage_lease_period_start(lease_period_index)
-			} else {
-				0
+				if first_block {
+					return Self::manage_lease_period_start(lease_period)
 				}
 			}
+
+			// We didn't return early above, so we didn't do anything.
+			0
+		}
 	}
 
 	#[pallet::call]
@@ -321,7 +326,7 @@ impl<T: Config> crate::traits::OnSwap for Pallet<T> {
 	}
 }
 
-impl<T: Config> Leaser for Pallet<T> {
+impl<T: Config> Leaser<T::BlockNumber> for Pallet<T> {
 	type AccountId = T::AccountId;
 	type LeasePeriod = T::BlockNumber;
 	type Currency = T::Currency;
@@ -333,7 +338,9 @@ impl<T: Config> Leaser for Pallet<T> {
 		period_begin: Self::LeasePeriod,
 		period_count: Self::LeasePeriod,
 	) -> Result<(), LeaseError> {
-		let current_lease_period = Self::lease_period_index();
+		let now = frame_system::Pallet::<T>::block_number();
+		let (current_lease_period, _) =
+			Self::lease_period_index(now).ok_or(LeaseError::NoLeasePeriod)?;
 		// Finally, we update the deposit held so it is `amount` for the new lease period
 		// indices that were won in the auction.
 		let offset = period_begin
@@ -427,12 +434,18 @@ impl<T: Config> Leaser for Pallet<T> {
 			.unwrap_or_else(Zero::zero)
 	}
 
-	fn lease_period() -> Self::LeasePeriod {
-		T::LeasePeriod::get()
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	fn lease_period_length() -> (T::BlockNumber, T::BlockNumber) {
+		(T::LeasePeriod::get(), T::LeaseOffset::get())
 	}
 
-	fn lease_period_index() -> Self::LeasePeriod {
-		<frame_system::Pallet<T>>::block_number() / T::LeasePeriod::get()
+	fn lease_period_index(b: T::BlockNumber) -> Option<(Self::LeasePeriod, bool)> {
+		// Note that blocks before `LeaseOffset` do not count as any lease period.
+		let offset_block_now = b.checked_sub(&T::LeaseOffset::get())?;
+		let lease_period = offset_block_now / T::LeasePeriod::get();
+		let first_block = (offset_block_now % T::LeasePeriod::get()).is_zero();
+
+		Some((lease_period, first_block))
 	}
 
 	fn already_leased(
@@ -440,7 +453,11 @@ impl<T: Config> Leaser for Pallet<T> {
 		first_period: Self::LeasePeriod,
 		last_period: Self::LeasePeriod,
 	) -> bool {
-		let current_lease_period = Self::lease_period_index();
+		let now = frame_system::Pallet::<T>::block_number();
+		let (current_lease_period, _) = match Self::lease_period_index(now) {
+			Some(clp) => clp,
+			None => return true,
+		};
 
 		// Can't look in the past, so we pick whichever is the biggest.
 		let start_period = first_period.max(current_lease_period);
@@ -545,6 +562,7 @@ mod tests {
 
 	parameter_types! {
 		pub const LeasePeriod: BlockNumber = 10;
+		pub static LeaseOffset: BlockNumber = 0;
 		pub const ParaDeposit: u64 = 1;
 	}
 
@@ -553,6 +571,7 @@ mod tests {
 		type Currency = Balances;