Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

// Moonbeam is free software: you can redistribute it and/or modify

5

// it under the terms of the GNU General Public License as published by

6

// the Free Software Foundation, either version 3 of the License, or

7

// (at your option) any later version.

8

9

// Moonbeam is distributed in the hope that it will be useful,

10

// but WITHOUT ANY WARRANTY; without even the implied warranty of

11

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

12

// GNU General Public License for more details.

13

14

// You should have received a copy of the GNU General Public License

15

// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

16

17

//! Moonriver Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{PalletInfo, PalletInfoAccess},

23

	weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight},

24

	BoundedVec,

25

};

26

use moonriver_runtime::xcm_config::AssetType;

27

use sp_core::ConstU32;

28

use sp_core::U256;

29

use sp_runtime::traits::Convert;

30

use xcm::{

31

	latest::prelude::{

32

		AccountId32, AccountKey20, All, Asset, AssetId, Assets as XcmAssets, BuyExecution,

33

		ClearOrigin, DepositAsset, Fungibility, GeneralIndex, Junction, Junctions, Limited,

34

		Location, OriginKind, PalletInstance, Parachain, QueryResponse, Reanchorable, Response,

35

		WeightLimit, Wild, WithdrawAsset, Xcm,

36

},

37

	IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm, WrapVersion,

38

};

39

use xcm_executor::traits::{ConvertLocation, TransferType};

40

use xcm_mock::parachain::{self, EvmForeignAssets, PolkadotXcm, Treasury};

41

use xcm_mock::relay_chain;

42

use xcm_mock::*;

43

use xcm_simulator::TestExt;

44

mod common;

45

use cumulus_primitives_core::relay_chain::HrmpChannelId;

46

use pallet_xcm_transactor::{

47

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

48

};

49

use xcm_primitives::{

50

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

51

};

52

53

28

fn add_supported_asset(asset_type: parachain::AssetType, units_per_second: u128) -> Result<(), ()> {

54

28

	let parachain::AssetType::Xcm(location_v3) = asset_type;

55

28

	let VersionedLocation::V5(location_v5) = VersionedLocation::V3(location_v3)

56

28

		.into_version(xcm::latest::VERSION)

57

28

		.map_err(|_| ())?

58

	else {

59

		return Err(());

60

};

61

	use frame_support::weights::WeightToFee as _;

62

28

	let native_amount_per_second: u128 =

63

28

		<parachain::Runtime as pallet_xcm_weight_trader::Config>::WeightToFee::weight_to_fee(

64

28

			&Weight::from_parts(

65

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

66

28

0,

67

28

),

68

69

28

		.try_into()

70

28

		.map_err(|_| ())?;

71

28

	let precision_factor = 10u128.pow(pallet_xcm_weight_trader::RELATIVE_PRICE_DECIMALS);

72

28

	let relative_price: u128 = if units_per_second > 0u128 {

73

10

		native_amount_per_second

74

10

			.saturating_mul(precision_factor)

75

10

			.saturating_div(units_per_second)

76

	} else {

77

18

		0u128

78

};

79

28

	pallet_xcm_weight_trader::SupportedAssets::<parachain::Runtime>::insert(

80

28

		location_v5,

81

28

		(true, relative_price),

82

);

83

28

	Ok(())

84

28

85

86

/// Helper function to set fee per second for an asset location (for compatibility with old tests).

87

/// Converts fee_per_second to relative_price and adds/edits the asset in the weight-trader.

88

9

fn set_fee_per_second_for_location(location: Location, fee_per_second: u128) -> Result<(), ()> {

89

	use moonbeam_tests_primitives::MemoryFeeTrader;

90

	use xcm_primitives::XcmFeeTrader;

91

92

	// Configure fees for XcmTransactor via the in-memory fee trader only, so that

93

	// the initial funding XCM transfers stay free and only transactor calls pay fees.

94

9

	<MemoryFeeTrader as XcmFeeTrader>::set_asset_price(location, fee_per_second).map_err(|_| ())

95

9

96

97

25

fn currency_to_asset(currency_id: parachain::CurrencyId, amount: u128) -> Asset {

98

25

	Asset {

99

25

		id: AssetId(

100

25

			<parachain::Runtime as pallet_xcm_transactor::Config>::CurrencyIdToLocation::convert(

101

25

				currency_id,

102

25

103

25

			.unwrap(),

104

25

),

105

25

		fun: Fungibility::Fungible(amount),

106

25

107

25

108

109

// Send a relay asset (like DOT) to a parachain A

110

#[test]

111

1

fn receive_relay_asset_from_relay() {

112

1

	MockNet::reset();

113

114

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

115

1

	let source_id: parachain::AssetId = source_location.clone().into();

116

1

	let asset_metadata = parachain::AssetMetadata {

117

1

		name: b"RelayToken".to_vec(),

118

1

		symbol: b"Relay".to_vec(),

119

1

		decimals: 12,

120

1

};

121

	// Register relay asset in parachain A

122

1

	ParaA::execute_with(|| {

123

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

124

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

125

1

			.try_into()

126

1

			.expect("v3 to latest location conversion failed");

127

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

128

1

			source_id,

129

1

			source_location_latest,

130

1

			asset_metadata.decimals,

131

1

			asset_metadata.symbol.try_into().expect("too long"),

132

1

			asset_metadata.name.try_into().expect("too long"),

133

));

134

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

135

1

});

136

137

	// Actually send relay asset to parachain

138

1

	let dest: Location = AccountKey20 {

139

1

		network: None,

140

1

		key: PARAALICE,

141

1

142

1

	.into();

143

1

	Relay::execute_with(|| {

144

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

145

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

146

1

			assets: Wild(All),

147

1

			beneficiary: dest.clone(),

148

1

		}]);

149

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

150

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

151

1

			Box::new(Parachain(1).into()),

152

1

			Box::new(([] /* Here */, 123).into()),

153

1

			Box::new(TransferType::LocalReserve),

154

1

			Box::new(fees_id),

155

1

			Box::new(TransferType::LocalReserve),

156

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

157

1

			WeightLimit::Unlimited

158

));

159

1

});

160

161

	// Verify that parachain received the asset

162

1

	ParaA::execute_with(|| {

163

		// free execution, full amount received

164

1

		assert_eq!(

165

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

166

1

			Ok(U256::from(123))

167

);

168

1

});

169

1

170

171

// Send relay asset (like DOT) back from Parachain A to relaychain

172

#[test]

173

1

fn send_relay_asset_to_relay() {

174

1

	MockNet::reset();

175

176

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

177

1

	let source_id: parachain::AssetId = source_location.clone().into();

178

179

1

	let asset_metadata = parachain::AssetMetadata {

180

1

		name: b"RelayToken".to_vec(),

181

1

		symbol: b"Relay".to_vec(),

182

1

		decimals: 12,

183

1

};

184

185

	// Register relay asset in paraA

186

1

	ParaA::execute_with(|| {

187

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

188

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

189

1

			.try_into()

190

1

			.expect("v3 to latest location conversion failed");

191

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

192

1

			source_id,

193

1

			source_location_latest,

194

1

			asset_metadata.decimals,

195

1

			asset_metadata.symbol.try_into().expect("too long"),

196

1

			asset_metadata.name.try_into().expect("too long"),

197

));

198

		// free execution

199

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

200

1

});

201

202

1

	let dest: Location = Junction::AccountKey20 {

203

1

		network: None,

204

1

		key: PARAALICE,

205

1

206

1

	.into();

207

208

	// First send relay chain asset to Parachain like in previous test

209

1

	Relay::execute_with(|| {

210

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

211

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

212

1

			assets: Wild(All),

213

1

			beneficiary: dest.clone(),

214

1

		}]);

215

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

216

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

217

1

			Box::new(Parachain(1).into()),

218

1

			Box::new(([] /* Here */, 123).into()),

219

1

			Box::new(TransferType::LocalReserve),

220

1

			Box::new(fees_id),

221

1

			Box::new(TransferType::LocalReserve),

222

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

223

1

			WeightLimit::Unlimited

224

));

225

1

});

226

227

1

	ParaA::execute_with(|| {

228

		// Free execution, full amount received

229

1

		assert_eq!(

230

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

231

1

			Ok(U256::from(123))

232

);

233

1

});

234

235

	// Lets gather the balance before sending back money

236

1

	let mut balance_before_sending = 0;

237

1

	Relay::execute_with(|| {

238

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

239

1

});

240

241

	// We now send back some money to the relay

242

1

	let dest_chain = Location::parent();

243

1

	let beneficiary = Location {

244

1

		parents: 0,

245

1

		interior: [AccountId32 {

246

1

			network: None,

247

1

			id: RELAYALICE.into(),

248

1

}]

249

1

		.into(),

250

1

};

251

252

1

	ParaA::execute_with(|| {

253

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 123);

254

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

255

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

256

1

			assets: Wild(All),

257

1

			beneficiary: beneficiary.clone(),

258

1

		}]);

259

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

260

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

261

1

			Box::new(VersionedLocation::from(dest_chain)),

262

1

			Box::new(VersionedAssets::from(vec![asset])),

263

1

			Box::new(TransferType::DestinationReserve),

264

1

			Box::new(fees_id),

265

1

			Box::new(TransferType::DestinationReserve),

266

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

267

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

268

));

269

1

});

270

271

	// The balances in paraAlice should have been substracted

272

1

	ParaA::execute_with(|| {

273

1

		assert_eq!(

274

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

275

1

			Ok(U256::from(0))

276

);

277

1

});

278

279

	// Balances in the relay should have been received

280

1

	Relay::execute_with(|| {

281

1

		assert!(RelayBalances::free_balance(&RELAYALICE) > balance_before_sending);

282

1

});

283

1

284

285

#[test]

286

1

fn send_relay_asset_to_para_b() {

287

1

	MockNet::reset();

288

289

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

290

1

	let source_id: parachain::AssetId = source_location.clone().into();

291

292

1

	let asset_metadata = parachain::AssetMetadata {

293

1

		name: b"RelayToken".to_vec(),

294

1

		symbol: b"Relay".to_vec(),

295

1

		decimals: 12,

296

1

};

297

298

	// Register asset in paraA. Free execution

299

1

	ParaA::execute_with(|| {

300

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

301

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

302

1

			.try_into()

303

1

			.expect("v3 to latest location conversion failed");

304

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

305

1

			source_id,

306

1

			source_location_latest,

307

1

			asset_metadata.decimals,

308

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

309

1

			asset_metadata.name.clone().try_into().expect("too long"),

310

));

311

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

312

1

});

313

314

	// Register asset in paraB. Free execution

315

1

	ParaB::execute_with(|| {

316

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

317

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

318

1

			.try_into()

319

1

			.expect("v3 to latest location conversion failed");

320

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

321

1

			source_id,

322

1

			source_location_latest,

323

1

			asset_metadata.decimals,

324

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

325

1

			asset_metadata.name.clone().try_into().expect("too long"),

326

));

327

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

328

1

});

329

330

	// First send relay chain asset to Parachain A like in previous test

331

1

	let dest: Location = Junction::AccountKey20 {

332

1

		network: None,

333

1

		key: PARAALICE,

334

1

335

1

	.into();

336

1

	Relay::execute_with(|| {

337

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

338

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

339

1

			assets: Wild(All),

340

1

			beneficiary: dest.clone(),

341

1

		}]);

342

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

343

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

344

1

			Box::new(Parachain(1).into()),

345

1

			Box::new(([] /* Here */, 123).into()),

346

1

			Box::new(TransferType::LocalReserve),

347

1

			Box::new(fees_id),

348

1

			Box::new(TransferType::LocalReserve),

349

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

350

1

			WeightLimit::Unlimited

351

));

352

1

});

353

354

1

	ParaA::execute_with(|| {

355

1

		assert_eq!(

356

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

357

1

			Ok(U256::from(123))

358

);

359

1

});

360

361

	// Now send relay asset from para A to para B

362

1

	let dest = Location {

363

1

		parents: 1,

364

1

		interior: [

365

1

			Parachain(2),

366

1

			AccountKey20 {

367

1

				network: None,

368

1

				key: PARAALICE.into(),

369

1

},

370

1

371

1

		.into(),

372

1

};

373

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

374

375

1

	ParaA::execute_with(|| {

376

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

377

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

378

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

379

1

			assets: Wild(All),

380

1

			beneficiary: beneficiary.clone(),

381

1

		}]);

382

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

383

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

384

1

			Box::new(VersionedLocation::from(chain_part)),

385

1

			Box::new(VersionedAssets::from(vec![asset])),

386

1

			Box::new(TransferType::RemoteReserve(Location::parent().into())),

387

1

			Box::new(fees_id),

388

1

			Box::new(TransferType::RemoteReserve(Location::parent().into())),

389

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

390

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

391

));

392

1

});

393

394

	// Para A balances should have been substracted

395

1

	ParaA::execute_with(|| {

396

1

		assert_eq!(

397

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

398

1

			Ok(U256::from(23))

399

);

400

1

});

401

402

	// Para B balances should have been credited

403

1

	ParaB::execute_with(|| {

404

1

		assert_eq!(

405

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

406

1

			Ok(U256::from(100))

407

);

408

1

});

409

1

410

411

#[test]

412

1

fn send_para_a_asset_to_para_b() {

413

1

	MockNet::reset();

414

415

	// This represents the asset in paraA

416

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

417

1

	let source_location: AssetType = para_a_balances

418

1

		.try_into()

419

1

		.expect("Location convertion to AssetType should succeed");

420

1

	let source_id: parachain::AssetId = source_location.clone().into();

421

422

1

	let asset_metadata = parachain::AssetMetadata {

423

1

		name: b"ParaAToken".to_vec(),

424

1

		symbol: b"ParaA".to_vec(),

425

1

		decimals: 18,

426

1

};

427

428

	// Register asset in paraB. Free execution

429

1

	ParaB::execute_with(|| {

430

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

431

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

432

1

			.try_into()

433

1

			.expect("v3 to latest location conversion failed");

434

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

435

1

			source_id,

436

1

			source_location_latest,

437

1

			asset_metadata.decimals,

438

1

			asset_metadata.symbol.try_into().expect("too long"),

439

1

			asset_metadata.name.try_into().expect("too long"),

440

));

441

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

442

1

});

443

444

	// Send para A asset from para A to para B

445

1

	let dest = Location {

446

1

		parents: 1,

447

1

		interior: [

448

1

			Parachain(2),

449

1

			AccountKey20 {

450

1

				network: None,

451

1

				key: PARAALICE.into(),

452

1

},

453

1

454

1

		.into(),

455

1

};

456

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

457

458

1

	ParaA::execute_with(|| {

459

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

460

1

		assert_ok!(PolkadotXcm::transfer_assets(

461

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

462

1

			Box::new(VersionedLocation::from(chain_part)),

463

1

			Box::new(VersionedLocation::from(beneficiary)),

464

1

			Box::new(VersionedAssets::from(vec![asset])),

465

0,

466

1

			WeightLimit::Limited(Weight::from_parts(800000u64, DEFAULT_PROOF_SIZE))

467

));

468

1

});

469

470

	// Native token is substracted in paraA

471

1

	ParaA::execute_with(|| {

472

		// free execution, full amount received

473

1

		assert_eq!(

474

1

			ParaBalances::free_balance(&PARAALICE.into()),

475

			INITIAL_BALANCE - 100

476

);

477

1

});

478

479

	// Asset is minted in paraB

480

1

	ParaB::execute_with(|| {

481

		// free execution, full amount received

482

1

		assert_eq!(

483

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

484

1

			Ok(U256::from(100))

485

);

486

1

});

487

1

488

489

#[test]

490

1

fn send_para_a_asset_from_para_b_to_para_c() {

491

1

	MockNet::reset();

492

493

	// Represents para A asset

494

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

495

1

	let source_location: AssetType = para_a_balances

496

1

		.try_into()

497

1

		.expect("Location convertion to AssetType should succeed");

498

1

	let source_id: parachain::AssetId = source_location.clone().into();

499

500

1

	let asset_metadata = parachain::AssetMetadata {

501

1

		name: b"ParaAToken".to_vec(),

502

1

		symbol: b"ParaA".to_vec(),

503

1

		decimals: 18,

504

1

};

505

506

	// Register para A asset in parachain B. Free execution

507

1

	ParaB::execute_with(|| {

508

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

509

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

510

1

			.try_into()

511

1

			.expect("v3 to latest location conversion failed");

512

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

513

1

			source_id,

514

1

			source_location_latest,

515

1

			asset_metadata.decimals,

516

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

517

1

			asset_metadata.name.clone().try_into().expect("too long"),

518

));

519

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

520

1

});

521

522

	// Register para A asset in parachain C. Free execution

523

1

	ParaC::execute_with(|| {

524

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

525

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

526

1

			.try_into()

527

1

			.expect("v3 to latest location conversion failed");

528

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

529

1

			source_id,

530

1

			source_location_latest,

531

1

			asset_metadata.decimals,

532

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

533

1

			asset_metadata.name.clone().try_into().expect("too long"),

534

));

535

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

536

1

});

537

538

	// Send para A asset to para B

539

1

	let dest = Location {

540

1

		parents: 1,

541

1

		interior: [

542

1

			Parachain(2),

543

1

			AccountKey20 {

544

1

				network: None,

545

1

				key: PARAALICE.into(),

546

1

},

547

1

548

1

		.into(),

549

1

};

550

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

551

552

1

	ParaA::execute_with(|| {

553

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

554

1

		assert_ok!(PolkadotXcm::transfer_assets(

555

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

556

1

			Box::new(VersionedLocation::from(chain_part)),

557

1

			Box::new(VersionedLocation::from(beneficiary)),

558

1

			Box::new(VersionedAssets::from(vec![asset])),

559

0,

560

1

			WeightLimit::Limited(Weight::from_parts(80u64, DEFAULT_PROOF_SIZE))

561

));

562

1

});

563

564

	// Para A balances have been substracted

565

1

	ParaA::execute_with(|| {

566

1

		assert_eq!(

567

1

			ParaBalances::free_balance(&PARAALICE.into()),

568

			INITIAL_BALANCE - 100

569

);

570

1

});

571

572

	// Para B balances have been credited

573

1

	ParaB::execute_with(|| {

574

1

		assert_eq!(

575

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

576

1

			Ok(U256::from(100))

577

);

578

1

});

579

580

	// Send para A asset from para B to para C

581

1

	let dest = Location {

582

1

		parents: 1,

583

1

		interior: [

584

1

			Parachain(3),

585

1

			AccountKey20 {

586

1

				network: None,

587

1

				key: PARAALICE.into(),

588

1

},

589

1

590

1

		.into(),

591

1

};

592

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

593

594

1

	ParaB::execute_with(|| {

595

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

596

1

		assert_ok!(PolkadotXcm::transfer_assets(

597

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

598

1

			Box::new(VersionedLocation::from(chain_part)),

599

1

			Box::new(VersionedLocation::from(beneficiary)),

600

1

			Box::new(VersionedAssets::from(vec![asset])),

601

0,

602

1

			WeightLimit::Limited(Weight::from_parts(80u64, DEFAULT_PROOF_SIZE))

603

));

604

1

});

605

606

	// The message passed through parachainA so we needed to pay since its the native token

607

1

	ParaC::execute_with(|| {

608

		// free execution, full amount received

609

1

		assert_eq!(

610

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

611

1

			Ok(U256::from(95))

612

);

613

1

});

614

1

615

616

#[test]

617

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

618

1

	MockNet::reset();

619

620

	// Para A asset

621

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

622

1

	let source_location: AssetType = para_a_balances

623

1

		.try_into()

624

1

		.expect("Location convertion to AssetType should succeed");

625

1

	let source_id: parachain::AssetId = source_location.clone().into();

626

627

1

	let asset_metadata = parachain::AssetMetadata {

628

1

		name: b"ParaAToken".to_vec(),

629

1

		symbol: b"ParaA".to_vec(),

630

1

		decimals: 18,

631

1

};

632

633

	// Register para A asset in para B

634

1

	ParaB::execute_with(|| {

635

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

636

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

637

1

			.try_into()

638

1

			.expect("v3 to latest location conversion failed");

639

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

640

1

			source_id,

641

1

			source_location_latest,

642

1

			asset_metadata.decimals,

643

1

			asset_metadata.symbol.try_into().expect("too long"),

644

1

			asset_metadata.name.try_into().expect("too long"),

645

));

646

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

647

1

});

648

649

	// Send para A asset to para B

650

