feat: unified trade events

integration-tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "runtime-integration-tests"
-version = "1.26.0"
+version = "1.27.0"
 description = "Integration tests"
 authors = ["GalacticCouncil"]
 edition = "2021"
@@ -44,6 +44,7 @@ pallet-evm-accounts = { workspace = true }
 pallet-xyk-liquidity-mining = { workspace = true }
 pallet-transaction-pause = { workspace = true }
 pallet-liquidation = { workspace = true }
+pallet-support = { workspace = true }
 
 pallet-treasury = { workspace = true }
 pallet-democracy = { workspace = true }
@@ -221,6 +222,7 @@ std = [
     "precompile-utils/std",
     "pallet-transaction-pause/std",
     "pallet-liquidation/std",
+    "pallet-support/std",
 ]
 
 # we don't include integration tests when benchmarking feature is enabled

integration-tests/src/cross_chain_transfer.rs

@@ -110,7 +110,7 @@ fn rococo_should_receive_asset_when_sent_from_hydra() {
 	Rococo::execute_with(|| {
 		assert_eq!(
 			hydradx_runtime::Balances::free_balance(AccountId::from(BOB)),
-			2_999_989_698_923 // 3 * HDX - fee
+			2_999_989_606_492 // 3 * HDX - fee
 		);
 	});
 }

integration-tests/src/dca.rs

@@ -24,6 +24,7 @@ use pallet_dca::types::{Order, Schedule};
 use pallet_omnipool::types::Tradability;
 use pallet_stableswap::types::AssetAmount;
 use pallet_stableswap::MAX_ASSETS_IN_POOL;
+use pallet_support::types::*;
 use primitives::{AssetId, Balance};
 use sp_runtime::traits::ConstU32;
 use sp_runtime::DispatchError;
@@ -201,6 +202,99 @@ mod omnipool {
 		});
 	}
 
+	#[test]
+	fn buy_schedule_execution_should_emit_swapped_events() {
+		TestNet::reset();
+		Hydra::execute_with(|| {
+			//Arrange
+			init_omnipool_with_oracle_for_block_10();
+
+			let dca_budget = 1000 * UNITS;
+			let amount_out = 100 * UNITS;
+			let schedule_id = 0;
+			let schedule1 = schedule_fake_with_buy_order(PoolType::Omnipool, HDX, DAI, amount_out, dca_budget);
+			create_schedule(ALICE, schedule1);
+
+			//Act
+			run_to_block(11, 12);
+
+			//Assert
+			let swapped_events = get_last_swapped_events();
+			let last_two_swapped_events = &get_last_swapped_events()[swapped_events.len() - 2..];
+			pretty_assertions::assert_eq!(
+				last_two_swapped_events,
+				vec![
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactOut,
+						inputs: vec![Asset::new(HDX, 140421094367051)],
+						outputs: vec![Asset::new(LRNA, 70210545436437)],
+						fees: vec![Fee::new(LRNA, 35105272718, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 0),
+							ExecutionType::Router(1),
+							ExecutionType::Omnipool(2)
+						]
+					}),
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactOut,
+						inputs: vec![Asset::new(LRNA, 70175440163719)],
+						outputs: vec![Asset::new(DAI, amount_out)],
+						fees: vec![Fee::new(DAI, 250626566417, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 0),
+							ExecutionType::Router(1),
+							ExecutionType::Omnipool(2)
+						],
+					})
+				]
+			);
+
+			run_to_block(13, 17);
+
+			let swapped_events = get_last_swapped_events();
+			let last_two_swapped_events = &get_last_swapped_events()[swapped_events.len() - 2..];
+			pretty_assertions::assert_eq!(
+				last_two_swapped_events,
+				vec![
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactOut,
+						inputs: vec![Asset::new(HDX, 140421107716515)],
+						outputs: vec![Asset::new(LRNA, 70210548448729)],
+						fees: vec![Fee::new(LRNA, 35105274224, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 3),
+							ExecutionType::Router(4),
+							ExecutionType::Omnipool(5)
+						],
+					}),
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactOut,
+						inputs: vec![Asset::new(LRNA, 70175443174505)],
+						outputs: vec![Asset::new(DAI, amount_out)],
+						fees: vec![Fee::new(DAI, 250626566417, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 3),
+							ExecutionType::Router(4),
+							ExecutionType::Omnipool(5)
+						],
+					})
+				]
+			);
+		});
+	}
+
 	#[test]
 	fn buy_schedule_execution_should_work_without_route() {
 		TestNet::reset();
@@ -588,6 +682,106 @@ mod omnipool {
 		});
 	}
 
