xcm-simulator tests (#363)

2026-04-24 20:07:56 +00:00 · 2024-11-26 13:30:00 -05:00
parent 8666cb50c1
commit 9a0e668deb
42 changed files with 1746 additions and 1 deletions
@@ -0,0 +1,248 @@
+pub mod xcm_mock;
+use frame_support::{assert_ok, weights::Weight};
+use parity_scale_codec::Encode;
+use xcm::prelude::*;
+use xcm_mock::*;
+use xcm_simulator::{mock_message_queue::ReceivedDmp, TestExt};
+
+// Helper function for forming buy execution message
+fn buy_execution<C>(fees: impl Into<Asset>) -> Instruction<C> {
+    BuyExecution { fees: fees.into(), weight_limit: Unlimited }
+}
+
+#[test]
+fn remote_account_ids_work() {
+    child_account_account_id(1, ALICE);
+    sibling_account_account_id(1, ALICE);
+    parent_account_account_id(ALICE);
+}
+
+#[test]
+fn dmp() {
+    MockNet::reset();
+
+    let remark = parachain::RuntimeCall::System(
+        frame_system::Call::<parachain::Runtime>::remark_with_event { remark: vec![1, 2, 3] },
+    );
+    Relay::execute_with(|| {
+        assert_ok!(RelayChainPalletXcm::send_xcm(
+            Here,
+            Parachain(1),
+            Xcm(vec![Transact {
+                origin_kind: OriginKind::SovereignAccount,
+                require_weight_at_most: Weight::from_parts(INITIAL_BALANCE as u64, 1024 * 1024),
+                call: remark.encode().into(),
+            }]),
+        ));
+    });
+
+    ParaA::execute_with(|| {
+        use parachain::{RuntimeEvent, System};
+        assert!(System::events().iter().any(|r| matches!(
+            r.event,
+            RuntimeEvent::System(frame_system::Event::Remarked { .. })
+        )));
+    });
+}
+
+#[test]
+fn ump() {
+    MockNet::reset();
+
+    let remark = relay_chain::RuntimeCall::System(
+        frame_system::Call::<relay_chain::Runtime>::remark_with_event { remark: vec![1, 2, 3] },
+    );
+    ParaA::execute_with(|| {
+        assert_ok!(ParachainPalletXcm::send_xcm(
+            Here,
+            Parent,
+            Xcm(vec![Transact {
+                origin_kind: OriginKind::SovereignAccount,
+                require_weight_at_most: Weight::from_parts(INITIAL_BALANCE as u64, 1024 * 1024),
+                call: remark.encode().into(),
+            }]),
+        ));
+    });
+
+    Relay::execute_with(|| {
+        use relay_chain::{RuntimeEvent, System};
+        assert!(System::events().iter().any(|r| matches!(
+            r.event,
+            RuntimeEvent::System(frame_system::Event::Remarked { .. })
+        )));
+    });
+}
+
+#[test]
+fn xcmp() {
+    MockNet::reset();
+
+    let remark = parachain::RuntimeCall::System(
+        frame_system::Call::<parachain::Runtime>::remark_with_event { remark: vec![1, 2, 3] },
+    );
+    ParaA::execute_with(|| {
+        assert_ok!(ParachainPalletXcm::send_xcm(
+            Here,
+            (Parent, Parachain(2)),
+            Xcm(vec![Transact {
+                origin_kind: OriginKind::SovereignAccount,
+                require_weight_at_most: Weight::from_parts(INITIAL_BALANCE as u64, 1024 * 1024),
+                call: remark.encode().into(),
+            }]),
+        ));
+    });
+
+    ParaB::execute_with(|| {
+        use parachain::{RuntimeEvent, System};
+        assert!(System::events().iter().any(|r| matches!(
+            r.event,
+            RuntimeEvent::System(frame_system::Event::Remarked { .. })
+        )));
+    });
+}
+
+#[test]
+fn remote_locking_and_unlocking() {
+    MockNet::reset();
+
+    let locked_amount = 100;
+
+    ParaB::execute_with(|| {
+        let message = Xcm(vec![LockAsset {
+            asset: (Here, locked_amount).into(),
+            unlocker: Parachain(1).into(),
+        }]);
+        assert_ok!(ParachainPalletXcm::send_xcm(Here, Parent, message.clone()));
+    });
+
+    Relay::execute_with(|| {
+        use pallet_balances::{BalanceLock, Reasons};
+        assert_eq!(
+            relay_chain::Balances::locks(child_account_id(2)),
+            vec![BalanceLock { id: *b"py/xcmlk", amount: locked_amount, reasons: Reasons::All }]
+        );
+    });
+
+    ParaA::execute_with(|| {
+        assert_eq!(
+            ReceivedDmp::<parachain::Runtime>::get(),
+            vec![Xcm(vec![NoteUnlockable {
+                owner: (Parent, Parachain(2)).into(),
+                asset: (Parent, locked_amount).into()
+            }])]
+        );
+    });
+
+    ParaB::execute_with(|| {
+        // Request unlocking part of the funds on the relay chain
+        let message = Xcm(vec![RequestUnlock {
+            asset: (Parent, locked_amount - 50).into(),
+            locker: Parent.into(),
+        }]);
+        assert_ok!(ParachainPalletXcm::send_xcm(Here, (Parent, Parachain(1)), message));
+    });
+
+    Relay::execute_with(|| {
+        use pallet_balances::{BalanceLock, Reasons};
+        // Lock is reduced
+        assert_eq!(
+            relay_chain::Balances::locks(child_account_id(2)),
+            vec![BalanceLock {
+                id: *b"py/xcmlk",
+                amount: locked_amount - 50,
+                reasons: Reasons::All
+            }]
+        );
+    });
+}
+
+/// Scenario:
+/// A parachain transfers funds on the relay chain to another parachain account.
+///
+/// Asserts that the parachain accounts are updated as expected.
+#[test]
+fn withdraw_and_deposit() {
+    MockNet::reset();
+
+    let send_amount = 10;
+
+    ParaA::execute_with(|| {
+        let message = Xcm(vec![
+            WithdrawAsset((Here, send_amount).into()),
+            buy_execution((Here, send_amount)),
+            DepositAsset { assets: AllCounted(1).into(), beneficiary: Parachain(2).into() },
+        ]);
+        // Send withdraw and deposit
+        assert_ok!(ParachainPalletXcm::send_xcm(Here, Parent, message.clone()));
+    });
+
+    Relay::execute_with(|| {
+        assert_eq!(
+            relay_chain::Balances::free_balance(child_account_id(1)),
+            INITIAL_BALANCE - send_amount
+        );
+        assert_eq!(
+            relay_chain::Balances::free_balance(child_account_id(2)),
+            INITIAL_BALANCE + send_amount
+        );
+    });
+}
+
+/// Scenario:
+/// A parachain wants to be notified that a transfer worked correctly.
+/// It sends a `QueryHolding` after the deposit to get notified on success.
+///
+/// Asserts that the balances are updated correctly and the expected XCM is sent.
+#[test]
+fn query_holding() {
+    MockNet::reset();
+
+    let send_amount = 10;
+    let query_id_set = 1234;
+
+    // Send a message which fully succeeds on the relay chain
+    ParaA::execute_with(|| {
+        let message = Xcm(vec![
+            WithdrawAsset((Here, send_amount).into()),
+            buy_execution((Here, send_amount)),
+            DepositAsset { assets: AllCounted(1).into(), beneficiary: Parachain(2).into() },
+            ReportHolding {
+                response_info: QueryResponseInfo {
+                    destination: Parachain(1).into(),
+                    query_id: query_id_set,
+                    max_weight: Weight::from_parts(1_000_000_000, 1024 * 1024),
+                },
+                assets: All.into(),
+            },
+        ]);
+        // Send withdraw and deposit with query holding
+        assert_ok!(ParachainPalletXcm::send_xcm(Here, Parent, message.clone(),));
+    });
+
+    // Check that transfer was executed
+    Relay::execute_with(|| {
+        // Withdraw executed
+        assert_eq!(
+            relay_chain::Balances::free_balance(child_account_id(1)),
+            INITIAL_BALANCE - send_amount
+        );
+        // Deposit executed
+        assert_eq!(
+            relay_chain::Balances::free_balance(child_account_id(2)),
+            INITIAL_BALANCE + send_amount
+        );
+    });
+
+    // Check that QueryResponse message was received
+    ParaA::execute_with(|| {
+        assert_eq!(
+            ReceivedDmp::<parachain::Runtime>::get(),
+            vec![Xcm(vec![QueryResponse {
+                query_id: query_id_set,
+                response: Response::Assets(Assets::new()),
+                max_weight: Weight::from_parts(1_000_000_000, 1024 * 1024),
+                querier: Some(Here.into()),
+            }])],
+        );
+    });
+}