1

	let dest = Location {

651

1

		parents: 1,

652

1

		interior: [

653

1

			Parachain(2),

654

1

			AccountKey20 {

655

1

				network: None,

656

1

				key: PARAALICE.into(),

657

1

},

658

1

659

1

		.into(),

660

1

};

661

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

662

663

1

	ParaA::execute_with(|| {

664

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

665

1

		assert_ok!(PolkadotXcm::transfer_assets(

666

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

667

1

			Box::new(VersionedLocation::from(chain_part)),

668

1

			Box::new(VersionedLocation::from(beneficiary)),

669

1

			Box::new(VersionedAssets::from(vec![asset])),

670

0,

671

1

			WeightLimit::Limited(Weight::from_parts(80u64, DEFAULT_PROOF_SIZE))

672

));

673

1

});

674

675

	// Balances have been subtracted

676

1

	ParaA::execute_with(|| {

677

1

		assert_eq!(

678

1

			ParaBalances::free_balance(&PARAALICE.into()),

679

			INITIAL_BALANCE - 100

680

);

681

1

});

682

683

	// Para B balances have been credited

684

1

	ParaB::execute_with(|| {

685

1

		assert_eq!(

686

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

687

1

			Ok(U256::from(100))

688

);

689

1

});

690

691

	// Send back para A asset to para A

692

1

	let dest = Location {

693

1

		parents: 1,

694

1

		interior: [

695

1

			Parachain(1),

696

1

			AccountKey20 {

697

1

				network: None,

698

1

				key: PARAALICE.into(),

699

1

},

700

1

701

1

		.into(),

702

1

};

703

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

704

705

1

	ParaB::execute_with(|| {

706

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

707

1

		assert_ok!(PolkadotXcm::transfer_assets(

708

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

709

1

			Box::new(VersionedLocation::from(chain_part)),

710

1

			Box::new(VersionedLocation::from(beneficiary)),

711

1

			Box::new(VersionedAssets::from(vec![asset])),

712

0,

713

1

			WeightLimit::Limited(Weight::from_parts(80u64, DEFAULT_PROOF_SIZE))

714

));

715

1

});

716

717

	// Para A asset has been credited

718

1

	ParaA::execute_with(|| {

719

		// Weight used is 4

720

1

		assert_eq!(

721

1

			ParaBalances::free_balance(&PARAALICE.into()),

722

			INITIAL_BALANCE - 4

723

);

724

1

});

725

1

726

727

#[test]

728

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

729

1

	MockNet::reset();

730

731

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

732

1

	let source_location: AssetType = para_a_balances

733

1

		.try_into()

734

1

		.expect("Location conversion to AssetType should succeed");

735

1

	let source_id: parachain::AssetId = source_location.clone().into();

736

737

1

	let asset_metadata = parachain::AssetMetadata {

738

1

		name: b"ParaAToken".to_vec(),

739

1

		symbol: b"ParaA".to_vec(),

740

1

		decimals: 18,

741

1

};

742

743

1

	ParaB::execute_with(|| {

744

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

745

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

746

1

			.try_into()

747

1

			.expect("v3 to latest location conversion failed");

748

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

749

1

			source_id,

750

1

			source_location_latest,

751

1

			asset_metadata.decimals,

752

1

			asset_metadata.symbol.try_into().expect("too long"),

753

1

			asset_metadata.name.try_into().expect("too long"),

754

));

755

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

756

1

});

757

758

1

	let dest = Location {

759

1

		parents: 1,

760

1

		interior: [

761

1

			Parachain(2),

762

1

			AccountKey20 {

763

1

				network: None,

764

1

				key: PARAALICE.into(),

765

1

},

766

1

767

1

		.into(),

768

1

};

769

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

770

771

1

	ParaA::execute_with(|| {

772

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

773

1

		assert_ok!(PolkadotXcm::transfer_assets(

774

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

775

1

			Box::new(VersionedLocation::from(chain_part)),

776

1

			Box::new(VersionedLocation::from(beneficiary)),

777

1

			Box::new(VersionedAssets::from(vec![asset])),

778

0,

779

1

			WeightLimit::Limited(Weight::from_parts(80u64, DEFAULT_PROOF_SIZE))

780

));

781

1

});

782

783

1

	ParaA::execute_with(|| {

784

		// Free execution, full amount received

785

1

		assert_eq!(

786

1

			ParaBalances::free_balance(&PARAALICE.into()),

787

			INITIAL_BALANCE - 100

788

);

789

1

});

790

791

1

	ParaB::execute_with(|| {

792

		// Free execution, full amount received

793

1

		assert_eq!(

794

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

795

1

			Ok(U256::from(100))

796

);

797

1

});

798

799

	// This time we will force the new reanchoring by manually sending the

800

	// Message through polkadotXCM pallet

801

802

1

	let dest = Location {

803

1

		parents: 1,

804

1

		interior: [Parachain(1)].into(),

805

1

};

806

807

1

	let reanchored_para_a_balances = Location::new(0, [PalletInstance(1u8)]);

808

809

1

	let message = xcm::VersionedXcm::<()>::V5(Xcm(vec![

810

1

		WithdrawAsset((reanchored_para_a_balances.clone(), 100).into()),

811

1

		ClearOrigin,

812

1

		BuyExecution {

813

1

			fees: (reanchored_para_a_balances, 100).into(),

814

1

			weight_limit: Limited(80.into()),

815

1

},

816

1

		DepositAsset {

817

1

			assets: All.into(),

818

1

			beneficiary: Location::new(

819

1

0,

820

1

				[AccountKey20 {

821

1

					network: None,

822

1

					key: PARAALICE,

823

1

}],

824

1

),

825

1

},

826

1

	]));

827

1

	ParaB::execute_with(|| {

828

		// Send a message to the sovereign account in ParaA to withdraw

829

		// and deposit asset

830

1

		assert_ok!(ParachainPalletXcm::send(

831

1

			parachain::RuntimeOrigin::root(),

832

1

			Box::new(dest.into()),

833

1

			Box::new(message),

834

));

835

1

});

836

837

1

	ParaB::execute_with(|| {

838

		// free execution, full amount received

839

1

		assert_eq!(

840

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

841

1

			Ok(U256::from(100))

842

);

843

1

});

844

845

	// This time we will force the new reanchoring by manually sending the

846

	// Message through polkadotXCM pallet

847

848

1

	let dest = Location {

849

1

		parents: 1,

850

1

		interior: [Parachain(1)].into(),

851

1

};

852

853

1

	let reanchored_para_a_balances = Location::new(0, [PalletInstance(1u8)]);

854

855

1

	let message = xcm::VersionedXcm::<()>::V5(Xcm(vec![

856

1

		WithdrawAsset((reanchored_para_a_balances.clone(), 100).into()),

857

1

		ClearOrigin,

858

1

		BuyExecution {

859

1

			fees: (reanchored_para_a_balances, 100).into(),

860

1

			weight_limit: Limited(80.into()),

861

1

},

862

1

		DepositAsset {

863

1

			assets: All.into(),

864

1

			beneficiary: Location::new(

865

1

0,

866

1

				[AccountKey20 {

867

1

					network: None,

868

1

					key: PARAALICE,

869

1

}],

870

1

),

871

1

},

872

1

	]));

873

1

	ParaB::execute_with(|| {

874

		// Send a message to the sovereign account in ParaA to withdraw

875

		// and deposit asset

876

1

		assert_ok!(ParachainPalletXcm::send(

877

1

			parachain::RuntimeOrigin::root(),

878

1

			Box::new(dest.into()),

879

1

			Box::new(message),

880

));

881

1

});

882

883

1

	ParaA::execute_with(|| {

884

		// Weight used is 4

885

1

		assert_eq!(

886

1

			ParaBalances::free_balance(&PARAALICE.into()),

887

			INITIAL_BALANCE - 4

888

);

889

1

});

890

1

891

892

#[test]

893

1

fn receive_relay_asset_with_trader() {

894

1

	MockNet::reset();

895

896

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

897

1

	let source_id: parachain::AssetId = source_location.clone().into();

898

899

1

	let asset_metadata = parachain::AssetMetadata {

900

1

		name: b"RelayToken".to_vec(),

901

1

		symbol: b"Relay".to_vec(),

902

1

		decimals: 12,

903

1

};

904

905

	// This time we are gonna put a rather high number of units per second

906

	// we know later we will divide by 1e12

907

	// Lets put 1e6 as units per second

908

1

	ParaA::execute_with(|| {

909

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

910

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

911

1

			.try_into()

912

1

			.expect("v3 to latest location conversion failed");

913

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

914

1

			source_id,

915

1

			source_location_latest,

916

1

			asset_metadata.decimals,

917

1

			asset_metadata.symbol.try_into().expect("too long"),

918

1

			asset_metadata.name.try_into().expect("too long"),

919

));

920

1

		assert_ok!(add_supported_asset(

921

1

			source_location.clone(),

922

			2500000000000u128

923

));

924

1

});

925

926

1

	let dest: Location = Junction::AccountKey20 {

927

1

		network: None,

928

1

		key: PARAALICE,

929

1

930

1

	.into();

931

	// We are sending 100 tokens from relay.

932

	// Amount spent in fees is Units per second * weight / 1_000_000_000_000 (weight per second)

933

	// weight is 4 since we are executing 4 instructions with a unitweightcost of 1.

934

	// Units per second should be 2_500_000_000_000_000

935

	// Therefore with no refund, we should receive 10 tokens less

936

	// Native trader fails for this, and we use the asset trader

937

1

	Relay::execute_with(|| {

938

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

939

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

940

1

			assets: Wild(All),

941

1

			beneficiary: dest.clone(),

942

1

		}]);

943

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

944

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

945

1

			Box::new(Parachain(1).into()),

946

1

			Box::new(([] /* Here */, 100).into()),

947

1

			Box::new(TransferType::LocalReserve),

948

1

			Box::new(fees_id),

949

1

			Box::new(TransferType::LocalReserve),

950

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

951

1

			WeightLimit::Unlimited

952

));

953

1

});

954

955

1

	ParaA::execute_with(|| {

956

		// non-free execution, not full amount received

957

1

		assert_eq!(

958

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

959

1

			Ok(U256::from(90))

960

);

961

		// Fee should have been received by treasury

962

1

		assert_eq!(

963

1

			EvmForeignAssets::balance(source_id, Treasury::account_id()),

964

1

			Ok(U256::from(10))

965

);

966

1

});

967

1

968

969

#[test]

970

1

fn send_para_a_asset_to_para_b_with_trader() {

971

1

	MockNet::reset();

972

973

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

974

1

	let source_location: AssetType = para_a_balances

975

1

		.try_into()

976

1

		.expect("Location convertion to AssetType should succeed");

977

1

	let source_id: parachain::AssetId = source_location.clone().into();

978

979

1

	let asset_metadata = parachain::AssetMetadata {

980

1

		name: b"ParaAToken".to_vec(),

981

1

		symbol: b"ParaA".to_vec(),

982

1

		decimals: 18,

983

1

};

984

985

1

	ParaB::execute_with(|| {

986

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

987

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

988

1

			.try_into()

989

1

			.expect("v3 to latest location conversion failed");

990

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

991

1

			source_id,

992

1

			source_location_latest,

993

1

			asset_metadata.decimals,

994

1

			asset_metadata.symbol.try_into().expect("too long"),

995

1

			asset_metadata.name.try_into().expect("too long"),

996

));

997

1

		assert_ok!(add_supported_asset(

998

1

			source_location.clone(),

999

			2500000000000u128

1000

));

1001

1

});

1002

1003

1

	let dest = Location {

1004

1

		parents: 1,

1005

1

		interior: [

1006

1

			Parachain(2),

1007

1

			AccountKey20 {

1008

1

				network: None,

1009

1

				key: PARAALICE.into(),

1010

1

},

1011

1

1012

1

		.into(),

1013

1

};

1014

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

1015

1016

	// In destination chain, we only need 4 weight

1017

	// We put 10 weight, 6 of which should be refunded and 4 of which should go to treasury

1018

1

	ParaA::execute_with(|| {

1019

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

1020

1

		assert_ok!(PolkadotXcm::transfer_assets(

1021

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1022

1

			Box::new(VersionedLocation::from(chain_part)),

1023

1

			Box::new(VersionedLocation::from(beneficiary)),

1024

1

			Box::new(VersionedAssets::from(vec![asset])),

1025

0,

1026

1

			WeightLimit::Limited(Weight::from_parts(10u64, DEFAULT_PROOF_SIZE))

1027

));

1028

1

});

1029

1

	ParaA::execute_with(|| {

1030

		// free execution, full amount received

1031

1

		assert_eq!(

1032

1

			ParaBalances::free_balance(&PARAALICE.into()),

1033

			INITIAL_BALANCE - 100

1034

);

1035

1

});

1036

1037

	// We are sending 100 tokens from para A.

1038

	// Amount spent in fees is Units per second * weight / 1_000_000_000_000 (weight per second)

1039

	// weight is 4 since we are executing 4 instructions with a unitweightcost of 1.

1040

	// Units per second should be 2_500_000_000_000_000

1041

	// Since we set 10 weight in destination chain, 25 will be charged upfront

1042

	// 15 of those will be refunded, while 10 will go to treasury as the true weight used

1043

	// will be 4

1044

1

	ParaB::execute_with(|| {

1045

1

		assert_eq!(

1046

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1047

1

			Ok(U256::from(90))

1048

);

1049

		// Fee should have been received by treasury

1050

1

		assert_eq!(

1051

1

			EvmForeignAssets::balance(source_id, Treasury::account_id()),

1052

1

			Ok(U256::from(10))

1053

);

1054

1

});

1055

1

1056

1057

#[test]

1058

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1059

1

	MockNet::reset();

1060

1061

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

1062

1

	let source_location: AssetType = para_a_balances

1063

1

		.try_into()

1064

1

		.expect("Location convertion to AssetType should succeed");

1065

1

	let source_id: parachain::AssetId = source_location.clone().into();

1066

1067

1

	let asset_metadata = parachain::AssetMetadata {

1068

1

		name: b"ParaAToken".to_vec(),

1069

1

		symbol: b"ParaA".to_vec(),

1070

1

		decimals: 18,

1071

1

};

1072

1073

1

	ParaB::execute_with(|| {

1074

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1075

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1076

1

			.try_into()

1077

1

			.expect("v3 to latest location conversion failed");

1078

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1079

1

			source_id,

1080

1

			source_location_latest,

1081

1

			asset_metadata.decimals,

1082

1

			asset_metadata.symbol.try_into().expect("too long"),

1083

1

			asset_metadata.name.try_into().expect("too long"),

1084

));

1085

		// With these units per second, 80K weight convrets to 1 asset unit

1086

1

		assert_ok!(add_supported_asset(source_location.clone(), 12500000u128));

1087

1

});

1088

1089

1

	let dest = Location {

1090

1

		parents: 1,

1091

1

		interior: [

1092

1

			Parachain(2),

1093

1

			AccountKey20 {

1094

1

				network: None,

1095

1

				key: PARAALICE.into(),

1096

1

},

1097

1

1098

1

		.into(),

1099

1

};

1100

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

1101

1102

	// we use transfer_with_fee

1103

1

	ParaA::execute_with(|| {

1104

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

1105

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::SelfReserve, 1);

1106

1

		assert_ok!(PolkadotXcm::transfer_assets(

1107

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1108

1

			Box::new(VersionedLocation::from(chain_part)),

1109

1

			Box::new(VersionedLocation::from(beneficiary)),

1110

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

1111

0,

1112

1

			WeightLimit::Limited(Weight::from_parts(800000u64, DEFAULT_PROOF_SIZE))

1113

));

1114

1

});

1115

1

	ParaA::execute_with(|| {

1116

		// 100 tokens transferred plus 1 taken from fees

1117

1

		assert_eq!(

1118

1

			ParaBalances::free_balance(&PARAALICE.into()),

1119

			INITIAL_BALANCE - 100 - 1

1120

);

1121

1

});

1122

1123

1

	ParaB::execute_with(|| {

1124

		// free execution, full amount received because trully the xcm instruction does not cost

1125

		// what it is specified

1126

1

		assert_eq!(

1127

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1128

1

			Ok(U256::from(101))

1129

);

1130

1

});

1131

1

1132

1133

#[test]

1134

1

fn error_when_not_paying_enough() {

1135

1

	MockNet::reset();

1136

1137

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

1138

1

	let source_id: parachain::AssetId = source_location.clone().into();

1139

1140

1

	let asset_metadata = parachain::AssetMetadata {

1141

1

		name: b"RelayToken".to_vec(),

1142

1

		symbol: b"Relay".to_vec(),

1143

1

		decimals: 12,

1144

1

};

1145

1146

1

	let dest: Location = Junction::AccountKey20 {

1147

1

		network: None,

1148

1

		key: PARAALICE,

1149

1

1150

1

	.into();

1151

	// This time we are gonna put a rather high number of units per second

1152

	// we know later we will divide by 1e12

1153

	// Lets put 1e6 as units per second

1154

1

	ParaA::execute_with(|| {

1155

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1156

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1157

1

			.try_into()

1158

1

			.expect("v3 to latest location conversion failed");

1159

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1160

1

			source_id,

1161

1

			source_location_latest,

1162

1

			asset_metadata.decimals,

1163

1

			asset_metadata.symbol.try_into().expect("too long"),

1164

1

			asset_metadata.name.try_into().expect("too long"),

1165

));

1166

1

		assert_ok!(add_supported_asset(

1167

1

			source_location.clone(),

1168

			2500000000000u128

1169

));

1170

1

});

1171

1172

	// We are sending 100 tokens from relay.

1173

	// If we set the dest weight to be 1e7, we know the buy_execution will spend 1e7*1e6/1e12 = 10

1174

	// Therefore with no refund, we should receive 10 tokens less

1175

1

	Relay::execute_with(|| {

1176

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1177

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1178

1

			assets: Wild(All),

1179

1

			beneficiary: dest.clone(),

1180

1

		}]);

1181

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1182

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1183

1

			Box::new(Parachain(1).into()),

1184

1

			Box::new(([] /* Here */, 5).into()),

1185

1

			Box::new(TransferType::LocalReserve),

1186

1

			Box::new(fees_id),

1187

1

			Box::new(TransferType::LocalReserve),

1188

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1189

1

			WeightLimit::Unlimited

1190

));

1191

1

});

1192

1193

1

	ParaA::execute_with(|| {

1194

		// amount not received as it is not paying enough

1195

1

		assert_eq!(

1196

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1197

1

			Ok(U256::from(0))

1198

);

1199

1

});

1200

1

1201

1202

#[test]

1203

1

fn transact_through_derivative_multilocation() {

1204

1

	MockNet::reset();

1205

1206

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

1207

1

	let source_id: parachain::AssetId = source_location.clone().into();

1208

1209

1

	let asset_metadata = parachain::AssetMetadata {

1210

1

		name: b"RelayToken".to_vec(),

1211

1

		symbol: b"Relay".to_vec(),

1212

1

		decimals: 12,

1213

1

};

1214

1215

1

	ParaA::execute_with(|| {

1216

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1217

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1218

1

			.try_into()

1219

1

			.expect("v3 to latest location conversion failed");

1220

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1221

1

			source_id,

1222

1

			source_location_latest,

1223

1

			asset_metadata.decimals,

1224

1

			asset_metadata.symbol.try_into().expect("too long"),

1225

1

			asset_metadata.name.try_into().expect("too long"),

1226

));

1227

1

		assert_ok!(add_supported_asset(source_location.clone(), 1u128));

1228

1229

		// Root can set transact info

1230

1

		assert_ok!(XcmTransactor::set_transact_info(

1231

1

			parachain::RuntimeOrigin::root(),

1232

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

1233

			// Relay charges 1000 for every instruction, and we have 3, so 3000

1234

1

			3000.into(),

1235

1

			20000000000.into(),

1236

1

			None

1237

));

1238

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

1239

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

1240

1

			.expect("must succeed");

1241

1

});

1242

1243

	// Let's construct the call to know how much weight it is going to require

1244

1245

1

	let dest: Location = AccountKey20 {

1246

1

		network: None,

1247

1

		key: PARAALICE,

1248

1

1249

1

	.into();

1250

1

	Relay::execute_with(|| {

1251

		// 4000000000 transact + 3000 correspond to 4000003000 tokens. 100 more for the transfer call

1252

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1253

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1254

1

			assets: Wild(All),

1255

1

			beneficiary: dest.clone(),

1256

1

		}]);

1257

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1258

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1259

1

			Box::new(Parachain(1).into()),

1260

1

			Box::new(([] /* Here */, 4000003100u128).into()),

1261

1

			Box::new(TransferType::LocalReserve),

1262

1

			Box::new(fees_id),

1263

1

			Box::new(TransferType::LocalReserve),

1264

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1265

1

			WeightLimit::Unlimited

1266

));

1267

1

});

1268

1269

1

	ParaA::execute_with(|| {

1270

		// free execution, full amount received

1271

1

		assert_eq!(

1272

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1273

1

			Ok(U256::from(4000003100u64))

1274

);

1275

1

});

1276

1277

	// Register address

1278

1

	ParaA::execute_with(|| {

1279

1

		assert_ok!(XcmTransactor::register(

1280

1

			parachain::RuntimeOrigin::root(),

1281

1

			PARAALICE.into(),

1282

0,

1283

));

1284

1

});

1285

1286

	// Send to registered address

1287

1288

1

	let registered_address = derivative_account_id(para_a_account(), 0);

1289

1

	let dest = Location {

1290

1

		parents: 1,

1291

1

		interior: [AccountId32 {

1292

1

			network: None,

1293

1

			id: registered_address.clone().into(),

1294

1

}]

1295

1

		.into(),

1296

1

};

1297

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

1298

1299

1

	ParaA::execute_with(|| {

1300

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

1301

		// free execution, full amount received

1302

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1303

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1304

1

			assets: Wild(All),

1305

1

			beneficiary: beneficiary.clone(),

1306

1

		}]);

1307

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1308

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1309

1

			Box::new(VersionedLocation::from(chain_part)),

1310

1

			Box::new(VersionedAssets::from(vec![asset])),

1311

1

			Box::new(TransferType::DestinationReserve),

1312

1

			Box::new(fees_id),

1313

1

			Box::new(TransferType::DestinationReserve),

1314

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1315

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

1316

));

1317

1

});

1318

1319

1

	ParaA::execute_with(|| {

1320

		// free execution, full amount received

1321

1

		assert_eq!(

1322

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1323

1

			Ok(U256::from(4000003000u64))

1324

);

1325

1

});

1326

1327

	// What we will do now is transfer this relay tokens from the derived account to the sovereign

1328

	// again

1329

1

	Relay::execute_with(|| {

1330

		// free execution,x	 full amount received

1331

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 4000003000);

1332

1

});

1333

1334

	// Encode the call. Balances transact to para_a_account

1335

	// First index

1336

1

	let mut encoded: Vec<u8> = Vec::new();

1337

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

1338

1

		relay_chain::Balances,

1339

1

>()

1340

1

	.unwrap() as u8;

1341

1342

1

	encoded.push(index);

1343

1344

	// Then call bytes

1345

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

1346

