feat!: xcm transfer rate limit pallet

integration-tests/Cargo.toml

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

integration-tests/src/cross_chain_transfer.rs

@@ -110,7 +110,7 @@ fn hydra_should_receive_asset_when_transferred_from_acala() {
 	Hydra::execute_with(|| {
 		assert_ok!(hydradx_runtime::AssetRegistry::set_location(
 			hydradx_runtime::RuntimeOrigin::root(),
-			1,
+			ACA,
 			hydradx_runtime::AssetLocation(MultiLocation::new(1, X2(Parachain(ACALA_PARA_ID), GeneralIndex(0))))
 		));
 	});
@@ -144,11 +144,11 @@ fn hydra_should_receive_asset_when_transferred_from_acala() {
 	let fee = 400641025641;
 	Hydra::execute_with(|| {
 		assert_eq!(
-			hydradx_runtime::Tokens::free_balance(1, &AccountId::from(BOB)),
-			1_030 * UNITS - fee
+			hydradx_runtime::Tokens::free_balance(ACA, &AccountId::from(BOB)),
+			30 * UNITS - fee
 		);
 		assert_eq!(
-			hydradx_runtime::Tokens::free_balance(1, &hydradx_runtime::Treasury::account_id()),
+			hydradx_runtime::Tokens::free_balance(ACA, &hydradx_runtime::Treasury::account_id()),
 			fee // fees should go to treasury
 		);
 	});

integration-tests/src/lib.rs

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

integration-tests/src/polkadot_test_net.rs

@@ -47,6 +47,7 @@ pub const DAI: AssetId = 2;
 pub const DOT: AssetId = 3;
 pub const ETH: AssetId = 4;
 pub const BTC: AssetId = 5;
+pub const ACA: AssetId = 6;
 
 decl_test_relay_chain! {
 	pub struct PolkadotRelay {
@@ -196,6 +197,7 @@ pub fn hydra_ext() -> sp_io::TestExternalities {
 			(b"DOT".to_vec(), 1_000u128, Some(DOT)),
 			(b"ETH".to_vec(), 1_000u128, Some(ETH)),
 			(b"BTC".to_vec(), 1_000u128, Some(BTC)),
+			(b"ACA".to_vec(), 1_000u128, Some(ACA)),
 		],
 		native_asset_name: b"HDX".to_vec(),
 		native_existential_deposit: existential_deposit,
@@ -242,6 +244,7 @@ pub fn hydra_ext() -> sp_io::TestExternalities {
 		currencies: vec![
 			(LRNA, Price::from(1)),
 			(DAI, Price::from(1)),
+			(ACA, Price::from(1)),
 			(BTC, Price::from_inner(134_000_000)),
 		],
 		account_currencies: vec![],
@@ -322,7 +325,7 @@ pub fn last_hydra_events(n: usize) -> Vec<hydradx_runtime::RuntimeEvent> {
 }
 
 pub fn expect_hydra_events(e: Vec<hydradx_runtime::RuntimeEvent>) {
-	assert_eq!(last_hydra_events(e.len()), e);
+	pretty_assertions::assert_eq!(last_hydra_events(e.len()), e);
 }
 
 pub fn set_relaychain_block_number(number: BlockNumber) {

integration-tests/src/xcm_rate_limiter.rs

@@ -0,0 +1,244 @@
+#![cfg(test)]
+
+use crate::polkadot_test_net::*;
+
+use common_runtime::Weight;
+use frame_support::assert_ok;
+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);
+	});
+
+	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: 1,
+				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);
+	});
+
+	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: 1,
+				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
+		);
+	});
+}

math/Cargo.toml

@@ -6,7 +6,7 @@ license = 'Apache-2.0'
 name = "hydra-dx-math"
 description = "A collection of utilities to make performing liquidity pool calculations more convenient."
 repository = '/~https://github.com/galacticcouncil/hydradx-math'
-version = "7.2.0"
+version = "7.2.1"
 
 [dependencies]
 primitive-types = {default-features = false, version = '0.12.0'}

math/src/lib.rs

@@ -23,6 +23,7 @@ pub mod lbp;
 pub mod liquidity_mining;
 pub mod omnipool;
 pub mod omnipool_subpools;
+pub mod rate_limiter;
 pub mod ratio;
 pub mod stableswap;
 pub mod support;

math/src/rate_limiter/math.rs

@@ -0,0 +1,45 @@
+use sp_arithmetic::traits::SaturatedConversion;
+
+use crate::types::Balance;
+
+/// Calculate how long to defer something based on ratio between `rate_limit` and `total_accumulated`.
+/// Will return 0 if `total_accumulated` is less than `rate_limit`.
+/// 2x `rate_limit` accumulated tokens will be deferred by `defer_duration`.
+pub fn calculate_deferred_duration(defer_duration: u32, rate_limit: Balance, total_accumulated: Balance) -> u32 {
+	let defer_duration: u128 = defer_duration.max(1).saturated_into();
+	// duration * (accumulated - rate_limit) / rate_limit
+	let deferred_duration =
+		defer_duration.saturating_mul(total_accumulated.saturating_sub(rate_limit)) / rate_limit.max(1);
+
+	deferred_duration.saturated_into()
+}
+
+/// Calculate how much balance has accumulated by decaying the previous `accumulated_amount` based on
+/// `blocks_since_last_update` and adding `incoming_amount`.
+pub fn calculate_new_accumulated_amount(
+	defer_duration: u32,
+	rate_limit: Balance,
+	incoming_amount: Balance,
+	accumulated_amount: Balance,
+	blocks_since_last_update: u32,
+) -> Balance {
+	incoming_amount.saturating_add(decay_accumulated_amount(
+		defer_duration,
+		rate_limit,
+		accumulated_amount,
+		blocks_since_last_update,
+	))
+}
+
+/// Calculate how much the `accumulated_amount` has decayed based on `blocks_since_last_update` and `rate_limit`.
+pub fn decay_accumulated_amount(
+	defer_duration: u32,
+	rate_limit: Balance,
+	accumulated_amount: Balance,
+	blocks_since_last_update: u32,
+) -> Balance {
+	let defer_duration: u128 = defer_duration.max(1).saturated_into();
+	// acc - rate_limit * blocks / duration
+	accumulated_amount
+		.saturating_sub(rate_limit.saturating_mul(blocks_since_last_update.saturated_into()) / defer_duration)
+}

math/src/rate_limiter/mod.rs

@@ -0,0 +1,6 @@
+pub mod math;
+
+#[cfg(test)]
+mod tests;
+
+pub use math::*;