Merge branch 'dami/xcm-asset-hub' of github.com:polytope-labs/hyperbridge into dami/xcm-asset-hub

# Conflicts:
#	modules/pallets/testsuite/src/tests/pallet_xcm_gateway.rs
#	modules/pallets/testsuite/src/xcm.rs

Author: dharjeezy

modules/pallets/testsuite/Cargo.toml

@@ -53,6 +53,7 @@ evm-state-machine = { workspace = true, default-features = true }
 subxt-utils = { workspace = true, default-features = true }
 ismp-grandpa = { workspace = true, default-features = true }
 rs_merkle = { version = "1.5.0"}
+log = { workspace = true }
 
 [dependencies.polkadot-sdk]
 workspace = true

modules/pallets/testsuite/src/tests/pallet_xcm_gateway.rs

@@ -37,38 +37,125 @@ use xcm_simulator::TestExt;
 use crate::runtime::ReputationAssetId;
 
 const SEND_AMOUNT: u128 = 1000_000_000_0000;
-const PARA_ID: u32 = 100;
+const PARA_ID: u32 = crate::xcm::SIBLING_PARA_ID;
 pub type RelayChainPalletXcm = pallet_xcm::Pallet<relay_chain::Runtime>;
 
 fn reserve_transfer_on_AH(amount: u128, beneficiary: Location) {
 	let asset_location_on_assethub = Location::new(1, Here);
 
-	let dest = Location::new(1, [Parachain(100)]);
+		//let asset_location_on_assethub_h256: H256 = sp_io::hashing::keccak_256(&asset_location_on_assethub.encode()).into();
+
+		let asset_id_on_paraa: H256 =
+				sp_io::hashing::keccak_256(&Location::new(1, Here).encode())
+					.into();
+
+
+			ParaA::execute_with(|| {
+				/*assert_ok!(runtime::Assets::force_create(
+                    runtime::RuntimeOrigin::root(),
+                    asset_id_on_paraa.into(),
+                    ALICE.into(),
+                    true,
+                    1
+                ));*/
+			});
+
+
+			ParaB::execute_with(|| {
+				let dest = Location::new(1, [Parachain(PARA_ID)]);
+				let beneficiary: Location = Junctions::X3(Arc::new([
+					Junction::AccountId32 { network: None, id: ALICE.into() },
+					Junction::AccountKey20 {
+						network: Some(NetworkId::Ethereum { chain_id: 97 }),
+						key: [1u8; 20],
+					},
+					Junction::GeneralIndex(60 * 60),
+				]))
+					.into_location();
+
+				let context = Junctions::X2(Arc::new([
+					Junction::GlobalConsensus(NetworkId::Polkadot),
+					Parachain(1000),
+				]));
 
 	let assets = Asset {
 		id: AssetId(asset_location_on_assethub.clone()),
 		fun: Fungibility::Fungible(amount),
 	};
 
-	let remote_xcm = Xcm(vec![
-		BuyExecution { fees: assets.clone(), weight_limit: WeightLimit::Unlimited },
-		DepositAsset { assets: Wild(All), beneficiary },
-	]);
+				let fee_asset = assets.clone().reanchored(&dest, &context).expect("should reanchor");
+				let fees = fee_asset.clone();
+
+				// let xcm = Xcm(vec![
+				// 	BuyExecution { fees, weight_limit:  WeightLimit::Unlimited },
+				// 	DepositAsset {
+				// 		assets: Wild(All),
+				// 		beneficiary,
+				// 	},
+				// ]);
+
+				// let message = Xcm(vec![
+				// 	SetFeesMode { jit_withdraw: true },
+				// 	TransferReserveAsset {
+				// 		assets: assets.into(),
+				// 		dest,
+				// 		xcm,
+				// 	},
+				// ]);
+
+				// assert_ok!(runtime::PalletXcm::execute(
+                //     runtime::RuntimeOrigin::signed(ALICE.into()),
+                //     Box::new(VersionedXcm::from(message)),
+                //    Weight::MAX
+                // ));
+
+				assert_ok!(runtime::PalletXcm::limited_reserve_transfer_assets(
+                    runtime::RuntimeOrigin::signed(ALICE.into()),
+                    Box::new(dest.into()),
+                    Box::new(beneficiary.into()),
+                    Box::new(vec![(asset_location_on_assethub, SEND_AMOUNT).into()].into()),
+                    0,
+                    WeightLimit::Unlimited,
+                ));
+			});
+
+
+			ParaA::execute_with(|| {
+
+				let bobs_balance = <runtime::Assets as Inspect<
+					<Test as frame_system::Config>::AccountId,
+				>>::balance(
+					asset_id_on_paraa,
+					&BOB,
+				);
+				dbg!(bobs_balance);
+
+				let parachain_account: ParaId =   PARA_ID.into();
+				let parachain_account = parachain_account.into_account_truncating();
+
+				let alice_balance = <runtime::Assets as Inspect<
+					<Test as frame_system::Config>::AccountId,
+				>>::balance(
+					asset_id_on_paraa,
+					&parachain_account,
+				);
+				dbg!(alice_balance);
+				let nonce = pallet_ismp::Nonce::<Test>::get();
+				assert_eq!(nonce, 1);
+
+				let protocol_fees = pallet_xcm_gateway::Pallet::<Test>::protocol_fee_percentage();
+				let custodied_amount = SEND_AMOUNT - (protocol_fees * SEND_AMOUNT);
+
+				let pallet_account_balance = <runtime::Assets as Inspect<
+					<Test as frame_system::Config>::AccountId,
+				>>::balance(
+					asset_id_on_paraa.into(),
+					&pallet_xcm_gateway::Pallet::<Test>::account_id(),
+				);
+				assert_eq!(custodied_amount, pallet_account_balance);
+			});
 
-	let message = Xcm(vec![
-		SetFeesMode { jit_withdraw: true },
-		TransferReserveAsset { assets: assets.into(), dest, xcm: remote_xcm },
-	]);
-
-	ParaB::execute_with(|| {
-		assert_ok!(runtime::PalletXcm::execute(
-			runtime::RuntimeOrigin::signed(ALICE.into()),
-			Box::new(VersionedXcm::from(message)),
-			Weight::MAX
-		));
-	});
 }