1

		dest: para_a_account(),

1347

1

		value: 100u32.into(),

1348

1

1349

1

	.encode();

1350

1

	encoded.append(&mut call_bytes);

1351

1352

1

	ParaA::execute_with(|| {

1353

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1354

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1355

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1356

0,

1357

1

			CurrencyPayment {

1358

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1359

1

					Location::parent()

1360

1

				))),

1361

1

				fee_amount: None

1362

1

},

1363

1

			encoded,

1364

			// 4000000000 + 3000 we should have taken out 4000003000 tokens from the caller

1365

1

			TransactWeights {

1366

1

				transact_required_weight_at_most: 4000000000.into(),

1367

1

				overall_weight: None

1368

1

},

1369

			false

1370

));

1371

1

});

1372

1373

1

	Relay::execute_with(|| {

1374

		// free execution,x	 full amount received

1375

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

1376

1377

1

		assert!(RelayBalances::free_balance(&registered_address) == 0);

1378

1

});

1379

1

1380

1381

#[test]

1382

1

fn transact_through_derivative_with_custom_fee_weight() {

1383

1

	MockNet::reset();

1384

1385

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

1386

1

	let source_id: parachain::AssetId = source_location.clone().into();

1387

1388

1

	let asset_metadata = parachain::AssetMetadata {

1389

1

		name: b"RelayToken".to_vec(),

1390

1

		symbol: b"Relay".to_vec(),

1391

1

		decimals: 12,

1392

1

};

1393

1394

1

	ParaA::execute_with(|| {

1395

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1396

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1397

1

			.try_into()

1398

1

			.expect("v3 to latest location conversion failed");

1399

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1400

1

			source_id,

1401

1

			source_location_latest,

1402

1

			asset_metadata.decimals,

1403

1

			asset_metadata.symbol.try_into().expect("too long"),

1404

1

			asset_metadata.name.try_into().expect("too long"),

1405

));

1406

1

		assert_ok!(add_supported_asset(source_location.clone(), 1u128));

1407

1

});

1408

1409

	// Let's construct the call to know how much weight it is going to require

1410

1411

1

	let dest: Location = AccountKey20 {

1412

1

		network: None,

1413

1

		key: PARAALICE,

1414

1

1415

1

	.into();

1416

1

	Relay::execute_with(|| {

1417

		// 4000000000 transact + 3000 correspond to 4000003000 tokens. 100 more for the transfer call

1418

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1419

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1420

1

			assets: Wild(All),

1421

1

			beneficiary: dest.clone(),

1422

1

		}]);

1423

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1424

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1425

1

			Box::new(Parachain(1).into()),

1426

1

			Box::new(([] /* Here */, 4000003100u128).into()),

1427

1

			Box::new(TransferType::LocalReserve),

1428

1

			Box::new(fees_id),

1429

1

			Box::new(TransferType::LocalReserve),

1430

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1431

1

			WeightLimit::Unlimited

1432

));

1433

1

});

1434

1435

1

	ParaA::execute_with(|| {

1436

		// free execution, full amount received

1437

1

		assert_eq!(

1438

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1439

1

			Ok(U256::from(4000003100u64))

1440

);

1441

1

});

1442

1443

	// Register address

1444

1

	ParaA::execute_with(|| {

1445

1

		assert_ok!(XcmTransactor::register(

1446

1

			parachain::RuntimeOrigin::root(),

1447

1

			PARAALICE.into(),

1448

0,

1449

));

1450

1

});

1451

1452

	// Send to registered address

1453

1454

1

	let registered_address = derivative_account_id(para_a_account(), 0);

1455

1

	let dest = Location {

1456

1

		parents: 1,

1457

1

		interior: [AccountId32 {

1458

1

			network: None,

1459

1

			id: registered_address.clone().into(),

1460

1

}]

1461

1

		.into(),

1462

1

};

1463

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

1464

1465

1

	ParaA::execute_with(|| {

1466

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

1467

		// free execution, full amount received

1468

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1469

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1470

1

			assets: Wild(All),

1471

1

			beneficiary: beneficiary.clone(),

1472

1

		}]);

1473

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1474

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1475

1

			Box::new(VersionedLocation::from(chain_part)),

1476

1

			Box::new(VersionedAssets::from(vec![asset])),

1477

1

			Box::new(TransferType::DestinationReserve),

1478

1

			Box::new(fees_id),

1479

1

			Box::new(TransferType::DestinationReserve),

1480

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1481

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

1482

));

1483

1

});

1484

1485

1

	ParaA::execute_with(|| {

1486

		// free execution, full amount received

1487

1

		assert_eq!(

1488

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1489

1

			Ok(U256::from(4000003000u64))

1490

);

1491

1

});

1492

1493

	// What we will do now is transfer this relay tokens from the derived account to the sovereign

1494

	// again

1495

1

	Relay::execute_with(|| {

1496

		// free execution,x	 full amount received

1497

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 4000003000);

1498

1

});

1499

1500

	// Encode the call. Balances transact to para_a_account

1501

	// First index

1502

1

	let mut encoded: Vec<u8> = Vec::new();

1503

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

1504

1

		relay_chain::Balances,

1505

1

>()

1506

1

	.unwrap() as u8;

1507

1508

1

	encoded.push(index);

1509

1510

	// Then call bytes

1511

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

1512

1

		dest: para_a_account(),

1513

1

		value: 100u32.into(),

1514

1

1515

1

	.encode();

1516

1

	encoded.append(&mut call_bytes);

1517

1518

1

	let overall_weight = 4000003000u64;

1519

1

	ParaA::execute_with(|| {

1520

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1521

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1522

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1523

0,

1524

1

			CurrencyPayment {

1525

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1526

1

					Location::parent()

1527

1

				))),

1528

1

				// 1-1 fee weight mapping

1529

1

				fee_amount: Some(overall_weight as u128)

1530

1

},

1531

			// 4000000000 + 3000 we should have taken out 4000003000 tokens from the caller

1532

1

			encoded,

1533

1

			TransactWeights {

1534

1

				transact_required_weight_at_most: 4000000000.into(),

1535

1

				overall_weight: Some(Limited(overall_weight.into()))

1536

1

},

1537

			false

1538

));

1539

1

		let event_found: Option<parachain::RuntimeEvent> = parachain::para_events()

1540

1

			.iter()

1541

18

			.find_map(|event| match event.clone() {

1542

				parachain::RuntimeEvent::PolkadotXcm(pallet_xcm::Event::AssetsTrapped {

1543

..

1544

				}) => Some(event.clone()),

1545

18

				_ => None,

1546

18

});

1547

		// Assert that the events do not contain the assets being trapped

1548

1

		assert!(event_found.is_none());

1549

1

});

1550

1551

1

	Relay::execute_with(|| {

1552

		// free execution,x	 full amount received

1553

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

1554

1555

1

		assert!(RelayBalances::free_balance(&registered_address) == 0);

1556

1

});

1557

1

1558

1559

#[test]

1560

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1561

1

	MockNet::reset();

1562

1563

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

1564

1

	let source_id: parachain::AssetId = source_location.clone().into();

1565

1566

1

	let asset_metadata = parachain::AssetMetadata {

1567

1

		name: b"RelayToken".to_vec(),

1568

1

		symbol: b"Relay".to_vec(),

1569

1

		decimals: 12,

1570

1

};

1571

1572

1

	ParaA::execute_with(|| {

1573

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1574

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1575

1

			.try_into()

1576

1

			.expect("v3 to latest location conversion failed");

1577

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1578

1

			source_id,

1579

1

			source_location_latest,

1580

1

			asset_metadata.decimals,

1581

1

			asset_metadata.symbol.try_into().expect("too long"),

1582

1

			asset_metadata.name.try_into().expect("too long"),

1583

));

1584

1

		assert_ok!(add_supported_asset(source_location.clone(), 1u128));

1585

1

});

1586

1587

	// Let's construct the call to know how much weight it is going to require

1588

1589

1

	let dest: Location = AccountKey20 {

1590

1

		network: None,

1591

1

		key: PARAALICE,

1592

1

1593

1

	.into();

1594

1

	Relay::execute_with(|| {

1595

		// 4000000000 transact + 9000 correspond to 4000009000 tokens. 100 more for the transfer call

1596

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1597

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1598

1

			assets: Wild(All),

1599

1

			beneficiary: dest.clone(),

1600

1

		}]);

1601

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1602

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1603

1

			Box::new(Parachain(1).into()),

1604

1

			Box::new(([] /* Here */, 4000009100u128).into()),

1605

1

			Box::new(TransferType::LocalReserve),

1606

1

			Box::new(fees_id),

1607

1

			Box::new(TransferType::LocalReserve),

1608

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1609

1

			WeightLimit::Unlimited

1610

));

1611

1

});

1612

1613

1

	ParaA::execute_with(|| {

1614

		// free execution, full amount received

1615

1

		assert_eq!(

1616

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1617

1

			Ok(U256::from(4000009100u64))

1618

);

1619

1

});

1620

1621

	// Register address

1622

1

	ParaA::execute_with(|| {

1623

1

		assert_ok!(XcmTransactor::register(

1624

1

			parachain::RuntimeOrigin::root(),

1625

1

			PARAALICE.into(),

1626

0,

1627

));

1628

1

});

1629

1630

	// Send to registered address

1631

1632

1

	let registered_address = derivative_account_id(para_a_account(), 0);

1633

1

	let dest = Location {

1634

1

		parents: 1,

1635

1

		interior: [AccountId32 {

1636

1

			network: None,

1637

1

			id: registered_address.clone().into(),

1638

1

}]

1639

1

		.into(),

1640

1

};

1641

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

1642

1643

1

	ParaA::execute_with(|| {

1644

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

1645

		// free execution, full amount received

1646

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1647

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1648

1

			assets: Wild(All),

1649

1

			beneficiary: beneficiary.clone(),

1650

1

		}]);

1651

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1652

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1653

1

			Box::new(VersionedLocation::from(chain_part)),

1654

1

			Box::new(VersionedAssets::from(vec![asset])),

1655

1

			Box::new(TransferType::DestinationReserve),

1656

1

			Box::new(fees_id),

1657

1

			Box::new(TransferType::DestinationReserve),

1658

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1659

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

1660

));

1661

1

});

1662

1663

1

	ParaA::execute_with(|| {

1664

		// free execution, full amount received

1665

1

		assert_eq!(

1666

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1667

1

			Ok(U256::from(4000009000u64))

1668

);

1669

1

});

1670

1671

	// What we will do now is transfer this relay tokens from the derived account to the sovereign

1672

	// again

1673

1

	Relay::execute_with(|| {

1674

		// free execution,x	 full amount received

1675

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 4000009000);

1676

1

});

1677

1678

	// Encode the call. Balances transact to para_a_account

1679

	// First index

1680

1

	let mut encoded: Vec<u8> = Vec::new();

1681

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

1682

1

		relay_chain::Balances,

1683

1

>()

1684

1

	.unwrap() as u8;

1685

1686

1

	encoded.push(index);

1687

1688

	// Then call bytes

1689

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

1690

1

		dest: para_a_account(),

1691

1

		value: 100u32.into(),

1692

1

1693

1

	.encode();

1694

1

	encoded.append(&mut call_bytes);

1695

1696

1

	let overall_weight = 4000009000u64;

1697

1

	ParaA::execute_with(|| {

1698

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1699

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1700

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1701

0,

1702

1

			CurrencyPayment {

1703

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1704

1

					Location::parent()

1705

1

				))),

1706

1

				// 1-1 fee weight mapping

1707

1

				fee_amount: Some(overall_weight as u128)

1708

1

},

1709

1

			encoded,

1710

1

			TransactWeights {

1711

1

				transact_required_weight_at_most: 4000000000.into(),

1712

1

				overall_weight: Some(Limited(overall_weight.into()))

1713

1

},

1714

			true

1715

));

1716

1

		let event_found: Option<parachain::RuntimeEvent> = parachain::para_events()

1717

1

			.iter()

1718

18

			.find_map(|event| match event.clone() {

1719

				parachain::RuntimeEvent::PolkadotXcm(pallet_xcm::Event::AssetsTrapped {

1720

..

1721

				}) => Some(event.clone()),

1722

18

				_ => None,

1723

18

});

1724

		// Assert that the events do not contain the assets being trapped

1725

1

		assert!(event_found.is_none());

1726

1

});

1727

1728

1

	Relay::execute_with(|| {

1729

		// free execution,x	 full amount received

1730

		// 4000009000 refunded + 100 transferred = 4000009100

1731

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 4000009100);

1732

1

		assert_eq!(RelayBalances::free_balance(&registered_address), 0);

1733

1

});

1734

1

1735

1736

#[test]

1737

1

fn transact_through_sovereign() {

1738

1

	MockNet::reset();

1739

1740

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

1741

1

	let source_id: parachain::AssetId = source_location.clone().into();

1742

1743

1

	let asset_metadata = parachain::AssetMetadata {

1744

1

		name: b"RelayToken".to_vec(),

1745

1

		symbol: b"Relay".to_vec(),

1746

1

		decimals: 12,

1747

1

};

1748

1749

1

	ParaA::execute_with(|| {

1750

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1751

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1752

1

			.try_into()

1753

1

			.expect("v3 to latest location conversion failed");

1754

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1755

1

			source_id,

1756

1

			source_location_latest,

1757

1

			asset_metadata.decimals,

1758

1

			asset_metadata.symbol.try_into().expect("too long"),

1759

1

			asset_metadata.name.try_into().expect("too long"),

1760

));

1761

1

		assert_ok!(add_supported_asset(source_location.clone(), 1u128));

1762

1763

		// Root can set transact info

1764

1

		assert_ok!(XcmTransactor::set_transact_info(

1765

1

			parachain::RuntimeOrigin::root(),

1766

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

1767

			// Relay charges 1000 for every instruction, and we have 3, so 3000

1768

1

			3000.into(),

1769

1

			20000000000.into(),

1770

1

			None

1771

));

1772

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

1773

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

1774

1

			.expect("must succeed");

1775

1

});

1776

1777

1

	let dest: Location = AccountKey20 {

1778

1

		network: None,

1779

1

		key: PARAALICE,

1780

1

1781

1

	.into();

1782

1

	Relay::execute_with(|| {

1783

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1784

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1785

1

			assets: Wild(All),

1786

1

			beneficiary: dest.clone(),

1787

1

		}]);

1788

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1789

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1790

1

			Box::new(Parachain(1).into()),

1791

1

			Box::new(([] /* Here */, 4000003100u128).into()),

1792

1

			Box::new(TransferType::LocalReserve),

1793

1

			Box::new(fees_id),

1794

1

			Box::new(TransferType::LocalReserve),

1795

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1796

1

			WeightLimit::Unlimited

1797

));

1798

1

});

1799

1800

1

	ParaA::execute_with(|| {

1801

		// free execution, full amount received

1802

1

		assert_eq!(

1803

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1804

1

			Ok(U256::from(4000003100u64))

1805

);

1806

1

});

1807

1808

	// Register address

1809

1

	ParaA::execute_with(|| {

1810

1

		assert_ok!(XcmTransactor::register(

1811

1

			parachain::RuntimeOrigin::root(),

1812

1

			PARAALICE.into(),

1813

0,

1814

));

1815

1

});

1816

1817

	// Send to registered address

1818

1

	let registered_address = derivative_account_id(para_a_account(), 0);

1819

1

	let dest = Location {

1820

1

		parents: 1,

1821

1

		interior: [AccountId32 {

1822

1

			network: None,

1823

1

			id: registered_address.clone().into(),

1824

1

}]

1825

1

		.into(),

1826

1

};

1827

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

1828

1829

1

	ParaA::execute_with(|| {

1830

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

1831

		// free execution, full amount received

1832

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1833

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1834

1

			assets: Wild(All),

1835

1

			beneficiary: beneficiary.clone(),

1836

1

		}]);

1837

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1838

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

1839

1

			Box::new(VersionedLocation::from(chain_part)),

1840

1

			Box::new(VersionedAssets::from(vec![asset])),

1841

1

			Box::new(TransferType::DestinationReserve),

1842

1

			Box::new(fees_id),

1843

1

			Box::new(TransferType::DestinationReserve),

1844

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1845

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

1846

));

1847

1

});

1848

1849

1

	ParaA::execute_with(|| {

1850

		// free execution, full amount received

1851

1

		assert_eq!(

1852

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1853

1

			Ok(U256::from(4000003000u64))

1854

);

1855

1

});

1856

1857

	// What we will do now is transfer this relay tokens from the derived account to the sovereign

1858

	// again

1859

1

	Relay::execute_with(|| {

1860

		// free execution,x	 full amount received

1861

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 4000003000);

1862

1

1863

1

});

1864

1865

	// We send the xcm transact operation to parent

1866

1

	let dest = Location {

1867

1

		parents: 1,

1868

1

		interior: /* Here */ [].into(),

1869

1

};

1870

1871

	// Encode the call. Balances transact to para_a_account

1872

	// First index

1873

1

	let mut encoded: Vec<u8> = Vec::new();

1874

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

1875

1

		relay_chain::Balances,

1876

1

>()

1877

1

	.unwrap() as u8;

1878

1879

1

	encoded.push(index);

1880

1881

	// Then call bytes

1882

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

1883

1

		dest: para_a_account(),

1884

1

		value: 100u32.into(),

1885

1

1886

1

	.encode();

1887

1

	encoded.append(&mut call_bytes);

1888

1889

	// Root can directly pass the execution byes to the sovereign

1890

1

	ParaA::execute_with(|| {

1891

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

1892

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1893

1

			xcm_primitives::UtilityAvailableCalls::AsDerivative(0, encoded),

1894

);

1895

1896

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1897

1

			parachain::RuntimeOrigin::root(),

1898

1

			Box::new(xcm::VersionedLocation::from(dest)),

1899

1

			Some(PARAALICE.into()),

1900

1

			CurrencyPayment {

1901

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

1902

1

					Location::parent()

1903

1

				))),

1904

1

				fee_amount: None

1905

1

},

1906

1

			utility_bytes,

1907

1

			OriginKind::SovereignAccount,

1908

1

			TransactWeights {

1909

1

				transact_required_weight_at_most: 4000000000.into(),

1910

1

				overall_weight: None

1911

1

},

1912

			false

1913

));

1914

1

});

1915

1916

1

	Relay::execute_with(|| {

1917

		// free execution,x	 full amount received

1918

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

1919

1920

1

		assert!(RelayBalances::free_balance(&registered_address) == 0);

1921

1

});

1922

1

1923

1924

#[test]

1925

1

fn transact_through_sovereign_fee_payer_none() {

1926

1

	MockNet::reset();

1927

1928

1

	ParaA::execute_with(|| {

1929

		// Root can set transact info

1930

1

		assert_ok!(XcmTransactor::set_transact_info(

1931

1

			parachain::RuntimeOrigin::root(),

1932

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

1933

			// Relay charges 1000 for every instruction, and we have 3, so 3000

1934

1

			3000.into(),

1935

1

			20000000000.into(),

1936

1

			None

1937

));

1938

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

1939

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

1940

1

			.expect("must succeed");

1941

1

});

1942

1943

1

	let derivative_address = derivative_account_id(para_a_account(), 0);

1944

1945

1

	Relay::execute_with(|| {

1946

		// Transfer 100 tokens to derivative_address on the relay

1947

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1948

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1949

1

			derivative_address.clone(),

1950

			100u128

1951

));

1952

1953

		// Transfer the XCM execution fee amount to ParaA's sovereign account

1954

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1955

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1956

1

			para_a_account(),

1957

			4000003000u128

1958

));

1959

1

});

1960

1961

	// Check balances before the transact call

1962

1

	Relay::execute_with(|| {

1963

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 4000003000);

1964

1

		assert_eq!(RelayBalances::free_balance(&derivative_address), 100);

1965

1

		assert_eq!(RelayBalances::free_balance(&RELAYBOB), 0);

1966

1

});

1967

1968

	// Encode the call. Balances transfer of 100 relay tokens to RELAYBOB

1969

1

	let mut encoded: Vec<u8> = Vec::new();

1970

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

1971

1

		relay_chain::Balances,

1972

1

>()

1973

1

	.unwrap() as u8;

1974

1975

1

	encoded.push(index);

1976

1977

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

1978

1

		dest: RELAYBOB,

1979

1

		value: 100u32.into(),

1980

1

1981

1

	.encode();

1982

1

	encoded.append(&mut call_bytes);

1983

1984

	// We send the xcm transact operation to parent

1985

1

	let dest = Location {

1986

1

		parents: 1,

1987

1

		interior: /* Here */ [].into(),

1988

1

};

1989

1990

	// Root can directly pass the execution byes to the sovereign

1991

1

	ParaA::execute_with(|| {

1992

		// The final call will be an AsDerivative using index 0

1993

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

1994

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1995

1

			xcm_primitives::UtilityAvailableCalls::AsDerivative(0, encoded),

1996

);

1997

1998

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1999

1

			parachain::RuntimeOrigin::root(),

2000

1

			Box::new(xcm::VersionedLocation::from(dest)),

2001

			// No fee_payer here. The sovereign account will pay the fees on destination.

2002

1

			None,

2003

1

			CurrencyPayment {

2004

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

2005

1

					Location::parent()

2006

1

				))),

2007

1

				fee_amount: None

2008

1

},

2009

1

			utility_bytes,

2010

1

			OriginKind::SovereignAccount,

2011

1

			TransactWeights {

2012

1

				transact_required_weight_at_most: 4000000000.into(),

2013

1

				overall_weight: None

2014

1

},

2015

			false

2016

));

2017

1

});

2018

2019

	// Check balances after the transact call are correct

2020

1

	Relay::execute_with(|| {

2021

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 0);

2022

1

		assert_eq!(RelayBalances::free_balance(&derivative_address), 0);

2023

1

		assert_eq!(RelayBalances::free_balance(&RELAYBOB), 100);

2024

1

});

