start with main changes

Author: Agusrodri

Cargo.lock

@@ -161,6 +161,7 @@ parachains-common = { workspace = true }
 async-backing-primitives = { workspace = true }
 moonkit-xcm-primitives = { workspace = true }
 nimbus-primitives = { workspace = true }
+pallet-async-backing = { workspace = true }
 pallet-author-inherent = { workspace = true }
 pallet-author-slot-filter = { workspace = true }
 pallet-relay-storage-roots = { workspace = true }
@@ -179,6 +180,7 @@ sha3 = { workspace = true, features = ["std"] }
 cumulus-primitives-parachain-inherent = { workspace = true }
 cumulus-test-relay-sproof-builder = { workspace = true }
 
+sp-timestamp = { workspace = true }
 polkadot-runtime-parachains = { workspace = true }
 xcm-simulator = { workspace = true }
 
@@ -220,6 +222,7 @@ std = [
 	"orml-xtokens/std",
 	"pallet-asset-manager/std",
 	"pallet-assets/std",
+	"pallet-async-backing/std",
 	"pallet-author-inherent/std",
 	"pallet-author-mapping/std",
 	"pallet-author-slot-filter/std",
@@ -370,6 +373,7 @@ try-runtime = [
 	"frame-try-runtime",
 	"moonbeam-runtime-common/try-runtime",
 	"pallet-asset-manager/try-runtime",
+	"pallet-async-backing/try-runtime",
 	"pallet-author-mapping/try-runtime",
 	"pallet-author-slot-filter/try-runtime",
 	"pallet-balances/try-runtime",

runtime/moonbeam/Cargo.toml

@@ -101,6 +101,7 @@ use sp_version::RuntimeVersion;
 
 use nimbus_primitives::CanAuthor;
 
+mod migrations;
 mod precompiles;
 pub use precompiles::{
 	MoonbeamPrecompiles, PrecompileName, FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,
@@ -146,7 +147,7 @@ pub const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(WEIGHT_REF_TIME_PER_
 	.saturating_div(2)
 	.set_proof_size(relay_chain::MAX_POV_SIZE as u64);
 
-pub const MILLISECS_PER_BLOCK: u64 = 12000;
+pub const MILLISECS_PER_BLOCK: u64 = 6_000;
 pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
 pub const HOURS: BlockNumber = MINUTES * 60;
 pub const DAYS: BlockNumber = HOURS * 24;
@@ -668,6 +669,19 @@ impl pallet_ethereum::Config for Runtime {
 	type ExtraDataLength = ConstU32<30>;
 }
 
+/// Maximum number of blocks simultaneously accepted by the Runtime, not yet included
+/// into the relay chain.
+const UNINCLUDED_SEGMENT_CAPACITY: u32 = 3;
+/// How many parachain blocks are processed by the relay chain per parent. Limits the
+/// number of blocks authored per slot.
+const BLOCK_PROCESSING_VELOCITY: u32 = 1;
+
+type ConsensusHook = pallet_async_backing::consensus_hook::FixedVelocityConsensusHook<
+	Runtime,
+	BLOCK_PROCESSING_VELOCITY,
+	UNINCLUDED_SEGMENT_CAPACITY,
+>;
+
 impl cumulus_pallet_parachain_system::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type OnSystemEvent = ();
@@ -676,8 +690,10 @@ impl cumulus_pallet_parachain_system::Config for Runtime {
 	type OutboundXcmpMessageSource = XcmpQueue;
 	type XcmpMessageHandler = XcmpQueue;
 	type ReservedXcmpWeight = ReservedXcmpWeight;
-	type CheckAssociatedRelayNumber = cumulus_pallet_parachain_system::RelayNumberStrictlyIncreases;
-	type ConsensusHook = cumulus_pallet_parachain_system::ExpectParentIncluded;
+	type CheckAssociatedRelayNumber =
+		cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases;
+	//TODO: replace by ConsensusHookWrapperForRelayTimestamp
+	type ConsensusHook = ConsensusHook;
 	type DmpQueue = frame_support::traits::EnqueueWithOrigin<MessageQueue, RelayOrigin>;
 	type WeightInfo = cumulus_pallet_parachain_system::weights::SubstrateWeight<Runtime>;
 }
@@ -768,13 +784,11 @@ impl pallet_parachain_staking::OnInactiveCollator<Runtime> for OnInactiveCollato
 type MonetaryGovernanceOrigin =
 	EitherOfDiverse<EnsureRoot<AccountId>, governance::custom_origins::GeneralAdmin>;
 
-/// TODO:
-/// Temporary type that we should replace by RelayChainSlotProvider once async backing is enabled.
-pub struct StakingRoundSlotProvider;
-impl Get<Slot> for StakingRoundSlotProvider {
+pub struct RelayChainSlotProvider;
+impl Get<Slot> for RelayChainSlotProvider {
 	fn get() -> Slot {
-		let block_number: u64 = frame_system::pallet::Pallet::<Runtime>::block_number().into();
-		Slot::from(block_number)
+		let slot_info = pallet_async_backing::pallet::Pallet::<Runtime>::slot_info();
+		slot_info.unwrap_or_default().0
 	}
 }
 
@@ -815,7 +829,7 @@ impl pallet_parachain_staking::Config for Runtime {
 	type PayoutCollatorReward = PayoutCollatorOrOrbiterReward;
 	type OnInactiveCollator = OnInactiveCollator;
 	type OnNewRound = OnNewRound;
-	type SlotProvider = StakingRoundSlotProvider;
+	type SlotProvider = RelayChainSlotProvider;
 	type WeightInfo = moonbeam_weights::pallet_parachain_staking::WeightInfo<Runtime>;
 	type MaxCandidates = ConstU32<200>;
 	type SlotDuration = ConstU64<12_000>;
@@ -837,6 +851,12 @@ impl pallet_author_slot_filter::Config for Runtime {
 	type WeightInfo = moonbeam_weights::pallet_author_slot_filter::WeightInfo<Runtime>;
 }
 
+impl pallet_async_backing::Config for Runtime {
+	type AllowMultipleBlocksPerSlot = ConstBool<true>;
+	type GetAndVerifySlot = pallet_async_backing::RelaySlot;
+	type ExpectedBlockTime = ConstU64<6000>;
+}
+
 parameter_types! {
 	pub const InitializationPayment: Perbill = Perbill::from_percent(30);
 	pub const RelaySignaturesThreshold: Perbill = Perbill::from_percent(100);
@@ -1103,7 +1123,10 @@ impl pallet_proxy::Config for Runtime {
 
 impl pallet_migrations::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
-	type MigrationsList = (moonbeam_runtime_common::migrations::CommonMigrations<Runtime>,);
+	type MigrationsList = (
+		moonbeam_runtime_common::migrations::CommonMigrations<Runtime>,
+		migrations::MoonbeamMigrations,
+	);
 	type XcmExecutionManager = XcmExecutionManager;
 }
 
@@ -1347,6 +1370,7 @@ construct_runtime! {
 		AuthorFilter: pallet_author_slot_filter::{Pallet, Call, Storage, Event, Config<T>} = 22,
 		AuthorMapping: pallet_author_mapping::{Pallet, Call, Config<T>, Storage, Event<T>} = 23,
 		MoonbeamOrbiters: pallet_moonbeam_orbiters::{Pallet, Call, Storage, Event<T>} = 24,
+		AsyncBacking: pallet_async_backing::{Pallet, Storage} = 25,
 
 		// Handy utilities.
 		Utility: pallet_utility::{Pallet, Call, Event} = 30,
@@ -1572,12 +1596,10 @@ moonbeam_runtime_common::impl_runtime_apis_plus_common! {
 
 	impl async_backing_primitives::UnincludedSegmentApi<Block> for Runtime {
 		fn can_build_upon(
-			_included_hash: <Block as BlockT>::Hash,
-			_slot: async_backing_primitives::Slot,
+			included_hash: <Block as BlockT>::Hash,
+			slot: async_backing_primitives::Slot,
 		) -> bool {
-			// This runtime API can be called only when asynchronous backing is enabled client-side
-			// We return false here to force the client to not use async backing in moonbeam.
-			false
+			ConsensusHook::can_build_upon(included_hash, slot)
 		}
 	}
 }

runtime/moonbeam/src/lib.rs

@@ -0,0 +1,43 @@
+// Copyright 2024 Moonbeam Foundation Inc.
+// This file is part of Moonbeam.
+
+// Moonbeam is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Moonbeam is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.
+
+//! # Moonbeam specific Migrations
+
+use crate::Runtime;
+use frame_support::{traits::OnRuntimeUpgrade, weights::Weight};
+use pallet_migrations::{GetMigrations, Migration};
+use pallet_parachain_staking::migrations::MultiplyRoundLenBy2;
+use sp_std::{prelude::*, vec};
+
+pub struct MoonbeamMigrations;
+
+impl GetMigrations for MoonbeamMigrations {
+	fn get_migrations() -> Vec<Box<dyn Migration>> {
+		vec![Box::new(PalletStakingMultiplyRoundLenBy2)]
+	}
+}
+
+// This migration should only be applied to runtimes with async backing enabled
+pub struct PalletStakingMultiplyRoundLenBy2;
+impl Migration for PalletStakingMultiplyRoundLenBy2 {
+	fn friendly_name(&self) -> &str {
+		"MM_MultiplyRoundLenBy2"
+	}
+
+	fn migrate(&self, _available_weight: Weight) -> Weight {
+		MultiplyRoundLenBy2::<Runtime>::on_runtime_upgrade()
+	}
+}

runtime/moonbeam/src/migrations.rs

@@ -26,12 +26,14 @@ pub use moonbeam_runtime::{
 	asset_config::AssetRegistrarMetadata,
 	currency::{GIGAWEI, GLMR, SUPPLY_FACTOR, WEI},
 	xcm_config::AssetType,
-	AccountId, AssetId, AssetManager, AuthorInherent, Balance, Balances, CrowdloanRewards,
-	Ethereum, Executive, Header, InflationInfo, ParachainStaking, Range, Runtime, RuntimeCall,
-	RuntimeEvent, System, TransactionConverter, TransactionPaymentAsGasPrice, UncheckedExtrinsic,
-	HOURS, WEEKS,
+	AccountId, AssetId, AssetManager, AsyncBacking, AuthorInherent, Balance, Balances,
+	CrowdloanRewards, Ethereum, Executive, Header, InflationInfo, ParachainStaking, Range, Runtime,
+	RuntimeCall, RuntimeEvent, System, TransactionConverter, TransactionPaymentAsGasPrice,
+	UncheckedExtrinsic, HOURS, WEEKS,
 };
 use nimbus_primitives::{NimbusId, NIMBUS_ENGINE_ID};
+use polkadot_parachain::primitives::HeadData;
+use sp_consensus_slots::Slot;
 use sp_core::{Encode, H160};
 use sp_runtime::{traits::Dispatchable, BuildStorage, Digest, DigestItem, Perbill, Percent};
 
@@ -83,6 +85,8 @@ pub fn run_to_block(n: u32, author: Option<NimbusId>) {
 			}
 		}
 
+		increase_last_relay_slot_number(1);
+
 		// Initialize the new block
 		AuthorInherent::on_initialize(System::block_number());
 		ParachainStaking::on_initialize(System::block_number());
@@ -339,8 +343,20 @@ pub fn root_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {
 pub fn set_parachain_inherent_data() {
 	use cumulus_primitives_core::PersistedValidationData;
 	use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;
-	let (relay_parent_storage_root, relay_chain_state) =
-		RelayStateSproofBuilder::default().into_state_root_and_proof();
+
+	let mut relay_sproof = RelayStateSproofBuilder::default();
+	relay_sproof.para_id = 100u32.into();
+	relay_sproof.included_para_head = Some(HeadData(vec![1, 2, 3]));
+
+	let additional_key_values = vec![(
+		moonbeam_core_primitives::well_known_relay_keys::TIMESTAMP_NOW.to_vec(),
+		sp_timestamp::Timestamp::default().encode(),
+	)];
+
+	relay_sproof.additional_key_values = additional_key_values;
+
+	let (relay_parent_storage_root, relay_chain_state) = relay_sproof.into_state_root_and_proof();
+
 	let vfp = PersistedValidationData {
 		relay_parent_number: 1u32,
 		relay_parent_storage_root,
@@ -371,3 +387,11 @@ pub fn ethereum_transaction(raw_hex_tx: &str) -> pallet_ethereum::Transaction {
 	assert!(transaction.is_ok());
 	transaction.unwrap()
 }
+
+pub(crate) fn increase_last_relay_slot_number(amount: u64) {
+	let last_relay_slot = u64::from(AsyncBacking::slot_info().unwrap_or_default().0);
+	frame_support::storage::unhashed::put(
+		&frame_support::storage::storage_prefix(b"AsyncBacking", b"SlotInfo"),
+		&((Slot::from(last_relay_slot + amount), 0)),
+	);
+}

runtime/moonbeam/tests/common/mod.rs

@@ -625,10 +625,9 @@ fn reward_block_authors() {
 		)])
 		.build()
 		.execute_with(|| {
-			set_parachain_inherent_data();
-			for x in 2..3599 {
-				run_to_block(x, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
-			}
+			increase_last_relay_slot_number(1);
+			// Just before round 3
+			run_to_block(7199, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
 			// no rewards doled out yet
 			assert_eq!(
 				Balances::usable_balance(AccountId::from(ALICE)),
@@ -638,7 +637,7 @@ fn reward_block_authors() {
 				Balances::usable_balance(AccountId::from(BOB)),
 				9_950_000 * GLMR,
 			);
-			run_to_block(3601, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
+			run_to_block(7201, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
 			// rewards minted and distributed
 			assert_eq!(
 				Balances::usable_balance(AccountId::from(ALICE)),
@@ -672,14 +671,14 @@ fn reward_block_authors_with_parachain_bond_reserved() {
 		)])
 		.build()
 		.execute_with(|| {
-			set_parachain_inherent_data();
+			increase_last_relay_slot_number(1);
 			assert_ok!(ParachainStaking::set_parachain_bond_account(
 				root_origin(),
 				AccountId::from(CHARLIE),
 			),);
 
 			// Stop just before round 3
-			run_to_block(3599, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
+			run_to_block(7199, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
 			// no collators rewards doled out yet
 			assert_eq!(
 				Balances::usable_balance(AccountId::from(ALICE)),
@@ -696,7 +695,7 @@ fn reward_block_authors_with_parachain_bond_reserved() {
 			);
 
 			// Go to round 3
-			run_to_block(3601, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
+			run_to_block(7201, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));
 
 			// collators rewards minted and distributed
 			assert_eq!(