+	#[test]
+	fn sell_schedule_execution_should_emit_swapped_event() {
+		TestNet::reset();
+		Hydra::execute_with(|| {
+			//Arrange
+			init_omnipool_with_oracle_for_block_10();
+			let alice_init_hdx_balance = 5000 * UNITS;
+			assert_ok!(Balances::force_set_balance(
+				RuntimeOrigin::root(),
+				ALICE.into(),
+				alice_init_hdx_balance,
+			));
+
+			let dca_budget = 1100 * UNITS;
+			let amount_to_sell = 100 * UNITS;
+			let schedule_id = 0;
+			let schedule1 =
+				schedule_fake_with_sell_order(ALICE, PoolType::Omnipool, dca_budget, HDX, DAI, amount_to_sell);
+			create_schedule(ALICE, schedule1);
+
+			//Act
+			run_to_block(11, 12);
+
+			//Assert
+			let swapped_events = get_last_swapped_events();
+			let last_two_swapped_events = &get_last_swapped_events()[swapped_events.len() - 2..];
+			pretty_assertions::assert_eq!(
+				last_two_swapped_events,
+				vec![
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactIn,
+						inputs: vec![Asset::new(HDX, amount_to_sell)],
+						outputs: vec![Asset::new(LRNA, 49999999159957)],
+						fees: vec![Fee::new(LRNA, 24999999579, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 0),
+							ExecutionType::Router(1),
+							ExecutionType::Omnipool(2)
+						],
+					}),
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactIn,
+						inputs: vec![Asset::new(LRNA, 49974999160378)],
+						outputs: vec![Asset::new(DAI, 71214372624126)],
+						fees: vec![Fee::new(DAI, 178482136903, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 0),
+							ExecutionType::Router(1),
+							ExecutionType::Omnipool(2)
+						],
+					})
+				]
+			);
+
+			run_to_block(13, 17);
+
+			let swapped_events = get_last_swapped_events();
+			let last_two_swapped_events = &get_last_swapped_events()[swapped_events.len() - 2..];
+			pretty_assertions::assert_eq!(
+				last_two_swapped_events,
+				vec![
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactIn,
+						inputs: vec![Asset::new(HDX, amount_to_sell)],
+						outputs: vec![Asset::new(LRNA, 49999997360044)],
+						fees: vec![Fee::new(LRNA, 24999998680, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 3),
+							ExecutionType::Router(4),
+							ExecutionType::Omnipool(5)
+						],
+					}),
+					RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+						swapper: ALICE.into(),
+						filler: Omnipool::protocol_account(),
+						filler_type: pallet_support::types::Filler::Omnipool,
+						operation: pallet_support::types::TradeOperation::ExactIn,
+						inputs: vec![Asset::new(LRNA, 49974997361364)],
+						outputs: vec![Asset::new(DAI, 71214367826179)],
+						fees: vec![Fee::new(DAI, 178482124878, Omnipool::protocol_account()),],
+						operation_stack: vec![
+							ExecutionType::DCA(schedule_id, 3),
+							ExecutionType::Router(4),
+							ExecutionType::Omnipool(5)
+						],
+					})
+				]
+			);
+		});
+	}
+
 	#[test]
 	fn sell_schedule_be_retried_when_route_is_invalid() {
 		TestNet::reset();
@@ -4032,7 +4226,6 @@ pub fn run_to_block(from: BlockNumber, to: BlockNumber) {
 	for b in from..=to {
 		do_trade_to_populate_oracle(DAI, HDX, UNITS);
 		set_relaychain_block_number(b);
-		do_trade_to_populate_oracle(DAI, HDX, UNITS);
 	}
 }
 

integration-tests/src/exchange_asset.rs

@@ -7,7 +7,12 @@ use frame_support::traits::fungible::Balanced;
 use frame_support::traits::tokens::Precision;
 use frame_support::weights::Weight;
 use frame_support::{assert_ok, pallet_prelude::*};
-use hydradx_runtime::AssetRegistry;
+use hydradx_runtime::Omnipool;
+use hydradx_runtime::Router;
+use hydradx_runtime::RuntimeEvent;
+use hydradx_runtime::RuntimeOrigin;
+use hydradx_runtime::TempAccountForXcmAssetExchange;
+use hydradx_runtime::{AssetRegistry, LRNA};
 use hydradx_traits::AssetKind;
 use hydradx_traits::Create;
 use orml_traits::currency::MultiCurrency;
@@ -21,7 +26,6 @@ use sp_runtime::DispatchResult;
 use sp_runtime::{FixedU128, Permill, TransactionOutcome};
 use sp_std::sync::Arc;
 use xcm_emulator::TestExt;
-
 pub const SELL: bool = true;
 pub const BUY: bool = false;
 
@@ -120,6 +124,86 @@ fn hydra_should_swap_assets_when_receiving_from_acala_with_sell() {
 		// We receive about 39_101 HDX (HDX is super cheap in our test)
 		let received = 39_101 * UNITS + BOB_INITIAL_NATIVE_BALANCE + 207_131_554_396;
 		assert_eq!(hydradx_runtime::Balances::free_balance(AccountId::from(BOB)), received);
+
+		let last_swapped_events = get_last_swapped_events();
+		let last_two_swapped_events = &last_swapped_events[last_swapped_events.len() - 2..];
+		let topic_id = [
+			180, 44, 225, 230, 61, 43, 219, 219, 222, 9, 44, 219, 86, 193, 219, 212, 120, 169, 197, 209, 39, 180, 219,
+			225, 224, 182, 134, 141, 41, 162, 96, 54,
+		];
+		pretty_assertions::assert_eq!(
+			last_two_swapped_events,
+			vec![
+				RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+					swapper: TempAccountForXcmAssetExchange::get(),
+					filler: Omnipool::protocol_account(),
+					filler_type: pallet_support::types::Filler::Omnipool,
+					operation: pallet_support::types::TradeOperation::ExactIn,
+					inputs: vec![pallet_support::types::Asset::new(ACA, 50000000000000),],
+					outputs: vec![pallet_support::types::Asset::new(LRNA::get(), 49180327868852)],
+					fees: vec![Fee::new(LRNA::get(), 24590163934, Omnipool::protocol_account()),],
+					operation_stack: vec![
+						ExecutionType::Xcm(topic_id, 0),
+						ExecutionType::XcmExchange(1),
+						ExecutionType::Router(2),
+						ExecutionType::Omnipool(3)
+					],
+				}),
+				RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+					swapper: TempAccountForXcmAssetExchange::get(),
+					filler: Omnipool::protocol_account(),
+					filler_type: pallet_support::types::Filler::Omnipool,
+					operation: pallet_support::types::TradeOperation::ExactIn,
+					inputs: vec![pallet_support::types::Asset::new(LRNA::get(), 49155737704918),],
+					outputs: vec![pallet_support::types::Asset::new(HDX, 39101207131554396)],
+					fees: vec![Fee::new(HDX, 97998012861039, Omnipool::protocol_account()),],
+					operation_stack: vec![
+						ExecutionType::Xcm(topic_id, 0),
+						ExecutionType::XcmExchange(1),
+						ExecutionType::Router(2),
+						ExecutionType::Omnipool(3)
+					],
+				})
+			]
+		);
+
+		//We assert that another trade doesnt have the xcm exchange type on stack
+		assert_ok!(Router::sell(
+			RuntimeOrigin::signed(ALICE.into()),
+			HDX,
+			ACA,
+			1 * UNITS,
+			0,
+			vec![],
+		));
+
+		let last_swapped_events = get_last_swapped_events();
+		let last_two_swapped_events = &last_swapped_events[last_swapped_events.len() - 2..];
+		pretty_assertions::assert_eq!(
+			last_two_swapped_events,
+			vec![
+				RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+					swapper: ALICE.into(),
+					filler: Omnipool::protocol_account(),
+					filler_type: pallet_support::types::Filler::Omnipool,
+					operation: pallet_support::types::TradeOperation::ExactIn,
+					inputs: vec![pallet_support::types::Asset::new(HDX, 1 * UNITS),],
+					outputs: vec![pallet_support::types::Asset::new(LRNA::get(), 1308673515)],
+					fees: vec![Fee::new(LRNA::get(), 654336, Omnipool::protocol_account()),],
+					operation_stack: vec![ExecutionType::Router(4), ExecutionType::Omnipool(5)],
+				}),
+				RuntimeEvent::AmmSupport(pallet_support::Event::Swapped {
+					swapper: ALICE.into(),
+					filler: Omnipool::protocol_account(),
+					filler_type: pallet_support::types::Filler::Omnipool,
+					operation: pallet_support::types::TradeOperation::ExactIn,
+					inputs: vec![pallet_support::types::Asset::new(LRNA::get(), 1308019179),],
+					outputs: vec![pallet_support::types::Asset::new(ACA, 1348602600)],
+					fees: vec![Fee::new(ACA, 3379957, Omnipool::protocol_account()),],
+					operation_stack: vec![ExecutionType::Router(4), ExecutionType::Omnipool(5)],
+				})
+			]
+		);
 	});
 }
 
@@ -1143,6 +1227,7 @@ fn half(asset: &Asset) -> Asset {
 		id: asset.clone().id,
 	}
 }
+use pallet_support::types::{ExecutionType, Fee};
 use rococo_runtime::xcm_config::BaseXcmWeight;
 use xcm_builder::FixedWeightBounds;
 use xcm_executor::traits::WeightBounds;