2025

1

2026

2027

#[test]

2028

1

fn transact_through_sovereign_with_custom_fee_weight() {

2029

1

	MockNet::reset();

2030

2031

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2032

1

	let source_id: parachain::AssetId = source_location.clone().into();

2033

2034

1

	let asset_metadata = parachain::AssetMetadata {

2035

1

		name: b"RelayToken".to_vec(),

2036

1

		symbol: b"Relay".to_vec(),

2037

1

		decimals: 12,

2038

1

};

2039

2040

1

	ParaA::execute_with(|| {

2041

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2042

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2043

1

			.try_into()

2044

1

			.expect("v3 to latest location conversion failed");

2045

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2046

1

			source_id,

2047

1

			source_location_latest,

2048

1

			asset_metadata.decimals,

2049

1

			asset_metadata.symbol.try_into().expect("too long"),

2050

1

			asset_metadata.name.try_into().expect("too long"),

2051

));

2052

1

		assert_ok!(add_supported_asset(source_location.clone(), 1u128));

2053

1

});

2054

2055

1

	let dest: Location = AccountKey20 {

2056

1

		network: None,

2057

1

		key: PARAALICE,

2058

1

2059

1

	.into();

2060

1

	Relay::execute_with(|| {

2061

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2062

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2063

1

			assets: Wild(All),

2064

1

			beneficiary: dest.clone(),

2065

1

		}]);

2066

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2067

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2068

1

			Box::new(Parachain(1).into()),

2069

1

			Box::new(([] /* Here */, 4000003100u128).into()),

2070

1

			Box::new(TransferType::LocalReserve),

2071

1

			Box::new(fees_id),

2072

1

			Box::new(TransferType::LocalReserve),

2073

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2074

1

			WeightLimit::Unlimited

2075

));

2076

1

});

2077

2078

1

	ParaA::execute_with(|| {

2079

		// free execution, full amount received

2080

1

		assert_eq!(

2081

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2082

1

			Ok(U256::from(4000003100u64))

2083

);

2084

1

});

2085

2086

	// Register address

2087

1

	ParaA::execute_with(|| {

2088

1

		assert_ok!(XcmTransactor::register(

2089

1

			parachain::RuntimeOrigin::root(),

2090

1

			PARAALICE.into(),

2091

0,

2092

));

2093

1

});

2094

2095

	// Send to registered address

2096

1

	let registered_address = derivative_account_id(para_a_account(), 0);

2097

1

	let dest = Location {

2098

1

		parents: 1,

2099

1

		interior: [AccountId32 {

2100

1

			network: None,

2101

1

			id: registered_address.clone().into(),

2102

1

}]

2103

1

		.into(),

2104

1

};

2105

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

2106

2107

1

	ParaA::execute_with(|| {

2108

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

2109

		// free execution, full amount received

2110

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

2111

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2112

1

			assets: Wild(All),

2113

1

			beneficiary: beneficiary.clone(),

2114

1

		}]);

2115

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2116

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

2117

1

			Box::new(VersionedLocation::from(chain_part)),

2118

1

			Box::new(VersionedAssets::from(vec![asset])),

2119

1

			Box::new(TransferType::DestinationReserve),

2120

1

			Box::new(fees_id),

2121

1

			Box::new(TransferType::DestinationReserve),

2122

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2123

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

2124

));

2125

1

});

2126

2127

1

	ParaA::execute_with(|| {

2128

		// free execution, full amount received

2129

1

		assert_eq!(

2130

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2131

1

			Ok(U256::from(4000003000u64))

2132

);

2133

1

});

2134

2135

	// What we will do now is transfer this relay tokens from the derived account to the sovereign

2136

	// again

2137

1

	Relay::execute_with(|| {

2138

		// free execution,x	 full amount received

2139

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 4000003000);

2140

1

2141

1

});

2142

2143

	// We send the xcm transact operation to parent

2144

1

	let dest = Location {

2145

1

		parents: 1,

2146

1

		interior: /* Here */ [].into(),

2147

1

};

2148

2149

	// Encode the call. Balances transact to para_a_account

2150

	// First index

2151

1

	let mut encoded: Vec<u8> = Vec::new();

2152

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

2153

1

		relay_chain::Balances,

2154

1

>()

2155

1

	.unwrap() as u8;

2156

2157

1

	encoded.push(index);

2158

2159

	// Then call bytes

2160

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

2161

1

		dest: para_a_account(),

2162

1

		value: 100u32.into(),

2163

1

2164

1

	.encode();

2165

1

	encoded.append(&mut call_bytes);

2166

2167

1

	let total_weight = 4000003000u64;

2168

	// Root can directly pass the execution byes to the sovereign

2169

1

	ParaA::execute_with(|| {

2170

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

2171

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2172

1

			xcm_primitives::UtilityAvailableCalls::AsDerivative(0, encoded),

2173

);

2174

2175

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2176

1

			parachain::RuntimeOrigin::root(),

2177

1

			Box::new(xcm::VersionedLocation::from(dest)),

2178

1

			Some(PARAALICE.into()),

2179

1

			CurrencyPayment {

2180

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

2181

1

					Location::parent()

2182

1

				))),

2183

1

				// 1-1 fee-weight mapping

2184

1

				fee_amount: Some(total_weight as u128)

2185

1

},

2186

1

			utility_bytes,

2187

1

			OriginKind::SovereignAccount,

2188

1

			TransactWeights {

2189

1

				transact_required_weight_at_most: 4000000000.into(),

2190

1

				overall_weight: Some(Limited(total_weight.into()))

2191

1

},

2192

			false

2193

));

2194

1

});

2195

2196

1

	Relay::execute_with(|| {

2197

		// free execution,x	 full amount received

2198

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

2199

2200

1

		assert!(RelayBalances::free_balance(&registered_address) == 0);

2201

1

});

2202

1

2203

2204

#[test]

2205

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2206

1

	MockNet::reset();

2207

2208

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2209

1

	let source_id: parachain::AssetId = source_location.clone().into();

2210

2211

1

	let asset_metadata = parachain::AssetMetadata {

2212

1

		name: b"RelayToken".to_vec(),

2213

1

		symbol: b"Relay".to_vec(),

2214

1

		decimals: 12,

2215

1

};

2216

2217

1

	ParaA::execute_with(|| {

2218

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2219

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2220

1

			.try_into()

2221

1

			.expect("v3 to latest location conversion failed");

2222

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2223

1

			source_id,

2224

1

			source_location_latest,

2225

1

			asset_metadata.decimals,

2226

1

			asset_metadata.symbol.try_into().expect("too long"),

2227

1

			asset_metadata.name.try_into().expect("too long"),

2228

));

2229

1

		assert_ok!(add_supported_asset(source_location.clone(), 1u128));

2230

1

});

2231

2232

1

	let dest: Location = AccountKey20 {

2233

1

		network: None,

2234

1

		key: PARAALICE,

2235

1

2236

1

	.into();

2237

1

	Relay::execute_with(|| {

2238

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2239

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2240

1

			assets: Wild(All),

2241

1

			beneficiary: dest.clone(),

2242

1

		}]);

2243

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2244

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2245

1

			Box::new(Parachain(1).into()),

2246

1

			Box::new(([] /* Here */, 4000009100u128).into()),

2247

1

			Box::new(TransferType::LocalReserve),

2248

1

			Box::new(fees_id),

2249

1

			Box::new(TransferType::LocalReserve),

2250

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2251

1

			WeightLimit::Unlimited

2252

));

2253

1

});

2254

2255

1

	ParaA::execute_with(|| {

2256

		// free execution, full amount received

2257

1

		assert_eq!(

2258

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2259

1

			Ok(U256::from(4000009100u64))

2260

);

2261

1

});

2262

2263

	// Register address

2264

1

	ParaA::execute_with(|| {

2265

1

		assert_ok!(XcmTransactor::register(

2266

1

			parachain::RuntimeOrigin::root(),

2267

1

			PARAALICE.into(),

2268

0,

2269

));

2270

1

});

2271

2272

	// Send to registered address

2273

1

	let registered_address = derivative_account_id(para_a_account(), 0);

2274

1

	let dest = Location {

2275

1

		parents: 1,

2276

1

		interior: [AccountId32 {

2277

1

			network: None,

2278

1

			id: registered_address.clone().into(),

2279

1

}]

2280

1

		.into(),

2281

1

};

2282

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

2283

2284

1

	ParaA::execute_with(|| {

2285

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_id), 100);

2286

		// free execution, full amount received

2287

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

2288

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2289

1

			assets: Wild(All),

2290

1

			beneficiary: beneficiary.clone(),

2291

1

		}]);

2292

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2293

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

2294

1

			Box::new(VersionedLocation::from(chain_part)),

2295

1

			Box::new(VersionedAssets::from(vec![asset])),

2296

1

			Box::new(TransferType::DestinationReserve),

2297

1

			Box::new(fees_id),

2298

1

			Box::new(TransferType::DestinationReserve),

2299

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2300

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

2301

));

2302

1

});

2303

2304

1

	ParaA::execute_with(|| {

2305

		// free execution, full amount received

2306

1

		assert_eq!(

2307

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2308

1

			Ok(U256::from(4000009000u64))

2309

);

2310

1

});

2311

2312

	// What we will do now is transfer this relay tokens from the derived account to the sovereign

2313

	// again

2314

1

	Relay::execute_with(|| {

2315

		// free execution,x	 full amount received

2316

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 4000009000);

2317

1

2318

1

});

2319

2320

	// We send the xcm transact operation to parent

2321

1

	let dest = Location {

2322

1

		parents: 1,

2323

1

		interior: /* Here */ [].into(),

2324

1

};

2325

2326

	// Encode the call. Balances transact to para_a_account

2327

	// First index

2328

1

	let mut encoded: Vec<u8> = Vec::new();

2329

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

2330

1

		relay_chain::Balances,

2331

1

>()

2332

1

	.unwrap() as u8;

2333

2334

1

	encoded.push(index);

2335

2336

	// Then call bytes

2337

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

2338

1

		dest: para_a_account(),

2339

1

		value: 100u32.into(),

2340

1

2341

1

	.encode();

2342

1

	encoded.append(&mut call_bytes);

2343

2344

1

	let total_weight = 4000009000u64;

2345

	// Root can directly pass the execution byes to the sovereign

2346

1

	ParaA::execute_with(|| {

2347

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

2348

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2349

1

			xcm_primitives::UtilityAvailableCalls::AsDerivative(0, encoded),

2350

);

2351

2352

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2353

1

			parachain::RuntimeOrigin::root(),

2354

1

			Box::new(xcm::VersionedLocation::from(dest)),

2355

1

			Some(PARAALICE.into()),

2356

1

			CurrencyPayment {

2357

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

2358

1

					Location::parent()

2359

1

				))),

2360

1

				// 1-1 fee-weight mapping

2361

1

				fee_amount: Some(total_weight as u128)

2362

1

},

2363

1

			utility_bytes,

2364

1

			OriginKind::SovereignAccount,

2365

1

			TransactWeights {

2366

1

				transact_required_weight_at_most: 4000000000.into(),

2367

1

				overall_weight: Some(Limited(total_weight.into()))

2368

1

},

2369

			true

2370

));

2371

1

});

2372

2373

1

	Relay::execute_with(|| {

2374

		// free execution, full amount received

2375

		// 4000009000 refunded + 100 transferred = 4000009100

2376

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 4000009100);

2377

2378

1

		assert_eq!(RelayBalances::free_balance(&registered_address), 0);

2379

1

});

2380

1

2381

2382

#[test]

2383

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2384

1

	MockNet::reset();

2385

2386

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2387

1

	let source_id: parachain::AssetId = source_location.clone().into();

2388

1

	let asset_metadata = parachain::AssetMetadata {

2389

1

		name: b"RelayToken".to_vec(),

2390

1

		symbol: b"Relay".to_vec(),

2391

1

		decimals: 12,

2392

1

};

2393

	// register relay asset in parachain A and set XCM version to 1

2394

1

	ParaA::execute_with(|| {

2395

1

		parachain::XcmVersioner::set_version(1);

2396

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2397

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2398

1

			.try_into()

2399

1

			.expect("v3 to latest location conversion failed");

2400

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2401

1

			source_id,

2402

1

			source_location_latest,

2403

1

			asset_metadata.decimals,

2404

1

			asset_metadata.symbol.try_into().expect("too long"),

2405

1

			asset_metadata.name.try_into().expect("too long"),

2406

));

2407

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

2408

1

});

2409

2410

1

	let response = Response::Version(2);

2411

1

	let querier: Location = ([]/* Here */).into();

2412

2413

	// This is irrelevant, nothing will be done with this message,

2414

	// but we need to pass a message as an argument to trigger the storage change

2415

1

	let mock_message: Xcm<()> = Xcm(vec![QueryResponse {

2416

1

		query_id: 0,

2417

1

		response,

2418

1

		max_weight: Weight::zero(),

2419

1

		querier: Some(querier),

2420

1

	}]);

2421

	// The router is mocked, and we cannot use WrapVersion in ChildParachainRouter. So we will force

2422

	// it directly here

2423

	// Actually send relay asset to parachain

2424

1

	let dest: Location = AccountKey20 {

2425

1

		network: None,

2426

1

		key: PARAALICE,

2427

1

2428

1

	.into();

2429

2430

1

	Relay::execute_with(|| {

2431

		// This sets the default version, for not known destinations

2432

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2433

1

			relay_chain::RuntimeOrigin::root(),

2434

1

			Some(3)

2435

));

2436

2437

		// Wrap version, which sets VersionedStorage

2438

		// This is necessary because the mock router does not use wrap_version, but

2439

		// this is not necessary in prod

2440

1

		assert_ok!(<RelayChainPalletXcm as WrapVersion>::wrap_version(

2441

1

			&Parachain(1).into(),

2442

1

			mock_message

2443

));

2444

2445

		// Transfer assets. Since it is an unknown destination, it will query for version

2446

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2447

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2448

1

			assets: Wild(All),

2449

1

			beneficiary: dest.clone(),

2450

1

		}]);

2451

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2452

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2453

1

			Box::new(Parachain(1).into()),

2454

1

			Box::new(([] /* Here */, 123).into()),

2455

1

			Box::new(TransferType::LocalReserve),

2456

1

			Box::new(fees_id),

2457

1

			Box::new(TransferType::LocalReserve),

2458

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2459

1

			WeightLimit::Unlimited

2460

));

2461

2462

		// Let's advance the relay. This should trigger the subscription message

2463

1

		relay_chain::relay_roll_to(2);

2464

2465

		// queries should have been updated

2466

1

		assert!(RelayChainPalletXcm::query(&0).is_some());

2467

1

});

2468

2469

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2470

1

		pallet_xcm::Event::SupportedVersionChanged {

2471

1

			location: Location {

2472

1

				parents: 0,

2473

1

				interior: [Parachain(1)].into(),

2474

1

},

2475

1

			version: 1,

2476

1

2477

1

		.into();

2478

2479

1

	Relay::execute_with(|| {

2480

		// Assert that the events vector contains the version change

2481

1

		assert!(relay_chain::relay_events().contains(&expected_supported_version));

2482

1

});

2483

2484

	// ParaA changes version to 2, and calls on_runtime_upgrade. This should notify the targets

2485

	// of the new version change

2486

1

	ParaA::execute_with(|| {

2487

		// Set version

2488

1

		parachain::XcmVersioner::set_version(2);

2489

		// Do runtime upgrade

2490

1

		parachain::on_runtime_upgrade();

2491

		// Initialize block, to call on_initialize and notify targets

2492

1

		parachain::para_roll_to(2);

2493

		// Expect the event in the parachain

2494

1

		assert!(parachain::para_events().iter().any(|e| matches!(

2495

2

e,

2496

			parachain::RuntimeEvent::PolkadotXcm(pallet_xcm::Event::VersionChangeNotified {

2497

				result: 2,

2498

..

2499

})

2500

		)));

2501

1

});

2502

2503

	// This event should have been seen in the relay

2504

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2505

1

		pallet_xcm::Event::SupportedVersionChanged {

2506

1

			location: Location {

2507

1

				parents: 0,

2508

1

				interior: [Parachain(1)].into(),

2509

1

},

2510

1

			version: 2,

2511

1

2512

1

		.into();

2513

2514

1

	Relay::execute_with(|| {

2515

		// Assert that the events vector contains the new version change

2516

1

		assert!(relay_chain::relay_events().contains(&expected_supported_version_2));

2517

1

});

2518

1

2519

2520

#[test]

2521

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2522

1

	MockNet::reset();

2523

2524

1

	let para_a_balances = Location::new(1, [Parachain(1), PalletInstance(1u8)]);

2525

1

	let source_location: AssetType = para_a_balances

2526

1

		.try_into()

2527

1

		.expect("Location convertion to AssetType should succeed");

2528

1

	let source_id: parachain::AssetId = source_location.clone().into();

2529

2530

1

	let asset_metadata = parachain::AssetMetadata {

2531

1

		name: b"ParaAToken".to_vec(),

2532

1

		symbol: b"ParaA".to_vec(),

2533

1

		decimals: 18,

2534

1

};

2535

1

	let response = Response::Version(2);

2536

1

	let querier: Location = [] /* Here */

2537

1

		.into();

2538

2539

	// This is irrelevant, nothing will be done with this message,

2540

	// but we need to pass a message as an argument to trigger the storage change

2541

1

	let mock_message: Xcm<()> = Xcm(vec![QueryResponse {

2542

1

		query_id: 0,

2543

1

		response,

2544

1

		max_weight: Weight::zero(),

2545

1

		querier: Some(querier),

2546

1

	}]);

2547

2548

1

	ParaA::execute_with(|| {

2549

		// advertised version

2550

1

		parachain::XcmVersioner::set_version(2);

2551

1

});

2552

2553

1

	ParaB::execute_with(|| {

2554

		// Let's try with v0

2555

1

		parachain::XcmVersioner::set_version(0);

2556

2557

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2558

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2559

1

			.try_into()

2560

1

			.expect("v3 to latest location conversion failed");

2561

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2562

1

			source_id,

2563

1

			source_location_latest,

2564

1

			asset_metadata.decimals,

2565

1

			asset_metadata.symbol.try_into().expect("too long"),

2566

1

			asset_metadata.name.try_into().expect("too long"),

2567

));

2568

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

2569

1

});

2570

2571

1

	ParaA::execute_with(|| {

2572

		// This sets the default version, for not known destinations

2573

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2574

1

			parachain::RuntimeOrigin::root(),

2575

1

			Some(3)

2576

));

2577

		// Wrap version, which sets VersionedStorage

2578

1

		assert_ok!(<ParachainPalletXcm as WrapVersion>::wrap_version(

2579

1

			&Location::new(1, [Parachain(2)]).into(),

2580

1

			mock_message

2581

));

2582

2583

1

		parachain::para_roll_to(2);

2584

2585

		// queries should have been updated

2586

1

		assert!(ParachainPalletXcm::query(&0).is_some());

2587

1

});

2588

2589

1

	let expected_supported_version: parachain::RuntimeEvent =

2590

1

		pallet_xcm::Event::SupportedVersionChanged {

2591

1

			location: Location {

2592

1

				parents: 1,

2593

1

				interior: [Parachain(2)].into(),

2594

1

},

2595

1

			version: 0,

2596

1

2597

1

		.into();

2598

2599

1

	ParaA::execute_with(|| {

2600

		// Assert that the events vector contains the version change

2601

1

		assert!(parachain::para_events().contains(&expected_supported_version));

2602

1

});

2603

2604

	// Let's ensure talking in v0 works

2605

1

	let dest = Location {

2606

1

		parents: 1,

2607

1

		interior: [

2608

1

			Parachain(2),

2609

1

			AccountKey20 {

2610

1

				network: None,

2611

1

				key: PARAALICE.into(),

2612

1

},

2613

1

2614

1

		.into(),

2615

1

};

2616

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

2617

1

	ParaA::execute_with(|| {

2618

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 100);

2619

		// free execution, full amount received

2620

1

		assert_ok!(PolkadotXcm::transfer_assets(

2621

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

2622

1

			Box::new(VersionedLocation::from(chain_part)),

2623

1

			Box::new(VersionedLocation::from(beneficiary)),

2624

1

			Box::new(VersionedAssets::from(vec![asset])),

2625

0,

2626

1

			WeightLimit::Limited(Weight::from_parts(80u64, DEFAULT_PROOF_SIZE))

2627

));

2628

		// free execution, full amount received

2629

1

		assert_eq!(

2630

1

			ParaBalances::free_balance(&PARAALICE.into()),

2631

			INITIAL_BALANCE - 100

2632

);

2633

1

});

2634

2635

1

	ParaB::execute_with(|| {

2636

		// free execution, full amount received

2637

1

		assert_eq!(

2638

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2639

1

			Ok(U256::from(100))

2640

);

2641

1

});

2642

2643

	// ParaB changes version to 2, and calls on_runtime_upgrade. This should notify the targets

2644

	// of the new version change

2645

1

	ParaB::execute_with(|| {

2646

		// Set version

2647

1

		parachain::XcmVersioner::set_version(2);

2648

		// Do runtime upgrade

2649

1

		parachain::on_runtime_upgrade();

2650

		// Initialize block, to call on_initialize and notify targets

2651

1

		parachain::para_roll_to(2);

2652

		// Expect the event in the parachain

2653

1

		assert!(parachain::para_events().iter().any(|e| matches!(

2654

2

e,

2655

			parachain::RuntimeEvent::PolkadotXcm(pallet_xcm::Event::VersionChangeNotified {

2656

				result: 2,

2657

..

2658

})

2659

		)));

2660

1

});

2661

2662

	// This event should have been seen in para A

2663

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2664

1

		pallet_xcm::Event::SupportedVersionChanged {

2665

1

			location: Location {

2666

1

				parents: 1,

2667

1

				interior: [Parachain(2)].into(),

2668

1

},

2669

1

			version: 2,

2670

1

2671

1

		.into();

2672

2673

	// Para A should have received the version change

2674

1

	ParaA::execute_with(|| {

2675

		// Assert that the events vector contains the new version change

2676

1

		assert!(parachain::para_events().contains(&expected_supported_version_2));

2677

1

});

2678

1

2679

2680

#[test]

2681

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2682

1

	MockNet::reset();

2683

2684

1

	let fresh_account = PARABOB;

2685

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2686

1

	let source_id: parachain::AssetId = source_location.clone().into();

2687

1

	let asset_metadata = parachain::AssetMetadata {

2688

1

		name: b"RelayToken".to_vec(),

2689

1

		symbol: b"Relay".to_vec(),

2690

1

		decimals: 12,

2691

1

};

2692

	// register relay asset in parachain A

2693

1

	ParaA::execute_with(|| {

2694

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2695

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2696

1

			.try_into()

2697

1

			.expect("v3 to latest location conversion failed");

2698

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2699

1

			source_id,

2700

1

			source_location_latest,

2701

1

			asset_metadata.decimals,

2702

1

			asset_metadata.symbol.try_into().expect("too long"),

2703

1

			asset_metadata.name.try_into().expect("too long"),

2704

));

2705

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

2706

1

});

