feat!: XCM Rate Limiter Integration

integration-tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "runtime-integration-tests"
-version = "1.9.1"
+version = "1.9.2"
 description = "Integration tests"
 authors = ["GalacticCouncil"]
 edition = "2021"

integration-tests/src/lib.rs

@@ -17,6 +17,7 @@ mod polkadot_test_net;
 mod staking;
 mod transact_call_filter;
 mod vesting;
+mod xcm_rate_limiter;
 
 #[macro_export]
 macro_rules! assert_balance {

integration-tests/src/xcm_rate_limiter.rs

@@ -0,0 +1,253 @@
+#![cfg(test)]
+
+use crate::polkadot_test_net::*;
+
+use frame_support::{assert_ok, pallet_prelude::Weight};
+use orml_traits::currency::MultiCurrency;
+use pallet_asset_registry::AssetType;
+use polkadot_xcm::prelude::*;
+use xcm_emulator::TestExt;
+
+/// Returns the message hash in the `XcmpMessageSent` event at the `n`th last event (1-indexed, so if the second to last
+/// event has the hash, pass `2`);
+fn get_message_hash_from_event(n: usize) -> Option<[u8; 32]> {
+	use cumulus_pallet_xcmp_queue::Event;
+	use hydradx_runtime::RuntimeEvent;
+	let RuntimeEvent::XcmpQueue(Event::XcmpMessageSent { message_hash }) = &last_hydra_events(n)[0] else {
+		panic!("expecting to find message sent event");
+	};
+	*message_hash
+}
+
+#[test]
+fn xcm_rate_limiter_should_limit_aca_when_limit_is_exceeded() {
+	// Arrange
+	TestNet::reset();
+
+	Hydra::execute_with(|| {
+		assert_ok!(hydradx_runtime::AssetRegistry::set_location(
+			hydradx_runtime::RuntimeOrigin::root(),
+			ACA,
+			hydradx_runtime::AssetLocation(MultiLocation::new(1, X2(Parachain(ACALA_PARA_ID), GeneralIndex(0))))
+		));
+
+		// set an xcm rate limit
+		assert_ok!(hydradx_runtime::AssetRegistry::update(
+			hydradx_runtime::RuntimeOrigin::root(),
+			ACA,
+			b"ACA".to_vec(),
+			AssetType::Token,
+			None,
+			Some(50 * UNITS),
+		));
+
+		assert_eq!(hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)), 0);
+
+		//Set it to same as the relay block number should be in XcmDeferFilter
+		//since we use different RelayChainBlockNumberProvider in runtime-benchmark feature
+		//where we return frame_system current time
+		frame_system::Pallet::<hydradx_runtime::Runtime>::set_block_number(4);
+	});
+
+	let amount = 100 * UNITS;
+	let mut message_hash = None;
+	Acala::execute_with(|| {
+		// Act
+		assert_ok!(hydradx_runtime::XTokens::transfer(
+			hydradx_runtime::RuntimeOrigin::signed(ALICE.into()),
+			0,
+			amount,
+			Box::new(
+				MultiLocation::new(
+					1,
+					X2(
+						Junction::Parachain(HYDRA_PARA_ID),
+						Junction::AccountId32 { id: BOB, network: None }
+					)
+				)
+				.into()
+			),
+			WeightLimit::Limited(Weight::from_ref_time(399_600_000_000))
+		));
+
+		message_hash = get_message_hash_from_event(2);
+
+		// Assert
+		assert_eq!(
+			hydradx_runtime::Balances::free_balance(&AccountId::from(ALICE)),
+			ALICE_INITIAL_NATIVE_BALANCE - amount
+		);
+	});
+
+	Hydra::execute_with(|| {
+		expect_hydra_events(vec![
+			cumulus_pallet_xcmp_queue::Event::XcmDeferred {
+				sender: ACALA_PARA_ID.into(),
+				sent_at: 3,
+				deferred_to: 604, // received at 4 plus 600 blocks of deferral
+				message_hash,
+			}
+			.into(),
+			pallet_relaychain_info::Event::CurrentBlockNumbers {
+				parachain_block_number: 4,
+				relaychain_block_number: 5,
+			}
+			.into(),
+		]);
+		assert_eq!(hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)), 0);
+	});
+}
+
+#[test]
+fn xcm_rate_limiter_should_not_limit_aca_when_limit_is_not_exceeded() {
+	// Arrange
+	TestNet::reset();
+
+	Hydra::execute_with(|| {
+		assert_ok!(hydradx_runtime::AssetRegistry::set_location(
+			hydradx_runtime::RuntimeOrigin::root(),
+			ACA,
+			hydradx_runtime::AssetLocation(MultiLocation::new(1, X2(Parachain(ACALA_PARA_ID), GeneralIndex(0))))
+		));
+
+		// set an xcm rate limit
+		assert_ok!(hydradx_runtime::AssetRegistry::update(
+			hydradx_runtime::RuntimeOrigin::root(),
+			ACA,
+			b"ACA".to_vec(),
+			AssetType::Token,
+			None,
+			Some(101 * UNITS),
+		));
+	});
+
+	let amount = 100 * UNITS;
+	Acala::execute_with(|| {
+		// Act
+		assert_ok!(hydradx_runtime::XTokens::transfer(
+			hydradx_runtime::RuntimeOrigin::signed(ALICE.into()),
+			0,
+			amount,
+			Box::new(
+				MultiLocation::new(
+					1,
+					X2(
+						Junction::Parachain(HYDRA_PARA_ID),
+						Junction::AccountId32 { id: BOB, network: None }
+					)
+				)
+				.into()
+			),
+			WeightLimit::Limited(Weight::from_ref_time(399_600_000_000))
+		));
+
+		// Assert
+		assert_eq!(
+			hydradx_runtime::Balances::free_balance(&AccountId::from(ALICE)),
+			ALICE_INITIAL_NATIVE_BALANCE - amount
+		);
+	});
+
+	Hydra::execute_with(|| {
+		let fee = hydradx_runtime::Tokens::free_balance(ACA, &hydradx_runtime::Treasury::account_id());
+		assert_eq!(
+			hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)),
+			amount - fee
+		);
+	});
+}
+
+#[test]
+fn deferred_messages_should_be_executable_by_root() {
+	// Arrange
+	TestNet::reset();
+
+	Hydra::execute_with(|| {
+		assert_ok!(hydradx_runtime::AssetRegistry::set_location(
+			hydradx_runtime::RuntimeOrigin::root(),
+			ACA,
+			hydradx_runtime::AssetLocation(MultiLocation::new(1, X2(Parachain(ACALA_PARA_ID), GeneralIndex(0))))
+		));
+
+		// set an xcm rate limit
+		assert_ok!(hydradx_runtime::AssetRegistry::update(
+			hydradx_runtime::RuntimeOrigin::root(),
+			ACA,
+			b"ACA".to_vec(),
+			AssetType::Token,
+			None,
+			Some(50 * UNITS),
+		));
+
+		assert_eq!(hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)), 0);
+
+		//Set it to same as the relay block number should be in XcmDeferFilter
+		//since we use different RelayChainBlockNumberProvider in runtime-benchmark feature
+		//where we return frame_system current time
+		frame_system::Pallet::<hydradx_runtime::Runtime>::set_block_number(4);
+	});
+
+	let amount = 100 * UNITS;
+	let mut message_hash = None;
+	let max_weight = Weight::from_ref_time(399_600_000_000);
+	Acala::execute_with(|| {
+		// Act
+		assert_ok!(hydradx_runtime::XTokens::transfer(
+			hydradx_runtime::RuntimeOrigin::signed(ALICE.into()),
+			0,
+			amount,
+			Box::new(
+				MultiLocation::new(
+					1,
+					X2(
+						Junction::Parachain(HYDRA_PARA_ID),
+						Junction::AccountId32 { id: BOB, network: None }
+					)
+				)
+				.into()
+			),
+			WeightLimit::Limited(max_weight),
+		));
+
+		message_hash = get_message_hash_from_event(2);
+
+		// Assert
+		assert_eq!(
+			hydradx_runtime::Balances::free_balance(&AccountId::from(ALICE)),
+			ALICE_INITIAL_NATIVE_BALANCE - amount
+		);
+	});
+
+	Hydra::execute_with(|| {
+		expect_hydra_events(vec![
+			cumulus_pallet_xcmp_queue::Event::XcmDeferred {
+				sender: ACALA_PARA_ID.into(),
+				sent_at: 3,
+				deferred_to: 604, // received at 4 plus 600 blocks of deferral
+				message_hash,
+			}
+			.into(),
+			pallet_relaychain_info::Event::CurrentBlockNumbers {
+				parachain_block_number: 4,
+				relaychain_block_number: 5,
+			}
+			.into(),
+		]);
+		assert_eq!(hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)), 0);
+
+		set_relaychain_block_number(604);
+
+		assert_eq!(hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)), 0);
+		assert_ok!(hydradx_runtime::XcmpQueue::service_deferred(
+			hydradx_runtime::RuntimeOrigin::root(),
+			max_weight,
+			ACALA_PARA_ID.into(),
+		));
+
+		let fee = hydradx_runtime::Tokens::free_balance(ACA, &hydradx_runtime::Treasury::account_id());
+		assert_eq!(
+			hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)),
+			amount - fee
+		);
+	});
+}

