pallet-dap-satellite: introduce minimal implementation and use it coretime-westend runtime

Author: sigurpol

Cargo.lock

@@ -356,6 +356,7 @@ members = [
 	"substrate/frame/conviction-voting",
 	"substrate/frame/core-fellowship",
 	"substrate/frame/dap",
+	"substrate/frame/dap-satellite",
 	"substrate/frame/delegated-staking",
 	"substrate/frame/democracy",
 	"substrate/frame/derivatives",
@@ -985,6 +986,7 @@ pallet-contracts-uapi = { path = "substrate/frame/contracts/uapi", default-featu
 pallet-conviction-voting = { path = "substrate/frame/conviction-voting", default-features = false }
 pallet-core-fellowship = { path = "substrate/frame/core-fellowship", default-features = false }
 pallet-dap = { path = "substrate/frame/dap", default-features = false }
+pallet-dap-satellite = { path = "substrate/frame/dap-satellite", default-features = false }
 pallet-default-config-example = { path = "substrate/frame/examples/default-config", default-features = false }
 pallet-delegated-staking = { path = "substrate/frame/delegated-staking", default-features = false }
 pallet-democracy = { path = "substrate/frame/democracy", default-features = false }

Cargo.toml

@@ -31,6 +31,7 @@ pallet-aura = { workspace = true }
 pallet-authorship = { workspace = true }
 pallet-balances = { workspace = true }
 pallet-broker = { workspace = true }
+pallet-dap-satellite = { workspace = true }
 pallet-message-queue = { workspace = true }
 pallet-multisig = { workspace = true }
 pallet-proxy = { workspace = true }
@@ -113,6 +114,7 @@ std = [
 	"pallet-balances/std",
 	"pallet-broker/std",
 	"pallet-collator-selection/std",
+	"pallet-dap-satellite/std",
 	"pallet-message-queue/std",
 	"pallet-multisig/std",
 	"pallet-proxy/std",
@@ -167,6 +169,7 @@ runtime-benchmarks = [
 	"pallet-balances/runtime-benchmarks",
 	"pallet-broker/runtime-benchmarks",
 	"pallet-collator-selection/runtime-benchmarks",
+	"pallet-dap-satellite/runtime-benchmarks",
 	"pallet-message-queue/runtime-benchmarks",
 	"pallet-multisig/runtime-benchmarks",
 	"pallet-proxy/runtime-benchmarks",
@@ -202,6 +205,7 @@ try-runtime = [
 	"pallet-balances/try-runtime",
 	"pallet-broker/try-runtime",
 	"pallet-collator-selection/try-runtime",
+	"pallet-dap-satellite/try-runtime",
 	"pallet-message-queue/try-runtime",
 	"pallet-multisig/try-runtime",
 	"pallet-proxy/try-runtime",

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

@@ -18,69 +18,22 @@ use crate::{xcm_config::LocationToAccountId, *};
 use codec::{Decode, Encode};
 use cumulus_pallet_parachain_system::RelaychainDataProvider;
 use cumulus_primitives_core::relay_chain;
-use frame_support::{
-	parameter_types,
-	traits::{
-		fungible::{Balanced, Credit, Inspect},
-		tokens::{Fortitude, Preservation},
-		DefensiveResult, OnUnbalanced,
-	},
-};
-use frame_system::Pallet as System;
+use frame_support::parameter_types;
 use pallet_broker::{
 	CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600, RCBlockNumberOf, TaskId, Timeslice,
 };
 use parachains_common::{AccountId, Balance};
-use sp_runtime::traits::{AccountIdConversion, MaybeConvert};
+use sp_runtime::traits::MaybeConvert;
 use westend_runtime_constants::system_parachain::coretime;
 use xcm::latest::prelude::*;
-use xcm_executor::traits::{ConvertLocation, TransactAsset};
-
-pub struct BurnCoretimeRevenue;
-impl OnUnbalanced<Credit<AccountId, Balances>> for BurnCoretimeRevenue {
-	fn on_nonzero_unbalanced(amount: Credit<AccountId, Balances>) {
-		let acc = RevenueAccumulationAccount::get();
-		if !System::<Runtime>::account_exists(&acc) {
-			System::<Runtime>::inc_providers(&acc);
-		}
-		Balances::resolve(&acc, amount).defensive_ok();
-	}
-}
+use xcm_executor::traits::ConvertLocation;
 
-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(())
-}
+/// Coretime revenue handler that sends funds to the DAP satellite account.
+///
+/// Previously, revenue was accumulated in a stash account and then burned at the relay chain.
+/// With DAP, revenue is accumulated in the satellite account and then periodically sent
+/// to the DAP buffer on AssetHub via XCM.
+pub type CoretimeRevenueToSatellite = pallet_dap_satellite::SlashToSatellite<Runtime>;
 
 /// A type containing the encoding of the coretime pallet in the Relay chain runtime. Used to
 /// construct any remote calls. The codec index must correspond to the index of `Coretime` in the
@@ -112,7 +65,6 @@ enum CoretimeProviderCalls {
 parameter_types! {
 	pub const BrokerPalletId: PalletId = PalletId(*b"py/broke");
 	pub const MinimumCreditPurchase: Balance = UNITS / 10;
-	pub RevenueAccumulationAccount: AccountId = BrokerPalletId::get().into_sub_account_truncating(b"burnstash");
 	pub const MinimumEndPrice: Balance = UNITS;
 }
 
@@ -287,21 +239,9 @@ impl CoretimeInterface for CoretimeAllocator {
 	}
 
 	fn on_new_timeslice(_timeslice: Timeslice) {
-		let stash = RevenueAccumulationAccount::get();
-		let value =
-			Balances::reducible_balance(&stash, Preservation::Expendable, Fortitude::Polite);
-
-		if value > 0 {
-			tracing::debug!(target: "runtime::coretime", %value, "Going to burn stashed tokens at RC");
-			match burn_at_relay(&stash, value) {
-				Ok(()) => {
-					tracing::debug!(target: "runtime::coretime", %value, "Successfully burnt tokens");
-				},
-				Err(err) => {
-					tracing::error!(target: "runtime::coretime", error=?err, "burn_at_relay failed");
-				},
-			}
-		}
+		// With DAP satellite, revenue is already accumulated in the satellite account via
+		// CoretimeRevenueToSatellite (OnRevenue handler). The satellite pallet then sends
+		// accumulated funds to AssetHub DAP via XCM
 	}
 }
 
@@ -317,7 +257,7 @@ impl MaybeConvert<TaskId, AccountId> for SovereignAccountOf {
 impl pallet_broker::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type Currency = Balances;
-	type OnRevenue = BurnCoretimeRevenue;
+	type OnRevenue = CoretimeRevenueToSatellite;
 	type TimeslicePeriod = ConstU32<{ coretime::TIMESLICE_PERIOD }>;
 	// We don't actually need any leases at launch but set to 10 in case we want to sudo some in.
 	type MaxLeasedCores = ConstU32<10>;

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

@@ -612,6 +612,10 @@ impl pallet_sudo::Config for Runtime {
 	type WeightInfo = pallet_sudo::weights::SubstrateWeight<Runtime>;
 }
 
+impl pallet_dap_satellite::Config for Runtime {
+	type Currency = Balances;
+}
+
 pub struct BrokerMigrationV4BlockConversion;
 
 impl pallet_broker::migration::v4::BlockToRelayHeightConversion<Runtime>
@@ -667,6 +671,9 @@ construct_runtime!(
 		// The main stage.
 		Broker: pallet_broker = 50,
 
+		// DAP Satellite - collects funds for eventual transfer to DAP on AssetHub
+		DapSatellite: pallet_dap_satellite = 60,
+
 		// Sudo
 		Sudo: pallet_sudo = 100,
 	}

cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs

@@ -1,16 +1,33 @@
-title: '[DRAFT] PoC DAP'
+title: 'Introduced pallet-dap'
 doc:
 - audience: Runtime Dev
   description: |-
     Initial PoC PR to play around with Dynamic Allocation Proposal here: https://hackmd.io/a0KSL4XHQ1WvcGZlKykGzg
 
-    So far, I am just currently removing treasury burn and staking slashing, redirecting them to the DAP / issuance buffer.
+    Initial version supports the following:
+      - Introduced FundingSink and FundingSource traits in frame-support
+      - Introduced pallet-dap with minimal implementation of FundingSink trait only. This pallet is meant to be
+      deployed on AssetHub as the central DAP pallet.
+      - Redirected treasury unspent to pallet-dap instead of burning
+      - Redirected staking slashes to pallet-dap instead of burning
+      - Introduced pallet-dap-satellite, to collect funds that otherwise would be burned (e.g. tx fees,
+      coretime revenues, ...) into a local satellite account. These funds are accumulated locally and
+      will be sent to pallet-dap periodically in future iterations. This pallet is meant to be deployed
+      on system chains like Coretime, People and BridheHub and on the RelayChain. It should not be deployed
+      on AssetHub, which hosts the central DAP pallet.
+
+    asset-hub-westend-runtime and staking-async test runtime have been modified to include pallet-dap and to send part of slashing and treasury's unspent funds to pallet-dap.
+    coretime-westend-runtime has been updated to include pallet-dap-satellite. Coretime revenues are now accumulated in the pallet-dap-satellite account instead of being burned.
 crates:
 - name: frame-support
   bump: major
 - name: pallet-dap
   bump: major
+- name: pallet-dap-satellite
+  bump: major
 - name: asset-hub-westend-runtime
   bump: major
 - name: pallet-staking-async
   bump: major
+- name: coretime-westend-runtime
+  bump: major

prdoc/pr_10481.prdoc

@@ -0,0 +1,60 @@
+[package]
+name = "pallet-dap-satellite"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "FRAME pallet for DAP Satellite - collects funds for periodic transfer to DAP on AssetHub"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { features = ["derive", "max-encoded-len"], workspace = true }
+frame-benchmarking = { optional = true, workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+log = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+sp-runtime = { workspace = true }
+
+[dev-dependencies]
+pallet-balances = { workspace = true, default-features = true }
+pallet-dap = { workspace = true, default-features = true }
+sp-core = { workspace = true, default-features = true }
+sp-io = { workspace = true, default-features = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-dap/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-dap/try-runtime",
+	"sp-runtime/try-runtime",
+]