2707

2708

	// Actually send relay asset to parachain

2709

1

	let dest: Location = AccountKey20 {

2710

1

		network: None,

2711

1

		key: fresh_account,

2712

1

2713

1

	.into();

2714

1

	Relay::execute_with(|| {

2715

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2716

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2717

1

			assets: Wild(All),

2718

1

			beneficiary: dest.clone(),

2719

1

		}]);

2720

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2721

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2722

1

			Box::new(Parachain(1).into()),

2723

1

			Box::new(([] /* Here */, 123).into()),

2724

1

			Box::new(TransferType::LocalReserve),

2725

1

			Box::new(fees_id),

2726

1

			Box::new(TransferType::LocalReserve),

2727

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2728

1

			WeightLimit::Unlimited

2729

));

2730

1

});

2731

2732

	// parachain should have received assets

2733

1

	ParaA::execute_with(|| {

2734

		// free execution, full amount received

2735

1

		assert_eq!(

2736

1

			EvmForeignAssets::balance(source_id, fresh_account.into()),

2737

1

			Ok(U256::from(123))

2738

);

2739

1

});

2740

1

2741

2742

#[test]

2743

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2744

1

	MockNet::reset();

2745

2746

1

	let fresh_account = [2u8; 20];

2747

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2748

1

	let source_id: parachain::AssetId = source_location.clone().into();

2749

1

	let asset_metadata = parachain::AssetMetadata {

2750

1

		name: b"RelayToken".to_vec(),

2751

1

		symbol: b"Relay".to_vec(),

2752

1

		decimals: 12,

2753

1

};

2754

	// register relay asset in parachain A

2755

1

	ParaA::execute_with(|| {

2756

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2757

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2758

1

			.try_into()

2759

1

			.expect("v3 to latest location conversion failed");

2760

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2761

1

			source_id,

2762

1

			source_location_latest,

2763

1

			asset_metadata.decimals,

2764

1

			asset_metadata.symbol.try_into().expect("too long"),

2765

1

			asset_metadata.name.try_into().expect("too long"),

2766

));

2767

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

2768

1

});

2769

2770

	// Actually send relay asset to parachain

2771

1

	let dest: Location = AccountKey20 {

2772

1

		network: None,

2773

1

		key: fresh_account,

2774

1

2775

1

	.into();

2776

1

	Relay::execute_with(|| {

2777

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2778

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2779

1

			assets: Wild(All),

2780

1

			beneficiary: dest.clone(),

2781

1

		}]);

2782

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2783

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2784

1

			Box::new(Parachain(1).into()),

2785

1

			Box::new(([] /* Here */, 123).into()),

2786

1

			Box::new(TransferType::LocalReserve),

2787

1

			Box::new(fees_id),

2788

1

			Box::new(TransferType::LocalReserve),

2789

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2790

1

			WeightLimit::Unlimited

2791

));

2792

1

});

2793

2794

	// parachain should have received assets

2795

1

	ParaA::execute_with(|| {

2796

		// free execution, full amount received

2797

1

		assert_eq!(

2798

1

			EvmForeignAssets::balance(source_id, fresh_account.into()),

2799

1

			Ok(U256::from(123))

2800

);

2801

1

});

2802

1

2803

2804

#[test]

2805

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2806

1

	MockNet::reset();

2807

2808

1

	let mut sufficient_account = [0u8; 20];

2809

1

	sufficient_account[0..20].copy_from_slice(&evm_account()[..]);

2810

2811

1

	let evm_account_id = parachain::AccountId::from(sufficient_account);

2812

2813

	// Evm account is self sufficient

2814

1

	ParaA::execute_with(|| {

2815

1

		assert_eq!(parachain::System::account(evm_account_id).sufficients, 1);

2816

1

});

2817

2818

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2819

1

	let source_id: parachain::AssetId = source_location.clone().into();

2820

1

	let asset_metadata = parachain::AssetMetadata {

2821

1

		name: b"RelayToken".to_vec(),

2822

1

		symbol: b"Relay".to_vec(),

2823

1

		decimals: 12,

2824

1

};

2825

	// register relay asset in parachain A

2826

1

	ParaA::execute_with(|| {

2827

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2828

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2829

1

			.try_into()

2830

1

			.expect("v3 to latest location conversion failed");

2831

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2832

1

			source_id,

2833

1

			source_location_latest,

2834

1

			asset_metadata.decimals,

2835

1

			asset_metadata.symbol.try_into().expect("too long"),

2836

1

			asset_metadata.name.try_into().expect("too long"),

2837

));

2838

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

2839

1

});

2840

2841

	// Actually send relay asset to parachain

2842

1

	let dest: Location = AccountKey20 {

2843

1

		network: None,

2844

1

		key: sufficient_account,

2845

1

2846

1

	.into();

2847

1

	Relay::execute_with(|| {

2848

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2849

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2850

1

			assets: Wild(All),

2851

1

			beneficiary: dest.clone(),

2852

1

		}]);

2853

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2854

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2855

1

			Box::new(Parachain(1).into()),

2856

1

			Box::new(([] /* Here */, 123).into()),

2857

1

			Box::new(TransferType::LocalReserve),

2858

1

			Box::new(fees_id),

2859

1

			Box::new(TransferType::LocalReserve),

2860

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2861

1

			WeightLimit::Unlimited

2862

));

2863

1

});

2864

2865

	// Evm account sufficient ref count increased by 1.

2866

1

	ParaA::execute_with(|| {

2867

		// TODO: since the suicided logic was introduced an smart contract account

2868

		// is not deleted completely until it's data is deleted. Data deletion

2869

		// will be implemented in a future release

2870

		// assert_eq!(parachain::System::account(evm_account_id).sufficients, 2);

2871

1

});

2872

2873

1

	ParaA::execute_with(|| {

2874

		// Remove the account from the evm context.

2875

1

		parachain::EVM::remove_account(&evm_account());

2876

		// Evm account sufficient ref count decreased by 1.

2877

		// TODO: since the suicided logic was introduced an smart contract account

2878

		// is not deleted completely until it's data is deleted. Data deletion

2879

		// will be implemented in a future release

2880

		// assert_eq!(parachain::System::account(evm_account_id).sufficients, 1);

2881

1

});

2882

1

2883

2884

#[test]

2885

1

fn empty_account_should_not_be_reset() {

2886

1

	MockNet::reset();

2887

2888

	// Test account has nonce 1 on genesis.

2889

1

	let sufficient_account = PARABOB;

2890

2891

1

	let evm_account_id = parachain::AccountId::from(sufficient_account);

2892

2893

1

	let source_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

2894

1

	let source_id: parachain::AssetId = source_location.clone().into();

2895

1

	let asset_metadata = parachain::AssetMetadata {

2896

1

		name: b"RelayToken".to_vec(),

2897

1

		symbol: b"Relay".to_vec(),

2898

1

		decimals: 12,

2899

1

};

2900

	// register relay asset in parachain A

2901

1

	ParaA::execute_with(|| {

2902

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2903

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2904

1

			.try_into()

2905

1

			.expect("v3 to latest location conversion failed");

2906

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2907

1

			source_id,

2908

1

			source_location_latest,

2909

1

			asset_metadata.decimals,

2910

1

			asset_metadata.symbol.try_into().expect("too long"),

2911

1

			asset_metadata.name.try_into().expect("too long"),

2912

));

2913

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

2914

1

});

2915

2916

	// Send native token to evm_account

2917

1

	ParaA::execute_with(|| {

2918

1

		assert_ok!(ParaBalances::transfer_allow_death(

2919

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

2920

1

			evm_account_id,

2921

2922

));

2923

1

});

2924

2925

	// Actually send relay asset to parachain

2926

1

	let dest: Location = AccountKey20 {

2927

1

		network: None,

2928

1

		key: sufficient_account,

2929

1

2930

1

	.into();

2931

1

	Relay::execute_with(|| {

2932

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2933

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2934

1

			assets: Wild(All),

2935

1

			beneficiary: dest.clone(),

2936

1

		}]);

2937

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2938

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2939

1

			Box::new(Parachain(1).into()),

2940

1

			Box::new(([] /* Here */, 123).into()),

2941

1

			Box::new(TransferType::LocalReserve),

2942

1

			Box::new(fees_id),

2943

1

			Box::new(TransferType::LocalReserve),

2944

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2945

1

			WeightLimit::Unlimited

2946

));

2947

1

});

2948

2949

1

	ParaA::execute_with(|| {

2950

		// Empty the assets from the account.

2951

		// As this makes the account go below the `min_balance`, the account is considered dead

2952

		// at eyes of pallet-assets, and the consumer reference is decreased by 1 and is now Zero.

2953

		// Transfer the assets from evm_account to PARAALICE

2954

1

		assert_ok!(EvmForeignAssets::transfer(

2955

1

			source_id,

2956

1

			evm_account_id,

2957

1

			PARAALICE.into(),

2958

1

			U256::from(123)

2959

));

2960

		// Verify account asset balance is Zero.

2961

1

		assert_eq!(

2962

1

			parachain::EvmForeignAssets::balance(source_id, evm_account_id.into()),

2963

1

			Ok(U256::from(0))

2964

);

2965

		// Because we no longer have consumer references, we can set the balance to Zero.

2966

		// This would reset the account if our ED were to be > than Zero.

2967

1

		assert_ok!(ParaBalances::force_set_balance(

2968

1

			parachain::RuntimeOrigin::root(),

2969

1

			evm_account_id,

2970

0,

2971

));

2972

		// Verify account native balance is Zero.

2973

1

		assert_eq!(ParaBalances::free_balance(&evm_account_id), 0);

2974

		// Remove the account from the evm context.

2975

		// This decreases the sufficients reference by 1 and now is Zero.

2976

1

		parachain::EVM::remove_account(&evm_account());

2977

		// Verify reference count.

2978

1

		let account = parachain::System::account(evm_account_id);

2979

1

		assert_eq!(account.sufficients, 0);

2980

1

		assert_eq!(account.consumers, 0);

2981

1

		assert_eq!(account.providers, 1);

2982

		// We expect the account to be alive in a Zero ED context.

2983

1

		assert_eq!(parachain::System::account_nonce(evm_account_id), 1);

2984

1

});

2985

1

2986

2987

#[test]

2988

1

fn test_statemine_like() {

2989

1

	MockNet::reset();

2990

2991

1

	let dest_para = Location::new(1, [Parachain(1)]);

2992

2993

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2994

1

		polkadot_parachain::primitives::Sibling,

2995

1

		statemine_like::AccountId,

2996

1

	>::convert_location(&dest_para)

2997

1

	.unwrap();

2998

2999

1

	let statemine_asset_a_balances = Location::new(

3000

1,

3001

1

3002

1

			Parachain(1000),

3003

1

			PalletInstance(5),

3004

1

			xcm::latest::prelude::GeneralIndex(0u128),

3005

1

],

3006

);

3007

1

	let source_location: AssetType = statemine_asset_a_balances

3008

1

		.try_into()

3009

1

		.expect("Location convertion to AssetType should succeed");

3010

1

	let source_id: parachain::AssetId = source_location.clone().into();

3011

3012

1

	let asset_metadata = parachain::AssetMetadata {

3013

1

		name: b"StatemineToken".to_vec(),

3014

1

		symbol: b"StatemineToken".to_vec(),

3015

1

		decimals: 12,

3016

1

};

3017

3018

1

	ParaA::execute_with(|| {

3019

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

3020

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3021

1

			.try_into()

3022

1

			.expect("v3 to latest location conversion failed");

3023

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3024

1

			source_id,

3025

1

			source_location_latest,

3026

1

			asset_metadata.decimals,

3027

1

			asset_metadata.symbol.try_into().expect("too long"),

3028

1

			asset_metadata.name.try_into().expect("too long"),

3029

));

3030

1

		assert_ok!(add_supported_asset(source_location.clone(), 0u128));

3031

1

});

3032

3033

1

	Statemine::execute_with(|| {

3034

		// Set new prefix

3035

1

		statemine_like::PrefixChanger::set_prefix(

3036

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

3037

);

3038

1

		assert_ok!(StatemineAssets::create(

3039

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3040

0,

3041

			RELAYALICE,

3042

3043

));

3044

3045

1

		assert_ok!(StatemineAssets::mint(

3046

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3047

0,

3048

			RELAYALICE,

3049

			300000000000000

3050

));

3051

3052

		// This is needed, since the asset is created as non-sufficient

3053

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3054

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3055

1

			sov,

3056

			100000000000000

3057

));

3058

3059

		// Actually send relay asset to parachain

3060

1

		let dest: Location = AccountKey20 {

3061

1

			network: None,

3062

1

			key: PARAALICE,

3063

1

3064

1

		.into();

3065

3066

		// Send with new prefix

3067

1

		let asset_location = Location::new(

3068

0,

3069

1

3070

1

				xcm::latest::prelude::PalletInstance(

3071

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

3072

1

),

3073

1

				xcm::latest::prelude::GeneralIndex(0),

3074

1

],

3075

);

3076

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

3077

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3078

1

			assets: Wild(All),

3079

1

			beneficiary: dest.clone(),

3080

1

		}]);

3081

1

		assert_ok!(

3082

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3083

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3084

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3085

1

				Box::new((asset_location, 123).into()),

3086

1

				Box::new(TransferType::LocalReserve),

3087

1

				Box::new(fees_id),

3088

1

				Box::new(TransferType::LocalReserve),

3089

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3090

1

				WeightLimit::Unlimited

3091

3092

);

3093

1

});

3094

3095

1

	ParaA::execute_with(|| {

3096

1

		assert_eq!(

3097

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

3098

1

			Ok(U256::from(123))

3099

);

3100

1

});

3101

1

3102

3103

#[test]

3104

1

fn send_statemine_asset_from_para_a_to_statemine_with_relay_fee() {

3105

1

	MockNet::reset();

3106

3107

	// Relay asset

3108

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3109

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3110

3111

1

	let relay_asset_metadata = parachain::AssetMetadata {

3112

1

		name: b"RelayToken".to_vec(),

3113

1

		symbol: b"Relay".to_vec(),

3114

1

		decimals: 12,

3115

1

};

3116

3117

	// Statemine asset

3118

1

	let statemine_asset = Location::new(

3119

1,

3120

1

3121

1

			Parachain(1000u32),

3122

1

			PalletInstance(5u8),

3123

1

			GeneralIndex(10u128),

3124

1

],

3125

);

3126

1

	let statemine_location_asset: AssetType = statemine_asset

3127

1

		.clone()

3128

1

		.try_into()

3129

1

		.expect("Location convertion to AssetType should succeed");

3130

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

3131

3132

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3133

1

		name: b"USDC".to_vec(),

3134

1

		symbol: b"USDC".to_vec(),

3135

1

		decimals: 12,

3136

1

};

3137

3138

1

	let dest_para = Location::new(1, [Parachain(1)]);

3139

3140

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3141

1

		polkadot_parachain::primitives::Sibling,

3142

1

		statemine_like::AccountId,

3143

1

	>::convert_location(&dest_para)

3144

1

	.unwrap();

3145

3146

1

	ParaA::execute_with(|| {

3147

1

		let parachain::AssetType::Xcm(relay_location_v3) = relay_location.clone();

3148

1

		let relay_location_latest: Location = xcm::VersionedLocation::V3(relay_location_v3)

3149

1

			.try_into()

3150

1

			.expect("v3 to latest location conversion failed");

3151

1

		let relay_id: parachain::AssetId = relay_location.clone().into();

3152

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3153

1

			relay_id,

3154

1

			relay_location_latest,

3155

1

			relay_asset_metadata.decimals,

3156

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3157

1

			relay_asset_metadata.name.try_into().expect("too long"),

3158

));

3159

1

		assert_ok!(add_supported_asset(relay_location.clone(), 0u128));

3160

3161

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

3162

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

3163

1

			.try_into()

3164

1

			.expect("v3 to latest location conversion failed");

3165

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

3166

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3167

1

			statemine_id,

3168

1

			statemine_location_latest,

3169

1

			asset_metadata_statemine_asset.decimals,

3170

1

			asset_metadata_statemine_asset

3171

1

				.symbol

3172

1

				.try_into()

3173

1

				.expect("too long"),

3174

1

			asset_metadata_statemine_asset

3175

1

				.name

3176

1

				.try_into()

3177

1

				.expect("too long"),

3178

));

3179

1

		assert_ok!(add_supported_asset(statemine_location_asset.clone(), 0u128));

3180

1

});

3181

3182

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3183

1

		network: None,

3184

1

		key: PARAALICE,

3185

1

3186

1

	.into();

3187

3188

	// Send relay chain asset to Alice in Parachain A

3189

1

	Relay::execute_with(|| {

3190

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

3191

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3192

1

			assets: Wild(All),

3193

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

3194

1

		}]);

3195

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

3196

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3197

1

			Box::new(Parachain(1).into()),

3198

1

			Box::new(([] /* Here */, 200).into()),

3199

1

			Box::new(TransferType::LocalReserve),

3200

1

			Box::new(fees_id),

3201

1

			Box::new(TransferType::LocalReserve),

3202

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3203

1

			WeightLimit::Unlimited

3204

));

3205

1

});

3206

3207

1

	Statemine::execute_with(|| {

3208

		// Set new prefix

3209

1

		statemine_like::PrefixChanger::set_prefix(

3210

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

3211

);

3212

3213

1

		assert_ok!(StatemineAssets::create(

3214

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3215

10,

3216

			RELAYALICE,

3217

3218

));

3219

3220

1

		assert_ok!(StatemineAssets::mint(

3221

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3222

10,

3223

			RELAYALICE,

3224

			300000000000000

3225

));

3226

3227

		// Send some native statemine tokens to sovereign for fees.

3228

		// We can't pay fees with USDC as the asset is minted as non-sufficient.

3229

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3230

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3231

1

			sov,

3232

			100000000000000

3233

));

3234

3235

		// Send statemine USDC asset to Alice in Parachain A

3236

1

		let parachain_beneficiary_from_statemine: Location = AccountKey20 {

3237

1

			network: None,

3238

1

			key: PARAALICE,

3239

1

3240

1

		.into();

3241

3242

		// Send with new prefix

3243

1

		let asset_location = Location::new(

3244

0,

3245

1

3246

1

				xcm::latest::prelude::PalletInstance(

3247

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

3248

1

),

3249

1

				GeneralIndex(10),

3250

1

],

3251

);

3252

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

3253

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3254

1

			assets: Wild(All),

3255

1

			beneficiary: parachain_beneficiary_from_statemine.clone(),

3256

1

		}]);

3257

1

		assert_ok!(

3258

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3259

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3260

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3261

1

				Box::new((asset_location, 125).into()),

3262

1

				Box::new(TransferType::LocalReserve),

3263

1

				Box::new(fees_id),

3264

1

				Box::new(TransferType::LocalReserve),

3265

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3266

1

				WeightLimit::Unlimited

3267

3268

);

3269

1

});

3270

3271

1

	let statemine_beneficiary = Location {

3272

1

		parents: 1,

3273

1

		interior: [

3274

1

			Parachain(1000),

3275

1

			AccountId32 {

3276

1

				network: None,

3277

1

				id: RELAYBOB.into(),

3278

1

},

3279

1

3280

1

		.into(),

3281

1

};

3282

3283

1

	ParaA::execute_with(|| {

3284

		// Alice has received 125 USDC

3285

1

		assert_eq!(

3286

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

3287

1

			Ok(U256::from(125))

3288

);

3289

3290

		// Alice has received 200 Relay assets

3291

1

		assert_eq!(

3292

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3293

1

			Ok(U256::from(200))

3294

);

3295

1

});

3296

3297

1

	Statemine::execute_with(|| {

3298

		// Check that BOB's balance is empty before the transfer

3299

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![]);

3300

1

});

3301

1

	let (chain_part, beneficiary) =

3302

1

		split_location_into_chain_part_and_beneficiary(statemine_beneficiary).unwrap();

3303

3304

	// Transfer USDC from Parachain A to Statemine using Relay asset as fee

3305

1

	ParaA::execute_with(|| {

3306

1

		let asset_1 = currency_to_asset(

3307

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3308

			100,

3309

);

3310

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3311

1

		let fees_id: VersionedAssetId = asset_2.id.clone().into();

3312

1

		let assets_to_send = vec![asset_1, asset_2];

3313

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3314

1

			assets: Wild(All),

3315

1

			beneficiary: beneficiary.clone(),

3316

1

		}]);