pallets/xcm-rate-limiter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-xcm-rate-limiter"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["GalacticCouncil <hydradx@galacticcouncil.io>"]
 edition = "2021"
 license = "Apache-2.0"

pallets/xcm-rate-limiter/src/lib.rs

@@ -164,16 +164,6 @@
 	impl<T: Config> Pallet<T> {}
 }
 
-fn get_loc_and_amount(m: &MultiAsset) -> Option<(MultiLocation, u128)> {
-	match m.id {
-		AssetId::Concrete(location) => match m.fun {
-			Fungibility::Fungible(amount) => Some((location, amount)),
-			_ => None,
-		},
-		_ => None,
-	}
-}
-
 impl<T: Config> Pallet<T> {
 	fn get_locations_and_amounts(instruction: &Instruction<T::RuntimeCall>) -> Vec<(MultiLocation, u128)> {
 		use Instruction::*;
@@ -187,6 +177,16 @@
 	}
 }
 
+fn get_loc_and_amount(m: &MultiAsset) -> Option<(MultiLocation, u128)> {
+	match m.id {
+		AssetId::Concrete(location) => match m.fun {
+			Fungibility::Fungible(amount) => Some((location, amount)),
+			_ => None,
+		},
+		_ => None,
+	}
+}
+
 impl<T: Config> XcmDeferFilter<T::RuntimeCall> for Pallet<T> {
 	fn deferred_by(
 		_para: polkadot_parachain::primitives::Id,

runtime/hydradx/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hydradx-runtime"
-version = "172.0.0"
+version = "173.0.0"
 authors = ["GalacticCouncil"]
 edition = "2021"
 license = "Apache 2.0"

runtime/hydradx/src/lib.rs

@@ -94,7 +94,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	spec_name: create_runtime_str!("hydradx"),
 	impl_name: create_runtime_str!("hydradx"),
 	authoring_version: 1,
-	spec_version: 172,
+	spec_version: 173,
 	impl_version: 0,
 	apis: RUNTIME_API_VERSIONS,
 	transaction_version: 1,
@@ -158,6 +158,7 @@ construct_runtime!(
 		Router: pallet_route_executor = 67,
 		DynamicFees: pallet_dynamic_fees = 68,
 		Staking: pallet_staking = 69,
+		XcmRateLimiter: pallet_xcm_rate_limiter = 70,
 		Bonds: pallet_bonds = 71,
 
 		// ORML related modules