-
 #[test]
 fn should_dispatch_ismp_request_when_assets_are_received_from_assethub() {
 	init_tracing();

modules/pallets/testsuite/src/xcm.rs

@@ -80,13 +80,13 @@ parameter_types! {
 }
 
 parameter_types! {
-	pub const KsmLocation: Location = Location::parent();
+	pub const RelayLocation: Location = Location::parent();
 	pub const RelayNetwork: Option<NetworkId> = None;
 	pub UniversalLocation: Junctions = Parachain(ParachainInfo::parachain_id().into()).into();
 }
 
 parameter_types! {
-	pub ExternalConsensus: InteriorLocation = [Parachain(100), Parachain(1000)].into();
+	pub ExternalConsensus: InteriorLocation = [Parachain(SIBLING_PARA_ID), Parachain(1000)].into();
 }
 
 pub type LocationToAccountId = (
@@ -207,12 +207,15 @@ impl DmpMessageHandler for DmpMessageExecutor {
 	}
 }
 
+/// 1000-2000 are considered system parachains, so let's use higher para_id
+pub const SIBLING_PARA_ID: u32 = 2222;
+
 decl_test_parachain! {
 	pub struct ParaA {
 		Runtime = Test,
 		XcmpMessageHandler = crate::runtime::MsgQueue,
 		DmpMessageHandler = DmpMessageExecutor,
-		new_ext = para_ext(100),
+		new_ext = para_ext(SIBLING_PARA_ID),
 	}
 }
 
@@ -241,7 +244,7 @@ decl_test_network! {
 	pub struct MockNet {
 		relay_chain = Relay,
 		parachains = vec![
-			(100, ParaA),
+			(SIBLING_PARA_ID, ParaA),
 			(1000, ParaB),
 		],
 	}
@@ -268,10 +271,9 @@ parameter_types! {
 pub struct TestReserve;
 impl ContainsPair<Asset, Location> for TestReserve {
 	fn contains(asset: &Asset, origin: &Location) -> bool {
-		println!("TestReserve::contains asset: {asset:?}, origin:{origin:?}");
-		//let assethub_location = Location::new(1, Parachain(ASSET_HUB_PARA_ID));
-		//&assethub_location == origin
-		true
+		log::trace!(target: "xcm", "TestReserve::contains asset: {asset:?}, origin:{origin:?}");
+		let assethub_location = Location::new(1, Parachain(ASSET_HUB_PARA_ID));
+		&assethub_location == origin
 	}
 }
 
@@ -282,7 +284,10 @@ impl staging_xcm_executor::Config for XcmConfig {
 	type AssetTransactor = LocalAssetTransactor;
 	type OriginConverter = XcmOriginToCallOrigin;
 	type IsReserve = TestReserve;
-	type IsTeleporter = ();
+	type IsTeleporter = (
+		// Important setting reflecting AssetHub
+		parachains_common::xcm_config::ConcreteAssetFromSystem<RelayLocation>,
+	);
 	type UniversalLocation = UniversalLocation;
 	type Barrier = Barrier;
 	type Weigher = FixedWeightBounds<UnitWeightCost, RuntimeCall, MaxInstructions>;