3317

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3318

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3319

1

			Box::new(VersionedLocation::from(chain_part)),

3320

1

			Box::new(VersionedAssets::from(assets_to_send)),

3321

1

			Box::new(TransferType::DestinationReserve),

3322

1

			Box::new(fees_id),

3323

1

			Box::new(TransferType::DestinationReserve),

3324

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3325

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

3326

));

3327

1

});

3328

3329

1

	ParaA::execute_with(|| {

3330

		// Alice has 100 USDC less

3331

1

		assert_eq!(

3332

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

3333

1

			Ok(U256::from(25))

3334

);

3335

3336

		// Alice has 100 relay asset less

3337

1

		assert_eq!(

3338

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3339

1

			Ok(U256::from(100))

3340

);

3341

1

});

3342

3343

1

	Statemine::execute_with(|| {

3344

		// Check that BOB received 100 USDC on statemine

3345

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

3346

1

});

3347

1

3348

3349

#[test]

3350

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer() {

3351

1

	MockNet::reset();

3352

3353

	// Relay asset

3354

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3355

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3356

3357

1

	let relay_asset_metadata = parachain::AssetMetadata {

3358

1

		name: b"RelayToken".to_vec(),

3359

1

		symbol: b"Relay".to_vec(),

3360

1

		decimals: 12,

3361

1

};

3362

3363

1

	let dest_para = Location::new(1, [Parachain(1)]);

3364

3365

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3366

1

		polkadot_parachain::primitives::Sibling,

3367

1

		statemine_like::AccountId,

3368

1

	>::convert_location(&dest_para)

3369

1

	.unwrap();

3370

3371

1

	ParaA::execute_with(|| {

3372

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3373

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3374

1

			.try_into()

3375

1

			.expect("v3 to latest location conversion failed");

3376

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3377

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3378

1

			source_id,

3379

1

			source_location_latest,

3380

1

			relay_asset_metadata.decimals,

3381

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3382

1

			relay_asset_metadata.name.try_into().expect("too long"),

3383

));

3384

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3385

1

});

3386

3387

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3388

1

		network: None,

3389

1

		key: PARAALICE,

3390

1

3391

1

	.into();

3392

3393

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3394

1

		network: None,

3395

1

		id: RELAYALICE.into(),

3396

1

3397

1

	.into();

3398

3399

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3400

1

	Relay::execute_with(|| {

3401

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3402

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3403

1

			Box::new(Parachain(1000).into()),

3404

1

			Box::new(

3405

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3406

1

					.clone()

3407

1

					.into()

3408

),

3409

1

			Box::new(([], 200).into()),

3410

0,

3411

1

			WeightLimit::Unlimited

3412

));

3413

1

});

3414

3415

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3416

1

	Statemine::execute_with(|| {

3417

		// Check Alice received 200 tokens on AssetHub

3418

1

		assert_eq!(

3419

1

			StatemineBalances::free_balance(RELAYALICE),

3420

			INITIAL_BALANCE + 200

3421

);

3422

3423

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3424

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3425

1

			sov,

3426

			110000000000000

3427

));

3428

3429

		// Now send those tokens to ParaA

3430

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3431

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3432

1

			assets: Wild(All),

3433

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3434

1

		}]);

3435

1

		assert_ok!(

3436

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3437

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3438

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3439

1

				Box::new((Location::parent(), 200).into()),

3440

1

				Box::new(TransferType::LocalReserve),

3441

1

				Box::new(fees_id),

3442

1

				Box::new(TransferType::LocalReserve),

3443

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3444

1

				WeightLimit::Unlimited

3445

3446

);

3447

1

});

3448

3449

1

	ParaA::execute_with(|| {

3450

		// Alice should have received the DOTs

3451

1

		assert_eq!(

3452

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3453

1

			Ok(U256::from(200))

3454

);

3455

1

});

3456

3457

1

	let dest = Location::new(

3458

1,

3459

1

3460

1

			Parachain(1000),

3461

1

			AccountId32 {

3462

1

				network: None,

3463

1

				id: RELAYBOB.into(),

3464

1

},

3465

1

],

3466

);

3467

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3468

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3469

1

	ParaA::execute_with(|| {

3470

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3471

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3472

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3473

1

			assets: Wild(All),

3474

1

			beneficiary: beneficiary.clone(),

3475

1

		}]);

3476

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3477

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3478

1

			Box::new(VersionedLocation::from(chain_part)),

3479

1

			Box::new(VersionedAssets::from(vec![asset])),

3480

1

			Box::new(TransferType::DestinationReserve),

3481

1

			Box::new(fees_id),

3482

1

			Box::new(TransferType::DestinationReserve),

3483

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3484

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3485

));

3486

3487

1

		assert_eq!(

3488

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3489

1

			Ok(U256::from(100))

3490

);

3491

1

});

3492

3493

1

	Statemine::execute_with(|| {

3494

		// Check that Bob received the tokens back in AssetHub

3495

1

		assert_eq!(

3496

1

			StatemineBalances::free_balance(RELAYBOB),

3497

			INITIAL_BALANCE + 100

3498

);

3499

1

});

3500

3501

	// Send back tokens from AH to ParaA from Bob's account

3502

1

	Statemine::execute_with(|| {

3503

		// Now send those tokens to ParaA

3504

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3505

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3506

1

			assets: Wild(All),

3507

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3508

1

		}]);

3509

1

		assert_ok!(

3510

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3511

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3512

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3513

1

				Box::new((Location::parent(), 100).into()),

3514

1

				Box::new(TransferType::LocalReserve),

3515

1

				Box::new(fees_id),

3516

1

				Box::new(TransferType::LocalReserve),

3517

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3518

1

				WeightLimit::Unlimited

3519

3520

);

3521

3522

		// 100 DOTs were deducted from Bob's account

3523

1

		assert_eq!(StatemineBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3524

1

});

3525

3526

1

	ParaA::execute_with(|| {

3527

		// Alice should have received 100 DOTs

3528

1

		assert_eq!(

3529

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3530

1

			Ok(U256::from(200))

3531

);

3532

1

});

3533

1

3534

3535

#[test]

3536

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_with_fee() {

3537

1

	MockNet::reset();

3538

3539

	// Relay asset

3540

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3541

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3542

3543

1

	let relay_asset_metadata = parachain::AssetMetadata {

3544

1

		name: b"RelayToken".to_vec(),

3545

1

		symbol: b"Relay".to_vec(),

3546

1

		decimals: 12,

3547

1

};

3548

3549

1

	let dest_para = Location::new(1, [Parachain(1)]);

3550

3551

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3552

1

		polkadot_parachain::primitives::Sibling,

3553

1

		statemine_like::AccountId,

3554

1

	>::convert_location(&dest_para)

3555

1

	.unwrap();

3556

3557

1

	ParaA::execute_with(|| {

3558

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3559

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3560

1

			.try_into()

3561

1

			.expect("v3 to latest location conversion failed");

3562

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3563

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3564

1

			source_id,

3565

1

			source_location_latest,

3566

1

			relay_asset_metadata.decimals,

3567

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3568

1

			relay_asset_metadata.name.try_into().expect("too long"),

3569

));

3570

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3571

1

});

3572

3573

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3574

1

		network: None,

3575

1

		key: PARAALICE,

3576

1

3577

1

	.into();

3578

3579

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3580

1

		network: None,

3581

1

		id: RELAYALICE.into(),

3582

1

3583

1

	.into();

3584

3585

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3586

1

	Relay::execute_with(|| {

3587

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3588

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3589

1

			Box::new(Parachain(1000).into()),

3590

1

			Box::new(

3591

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3592

1

					.clone()

3593

1

					.into()

3594

),

3595

1

			Box::new(([], 200).into()),

3596

0,

3597

1

			WeightLimit::Unlimited

3598

));

3599

1

});

3600

3601

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3602

1

	Statemine::execute_with(|| {

3603

		// Check Alice received 200 tokens on AssetHub

3604

1

		assert_eq!(

3605

1

			StatemineBalances::free_balance(RELAYALICE),

3606

			INITIAL_BALANCE + 200

3607

);

3608

3609

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3610

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3611

1

			sov,

3612

			110000000000000

3613

));

3614

3615

		// Now send those tokens to ParaA

3616

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3617

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3618

1

			assets: Wild(All),

3619

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3620

1

		}]);

3621

1

		assert_ok!(

3622

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3623

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3624

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3625

1

				Box::new((Location::parent(), 200).into()),

3626

1

				Box::new(TransferType::LocalReserve),

3627

1

				Box::new(fees_id),

3628

1

				Box::new(TransferType::LocalReserve),

3629

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3630

1

				WeightLimit::Unlimited

3631

3632

);

3633

1

});

3634

3635

1

	ParaA::execute_with(|| {

3636

		// Alice should have received the DOTs

3637

1

		assert_eq!(

3638

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3639

1

			Ok(U256::from(200))

3640

);

3641

1

});

3642

3643

1

	let dest = Location::new(

3644

1,

3645

1

3646

1

			Parachain(1000),

3647

1

			AccountId32 {

3648

1

				network: None,

3649

1

				id: RELAYBOB.into(),

3650

1

},

3651

1

],

3652

);

3653

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3654

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3655

1

	ParaA::execute_with(|| {

3656

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3657

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3658

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3659

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3660

1

			assets: Wild(All),

3661

1

			beneficiary: beneficiary.clone(),

3662

1

		}]);

3663

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3664

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3665

1

			Box::new(VersionedLocation::from(chain_part)),

3666

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

3667

1

			Box::new(TransferType::DestinationReserve),

3668

1

			Box::new(fees_id),

3669

1

			Box::new(TransferType::DestinationReserve),

3670

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3671

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3672

));

3673

3674

1

		assert_eq!(

3675

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3676

1

			Ok(U256::from(90))

3677

);

3678

1

});

3679

3680

1

	Statemine::execute_with(|| {

3681

		// Free execution: check that Bob received the tokens back in AssetHub

3682

1

		assert_eq!(

3683

1

			StatemineBalances::free_balance(RELAYBOB),

3684

			INITIAL_BALANCE + 110

3685

);

3686

1

});

3687

3688

	// Send back tokens from AH to ParaA from Bob's account

3689

1

	Statemine::execute_with(|| {

3690

		// Now send those tokens to ParaA

3691

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3692

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3693

1

			assets: Wild(All),

3694

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3695

1

		}]);

3696

1

		assert_ok!(

3697

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3698

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3699

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3700

1

				Box::new((Location::parent(), 100).into()),

3701

1

				Box::new(TransferType::LocalReserve),

3702

1

				Box::new(fees_id),

3703

1

				Box::new(TransferType::LocalReserve),

3704

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3705

1

				WeightLimit::Unlimited

3706

3707

);

3708

3709

		// 100 DOTs were deducted from Bob's account

3710

1

		assert_eq!(

3711

1

			StatemineBalances::free_balance(RELAYBOB),

3712

			INITIAL_BALANCE + 10

3713

);

3714

1

});

3715

3716

1

	ParaA::execute_with(|| {

3717

		// Alice should have received 100 DOTs

3718

1

		assert_eq!(

3719

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3720

1

			Ok(U256::from(190))

3721

);

3722

1

});

3723

1

3724

3725

#[test]

3726

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiasset() {

3727

1

	MockNet::reset();

3728

3729

	// Relay asset

3730

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3731

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3732

3733

1

	let relay_asset_metadata = parachain::AssetMetadata {

3734

1

		name: b"RelayToken".to_vec(),

3735

1

		symbol: b"Relay".to_vec(),

3736

1

		decimals: 12,

3737

1

};

3738

3739

1

	let dest_para = Location::new(1, [Parachain(1)]);

3740

3741

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3742

1

		polkadot_parachain::primitives::Sibling,

3743

1

		statemine_like::AccountId,

3744

1

	>::convert_location(&dest_para)

3745

1

	.unwrap();

3746

3747

1

	ParaA::execute_with(|| {

3748

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3749

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3750

1

			.try_into()

3751

1

			.expect("v3 to latest location conversion failed");

3752

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3753

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3754

1

			source_id,

3755

1

			source_location_latest,

3756

1

			relay_asset_metadata.decimals,

3757

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3758

1

			relay_asset_metadata.name.try_into().expect("too long"),

3759

));

3760

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3761

1

});

3762

3763

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3764

1

		network: None,

3765

1

		key: PARAALICE,

3766

1

3767

1

	.into();

3768

3769

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3770

1

		network: None,

3771

1

		id: RELAYALICE.into(),

3772

1

3773

1

	.into();

3774

3775

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3776

1

	Relay::execute_with(|| {

3777

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3778

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3779

1

			Box::new(Parachain(1000).into()),

3780

1

			Box::new(

3781

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3782

1

					.clone()

3783

1

					.into()

3784

),

3785

1

			Box::new(([], 200).into()),

3786

0,

3787

1

			WeightLimit::Unlimited

3788

));

3789

1

});

3790

3791

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3792

1

	Statemine::execute_with(|| {

3793

		// Check Alice received 200 tokens on AssetHub

3794

1

		assert_eq!(

3795

1

			StatemineBalances::free_balance(RELAYALICE),

3796

			INITIAL_BALANCE + 200

3797

);

3798

3799

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3800

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3801

1

			sov,

3802

			110000000000000

3803

));

3804

3805

		// Now send those tokens to ParaA

3806

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3807

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3808

1

			assets: Wild(All),

3809

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3810

1

		}]);

3811

1

		assert_ok!(

3812

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3813

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3814

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3815

1

				Box::new((Location::parent(), 200).into()),

3816

1

				Box::new(TransferType::LocalReserve),

3817

1

				Box::new(fees_id),

3818

1

				Box::new(TransferType::LocalReserve),

3819

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3820

1

				WeightLimit::Unlimited

3821

3822

);

3823

1

});

3824

3825

1

	ParaA::execute_with(|| {

3826

		// Alice should have received the DOTs

3827

1

		assert_eq!(

3828

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3829

1

			Ok(U256::from(200))

3830

);

3831

1

});

3832

3833

1

	let dest = Location::new(

3834

1,

3835

1

3836

1

			Parachain(1000),

3837

1

			AccountId32 {

3838

1

				network: None,

3839

1

				id: RELAYBOB.into(),

3840

1

},

3841

1

],

3842

);

3843

3844

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3845

3846

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3847

1

	ParaA::execute_with(|| {

3848

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3849

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3850

1

			assets: Wild(All),

3851

1

			beneficiary: beneficiary.clone(),

3852

1

		}]);

3853

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3854

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3855

1

			Box::new(VersionedLocation::from(chain_part)),

3856

1

			Box::new(VersionedAssets::from(

3857

1

				vec![(Location::parent(), 100).into()]

3858

)),

3859

1

			Box::new(TransferType::DestinationReserve),

3860

1

			Box::new(fees_id),

3861

1

			Box::new(TransferType::DestinationReserve),

3862

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3863

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3864

));

3865

3866

1

		assert_eq!(

3867

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3868

1

			Ok(U256::from(100))

3869

);

3870

1

});

3871

3872

1

	Statemine::execute_with(|| {

3873

		// Check that Bob received the tokens back in AssetHub

3874

1

		assert_eq!(

3875

1

			StatemineBalances::free_balance(RELAYBOB),

3876

			INITIAL_BALANCE + 100

3877

);

3878

1

});

3879

3880

	// Send back tokens from AH to ParaA from Bob's account

3881

1

	Statemine::execute_with(|| {

3882

		// Now send those tokens to ParaA

3883

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3884

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3885

1

			assets: Wild(All),

3886

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3887

1

		}]);

3888

1

		assert_ok!(

3889

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3890

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3891

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3892

1

				Box::new((Location::parent(), 100).into()),

3893

1

				Box::new(TransferType::LocalReserve),

3894

1

				Box::new(fees_id),

3895

1

				Box::new(TransferType::LocalReserve),

3896

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3897

1

				WeightLimit::Unlimited

3898

3899

);

3900

3901

		// 100 DOTs were deducted from Bob's account

3902

1

		assert_eq!(StatemineBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3903

1

});

3904

3905

1

	ParaA::execute_with(|| {

3906

		// Alice should have received 100 DOTs

3907

1

		assert_eq!(

3908

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3909

1

			Ok(U256::from(200))

3910

);

3911

1

});

3912

1

3913

3914

#[test]

3915

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multicurrencies() {

3916

1

	MockNet::reset();

3917

3918

	// Relay asset

3919

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3920

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3921

3922

1

	let relay_asset_metadata = parachain::AssetMetadata {

3923

1

		name: b"RelayToken".to_vec(),

3924

1

		symbol: b"Relay".to_vec(),

3925

1

		decimals: 12,

3926

1

};

3927

3928

	// Statemine asset

3929

1

	let statemine_asset = Location::new(

3930

1,

3931

1

3932

1

			Parachain(1000u32),

3933

1

			PalletInstance(5u8),

3934

1

			GeneralIndex(10u128),

3935

1

],

3936

);

3937

1

	let statemine_location_asset: AssetType = statemine_asset

3938

1

		.clone()

3939

1

		.try_into()

3940

1

		.expect("Location convertion to AssetType should succeed");

3941

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

3942

3943

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3944

1

		name: b"USDC".to_vec(),

3945

1

		symbol: b"USDC".to_vec(),

3946

1

		decimals: 12,

3947

1

};

3948

3949

1

	let dest_para = Location::new(1, [Parachain(1)]);

3950

3951

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3952

1

		polkadot_parachain::primitives::Sibling,

3953

1

		statemine_like::AccountId,

3954

1

	>::convert_location(&dest_para)

3955

1

	.unwrap();

3956

3957

1

	ParaA::execute_with(|| {

3958

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3959

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3960

1

			.try_into()

3961

1

			.expect("v3 to latest location conversion failed");

3962

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3963

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3964

1

			source_id,

3965

1

			source_location_latest,

3966

1

			relay_asset_metadata.decimals,

3967

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3968

1

			relay_asset_metadata.name.try_into().expect("too long"),

3969

));

3970

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3971

3972

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

3973

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

3974

1

			.try_into()

3975

1

			.expect("v3 to latest location conversion failed");

3976

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

3977

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3978

1

			statemine_id,

3979

1

			statemine_location_latest,

3980

1

			asset_metadata_statemine_asset.decimals,

3981

1

			asset_metadata_statemine_asset

3982

1

				.symbol

3983

1

				.try_into()

3984

1

				.expect("too long"),

3985

1

			asset_metadata_statemine_asset

3986

1

				.name

3987

1

				.try_into()

3988

1

				.expect("too long"),

3989

));

3990

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

3991

1

});

3992

3993

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3994

1

		network: None,

3995

1

		key: PARAALICE,

3996

1

3997

1

	.into();

3998

3999

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

4000

1

		network: None,

4001

1

		id: RELAYALICE.into(),

4002

1

4003

1

	.into();

4004

4005

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4006

1

	Relay::execute_with(|| {

4007

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4008

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4009

1

			Box::new(Parachain(1000).into()),

4010

1

			Box::new(

4011

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4012

1

					.clone()

4013

1

					.into()

4014

),

4015

1

			Box::new(([], 200).into()),

4016

0,

4017

1

			WeightLimit::Unlimited

4018

));

4019

1

});

4020

4021

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4022

1

	Statemine::execute_with(|| {

4023

		// Check Alice received 200 tokens on AssetHub

4024

1

		assert_eq!(

4025

1

			StatemineBalances::free_balance(RELAYALICE),

4026

			INITIAL_BALANCE + 200

4027

);

4028

4029

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4030

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4031

1

			sov,

4032

			110000000000000

4033

));

4034

4035

1

		statemine_like::PrefixChanger::set_prefix(

4036

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4037

);

4038

4039

1

		assert_ok!(StatemineAssets::create(

4040

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4041

10,

4042

			RELAYALICE,

4043

4044

));

4045

4046

1

		assert_ok!(StatemineAssets::mint(

4047

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4048

10,

4049

			RELAYALICE,

4050

			300000000000000

4051

));

4052

4053

		// Now send relay tokens to ParaA

4054

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4055

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4056

1

			assets: Wild(All),

4057

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4058

1

		}]);

4059

1

		assert_ok!(

4060

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4061

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4062

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4063

1

				Box::new((Location::parent(), 200).into()),

4064

1

				Box::new(TransferType::LocalReserve),

4065

1

				Box::new(fees_id),

4066

1

				Box::new(TransferType::LocalReserve),

4067

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4068

1

				WeightLimit::Unlimited

4069

4070

);

4071

4072

		// Send USDC

4073

1

		let asset_location = Location::new(

4074

0,

4075

1

4076

1

				xcm::latest::prelude::PalletInstance(

4077

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

4078

1

),

4079

1

				GeneralIndex(10),

4080

1

],

4081

);

4082

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

4083

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4084

1

			assets: Wild(All),

4085

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4086

1

		}]);

4087

1

		assert_ok!(

4088

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4089

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4090

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4091

1

				Box::new((asset_location, 125).into()),

4092

1

				Box::new(TransferType::LocalReserve),

4093

1

				Box::new(fees_id),

4094

1

				Box::new(TransferType::LocalReserve),

4095

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4096

1

				WeightLimit::Unlimited

4097

4098

);

4099

1

});

4100

4101

1

	ParaA::execute_with(|| {

4102

		// Alice should have received the DOTs

4103

1

		assert_eq!(

4104

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4105

1

			Ok(U256::from(200))

4106

);

4107

4108

		// Alice has received 125 USDC

4109

1

		assert_eq!(

4110

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4111

1

			Ok(U256::from(125))

4112

);

4113

1

});

4114

4115

1

	let dest = Location::new(

4116

1,

4117

1

4118

1

			Parachain(1000),

4119

1

			AccountId32 {

4120

1

				network: None,

4121

1

				id: RELAYBOB.into(),

4122

1

},

4123

1

],

4124

);

4125

