Coretime: Add request revenue info

cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml

@@ -199,4 +199,6 @@ try-runtime = [
 	"sp-runtime/try-runtime",
 ]
 
-fast-runtime = []
+fast-runtime = [
+	"rococo-runtime-constants/fast-runtime",
+]

cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs

@@ -20,20 +20,89 @@ use cumulus_pallet_parachain_system::RelaychainDataProvider;
 use cumulus_primitives_core::relay_chain;
 use frame_support::{
 	parameter_types,
+	storage::with_transaction,
 	traits::{
-		fungible::{Balanced, Credit},
-		OnUnbalanced,
+		fungible::{Balanced, Credit, Inspect},
+		tokens::{Fortitude, Preservation},
+		DefensiveResult, OnUnbalanced,
 	},
 };
-use pallet_broker::{CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600, RCBlockNumberOf};
-use parachains_common::{AccountId, Balance, BlockNumber};
+use pallet_broker::{
+	traits::NewTimesliceHook, CoreAssignment, CoreIndex, CoretimeInterface, OnDemandRevenueRecord,
+	PartsOf57600, RCBlockNumberOf, RevenueInbox,
+};
+use parachains_common::{AccountId, Balance};
+use rococo_runtime_constants::system_parachain::coretime;
+use sp_runtime::{traits::AccountIdConversion, TransactionOutcome};
 use xcm::latest::prelude::*;
+use xcm_executor::traits::TransactAsset;
 
-pub struct CreditToCollatorPot;
-impl OnUnbalanced<Credit<AccountId, Balances>> for CreditToCollatorPot {
-	fn on_nonzero_unbalanced(credit: Credit<AccountId, Balances>) {
-		let staking_pot = CollatorSelection::account_id();
-		let _ = <Balances as Balanced<_>>::resolve(&staking_pot, credit);
+pub struct StashToBurn;
+impl OnUnbalanced<Credit<AccountId, Balances>> for StashToBurn {
+	fn on_nonzero_unbalanced(amount: Credit<AccountId, Balances>) {
+		Balances::resolve(&BurnStashAccount::get(), amount).defensive_ok();
+	}
+}
+
+type AssetTransactor = <xcm_config::XcmConfig as xcm_executor::Config>::AssetTransactor;
+
+fn burn_at_relay(stash: &AccountId, value: Balance) -> Result<(), XcmError> {
+	let dest = Location::parent();
+	let stash_location =
+		Junction::AccountId32 { network: None, id: stash.clone().into() }.into_location();
+	let asset = Asset { id: AssetId(Location::parent()), fun: Fungible(value) };
+	let dummy_xcm_context = XcmContext { origin: None, message_id: [0; 32], topic: None };
+
+	let withdrawn = AssetTransactor::withdraw_asset(&asset, &stash_location, None)?;
+
+	AssetTransactor::can_check_out(&dest, &asset, &dummy_xcm_context)?;
+
+	let parent_assets = Into::<Assets>::into(withdrawn)
+		.reanchored(&dest, &Here.into())
+		.defensive_map_err(|_| XcmError::ReanchorFailed)?;
+
+	PolkadotXcm::send_xcm(
+		Here,
+		Location::parent(),
+		Xcm(vec![
+			Instruction::UnpaidExecution {
+				weight_limit: WeightLimit::Unlimited,
+				check_origin: None,
+			},
+			ReceiveTeleportedAsset(parent_assets.clone()),
+			BurnAsset(parent_assets),
+		]),
+	)?;
+
+	AssetTransactor::check_out(&dest, &asset, &dummy_xcm_context);
+
+	Ok(())
+}
+
+pub struct BurnStash;
+impl NewTimesliceHook for BurnStash {
+	fn on_new_timeslice(_t: pallet_broker::Timeslice) {
+		let stash = BurnStashAccount::get();
+		let value = Balances::reducible_balance(&stash, Preservation::Expendable, Fortitude::Force);
+
+		if value > 0 {
+			log::debug!(target: "runtime::coretime", "Going to burn {value} stashed tokens at RC");
+			with_transaction(|| -> TransactionOutcome<Result<(), DispatchError>> {
+				match burn_at_relay(&stash, value) {
+					Ok(()) => {
+						log::debug!(target: "runtime::coretime", "Succesfully burnt {value} tokens");
+						TransactionOutcome::Commit(Ok(()))
+					},
+					Err(err) => {
+						log::error!(target: "runtime::coretime", "burn_at_relay failed: {err:?}");
+						TransactionOutcome::Rollback(Err(DispatchError::Other(
+							"Failed to burn funds on relay chain",
+						)))
+					},
+				}
+			})
+			.defensive_ok();
+		}
 	}
 }
 
@@ -66,11 +135,7 @@ enum CoretimeProviderCalls {
 
 parameter_types! {
 	pub const BrokerPalletId: PalletId = PalletId(*b"py/broke");
-}
-
-parameter_types! {
-	pub storage CoreCount: Option<CoreIndex> = None;
-	pub storage CoretimeRevenue: Option<(BlockNumber, Balance)> = None;
+	pub BurnStashAccount: AccountId = BrokerPalletId::get().into_sub_account_truncating(b"burnstash");
 }
 
 /// Type that implements the `CoretimeInterface` for the allocation of Coretime. Meant to operate
@@ -205,26 +270,25 @@ impl CoretimeInterface for CoretimeAllocator {
 		}
 	}
 
-	fn check_notify_revenue_info() -> Option<(RCBlockNumberOf<Self>, Self::Balance)> {
-		let revenue = CoretimeRevenue::get();
-		CoretimeRevenue::set(&None);
-		revenue
+	fn check_notify_revenue_info(
+	) -> Option<OnDemandRevenueRecord<RCBlockNumberOf<Self>, Self::Balance>> {
+		RevenueInbox::<Runtime>::take()
 	}
 
 	#[cfg(feature = "runtime-benchmarks")]
-	fn ensure_notify_revenue_info(when: RCBlockNumberOf<Self>, revenue: Self::Balance) {
-		CoretimeRevenue::set(&Some((when, revenue)));
+	fn ensure_notify_revenue_info(
+		info: OnDemandRevenueRecord<RCBlockNumberOf<Self>, Self::Balance>,
+	) {
+		RevenueInbox::<Runtime>::put(info);
 	}
 }
 
 impl pallet_broker::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
-	type OnRevenue = CreditToCollatorPot;
-	#[cfg(feature = "fast-runtime")]
-	type TimeslicePeriod = ConstU32<10>;
-	#[cfg(not(feature = "fast-runtime"))]
-	type TimeslicePeriod = ConstU32<80>;
+	type OnRevenue = StashToBurn;
+	type OnNewTimeslice = BurnStash;
+	type TimeslicePeriod = ConstU32<{ coretime::TIMESLICE_PERIOD }>;
 	type MaxLeasedCores = ConstU32<50>;
 	type MaxReservedCores = ConstU32<10>;
 	type Coretime = CoretimeAllocator;