4126

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4127

4128

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4129

1

	ParaA::execute_with(|| {

4130

1

		let asset_1 = currency_to_asset(

4131

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

4132

			100,

4133

);

4134

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

4135

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4136

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4137

1

			assets: Wild(All),

4138

1

			beneficiary: beneficiary.clone(),

4139

1

		}]);

4140

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4141

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4142

1

			Box::new(VersionedLocation::from(chain_part)),

4143

1

			Box::new(VersionedAssets::from(vec![asset_1, asset_2])),

4144

1

			Box::new(TransferType::DestinationReserve),

4145

1

			Box::new(fees_id),

4146

1

			Box::new(TransferType::DestinationReserve),

4147

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4148

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4149

));

4150

4151

1

		assert_eq!(

4152

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4153

1

			Ok(U256::from(100))

4154

);

4155

1

});

4156

4157

1

	Statemine::execute_with(|| {

4158

		// Check that Bob received relay tokens back in AssetHub

4159

		// (100 - MinXcmFee)

4160

1

		assert_eq!(

4161

1

			StatemineBalances::free_balance(RELAYBOB),

4162

			INITIAL_BALANCE + 100

4163

);

4164

4165

		// Check that BOB received 100 USDC on AssetHub

4166

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4167

1

});

4168

4169

	// Send back tokens from AH to ParaA from Bob's account

4170

1

	Statemine::execute_with(|| {

4171

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4172

4173

		// Now send those tokens to ParaA

4174

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4175

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4176

1

			assets: Wild(All),

4177

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4178

1

		}]);

4179

1

		assert_ok!(

4180

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4181

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

4182

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4183

1

				Box::new((Location::parent(), 100).into()),

4184

1

				Box::new(TransferType::LocalReserve),

4185

1

				Box::new(fees_id),

4186

1

				Box::new(TransferType::LocalReserve),

4187

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4188

1

				WeightLimit::Unlimited

4189

4190

);

4191

4192

		// 100 DOTs were deducted from Bob's account

4193

1

		assert_eq!(

4194

1

			StatemineBalances::free_balance(RELAYBOB),

4195

1

			bob_previous_balance - 100

4196

);

4197

1

});

4198

4199

1

	ParaA::execute_with(|| {

4200

		// Alice should have received 100 DOTs

4201

1

		assert_eq!(

4202

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4203

1

			Ok(U256::from(200))

4204

);

4205

1

});

4206

1

4207

4208

#[test]

4209

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiassets() {

4210

1

	MockNet::reset();

4211

4212

	// Relay asset

4213

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

4214

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

4215

4216

1

	let relay_asset_metadata = parachain::AssetMetadata {

4217

1

		name: b"RelayToken".to_vec(),

4218

1

		symbol: b"Relay".to_vec(),

4219

1

		decimals: 12,

4220

1

};

4221

4222

	// Statemine asset

4223

1

	let statemine_asset = Location::new(

4224

1,

4225

1

4226

1

			Parachain(1000u32),

4227

1

			PalletInstance(5u8),

4228

1

			GeneralIndex(10u128),

4229

1

],

4230

);

4231

1

	let statemine_location_asset: AssetType = statemine_asset

4232

1

		.clone()

4233

1

		.try_into()

4234

1

		.expect("Location convertion to AssetType should succeed");

4235

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

4236

4237

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

4238

1

		name: b"USDC".to_vec(),

4239

1

		symbol: b"USDC".to_vec(),

4240

1

		decimals: 12,

4241

1

};

4242

4243

1

	let dest_para = Location::new(1, [Parachain(1)]);

4244

4245

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

4246

1

		polkadot_parachain::primitives::Sibling,

4247

1

		statemine_like::AccountId,

4248

1

	>::convert_location(&dest_para)

4249

1

	.unwrap();

4250

4251

1

	ParaA::execute_with(|| {

4252

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

4253

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

4254

1

			.try_into()

4255

1

			.expect("v3 to latest location conversion failed");

4256

1

		let source_id: parachain::AssetId = relay_location.clone().into();

4257

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4258

1

			source_id,

4259

1

			source_location_latest,

4260

1

			relay_asset_metadata.decimals,

4261

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

4262

1

			relay_asset_metadata.name.try_into().expect("too long"),

4263

));

4264

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4265

4266

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

4267

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

4268

1

			.try_into()

4269

1

			.expect("v3 to latest location conversion failed");

4270

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

4271

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4272

1

			statemine_id,

4273

1

			statemine_location_latest,

4274

1

			asset_metadata_statemine_asset.decimals,

4275

1

			asset_metadata_statemine_asset

4276

1

				.symbol

4277

1

				.try_into()

4278

1

				.expect("too long"),

4279

1

			asset_metadata_statemine_asset

4280

1

				.name

4281

1

				.try_into()

4282

1

				.expect("too long"),

4283

));

4284

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

4285

1

});

4286

4287

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4288

1

		network: None,

4289

1

		key: PARAALICE,

4290

1

4291

1

	.into();

4292

4293

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

4294

1

		network: None,

4295

1

		id: RELAYALICE.into(),

4296

1

4297

1

	.into();

4298

4299

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4300

1

	Relay::execute_with(|| {

4301

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4302

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4303

1

			Box::new(Parachain(1000).into()),

4304

1

			Box::new(

4305

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4306

1

					.clone()

4307

1

					.into()

4308

),

4309

1

			Box::new(([], 200).into()),

4310

0,

4311

1

			WeightLimit::Unlimited

4312

));

4313

1

});

4314

4315

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4316

1

	Statemine::execute_with(|| {

4317

		// Check Alice received 200 tokens on AssetHub

4318

1

		assert_eq!(

4319

1

			StatemineBalances::free_balance(RELAYALICE),

4320

			INITIAL_BALANCE + 200

4321

);

4322

4323

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4324

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4325

1

			sov,

4326

			110000000000000

4327

));

4328

4329

1

		statemine_like::PrefixChanger::set_prefix(

4330

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4331

);

4332

4333

1

		assert_ok!(StatemineAssets::create(

4334

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4335

10,

4336

			RELAYALICE,

4337

4338

));

4339

4340

1

		assert_ok!(StatemineAssets::mint(

4341

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4342

10,

4343

			RELAYALICE,

4344

			300000000000000

4345

));

4346

4347

		// Now send relay tokens to ParaA

4348

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4349

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4350

1

			assets: Wild(All),

4351

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4352

1

		}]);

4353

1

		assert_ok!(

4354

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4355

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4356

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4357

1

				Box::new((Location::parent(), 200).into()),

4358

1

				Box::new(TransferType::LocalReserve),

4359

1

				Box::new(fees_id),

4360

1

				Box::new(TransferType::LocalReserve),

4361

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4362

1

				WeightLimit::Unlimited

4363

4364

);

4365

4366

		// Send USDC

4367

1

		let asset_location = Location::new(

4368

0,

4369

1

4370

1

				xcm::latest::prelude::PalletInstance(

4371

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

4372

1

),

4373

1

				GeneralIndex(10),

4374

1

],

4375

);

4376

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

4377

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4378

1

			assets: Wild(All),

4379

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4380

1

		}]);

4381

1

		assert_ok!(

4382

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4383

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4384

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4385

1

				Box::new((asset_location, 125).into()),

4386

1

				Box::new(TransferType::LocalReserve),

4387

1

				Box::new(fees_id),

4388

1

				Box::new(TransferType::LocalReserve),

4389

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4390

1

				WeightLimit::Unlimited

4391

4392

);

4393

1

});

4394

4395

1

	ParaA::execute_with(|| {

4396

		// Alice should have received the DOTs

4397

1

		assert_eq!(

4398

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4399

1

			Ok(U256::from(200))

4400

);

4401

4402

		// Alice has received 125 USDC

4403

1

		assert_eq!(

4404

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4405

1

			Ok(U256::from(125))

4406

);

4407

1

});

4408

4409

1

	let dest = Location::new(

4410

1,

4411

1

4412

1

			Parachain(1000),

4413

1

			AccountId32 {

4414

1

				network: None,

4415

1

				id: RELAYBOB.into(),

4416

1

},

4417

1

],

4418

);

4419

4420

1

	let statemine_asset_to_send = Asset {

4421

1

		id: AssetId(statemine_asset),

4422

1

		fun: Fungibility::Fungible(100),

4423

1

};

4424

4425

1

	let relay_asset_to_send = Asset {

4426

1

		id: AssetId(Location::parent()),

4427

1

		fun: Fungibility::Fungible(100),

4428

1

};

4429

4430

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4431

1

	let assets_to_send: XcmAssets =

4432

1

		XcmAssets::from(vec![statemine_asset_to_send, relay_asset_to_send.clone()]);

4433

	// For some reason the order of the assets is inverted when creating the array above.

4434

	// We need to use relay asset for fees, so we pick index 0.

4435

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4436

4437

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4438

1

	ParaA::execute_with(|| {

4439

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4440

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4441

1

			assets: Wild(All),

4442

1

			beneficiary: beneficiary.clone(),

4443

1

		}]);

4444

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4445

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4446

1

			Box::new(VersionedLocation::from(chain_part)),

4447

1

			Box::new(VersionedAssets::from(assets_to_send)),

4448

1

			Box::new(TransferType::DestinationReserve),

4449

1

			Box::new(fees_id),

4450

1

			Box::new(TransferType::DestinationReserve),

4451

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4452

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4453

));

4454

4455

1

		assert_eq!(

4456

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4457

1

			Ok(U256::from(100))

4458

);

4459

1

});

4460

4461

1

	Statemine::execute_with(|| {

4462

		// Check that Bob received relay tokens back in AssetHub

4463

		// (100 - MinXcmFee)

4464

1

		assert_eq!(

4465

1

			StatemineBalances::free_balance(RELAYBOB),

4466

			INITIAL_BALANCE + 100

4467

);

4468

4469

		// Check that BOB received 100 USDC on AssetHub

4470

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4471

1

});

4472

4473

	// Send back tokens from AH to ParaA from Bob's account

4474

1

	Statemine::execute_with(|| {

4475

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4476

4477

		// Now send those tokens to ParaA

4478

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4479

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4480

1

			assets: Wild(All),

4481

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4482

1

		}]);

4483

1

		assert_ok!(

4484

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4485

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

4486

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4487

1

				Box::new((Location::parent(), 100).into()),

4488

1

				Box::new(TransferType::LocalReserve),

4489

1

				Box::new(fees_id),

4490

1

				Box::new(TransferType::LocalReserve),

4491

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4492

1

				WeightLimit::Unlimited

4493

4494

);

4495

4496

		// 100 DOTs were deducted from Bob's account

4497

1

		assert_eq!(

4498

1

			StatemineBalances::free_balance(RELAYBOB),

4499

1

			bob_previous_balance - 100

4500

);

4501

1

});

4502

4503

1

	ParaA::execute_with(|| {

4504

		// Alice should have received 100 DOTs

4505

1

		assert_eq!(

4506

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4507

1

			Ok(U256::from(200))

4508

);

4509

1

});

4510

1

4511

4512

#[test]

4513

1

fn transact_through_signed_multilocation() {

4514

1

	MockNet::reset();

4515

1

	let mut ancestry = Location::parent();

4516

4517

1

	ParaA::execute_with(|| {

4518

		// Root can set transact info

4519

1

		assert_ok!(XcmTransactor::set_transact_info(

4520

1

			parachain::RuntimeOrigin::root(),

4521

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4522

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4523

1

			3000.into(),

4524

1

			20000000000.into(),

4525

			// 4 instructions in transact through signed

4526

1

			Some(4000.into())

4527

));

4528

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4529

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

4530

1

			.expect("must succeed");

4531

1

		ancestry = parachain::UniversalLocation::get().into();

4532

1

});

4533

4534

	// Let's construct the Junction that we will append with DescendOrigin

4535

1

	let signed_origin: Junctions = [AccountKey20 {

4536

1

		network: None,

4537

1

		key: PARAALICE,

4538

1

}]

4539

1

	.into();

4540

4541

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4542

1

	descend_origin_multilocation

4543

1

		.append_with(signed_origin)

4544

1

		.unwrap();

4545

4546

	// To convert it to what the relay will see instead of us

4547

1

	descend_origin_multilocation

4548

1

		.reanchor(&Location::parent(), &ancestry.interior)

4549

1

		.unwrap();

4550

4551

1

	let derived = xcm_builder::Account32Hash::<

4552

1

		relay_chain::KusamaNetwork,

4553

1

		relay_chain::AccountId,

4554

1

	>::convert_location(&descend_origin_multilocation)

4555

1

	.unwrap();

4556

4557

1

	Relay::execute_with(|| {

4558

		// free execution, full amount received

4559

1

		assert_ok!(RelayBalances::transfer_allow_death(

4560

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4561

1

			derived.clone(),

4562

			4000004100u128,

4563

));

4564

		// derived account has all funds

4565

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4566

		// sovereign account has 0 funds

4567

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4568

1

});

4569

4570

	// Encode the call. Balances transact to para_a_account

4571

	// First index

4572

1

	let mut encoded: Vec<u8> = Vec::new();

4573

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4574

1

		relay_chain::Balances,

4575

1

>()

4576

1

	.unwrap() as u8;

4577

4578

1

	encoded.push(index);

4579

4580

	// Then call bytes

4581

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4582

1

		// 100 to sovereign

4583

1

		dest: para_a_account(),

4584

1

		value: 100u32.into(),

4585

1

4586

1

	.encode();

4587

1

	encoded.append(&mut call_bytes);

4588

4589

1

	ParaA::execute_with(|| {

4590

1

		assert_ok!(XcmTransactor::transact_through_signed(

4591

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4592

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4593

1

			CurrencyPayment {

4594

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4595

1

					Location::parent()

4596

1

				))),

4597

1

				fee_amount: None

4598

1

},

4599

1

			encoded,

4600

			// 4000000000 for transfer + 4000 for XCM

4601

			// 1-1 to fee

4602

1

			TransactWeights {

4603

1

				transact_required_weight_at_most: 4000000000.into(),

4604

1

				overall_weight: None

4605

1

},

4606

			false

4607

));

4608

1

});

4609

4610

1

	Relay::execute_with(|| {

4611

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4612

4613

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4614

1

});

4615

1

4616

4617

#[test]

4618

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4619

1

	MockNet::reset();

4620

1

	let mut ancestry = Location::parent();

4621

4622

1

	ParaA::execute_with(|| {

4623

1

		ancestry = parachain::UniversalLocation::get().into();

4624

1

});

4625

4626

	// Let's construct the Junction that we will append with DescendOrigin

4627

1

	let signed_origin: Junctions = [AccountKey20 {

4628

1

		network: None,

4629

1

		key: PARAALICE,

4630

1

}]

4631

1

	.into();

4632

4633

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4634

1

	descend_origin_multilocation

4635

1

		.append_with(signed_origin)

4636

1

		.unwrap();

4637

4638

	// To convert it to what the relay will see instead of us

4639

1

	descend_origin_multilocation

4640

1

		.reanchor(&Location::parent(), &ancestry.interior)

4641

1

		.unwrap();

4642

4643

1

	let derived = xcm_builder::Account32Hash::<

4644

1

		relay_chain::KusamaNetwork,

4645

1

		relay_chain::AccountId,

4646

1

	>::convert_location(&descend_origin_multilocation)

4647

1

	.unwrap();

4648

4649

1

	Relay::execute_with(|| {

4650

		// free execution, full amount received

4651

1

		assert_ok!(RelayBalances::transfer_allow_death(

4652

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4653

1

			derived.clone(),

4654

			4000004100u128,

4655

));

4656

		// derived account has all funds

4657

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4658

		// sovereign account has 0 funds

4659

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4660

1

});

4661

4662

	// Encode the call. Balances transact to para_a_account

4663

	// First index

4664

1

	let mut encoded: Vec<u8> = Vec::new();

4665

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4666

1

		relay_chain::Balances,

4667

1

>()

4668

1

	.unwrap() as u8;

4669

4670

1

	encoded.push(index);

4671

4672

	// Then call bytes

4673

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4674

1

		// 100 to sovereign

4675

1

		dest: para_a_account(),

4676

1

		value: 100u32.into(),

4677

1

4678

1

	.encode();

4679

1

	encoded.append(&mut call_bytes);

4680

4681

1

	let total_weight = 4000004000u64;

4682

1

	ParaA::execute_with(|| {

4683

1

		assert_ok!(XcmTransactor::transact_through_signed(

4684

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4685

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4686

1

			CurrencyPayment {

4687

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4688

1

					Location::parent()

4689

1

				))),

4690

1

				fee_amount: Some(total_weight as u128)

4691

1

},

4692

1

			encoded,

4693

			// 4000000000 for transfer + 4000 for XCM

4694

1

			TransactWeights {

4695

1

				transact_required_weight_at_most: 4000000000.into(),

4696

1

				overall_weight: Some(Limited(total_weight.into()))

4697

1

},

4698

			false

4699

));

4700

1

});

4701

4702

1

	Relay::execute_with(|| {

4703

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4704

4705

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4706

1

});

4707

1

4708

4709

#[test]

4710

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4711

1

	MockNet::reset();

4712

1

	let mut ancestry = Location::parent();

4713

4714

1

	ParaA::execute_with(|| {

4715

1

		ancestry = parachain::UniversalLocation::get().into();

4716

1

});

4717

4718

	// Let's construct the Junction that we will append with DescendOrigin

4719

1

	let signed_origin: Junctions = [AccountKey20 {

4720

1

		network: None,

4721

1

		key: PARAALICE,

4722

1

}]

4723

1

	.into();

4724

4725

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4726

1

	descend_origin_multilocation

4727

1

		.append_with(signed_origin)

4728

1

		.unwrap();

4729

4730

	// To convert it to what the relay will see instead of us

4731

1

	descend_origin_multilocation

4732

1

		.reanchor(&Location::parent(), &ancestry.interior)

4733

1

		.unwrap();

4734

4735

1

	let derived = xcm_builder::Account32Hash::<

4736

1

		relay_chain::KusamaNetwork,

4737

1

		relay_chain::AccountId,

4738

1

	>::convert_location(&descend_origin_multilocation)

4739

1

	.unwrap();

4740

4741

1

	Relay::execute_with(|| {

4742

		// free execution, full amount received

4743

1

		assert_ok!(RelayBalances::transfer_allow_death(

4744

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4745

1

			derived.clone(),

4746

			4000009100u128,

4747

));

4748

		// derived account has all funds

4749

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4750

		// sovereign account has 0 funds

4751

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4752

1

});

4753

4754

	// Encode the call. Balances transact to para_a_account

4755

	// First index

4756

1

	let mut encoded: Vec<u8> = Vec::new();

4757

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4758

1

		relay_chain::Balances,

4759

1

>()

4760

1

	.unwrap() as u8;

4761

4762

1

	encoded.push(index);

4763

4764

	// Then call bytes

4765

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4766

1

		// 100 to sovereign

4767

1

		dest: para_a_account(),

4768

1

		value: 100u32.into(),

4769

1

4770

1

	.encode();

4771

1

	encoded.append(&mut call_bytes);

4772

4773

1

	let total_weight = 4000009000u64;

4774

1

	ParaA::execute_with(|| {

4775

1

		assert_ok!(XcmTransactor::transact_through_signed(

4776

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4777

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4778

1

			CurrencyPayment {

4779

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4780

1

					Location::parent()

4781

1

				))),

4782

1

				fee_amount: Some(total_weight as u128)

4783

1

},

4784

1

			encoded,

4785

			// 4000000000 for transfer + 9000 for XCM

4786

1

			TransactWeights {

4787

1

				transact_required_weight_at_most: 4000000000.into(),

4788

1

				overall_weight: Some(Limited(total_weight.into()))

4789

1

},

4790

			true

4791

));

4792

1

});

4793

4794

1

	Relay::execute_with(|| {

4795

		// 100 transferred

4796

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4797

4798

		// 4000009000 refunded

4799

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4800

1

});

4801

1

4802

4803

#[test]

4804

1

fn transact_through_signed_multilocation_para_to_para() {

4805

1

	MockNet::reset();

4806

1

	let mut ancestry = Location::parent();

4807

4808

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4809

4810

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4811

4812

1

	ParaA::execute_with(|| {

4813

		// Root can set transact info

4814

1

		assert_ok!(XcmTransactor::set_transact_info(

4815

1

			parachain::RuntimeOrigin::root(),

4816

			// ParaB

4817

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4818

			// Para charges 1000 for every instruction, and we have 3, so 3

4819

1

			3.into(),

4820

1

			20000000000.into(),

4821

			// 4 instructions in transact through signed

4822

1

			Some(4.into())

4823

));

4824

		// Root can set transact info

4825

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4826

1

		set_fee_per_second_for_location(

4827

1

			para_b_balances.clone(),

4828

1

			parachain::ParaTokensPerSecond::get(),

4829

4830

1

		.expect("must succeed");

4831

1

		ancestry = parachain::UniversalLocation::get().into();

4832

1

});

4833

4834

	// Let's construct the Junction that we will append with DescendOrigin

4835

1

	let signed_origin: Junctions = [AccountKey20 {

4836

1

		network: None,

4837

1

		key: PARAALICE,

4838

1

}]

4839

1

	.into();

4840

4841

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4842

1

	descend_origin_location.append_with(signed_origin).unwrap();

4843

4844

	// To convert it to what the paraB will see instead of us

4845

1

	descend_origin_location

4846

1

		.reanchor(&para_b_location, &ancestry.interior)

4847

1

		.unwrap();

4848

4849

1

	let derived = xcm_builder::HashedDescription::<

4850

1

		parachain::AccountId,

4851

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4852

1

	>::convert_location(&descend_origin_location)

4853

1

	.unwrap();

4854

4855

1

	ParaB::execute_with(|| {

4856

		// free execution, full amount received

4857

1

		assert_ok!(ParaBalances::transfer_allow_death(

4858

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4859

1

			derived.clone(),

4860

			4000000104u128,

4861

));

4862

		// derived account has all funds

4863

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4864

		// sovereign account has 0 funds

4865

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4866

1

});

4867

4868

	// Encode the call. Balances transact to para_a_account

4869

	// First index

4870

1

	let mut encoded: Vec<u8> = Vec::new();

4871

1

	let index =

4872

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4873

1

			.unwrap() as u8;

4874

4875

1

	encoded.push(index);

4876

4877

	// Then call bytes

4878

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4879

1

		// 100 to sovereign

4880

1

		dest: para_a_account_20(),

4881

1

		value: 100u32.into(),

4882

1

4883

1

	.encode();

4884

1

	encoded.append(&mut call_bytes);

4885

4886

1

	ParaA::execute_with(|| {

4887

1

		assert_ok!(XcmTransactor::transact_through_signed(

4888

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4889

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4890

1

			CurrencyPayment {

4891

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4892

1

					para_b_balances

4893

1

				))),

4894

1

				fee_amount: None

4895

1

},

4896

1

			encoded,

4897

			// 4000000000 for transfer + 4000 for XCM

4898

			// 1-1 to fee

4899

1

			TransactWeights {

4900

1

				transact_required_weight_at_most: 4000000000.into(),

4901

1

				overall_weight: None

4902

1

},

4903

			false

4904

));

4905

1

});

4906

4907

1

	ParaB::execute_with(|| {

4908

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4909

4910

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4911

1

});

4912

1

4913

4914

#[test]

4915

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4916

1

	MockNet::reset();

4917

1

	let mut ancestry = Location::parent();

4918

4919

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4920

4921

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4922

4923

1

	ParaA::execute_with(|| {

4924

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4925

1

		set_fee_per_second_for_location(

4926

1

			para_b_balances.clone(),

4927

1

			parachain::ParaTokensPerSecond::get(),

4928

4929

1

		.expect("must succeed");

4930

1

		ancestry = parachain::UniversalLocation::get().into();

4931

1

});

4932

4933

	// Let's construct the Junction that we will append with DescendOrigin

4934

1

	let signed_origin: Junctions = [AccountKey20 {

4935

1

		network: None,

4936

1

		key: PARAALICE,

4937

1

}]

4938

1

	.into();

4939

4940

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4941

1

	descend_origin_location.append_with(signed_origin).unwrap();

4942

4943

	// To convert it to what the paraB will see instead of us

4944

1

	descend_origin_location

4945

1

		.reanchor(&para_b_location, &ancestry.interior)

4946

1

		.unwrap();

4947

4948

1

	let derived = xcm_builder::HashedDescription::<

4949

1

		parachain::AccountId,

4950

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4951

1

	>::convert_location(&descend_origin_location)

4952

1

	.unwrap();

4953

4954

1

	ParaB::execute_with(|| {

4955

		// free execution, full amount received

4956

1

		assert_ok!(ParaBalances::transfer_allow_death(

4957

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4958

1

			derived.clone(),

4959

			4000009100u128,

4960

));

4961

		// derived account has all funds

4962

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4963

		// sovereign account has 0 funds

4964

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4965

1

});

4966

4967

	// Encode the call. Balances transact to para_a_account

4968

	// First index

4969

1

	let mut encoded: Vec<u8> = Vec::new();

4970

1

	let index =

4971

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4972

1

			.unwrap() as u8;

4973

4974

1

	encoded.push(index);

4975

4976

	// Then call bytes

4977

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4978

1

		// 100 to sovereign

4979

1

		dest: para_a_account_20(),

4980

1

		value: 100u32.into(),

4981

1

4982

1

	.encode();

4983

1

	encoded.append(&mut call_bytes);

4984

4985

1

	let overall_weight = 4000009000u64;

4986

1

	ParaA::execute_with(|| {

4987

1

		assert_ok!(XcmTransactor::transact_through_signed(

4988

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4989

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4990

1

			CurrencyPayment {

4991

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4992

1

					para_b_balances

4993

1

				))),

4994

1

				fee_amount: Some(overall_weight as u128)

4995

1

},

4996

1

			encoded,

4997

			// 4000000000 for transfer + 9000 for XCM

4998

1

			TransactWeights {

4999

1

				transact_required_weight_at_most: 4000000000.into(),

5000

1

				overall_weight: Some(Limited(overall_weight.into()))

5001

1

},

5002

			true

5003

));

5004

1

});

5005

5006

1

	ParaB::execute_with(|| {

5007

		// Check the derived account was refunded

5008

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

5009

5010

		// Check the transfer was executed

5011

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

5012

1

});

5013

1

5014

5015

#[test]

5016

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

5017

1

	MockNet::reset();

5018

1

	let mut ancestry = Location::parent();

5019

5020

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5021

5022

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5023

5024

1

	ParaA::execute_with(|| {

5025

		// Root can set transact info

5026

1

		assert_ok!(XcmTransactor::set_transact_info(

5027

1

			parachain::RuntimeOrigin::root(),

5028

			// ParaB

5029

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5030

			// Para charges 1000 for every instruction, and we have 3, so 3

5031

1

			3.into(),

5032

1

			20000000000.into(),

5033

			// 4 instructions in transact through signed

5034

1

			Some(4.into())

5035

));

5036

		// Root can set transact info

5037

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5038

1

		set_fee_per_second_for_location(

5039

1

			para_b_balances.clone(),

5040

1

			parachain::ParaTokensPerSecond::get(),

5041

5042

1

		.expect("must succeed");

5043

1

		ancestry = parachain::UniversalLocation::get().into();

5044

1

});

5045

5046

	// Let's construct the Junction that we will append with DescendOrigin

5047

1

	let signed_origin: Junctions = [AccountKey20 {

5048

1

		network: None,

5049

1

		key: PARAALICE,

5050

1

}]

5051

1

	.into();

5052

5053

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5054

1

	descend_origin_location.append_with(signed_origin).unwrap();

5055

5056

	// To convert it to what the paraB will see instead of us

5057

1

	descend_origin_location

5058

1

		.reanchor(&para_b_location, &ancestry.interior)

5059

1

		.unwrap();

5060

5061

1

	let derived = xcm_builder::HashedDescription::<

5062

1

		parachain::AccountId,

5063

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5064

1

	>::convert_location(&descend_origin_location)

5065

1

	.unwrap();

5066

5067

1

	let mut parachain_b_alice_balances_before = 0;

5068

1

	ParaB::execute_with(|| {

5069

1

		assert_ok!(ParaBalances::transfer_allow_death(

5070

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5071

1

			derived.clone(),

5072

			4000000104u128,

5073

));

5074

		// derived account has all funds

5075

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5076

		// sovereign account has 0 funds

5077

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5078

5079

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5080

1

});

5081

5082

	// Encode the call. Balances transact to para_a_account

5083

	// First index

5084

1

	let mut encoded: Vec<u8> = Vec::new();

5085

1

	let index =

5086

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5087

1

			.unwrap() as u8;

5088

5089

1

	encoded.push(index);

5090

5091

	use sp_core::U256;

5092

	// Let's do a EVM transfer

5093

1

	let eth_tx =

5094

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5095

1

			gas_limit: U256::from(21000),

5096

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5097

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5098

1

			value: U256::from(100),

5099

1

			input: BoundedVec::<

5100

1

u8,

5101

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5102

1

			>::try_from(vec![]).unwrap(),

5103

1

			access_list: None,

5104

1

});

5105

5106

	// Then call bytes

5107

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

5108

1

		xcm_transaction: eth_tx,

5109

1

5110

1

	.encode();

5111

1

	encoded.append(&mut call_bytes);

5112

5113

1

	ParaA::execute_with(|| {

5114

1

		assert_ok!(XcmTransactor::transact_through_signed(

5115

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5116

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5117

1

			CurrencyPayment {

5118

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5119

1

					para_b_balances

5120

1

				))),

5121

1

				fee_amount: None

5122

1

},

5123

1

			encoded,

5124

			// 4000000000 for transfer + 4000 for XCM

5125

			// 1-1 to fee

5126

1

			TransactWeights {

5127

1

				transact_required_weight_at_most: 4000000000.into(),

5128

1

				overall_weight: None

5129

1

},

5130

			false

5131

));

5132

1

});

5133

5134

1

	ParaB::execute_with(|| {

5135

		// Make sure the EVM transfer went through

5136

1

		assert!(

5137

1

			ParaBalances::free_balance(&PARAALICE.into())

5138

1

				== parachain_b_alice_balances_before + 100

5139

);

5140

1

});

5141

1

5142

5143

#[test]

5144

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

5145

1

	MockNet::reset();

5146

1

	let mut ancestry = Location::parent();

5147

5148

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5149

5150

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5151

5152

1

	ParaA::execute_with(|| {

5153

		// Root can set transact info

5154

1

		assert_ok!(XcmTransactor::set_transact_info(

5155

1

			parachain::RuntimeOrigin::root(),

5156

			// ParaB

5157

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5158

			// Para charges 1000 for every instruction, and we have 3, so 3

5159

1

			3.into(),

5160

1

			20000000000.into(),

5161

			// 4 instructions in transact through signed

5162

1

			Some(4.into())

5163

));

5164

		// Root can set transact info

5165

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5166

1

		set_fee_per_second_for_location(

5167

1

			para_b_balances.clone(),

5168

1

			parachain::ParaTokensPerSecond::get(),

5169

5170

1

		.expect("must succeed");

5171

1

		ancestry = parachain::UniversalLocation::get().into();

5172

1

});

5173

5174

	// Let's construct the Junction that we will append with DescendOrigin

5175

1

	let signed_origin: Junctions = [AccountKey20 {

5176

1

		network: None,

5177

1

		key: PARAALICE,

5178

1

}]

5179

1

	.into();

5180

5181

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5182

1

	descend_origin_location.append_with(signed_origin).unwrap();

5183

5184

	// To convert it to what the paraB will see instead of us

5185

1

	descend_origin_location

5186

1

		.reanchor(&para_b_location, &ancestry.interior)

5187

1

		.unwrap();

5188

5189

1

	let derived = xcm_builder::HashedDescription::<

5190

1

		parachain::AccountId,

5191

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5192

1

	>::convert_location(&descend_origin_location)

5193

1

	.unwrap();

5194

5195

1

	let mut parachain_b_alice_balances_before = 0;

5196

1

	ParaB::execute_with(|| {

5197

1

		assert_ok!(ParaBalances::transfer_allow_death(

5198

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5199

1

			derived.clone(),

5200

			4000000104u128,

5201

));

5202

		// derived account has all funds

5203

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5204

		// sovereign account has 0 funds

5205

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5206

5207

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5208

1

});

5209

5210

	// Encode the call. Balances transact to para_a_account

5211

	// First index

5212

1

	let mut encoded: Vec<u8> = Vec::new();

5213

1

	let index =

5214

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5215

1

			.unwrap() as u8;

5216

5217

1

	encoded.push(index);

5218

5219

	use sp_core::U256;

5220

	// Let's do a EVM transfer

5221

1

	let eth_tx =

5222

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5223

1

			gas_limit: U256::from(21000),

5224

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5225

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5226

1

			value: U256::from(100),

5227

1

			input: BoundedVec::<

5228

1

u8,

5229

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5230

1

			>::try_from(vec![]).unwrap(),

5231

1

			access_list: None,

5232

1

});

5233

5234

	// Then call bytes

5235

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5236

1

		transact_as: PARAALICE.into(),

5237

1

		xcm_transaction: eth_tx,

5238

1

5239

1

	.encode();

5240

1

	encoded.append(&mut call_bytes);

5241

5242

1

	ParaA::execute_with(|| {

5243

1

		assert_ok!(XcmTransactor::transact_through_signed(

5244

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5245

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5246

1

			CurrencyPayment {

5247

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5248

1

					para_b_balances

5249

1

				))),

5250

1

				fee_amount: None

5251

1

},

5252

1

			encoded,

5253

1

			TransactWeights {

5254

1

				transact_required_weight_at_most: 4000000000.into(),

5255

1

				overall_weight: None

5256

1

},

5257

			false

5258

));

5259

1

});

5260

5261

1

	ParaB::execute_with(|| {

5262

		// Make sure the EVM transfer wasn't executed

5263

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

5264

1

});

5265

1

5266

5267

#[test]

5268

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

5269

1

	MockNet::reset();

5270

1

	let mut ancestry = Location::parent();

5271

5272

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5273

5274

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5275

5276

1

	ParaA::execute_with(|| {

5277

		// Root can set transact info

5278

1

		assert_ok!(XcmTransactor::set_transact_info(

5279

1

			parachain::RuntimeOrigin::root(),

5280

			// ParaB

5281

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5282

			// Para charges 1000 for every instruction, and we have 3, so 3

5283

1

			3.into(),

5284

1

			20000000000.into(),

5285

			// 4 instructions in transact through signed

5286

1

			Some(4.into())

5287

));

5288

		// Root can set transact info

5289

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5290

1

		set_fee_per_second_for_location(

5291

1

			para_b_balances.clone(),

5292

1

			parachain::ParaTokensPerSecond::get(),

5293

5294

1

		.expect("must succeed");

5295

1

		ancestry = parachain::UniversalLocation::get().into();

5296

1

});

5297

5298

	// Let's construct the Junction that we will append with DescendOrigin

5299

1

	let signed_origin: Junctions = [AccountKey20 {

5300

1

		network: None,

5301

1

		key: PARAALICE,

5302

1

}]

5303

1

	.into();

5304

5305

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5306

1

	descend_origin_location.append_with(signed_origin).unwrap();

5307

5308

	// To convert it to what the paraB will see instead of us

5309

1

	descend_origin_location

5310

1

		.reanchor(&para_b_location, &ancestry.interior)

5311

1

		.unwrap();

5312

5313

1

	let derived = xcm_builder::HashedDescription::<

5314

1

		parachain::AccountId,

5315

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5316

1

	>::convert_location(&descend_origin_location)

5317

1

	.unwrap();

5318

5319

1

	let transfer_recipient = evm_account();

5320

1

	let mut transfer_recipient_balance_before = 0;

5321

1

	ParaB::execute_with(|| {

5322

1

		assert_ok!(ParaBalances::transfer_allow_death(

5323

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5324

1

			derived.clone(),

5325

			4000000104u128,

5326

));

5327

		// derived account has all funds

5328

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5329

		// sovereign account has 0 funds

5330

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5331

5332

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5333

5334

		// Add proxy ALICE  -> derived

5335

1

		let _ = parachain::Proxy::add_proxy_delegate(

5336

1

			&PARAALICE.into(),

5337

1

			derived,

5338

1

			parachain::ProxyType::Any,

5339

1

0,

5340

1

);

5341

1

});

5342

5343

	// Encode the call. Balances transact to para_a_account

5344

	// First index

5345

1

	let mut encoded: Vec<u8> = Vec::new();

5346

1

	let index =

5347

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5348

1

			.unwrap() as u8;

5349

5350

1

	encoded.push(index);

5351

5352

	use sp_core::U256;

5353

	// Let's do a EVM transfer

5354

1

	let eth_tx =

5355

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5356

1

			gas_limit: U256::from(21000),

5357

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5358

1

			value: U256::from(100),

5359

1

			input: BoundedVec::<

5360

1

u8,

5361

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5362

1

			>::try_from(vec![]).unwrap(),

5363

1

			access_list: None,

5364

1

});

5365

5366

	// Then call bytes

5367

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5368

1

		transact_as: PARAALICE.into(),

5369

1

		xcm_transaction: eth_tx,

5370

1

5371

1

	.encode();

5372

1

	encoded.append(&mut call_bytes);

5373

5374

1

	ParaA::execute_with(|| {

5375

1

		assert_ok!(XcmTransactor::transact_through_signed(

5376

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5377

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5378

1

			CurrencyPayment {

5379

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5380

1

					para_b_balances

5381

1

				))),

5382

1

				fee_amount: None

5383

1

},

5384

1

			encoded,

5385

1

			TransactWeights {

5386

1

				transact_required_weight_at_most: 4000000000.into(),

5387

1

				overall_weight: None

5388

1

},

5389

			false

5390

));

5391

1

});

5392

5393

1

	ParaB::execute_with(|| {

5394

		// Make sure the EVM transfer was executed

5395

1

		assert!(

5396

1

			ParaBalances::free_balance(&transfer_recipient.into())

5397

1

				== transfer_recipient_balance_before + 100

5398

);

5399

1

});

5400

1

5401

5402

#[test]

5403

1

fn hrmp_init_accept_through_root() {

5404

1

	MockNet::reset();

5405

5406

1

	Relay::execute_with(|| {

5407

1

		assert_ok!(RelayBalances::transfer_allow_death(

5408

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5409

1

			para_a_account(),

5410

			1000u128

5411

));

5412

1

		assert_ok!(RelayBalances::transfer_allow_death(

5413

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5414

1

			para_b_account(),

5415

			1000u128

5416

));

5417

1

});

5418

5419

1

	ParaA::execute_with(|| {

5420

1

		let total_fee = 1_000u128;

5421

1

		let total_weight: u64 = 1_000_000_000;

5422

1

		let tx_weight: u64 = 500_000_000;

5423

		// Root can send hrmp init channel

5424

1

		assert_ok!(XcmTransactor::hrmp_manage(

5425

1

			parachain::RuntimeOrigin::root(),

5426

1

			HrmpOperation::InitOpen(HrmpInitParams {

5427

1

				para_id: 2u32.into(),

5428

1

				proposed_max_capacity: 1,

5429

1

				proposed_max_message_size: 1

5430

1

}),

5431

1

			CurrencyPayment {

5432

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5433

1

					Location::parent()

5434

1

				))),

5435

1

				fee_amount: Some(total_fee)

5436

1

},

5437

1

			TransactWeights {

5438

1

				transact_required_weight_at_most: tx_weight.into(),

5439

1

				overall_weight: Some(Limited(total_weight.into()))

5440

1

5441

));

5442

1

});

5443

1

	Relay::execute_with(|| {

5444

1

		let expected_event: relay_chain::RuntimeEvent =

5445

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5446

1

				sender: 1u32.into(),

5447

1

				recipient: 2u32.into(),

5448

1

				proposed_max_capacity: 1u32,

5449

1

				proposed_max_message_size: 1u32,

5450

1

5451

1

			.into();

5452

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5453

1

});

5454

1

	ParaB::execute_with(|| {

5455

1

		let total_fee = 1_000u128;

5456

1

		let total_weight: u64 = 1_000_000_000;

5457

1

		let tx_weight: u64 = 500_000_000;

5458

		// Root can send hrmp accept channel

5459

1

		assert_ok!(XcmTransactor::hrmp_manage(

5460

1

			parachain::RuntimeOrigin::root(),

5461

1

			HrmpOperation::Accept {

5462

1

				para_id: 1u32.into()

5463

1

},

5464

1

			CurrencyPayment {

5465

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5466

1

					Location::parent()

5467

1

				))),

5468

1

				fee_amount: Some(total_fee)

5469

1

},

5470

1

			TransactWeights {

5471

1

				transact_required_weight_at_most: tx_weight.into(),

5472

1

				overall_weight: Some(Limited(total_weight.into()))

5473

1

5474

));

5475

1

});

5476

5477

1

	Relay::execute_with(|| {

5478

1

		let expected_event: relay_chain::RuntimeEvent =

5479

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5480

1

				sender: 1u32.into(),

5481

1

				recipient: 2u32.into(),

5482

1

5483

1

			.into();

5484

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5485

1

});

5486

1

5487

5488

#[test]

5489

1

fn hrmp_close_works() {

5490

1

	MockNet::reset();

5491

5492

1

	Relay::execute_with(|| {

5493

1

		assert_ok!(RelayBalances::transfer_allow_death(

5494

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5495

1

			para_a_account(),

5496

			1000u128

5497

));

5498

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5499

1

			relay_chain::RuntimeOrigin::root(),

5500

1

			1u32.into(),

5501

1

			2u32.into(),

5502

			1u32,

5503

			1u32

5504

));

5505

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5506

1

			relay_chain::RuntimeOrigin::root(),

5507

			1u32

5508

));

5509

1

});

5510

5511

1

	ParaA::execute_with(|| {

5512

1

		let total_fee = 1_000u128;

5513

1

		let total_weight: u64 = 1_000_000_000;

5514

1

		let tx_weight: u64 = 500_000_000;

5515

		// Root can send hrmp close

5516

1

		assert_ok!(XcmTransactor::hrmp_manage(

5517

1

			parachain::RuntimeOrigin::root(),

5518

1

			HrmpOperation::Close(HrmpChannelId {

5519

1

				sender: 1u32.into(),

5520

1

				recipient: 2u32.into()

5521

1

}),

5522

1

			CurrencyPayment {

5523

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5524

1

					Location::parent()

5525

1

				))),

5526

1

				fee_amount: Some(total_fee)

5527

1

},

5528

1

			TransactWeights {

5529

1

				transact_required_weight_at_most: tx_weight.into(),

5530

1

				overall_weight: Some(Limited(total_weight.into()))

5531

1

5532

));

5533

1

});

5534

1

	Relay::execute_with(|| {

5535

1

		let expected_event: relay_chain::RuntimeEvent =

5536

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5537

1

				by_parachain: 1u32.into(),

5538

1

				channel_id: HrmpChannelId {

5539

1

					sender: 1u32.into(),

5540

1

					recipient: 2u32.into(),

5541

1

},

5542

1

5543

1

			.into();

5544

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5545

1

});

5546

1

5547

5548

use crate::xcm_mock::parachain::XcmWeightTrader;

5549

use parity_scale_codec::{Decode, Encode};

5550

use sp_io::hashing::blake2_256;

5551

5552

// Helper to derive accountIds

5553

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5554

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5555

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5556

7