Grcov report - xcm

1

// Copyright 2019-2022 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

//! Moonbeam Runtime Xcm Tests

18

19

mod xcm_mock;

20

21

use cumulus_primitives_core::relay_chain::HrmpChannelId;

22

use frame_support::{

23

	assert_ok,

24

	traits::{PalletInfo, PalletInfoAccess},

25

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

26

	BoundedVec,

27

};

28

use pallet_xcm_transactor::{

29

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

30

};

31

use sp_core::ConstU32;

32

use sp_runtime::traits::{Convert, MaybeEquivalence};

33

use xcm::{

34

	latest::{

35

		prelude::{

36

			AccountId32, AccountKey20, Fungible, GeneralIndex, Junction, Junctions, Limited,

37

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

38

			WeightLimit, Xcm,

39

},

40

		Asset, AssetId, Assets as XcmAssets, Fungibility,

41

},

42

	IntoVersion, VersionedAssets, VersionedLocation, WrapVersion,

43

};

44

use xcm_executor::traits::ConvertLocation;

45

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

46

use xcm_mock::relay_chain;

47

use xcm_mock::*;

48

use xcm_primitives::{

49

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

50

};

51

use xcm_simulator::TestExt;

52

53

26

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

54

26

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

55

26

	let VersionedLocation::V4(location_v4) = VersionedLocation::V3(location_v3)

56

26

		.into_version(4)

57

26

		.map_err(|_| ())?

58

	else {

59

		return Err(());

60

};

61

	use frame_support::weights::WeightToFee as _;

62

26

	let native_amount_per_second: u128 =

63

26

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

64

26

			&Weight::from_parts(

65

26

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

66

26

0,

67

26

),

68

26

69

26

		.try_into()

70

26

		.map_err(|_| ())?;

71

26

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

72

26

	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

16

		0u128

78

};

79

26

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

80

26

		location_v4,

81

26

		(true, relative_price),

82

26

);

83

26

	Ok(())

84

26

85

86

23

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

87

23

	Asset {

88

23

		id: AssetId(

89

23

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

90

23

				currency_id,

91

23

92

23

			.unwrap(),

93

23

),

94

23

		fun: Fungibility::Fungible(amount),

95

23

96

23

97

98

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

99

#[test]

100

1

fn receive_relay_asset_from_relay() {

101

1

	MockNet::reset();

102

1

103

1

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

104

1

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

105

1

	let asset_metadata = parachain::AssetMetadata {

106

1

		name: b"RelayToken".to_vec(),

107

1

		symbol: b"Relay".to_vec(),

108

1

		decimals: 12,

109

1

};

110

1

111

1

	// Register relay asset in paraA

112

1

	ParaA::execute_with(|| {

113

1

		assert_ok!(AssetManager::register_foreign_asset(

114

1

			parachain::RuntimeOrigin::root(),

115

1

			source_location.clone(),

116

1

			asset_metadata,

117

1

			1u128,

118

1

			true

119

1

));

120

1

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

121

1

});

122

1

123

1

	// Actually send relay asset to parachain

124

1

	let dest: Location = AccountKey20 {

125

1

		network: None,

126

1

		key: PARAALICE,

127

1

128

1

	.into();

129

1

130

1

	// First send relay chain asset to Parachain

131

1

	Relay::execute_with(|| {

132

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

133

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

134

1

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

135

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

136

1

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

137

1

0,

138

1

			WeightLimit::Unlimited

139

1

));

140

1

});

141

1

142

1

	// Verify that parachain received the asset

143

1

	ParaA::execute_with(|| {

144

1

		// free execution, full amount received

145

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 123);

146

1

});

147

1

148

149

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

150

#[test]

151

1

fn send_relay_asset_to_relay() {

152

1

	MockNet::reset();

153

1

154

1

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

155

1

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

156

1

157

1

	let asset_metadata = parachain::AssetMetadata {

158

1

		name: b"RelayToken".to_vec(),

159

1

		symbol: b"Relay".to_vec(),

160

1

		decimals: 12,

161

1

};

162

1

163

1

	// Register relay asset in paraA

164

1

	ParaA::execute_with(|| {

165

1

		assert_ok!(AssetManager::register_foreign_asset(

166

1

			parachain::RuntimeOrigin::root(),

167

1

			source_location.clone(),

168

1

			asset_metadata,

169

1

			1u128,

170

1

			true

171

1

));

172

		// Free execution

173

1

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

174

1

});

175

1

176

1

	let dest: Location = Junction::AccountKey20 {

177

1

		network: None,

178

1

		key: PARAALICE,

179

1

180

1

	.into();

181

1

182

1

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

183

1

	Relay::execute_with(|| {

184

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

185

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

186

1

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

187

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

188

1

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

189

1

0,

190

1

			WeightLimit::Unlimited

191

1

));

192

1

});

193

1

194

1

	ParaA::execute_with(|| {

195

1

		// Free execution, full amount received

196

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 123);

197

1

});

198

1

199

1

	// Lets gather the balance before sending back money

200

1

	let mut balance_before_sending = 0;

201

1

	Relay::execute_with(|| {

202

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

203

1

});

204

1

205

1

	// We now send back some money to the relay

206

1

	let dest = Location {

207

1

		parents: 1,

208

1

		interior: [AccountId32 {

209

1

			network: None,

210

1

			id: RELAYALICE.into(),

211

1

}]

212

1

		.into(),

213

1

};

214

1

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

215

1

	ParaA::execute_with(|| {

216

1

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

217

1

		assert_ok!(PolkadotXcm::transfer_assets(

218

1

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

219

1

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

220

1

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

221

1

			Box::new(VersionedAssets::V4(asset.into())),

222

1

0,

223

1

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

224

1

));

225

1

});

226

1

227

1

	// The balances in paraAlice should have been substracted

228

1

	ParaA::execute_with(|| {

229

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 0);

230

1

});

231

1

232

1

	// Balances in the relay should have been received

233

1

	Relay::execute_with(|| {

234

1

		// free execution,x	 full amount received

235

1

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

236

1

});

237

1

238

239

#[test]

240

1

fn send_relay_asset_to_para_b() {

241

1

	MockNet::reset();

242

1

243

1

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

244

1

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

245

1

246

1

	let asset_metadata = parachain::AssetMetadata {

247

1

		name: b"RelayToken".to_vec(),

248

1

		symbol: b"Relay".to_vec(),

249

1

		decimals: 12,

250

1

};

251

1

252

1

	// Register asset in paraA. Free execution

253

1

	ParaA::execute_with(|| {

254

1

		assert_ok!(AssetManager::register_foreign_asset(

255

1

			parachain::RuntimeOrigin::root(),

256

1

			source_location.clone(),

257

1

			asset_metadata.clone(),

258

1

			1u128,

259

1

			true

260

1

));

261

1

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

262

1

});

263

1

264

1

	// Register asset in paraB. Free execution

265

1

	ParaB::execute_with(|| {

266

1

		assert_ok!(AssetManager::register_foreign_asset(

267

1

			parachain::RuntimeOrigin::root(),

268

1

			source_location.clone(),

269

1

			asset_metadata,

270

1

			1u128,

271

1

			true

272

1

));

273

1

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

274

1

});

275

1

276

1

	let dest: Location = Junction::AccountKey20 {

277

1

		network: None,

278

1

		key: PARAALICE,

279

1

280

1

	.into();

281

1

	Relay::execute_with(|| {

282

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

283

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

284

1

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

285

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

286

1

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

287

1

0,

288

1

			WeightLimit::Unlimited

289

1

));

290

1

});

291

1

292

1

	ParaA::execute_with(|| {

293

1

		// free execution, full amount received

294

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 123);

295

1

});

296

1

297

1

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

298

1

	let dest = Location {

299

1

		parents: 1,

300

1

		interior: [

301

1

			Parachain(2),

302

1

			AccountKey20 {

303

1

				network: None,

304

1

				key: PARAALICE.into(),

305

1

},

306

1

307

1

		.into(),

308

1

};

309

1

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

310

1

	ParaA::execute_with(|| {

311

1

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

312

1

		assert_ok!(PolkadotXcm::transfer_assets(

313

1

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

314

1

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

315

1

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

316

1

			Box::new(VersionedAssets::V4(asset.into())),

317

1

0,

318

1

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

319

1

));

320

1

});

321

1

322

1

	// Para A balances should have been substracted

323

1

	ParaA::execute_with(|| {

324

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 23);

325

1

});

326

1

327

1

	// Para B balances should have been credited

328

1

	ParaB::execute_with(|| {

329

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 100);

330

1

});

331

1

332

333

#[test]

334

1

fn send_para_a_asset_to_para_b() {

335

1

	MockNet::reset();

336

1

337

1

	// This represents the asset in paraA

338

1

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

339

1

	let source_location = parachain::AssetType::Xcm(

340

1

		xcm_builder::WithLatestLocationConverter::convert(&para_a_balances).expect("convert to v3"),

341

1

);

342

1

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

343

1

344

1

	let asset_metadata = parachain::AssetMetadata {

345

1

		name: b"ParaAToken".to_vec(),

346

1

		symbol: b"ParaA".to_vec(),

347

1

		decimals: 18,

348

1

};

349

1

350

1

	// Register asset in paraB. Free execution

351

1

	ParaB::execute_with(|| {

352

1

		assert_ok!(AssetManager::register_foreign_asset(

353

1

			parachain::RuntimeOrigin::root(),

354

1

			source_location.clone(),

355

1

			asset_metadata,

356

1

			1u128,

357

1

			true

358

1

));

359

1

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

360

1

});

361

1

362

1

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

363

1

	let dest = Location {

364

1

		parents: 1,

365

1

		interior: [

366

1

			Parachain(2),

367

1

			AccountKey20 {

368

1

				network: None,

369

1

				key: PARAALICE.into(),

370

1

},

371

1

372

1

		.into(),

373

1

};

374

1

375

1

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

376

1

	// Native token is substracted in paraA

377

1

	ParaA::execute_with(|| {

378

1

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

379

1

		// Free execution, full amount received

380

1

		assert_ok!(PolkadotXcm::transfer_assets(

381

1

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

382

1

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

383

1

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

384

1

			Box::new(VersionedAssets::V4(asset.into())),

385

1

0,

386

1

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

387

1

));

388

1

});

389

1

390

1

	ParaA::execute_with(|| {

391

1

		assert_eq!(

392

1

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

393

1

			INITIAL_BALANCE - 100

394

1

);

395

1

});

396

1

397

1

	// Asset is minted in paraB

398

1

	ParaB::execute_with(|| {

399

1

		// Free execution, full amount received

400

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 100);

401

1

});

402

1

403

404

#[test]

405

1

fn send_para_a_asset_from_para_b_to_para_c() {

406

1

	MockNet::reset();

407

1

408

1

	// Represents para A asset

409

1

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

410

1

	let source_location = parachain::AssetType::Xcm(

411

1

		xcm_builder::WithLatestLocationConverter::convert(&para_a_balances).expect("convert to v3"),

412

1

);

413

1

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

414

1

415

1

	let asset_metadata = parachain::AssetMetadata {

416

1

		name: b"ParaAToken".to_vec(),

417

1

		symbol: b"ParaA".to_vec(),

418

1

		decimals: 18,

419

1

};

420

1

421

1

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

422

1

	ParaB::execute_with(|| {

423

1

		assert_ok!(AssetManager::register_foreign_asset(

424

1

			parachain::RuntimeOrigin::root(),

425

1

			source_location.clone(),

426

1

			asset_metadata.clone(),

427

1

			1u128,

428

1

			true

429

1

));

430

1

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

431

1

});

432

1

433

1

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

434

1

	ParaC::execute_with(|| {

435

1

		assert_ok!(AssetManager::register_foreign_asset(

436

1

			parachain::RuntimeOrigin::root(),

437

1

			source_location.clone(),

438

1

			asset_metadata,

439

1

			1u128,

440

1

			true

441

1

));

442

1

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

443

1

});

444

1

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

1

	ParaA::execute_with(|| {

458

1

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

459

1

		assert_ok!(PolkadotXcm::transfer_assets(

460

1

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

461

1

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

462

1

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

463

1

			Box::new(VersionedAssets::V4(asset.into())),

464

1

0,

465

1

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

466

1

));

467

1

});

468

1

469

1

	// Para A balances have been substracted

470

1

	ParaA::execute_with(|| {

471

1

		assert_eq!(

472

1

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

473

1

			INITIAL_BALANCE - 100

474

1

);

475

1

});

476

1

477

1

	// Para B balances have been credited

478

1

	ParaB::execute_with(|| {

479

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 100);

480

1

});

481

1

482

1

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

483

1

	let dest = Location {

484

1

		parents: 1,

485

1

		interior: [

486

1

			Parachain(3),

487

1

			AccountKey20 {

488

1

				network: None,

489

1

				key: PARAALICE.into(),

490

1

},

491

1

492

1

		.into(),

493

1

};

494

1

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

495

1

	ParaB::execute_with(|| {

496

1

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

497

1

		assert_ok!(PolkadotXcm::transfer_assets(

498

1

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

499

1

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

500

1

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

501

1

			Box::new(VersionedAssets::V4(asset.into())),

502

1

0,

503

1

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

504

1

));

505

1

});

506

1

507

1

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

508

1

	ParaC::execute_with(|| {

509

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 96);

510

1

});

511

1

512

513

#[test]

514

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

515

1

	MockNet::reset();

516

1

517

1

	// para A asset

518

1

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

519

1

	let source_location = parachain::AssetType::Xcm(

520

1

		xcm_builder::WithLatestLocationConverter::convert(&para_a_balances).expect("convert to v3"),

521

1

);

522

1

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

523

1

524

1

	let asset_metadata = parachain::AssetMetadata {

525

1

		name: b"ParaAToken".to_vec(),

526

1

		symbol: b"ParaA".to_vec(),

527

1

		decimals: 18,

528

1

};

529

1

530

1

	// Register para A asset in para B

531

1

	ParaB::execute_with(|| {

532

1

		assert_ok!(AssetManager::register_foreign_asset(

533

1

			parachain::RuntimeOrigin::root(),

534

1

			source_location.clone(),

535

1

			asset_metadata,

536

1

			1u128,

537

1

			true

538

1

));

539

1

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

540

1

});

541

1

542

1

	// Send para A asset to para B

543

1

	let dest = Location {

544

1

		parents: 1,

545

1

		interior: [

546

1

			Parachain(2),

547

1

			AccountKey20 {

548

1

				network: None,

549

1

				key: PARAALICE.into(),

550

1

},

551

1

552

1

		.into(),

553

1

};

554

1

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

555

1

	ParaA::execute_with(|| {

556

1

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

557

1

		assert_ok!(PolkadotXcm::transfer_assets(

558

1

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

559

1

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

560

1

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

561

1

			Box::new(VersionedAssets::V4(asset.into())),

562

1

0,

563

1

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

564

1

));

565

1

});

566

1

567

1

	// Balances have been substracted

568

1

	ParaA::execute_with(|| {

569

1

		assert_eq!(

570

1

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

571

1

			INITIAL_BALANCE - 100

572

1

);

573

1

});

574

1

575

1

	// Para B balances have been credited

576

1

	ParaB::execute_with(|| {

577

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 100);

578

1

});

579

1

580

1

	// Send back para A asset to para A

581

1

	let dest = Location {

582

1

		parents: 1,

583

1

		interior: [

584

1

			Parachain(1),

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

1

	ParaB::execute_with(|| {

594

1

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

595

1

		assert_ok!(PolkadotXcm::transfer_assets(

596

1

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

597

1

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

598

1

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

599

1

			Box::new(VersionedAssets::V4(asset.into())),

600

1

0,

601

1

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

602

1

));

603

1

});

604

1

605

1

	ParaA::execute_with(|| {

606

1

		// Weight used is 4

607

1

		assert_eq!(

608

1

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

609

1

			INITIAL_BALANCE - 4

610

1

);

611

1

});

612

1

613

614

#[test]

615

1

fn receive_relay_asset_with_trader() {

616

1

	MockNet::reset();

617

1

618

1

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

619

1

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

620

1

621

1

	let asset_metadata = parachain::AssetMetadata {

622

1

		name: b"RelayToken".to_vec(),

623

1

		symbol: b"Relay".to_vec(),

624

1

		decimals: 12,

625

1

};

626

1

627

1

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

628

1

	// we know later we will divide by 1e12

629

1

	// Lets put 1e6 as units per second

630

1

	ParaA::execute_with(|| {

631

1

		assert_ok!(AssetManager::register_foreign_asset(

632

1

			parachain::RuntimeOrigin::root(),

633

1

			source_location.clone(),

634

1

			asset_metadata,

635

1

			1u128,

636

1

			true

637

1

));

638

1

		assert_ok!(add_supported_asset(

639

1

			source_location.clone(),

640

1

			2500000000000u128

641

1

));

642

1

});

643

1

644

1

	let dest: Location = Junction::AccountKey20 {

645

1

		network: None,

646

1

		key: PARAALICE,

647

1

648

1

	.into();

649

1

	// We are sending 100 tokens from relay.

650

1

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

651

1

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

652

1

	// Units per second should be 2_500_000_000_000_000

653

1

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

654

1

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

655

1

	Relay::execute_with(|| {

656

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

657

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

658

1

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

659

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

660

1

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

661

1

0,

662

1

			WeightLimit::Unlimited

663

1

));

664

1

});

665

1

666

1

	ParaA::execute_with(|| {

667

1

		// non-free execution, not full amount received

668

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 90);

669

		// Fee should have been received by treasury

670

1

		assert_eq!(Assets::balance(source_id, &Treasury::account_id()), 10);

671

1

});

672

1

673

674

#[test]

675

1

fn send_para_a_asset_to_para_b_with_trader() {

676

1

	MockNet::reset();

677

1

678

1

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

679

1

	let source_location = parachain::AssetType::Xcm(

680

1

		xcm_builder::WithLatestLocationConverter::convert(&para_a_balances).expect("convert to v3"),

681

1

);

682

1

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

683

1

684

1

	let asset_metadata = parachain::AssetMetadata {

685

1

		name: b"ParaAToken".to_vec(),

686

1

		symbol: b"ParaA".to_vec(),

687

1

		decimals: 18,

688

1

};

689

1

690

1

	ParaB::execute_with(|| {

691

1

		assert_ok!(AssetManager::register_foreign_asset(

692

1

			parachain::RuntimeOrigin::root(),

693

1

			source_location.clone(),

694

1

			asset_metadata,

695

1

			1u128,

696

1

			true

697

1

));

698

1

		assert_ok!(add_supported_asset(

699

1

			source_location.clone(),

700

1

			2500000000000u128

701

1

));

702

1

});

703

1

704

1

	let dest = Location {

705

1

		parents: 1,

706

1

		interior: [

707

1

			Parachain(2),

708

1

			AccountKey20 {

709

1

				network: None,

710

1

				key: PARAALICE.into(),

711

1

},

712

1

713

1

		.into(),

714

1

};

715

1

716

1

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

717

1

	// In destination chain, we only need 4 weight

718

1

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

719

1

	ParaA::execute_with(|| {

720

1

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

721

1

		assert_ok!(PolkadotXcm::transfer_assets(

722

1

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

723

1

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

724

1

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

725

1

			Box::new(VersionedAssets::V4(asset.into())),

726

1

0,

727

1

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

728

1

));

729

1

});

730

1

	ParaA::execute_with(|| {

731

1

		// free execution, full amount received

732

1

		assert_eq!(

733

1

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

734

1

			INITIAL_BALANCE - 100

735

1

);

736

1

});

737

1

738

1

	// We are sending 100 tokens from para A.

739

1

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

740

1

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

741

1

	// Units per second should be 2_500_000_000_000_000

742

1

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

743

1

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

744

1

	// will be 4

745

1

	ParaB::execute_with(|| {

746

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 90);

747

		// Fee should have been received by treasury

748

1

		assert_eq!(Assets::balance(source_id, &Treasury::account_id()), 10);

749

1

});

750

1

751

752

#[test]

753

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

754

1

	MockNet::reset();

755

1

756

1

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

757

1

	let source_location = parachain::AssetType::Xcm(

758

1

		xcm_builder::WithLatestLocationConverter::convert(&para_a_balances).expect("convert to v3"),

759

1

);

760

1

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

761

1

762

1

	let asset_metadata = parachain::AssetMetadata {

763

1

		name: b"ParaAToken".to_vec(),

764

1

		symbol: b"ParaA".to_vec(),

765

1

		decimals: 18,

766

1

};

767

1

768

1

	ParaB::execute_with(|| {

769

1

		assert_ok!(AssetManager::register_foreign_asset(

770

1

			parachain::RuntimeOrigin::root(),

771

1

			source_location.clone(),

772

1

			asset_metadata,

773

1

			1u128,

774

1

			true

775

1

));

776

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

777

1

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

778

1

});

779

1

780

1

	let dest = Location {

781

1

		parents: 1,

782

1

		interior: [

783

1

			Parachain(2),

784

1

			AccountKey20 {

785

1

				network: None,

786

1

				key: PARAALICE.into(),

787

1

},

788

1

789

1

		.into(),

790

1

};

791

1

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

792

1

	// we use transfer_with_fee

793

1

	ParaA::execute_with(|| {

794

1

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

795

1

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

796

1

		assert_ok!(PolkadotXcm::transfer_assets(

797

1

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

798

1

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

799

1

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

800

1

			Box::new(VersionedAssets::V4(vec![asset_fee, asset].into())),

801

1

0,

802

1

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

803

1

));

804

1

});

805

1

	ParaA::execute_with(|| {

806

1

		// 100 tokens transferred plus 1 taken from fees

807

1

		assert_eq!(

808

1

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

809

1

			INITIAL_BALANCE - 100 - 1

810

1

);

811

1

});

812

1

813

1

	ParaB::execute_with(|| {

814

1

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

815

1

		// what it is specified

816

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 101);

817

1

});

818

1

819

820

#[test]

821

1

fn error_when_not_paying_enough() {

822

1

	MockNet::reset();

823

1

824

1

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

825

1

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

826

1

827

1

	let asset_metadata = parachain::AssetMetadata {

828

1

		name: b"RelayToken".to_vec(),

829

1

		symbol: b"Relay".to_vec(),

830

1

		decimals: 12,

831

1

};

832

1

833

1

	let dest: Location = Junction::AccountKey20 {

834

1

		network: None,

835

1

		key: PARAALICE,

836

1

837

1

	.into();

838

1

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

839

1

	// we know later we will divide by 1e12

840

1

	// Lets put 1e6 as units per second

841

1

	ParaA::execute_with(|| {

842

1

		assert_ok!(AssetManager::register_foreign_asset(

843

1

			parachain::RuntimeOrigin::root(),

844

1

			source_location.clone(),

845

1

			asset_metadata,

846

1

			1u128,

847

1

			true

848

1

));

849

1

		assert_ok!(add_supported_asset(

850

1

			source_location.clone(),

851

1

			2500000000000u128

852

1

));

853

1

});

854

1

855

1

	// We are sending 100 tokens from relay.

856

1

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

857

1

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

858

1

	Relay::execute_with(|| {

859

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

860

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

861

1

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

862

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

863

1

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

864

1

0,

865

1

			WeightLimit::Unlimited

866

1

));

867

1

});

868

1

869

1

	ParaA::execute_with(|| {

870

1

		// amount not received as it is not paying enough

871

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 0);

872

1

});

873

1

874

875

#[test]

876

1

fn transact_through_derivative_multilocation() {

877

1

	MockNet::reset();

878

1

879

1

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

880

1

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

881

1

882

1

	let asset_metadata = parachain::AssetMetadata {

883

1

		name: b"RelayToken".to_vec(),

884

1

		symbol: b"Relay".to_vec(),

885

1

		decimals: 12,

886

1

};

887

1

888

1

	ParaA::execute_with(|| {

889

1

		assert_ok!(AssetManager::register_foreign_asset(

890

1

			parachain::RuntimeOrigin::root(),

891

1

			source_location.clone(),

892

1

			asset_metadata,

893

1

			1u128,

894

1

			true

895

1

));

896

1

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

897

898

		// Root can set transact info

899

1

		assert_ok!(XcmTransactor::set_transact_info(

900

1

			parachain::RuntimeOrigin::root(),

901

1

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

902

1

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

903

1

			3000.into(),

904

1

			20000000000.into(),

905

1

			None

906

1

));

907

		// Root can set transact info

908

1

		assert_ok!(XcmTransactor::set_fee_per_second(

909

1

			parachain::RuntimeOrigin::root(),

910

1

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

911

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

912

1

));

913

1

});

914

1

915

1

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

916

1

917

1

	let dest: Location = AccountKey20 {

918

1

		network: None,

919

1

		key: PARAALICE,

920

1

921

1

	.into();

922

1

	Relay::execute_with(|| {

923

1

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

924

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

925

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

926

1

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

927

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

928

1

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

929

1

0,

930

1

			WeightLimit::Unlimited

931

1

));

932

1

});

933

1

934

1

	ParaA::execute_with(|| {

935

1

		// free execution, full amount received

936

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003100);

937

1

});

938

1

939

1

	// Register address

940

1

	ParaA::execute_with(|| {

941

1

		assert_ok!(XcmTransactor::register(

942

1

			parachain::RuntimeOrigin::root(),

943

1

			PARAALICE.into(),

944

1

0,

945

1

));

946

1

});

947

1

948

1

	// Send to registered address

949

1

950

1

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

951

1

	let dest = Location {

952

1

		parents: 1,

953

1

		interior: [AccountId32 {

954

1

			network: None,

955

1

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

956

1

}]

957

1

		.into(),

958

1

};

959

1

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

960

1

961

1

	ParaA::execute_with(|| {

962

1

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

963

1

		// free execution, full amount received

964

1

		assert_ok!(PolkadotXcm::transfer_assets(

965

1

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

966

1

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

967

1

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

968

1

			Box::new(VersionedAssets::V4(asset.into())),

969

1

0,

970

1

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

971

1

));

972

1

});

973

1

974

1

	ParaA::execute_with(|| {

975

1

		// free execution, full amount received

976

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003000);

977

1

});

978

1

979

1

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

980

1

	// again

981

1

	Relay::execute_with(|| {

982

1

		// free execution,x	 full amount received

983

1

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

984

1

});

985

1

986

1

	// Encode the call. Balances transact to para_a_account

987

1

	// First index

988

1

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

989

1

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

990

1

		relay_chain::Balances,

991

1

>()

992

1

	.unwrap() as u8;

993

1

994

1

	encoded.push(index);

995

1

996

1

	// Then call bytes

997

1

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

998

1

		dest: para_a_account(),

999

1

		value: 100u32.into(),

1000

1

1001

1

	.encode();

1002

1

	encoded.append(&mut call_bytes);

1003

1

1004

1

	ParaA::execute_with(|| {

1005

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1006

1

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

1007

1

			parachain::MockTransactors::Relay,

1008

1

0,

1009

1

			CurrencyPayment {

1010

1

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

1011

1

					Location::parent()

1012

1

				))),

1013

1

				fee_amount: None

1014

1

},

1015

1

			encoded,

1016

1

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

1017

1

			TransactWeights {

1018

1

				transact_required_weight_at_most: 4000000000.into(),

1019

1

				overall_weight: None

1020

1

},

1021

1

			false

1022

1

));

1023

1

});

1024

1

1025

1

	Relay::execute_with(|| {

1026

1

		// free execution,x	 full amount received

1027

1

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

1028

1029

1

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

1030

1

});

1031

1

1032

1033

#[test]

1034

1

fn transact_through_derivative_with_custom_fee_weight() {

1035

1

	MockNet::reset();

1036

1

1037

1

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

1038

1

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

1039

1

1040

1

	let asset_metadata = parachain::AssetMetadata {

1041

1

		name: b"RelayToken".to_vec(),

1042

1

		symbol: b"Relay".to_vec(),

1043

1

		decimals: 12,

1044

1

};

1045

1

1046

1

	ParaA::execute_with(|| {

1047

1

		assert_ok!(AssetManager::register_foreign_asset(

1048

1

			parachain::RuntimeOrigin::root(),

1049

1

			source_location.clone(),

1050

1

			asset_metadata,

1051

1

			1u128,

1052

1

			true

1053

1

));

1054

1

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

1055

1

});

1056

1

1057

1

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

1058

1

1059

1

	let dest: Location = AccountKey20 {

1060

1

		network: None,

1061

1

		key: PARAALICE,

1062

1

1063

1

	.into();

1064

1

	Relay::execute_with(|| {

1065

1

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

1066

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1067

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1068

1

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

1069

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

1070

1

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

1071

1

0,

1072

1

			WeightLimit::Unlimited

1073

1

));

1074

1

});

1075

1

1076

1

	ParaA::execute_with(|| {

1077

1

		// free execution, full amount received

1078

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003100);

1079

1

});

1080

1

1081

1

	// Register address

1082

1

	ParaA::execute_with(|| {

1083

1

		assert_ok!(XcmTransactor::register(

1084

1

			parachain::RuntimeOrigin::root(),

1085

1

			PARAALICE.into(),

1086

1

0,

1087

1

));

1088

1

});

1089

1

1090

1

	// Send to registered address

1091

1

1092

1

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

1093

1

	let dest = Location {

1094

1

		parents: 1,

1095

1

		interior: [AccountId32 {

1096

1

			network: None,

1097

1

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

1098

1

}]

1099

1

		.into(),

1100

1

};

1101

1

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

1102

1

1103

1

	ParaA::execute_with(|| {

1104

1

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

1105

1

		// free execution, full amount received

1106

1

		assert_ok!(PolkadotXcm::transfer_assets(

1107

1

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

1108

1

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

1109

1

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

1110

1

			Box::new(VersionedAssets::V4(asset.into())),

1111

1

0,

1112

1

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

1113

1

));

1114

1

});

1115

1

1116

1

	ParaA::execute_with(|| {

1117

1

		// free execution, full amount received

1118

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003000);

1119

1

});

1120

1

1121

1

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

1122

1

	// again

1123

1

	Relay::execute_with(|| {

1124

1

		// free execution,x	 full amount received

1125

1

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

1126

1

});

1127

1

1128

1

	// Encode the call. Balances transact to para_a_account

1129

1

	// First index

1130

1

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

1131

1

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

1132

1

		relay_chain::Balances,

1133

1

>()

1134

1

	.unwrap() as u8;

1135

1

1136

1

	encoded.push(index);

1137

1

1138

1

	// Then call bytes

1139

1

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

1140

1

		dest: para_a_account(),

1141

1

		value: 100u32.into(),

1142

1

1143

1

	.encode();

1144

1

	encoded.append(&mut call_bytes);

1145

1

1146

1

	let overall_weight = 4000003000u64;

1147

1

	ParaA::execute_with(|| {

1148

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1149

1

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

1150

1

			parachain::MockTransactors::Relay,

1151

1

0,

1152

1

			CurrencyPayment {

1153

1

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

1154

1

					Location::parent()

1155

1

				))),

1156

1

				// 1-1 fee weight mapping

1157

1

				fee_amount: Some(overall_weight as u128)

1158

1

},

1159

1

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

1160

1

			encoded,

1161

1

			TransactWeights {

1162

1

				transact_required_weight_at_most: 4000000000.into(),

1163

1

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

1164

1

},

1165

1

			false

1166

1

));

1167

1

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

1168

1

			.iter()

1169

12

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

1170

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

1171

..

1172

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

1173

12

				_ => None,

1174

12

});

1175

1

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

1176

1

		assert!(event_found.is_none());

1177

1

});

1178

1

1179

1

	Relay::execute_with(|| {

1180

1

		// free execution,x	 full amount received

1181

1

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

1182

1183

1

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

1184

1

});

1185

1

1186

1187

#[test]

1188

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1189

1

	MockNet::reset();

1190

1

1191

1

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

1192

1

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

1193

1

1194

1

	let asset_metadata = parachain::AssetMetadata {

1195

1

		name: b"RelayToken".to_vec(),

1196

1

		symbol: b"Relay".to_vec(),

1197

1

		decimals: 12,

1198

1

};

1199

1

1200

1

	ParaA::execute_with(|| {

1201

1

		assert_ok!(AssetManager::register_foreign_asset(

1202

1

			parachain::RuntimeOrigin::root(),

1203

1

			source_location.clone(),

1204

1

			asset_metadata,

1205

1

			1u128,

1206

1

			true

1207

1

));

1208

1

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

1209

1

});

1210

1

1211

1

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

1212

1

1213

1

	let dest: Location = AccountKey20 {

1214

1

		network: None,

1215

1

		key: PARAALICE,

1216

1

1217

1

	.into();

1218

1

	Relay::execute_with(|| {

1219

1

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

1220

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1221

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1222

1

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

1223

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

1224

1

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

1225

1

0,

1226

1

			WeightLimit::Unlimited

1227

1

));

1228

1

});

1229

1

1230

1

	ParaA::execute_with(|| {

1231

1

		// free execution, full amount received

1232

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000009100);

1233

1

});

1234

1

1235

1

	// Register address

1236

1

	ParaA::execute_with(|| {

1237

1

		assert_ok!(XcmTransactor::register(

1238

1

			parachain::RuntimeOrigin::root(),

1239

1

			PARAALICE.into(),

1240

1

0,

1241

1

));

1242

1

});

1243

1

1244

1

	// Send to registered address

1245

1

1246

1

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

1247

1

	let dest = Location {

1248

1

		parents: 1,

1249

1

		interior: [AccountId32 {

1250

1

			network: None,

1251

1

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

1252

1

}]

1253

1

		.into(),

1254

1

};

1255

1

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

1256

1

1257

1

	ParaA::execute_with(|| {

1258

1

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

1259

1

		// free execution, full amount received

1260

1

		assert_ok!(PolkadotXcm::transfer_assets(

1261

1

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

1262

1

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

1263

1

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

1264

1

			Box::new(VersionedAssets::V4(asset.into())),

1265

1

0,

1266

1

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

1267

1

));

1268

1

});

1269

1

1270

1

	ParaA::execute_with(|| {

1271

1

		// free execution, full amount received

1272

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000009000);

1273

1

});

1274

1

1275

1

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

1276

1

	// again

1277

1

	Relay::execute_with(|| {

1278

1

		// free execution,x	 full amount received

1279

1

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

1280

1

});

1281

1

1282

1

	// Encode the call. Balances transact to para_a_account

1283

1

	// First index

1284

1

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

1285

1

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

1286

1

		relay_chain::Balances,

1287

1

>()

1288

1

	.unwrap() as u8;

1289

1

1290

1

	encoded.push(index);

1291

1

1292

1

	// Then call bytes

1293

1

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

1294

1

		dest: para_a_account(),

1295

1

		value: 100u32.into(),

1296

1

1297

1

	.encode();

1298

1

	encoded.append(&mut call_bytes);

1299

1

1300

1

	let overall_weight = 4000009000u64;

1301

1

	ParaA::execute_with(|| {

1302

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1303

1

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

1304

1

			parachain::MockTransactors::Relay,

1305

1

0,

1306

1

			CurrencyPayment {

1307

1

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

1308

1

					Location::parent()

1309

1

				))),

1310

1

				// 1-1 fee weight mapping

1311

1

				fee_amount: Some(overall_weight as u128)

1312

1

},

1313

1

			encoded,

1314

1

			TransactWeights {

1315

1

				transact_required_weight_at_most: 4000000000.into(),

1316

1

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

1317

1

},

1318

1

			true

1319

1

));

1320

1

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

1321

1

			.iter()

1322

12

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

1323

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

1324

..

1325

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

1326

12

				_ => None,

1327

12

});

1328

1

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

1329

1

		assert!(event_found.is_none());

1330

1

});

1331

1

1332

1

	Relay::execute_with(|| {

1333

1

		// free execution,x	 full amount received

1334

1

		// 4000005186 refunded + 100 transferred = 4000005286

1335

1

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

1336

1

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

1337

1

});

1338

1

1339

1340

#[test]

1341

1

fn transact_through_sovereign() {

1342

1

	MockNet::reset();

1343

1

1344

1

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

1345

1

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

1346

1

1347

1

	let asset_metadata = parachain::AssetMetadata {

1348

1

		name: b"RelayToken".to_vec(),

1349

1

		symbol: b"Relay".to_vec(),

1350

1

		decimals: 12,

1351

1

};

1352

1

1353

1

	ParaA::execute_with(|| {

1354

1

		assert_ok!(AssetManager::register_foreign_asset(

1355

1

			parachain::RuntimeOrigin::root(),

1356

1

			source_location.clone(),

1357

1

			asset_metadata,

1358

1

			1u128,

1359

1

			true

1360

1

));

1361

1

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

1362

1363

		// Root can set transact info

1364

1

		assert_ok!(XcmTransactor::set_transact_info(

1365

1

			parachain::RuntimeOrigin::root(),

1366

1

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

1367

1

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

1368

1

			3000.into(),

1369

1

			20000000000.into(),

1370

1

			None

1371

1

));

1372

		// Root can set transact info

1373

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1374

1

			parachain::RuntimeOrigin::root(),

1375

1

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

1376

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1377

1

));

1378

1

});

1379

1

1380

1

	let dest: Location = AccountKey20 {

1381

1

		network: None,

1382

1

		key: PARAALICE,

1383

1

1384

1

	.into();

1385

1

	Relay::execute_with(|| {

1386

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1387

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1388

1

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

1389

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

1390

1

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

1391

1

0,

1392

1

			WeightLimit::Unlimited

1393

1

));

1394

1

});

1395

1

1396

1

	ParaA::execute_with(|| {

1397

1

		// free execution, full amount received

1398

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003100);

1399

1

});

1400

1

1401

1

	// Register address

1402

1

	ParaA::execute_with(|| {

1403

1

		assert_ok!(XcmTransactor::register(

1404

1

			parachain::RuntimeOrigin::root(),

1405

1

			PARAALICE.into(),

1406

1

0,

1407

1

));

1408

1

});

1409

1

1410

1

	// Send to registered address

1411

1

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

1412

1

	let dest = Location {

1413

1

		parents: 1,

1414

1

		interior: [AccountId32 {

1415

1

			network: None,

1416

1

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

1417

1

}]

1418

1

		.into(),

1419

1

};

1420

1

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

1421

1

1422

1

	ParaA::execute_with(|| {

1423

1

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

1424

1

		// free execution, full amount received

1425

1

		assert_ok!(PolkadotXcm::transfer_assets(

1426

1

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

1427

1

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

1428

1

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

1429

1

			Box::new(VersionedAssets::V4(asset.into())),

1430

1

0,

1431

1

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

1432

1

));

1433

1

});

1434

1

1435

1

	ParaA::execute_with(|| {

1436

1

		// free execution, full amount received

1437

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003000);

1438

1

});

1439

1

1440

1

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

1441

1

	// again

1442

1

	Relay::execute_with(|| {

1443

1

		// free execution,x	 full amount received

1444

1

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

1445

1

1446

1

});

1447

1

1448

1

	// We send the xcm transact operation to parent

1449

1

	let dest = Location {

1450

1

		parents: 1,

1451

1

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

1452

1

};

1453

1

1454

1

	// Encode the call. Balances transact to para_a_account

1455

1

	// First index

1456

1

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

1457

1

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

1458

1

		relay_chain::Balances,

1459

1

>()

1460

1

	.unwrap() as u8;

1461

1

1462

1

	encoded.push(index);

1463

1

1464

1

	// Then call bytes

1465

1

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

1466

1

		dest: para_a_account(),

1467

1

		value: 100u32.into(),

1468

1

1469

1

	.encode();

1470

1

	encoded.append(&mut call_bytes);

1471

1

1472

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1473

1

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

1474

1

);

1475

1

1476

1

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

1477

1

	ParaA::execute_with(|| {

1478

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1479

1

			parachain::RuntimeOrigin::root(),

1480

1

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

1481

1

			Some(PARAALICE.into()),

1482

1

			CurrencyPayment {

1483

1

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

1484

1

					Location::parent()

1485

1

				))),

1486

1

				fee_amount: None

1487

1

},

1488

1

			utility_bytes,

1489

1

			OriginKind::SovereignAccount,

1490

1

			TransactWeights {

1491

1

				transact_required_weight_at_most: 4000000000.into(),

1492

1

				overall_weight: None

1493

1

},

1494

1

			false

1495

1

));

1496

1

});

1497

1

1498

1

	Relay::execute_with(|| {

1499

1

		// free execution,x	 full amount received

1500

1

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

1501

1502

1

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

1503

1

});

1504

1

1505

1506

#[test]

1507

1

fn transact_through_sovereign_fee_payer_none() {

1508

1

	MockNet::reset();

1509

1

1510

1

	ParaA::execute_with(|| {

1511

1

		// Root can set transact info

1512

1

		assert_ok!(XcmTransactor::set_transact_info(

1513

1

			parachain::RuntimeOrigin::root(),

1514

1

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

1515

1

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

1516

1

			3000.into(),

1517

1

			20000000000.into(),

1518

1

			None

1519

1

));

1520

		// Root can set transact info

1521

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1522

1

			parachain::RuntimeOrigin::root(),

1523

1

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

1524

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1525

1

));

1526

1

});

1527

1

1528

1

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

1529

1

1530

1

	Relay::execute_with(|| {

1531

1

		// Transfer 100 tokens to derivative_address on the relay

1532

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1533

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1534

1

			derivative_address.clone(),

1535

1

			100u128

1536

1

));

1537

1538

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

1539

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1540

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1541

1

			para_a_account(),

1542

1

			4000003000u128

1543

1

));

1544

1

});

1545

1

1546

1

	// Check balances before the transact call

1547

1

	Relay::execute_with(|| {

1548

1

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

1549

1

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

1550

1

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

1551

1

});

1552

1

1553

1

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

1554

1

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

1555

1

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

1556

1

		relay_chain::Balances,

1557

1

>()

1558

1

	.unwrap() as u8;

1559

1

1560

1

	encoded.push(index);

1561

1

1562

1

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

1563

1

		dest: RELAYBOB,

1564

1

		value: 100u32.into(),

1565

1

1566

1

	.encode();

1567

1

	encoded.append(&mut call_bytes);

1568

1

1569

1

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

1570

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1571

1

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

1572

1

);

1573

1

1574

1

	// We send the xcm transact operation to parent

1575

1

	let dest = Location {

1576

1

		parents: 1,

1577

1

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

1578

1

};

1579

1

1580

1

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

1581

1

	ParaA::execute_with(|| {

1582

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1583

1

			parachain::RuntimeOrigin::root(),

1584

1

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

1585

1

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

1586

1

			None,

1587

1

			CurrencyPayment {

1588

1

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

1589

1

					Location::parent()

1590

1

				))),

1591

1

				fee_amount: None

1592

1

},

1593

1

			utility_bytes,

1594

1

			OriginKind::SovereignAccount,

1595

1

			TransactWeights {

1596

1

				transact_required_weight_at_most: 4000000000.into(),

1597

1

				overall_weight: None

1598

1

},

1599

1

			false

1600

1

));

1601

1

});

1602

1

1603

1

	// Check balances after the transact call are correct

1604

1

	Relay::execute_with(|| {

1605

1

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

1606

1

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

1607

1

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

1608

1

});

1609

1

1610

1611

#[test]

1612

1

fn transact_through_sovereign_with_custom_fee_weight() {

1613

1

	MockNet::reset();

1614

1

1615

1

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

1616

1

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

1617

1

1618

1

	let asset_metadata = parachain::AssetMetadata {

1619

1

		name: b"RelayToken".to_vec(),

1620

1

		symbol: b"Relay".to_vec(),

1621

1

		decimals: 12,

1622

1

};

1623

1

1624

1

	ParaA::execute_with(|| {

1625

1

		assert_ok!(AssetManager::register_foreign_asset(

1626

1

			parachain::RuntimeOrigin::root(),

1627

1

			source_location.clone(),

1628

1

			asset_metadata,

1629

1

			1u128,

1630

1

			true

1631

1

));

1632

1

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

1633

1

});

1634

1

1635

1

	let dest: Location = AccountKey20 {

1636

1

		network: None,

1637

1

		key: PARAALICE,

1638

1

1639

1

	.into();

1640

1

	Relay::execute_with(|| {

1641

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1642

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1643

1

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

1644

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

1645

1

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

1646

1

0,

1647

1

			WeightLimit::Unlimited

1648

1

));

1649

1

});

1650

1

1651

1

	ParaA::execute_with(|| {

1652

1

		// free execution, full amount received

1653

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003100);

1654

1

});

1655

1

1656

1

	// Register address

1657

1

	ParaA::execute_with(|| {

1658

1

		assert_ok!(XcmTransactor::register(

1659

1

			parachain::RuntimeOrigin::root(),

1660

1

			PARAALICE.into(),

1661

1

0,

1662

1

));

1663

1

});

1664

1

1665

1

	// Send to registered address

1666

1

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

1667

1

	let dest = Location {

1668

1

		parents: 1,

1669

1

		interior: [AccountId32 {

1670

1

			network: None,

1671

1

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

1672

1

}]

1673

1

		.into(),

1674

1

};

1675

1

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

1676

1

1677

1

	ParaA::execute_with(|| {

1678

1

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

1679

1

		// free execution, full amount received

1680

1

		assert_ok!(PolkadotXcm::transfer_assets(

1681

1

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

1682

1

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

1683

1

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

1684

1

			Box::new(VersionedAssets::V4(asset.into())),

1685

1

0,

1686

1

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

1687

1

));

1688

1

});

1689

1

1690

1

	ParaA::execute_with(|| {

1691

1

		// free execution, full amount received

1692

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000003000);

1693

1

});

1694

1

1695

1

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

1696

1

	// again

1697

1

	Relay::execute_with(|| {

1698

1

		// free execution,x	 full amount received

1699

1

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

1700

1

1701

1

});

1702

1

1703

1

	// We send the xcm transact operation to parent

1704

1

	let dest = Location {

1705

1

		parents: 1,

1706

1

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

1707

1

};

1708

1

1709

1

	// Encode the call. Balances transact to para_a_account

1710

1

	// First index

1711

1

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

1712

1

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

1713

1

		relay_chain::Balances,

1714

1

>()

1715

1

	.unwrap() as u8;

1716

1

1717

1

	encoded.push(index);

1718

1

1719

1

	// Then call bytes

1720

1

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

1721

1

		dest: para_a_account(),

1722

1

		value: 100u32.into(),

1723

1

1724

1

	.encode();

1725

1

	encoded.append(&mut call_bytes);

1726

1

1727

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1728

1

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

1729

1

);

1730

1

1731

1

	let total_weight = 4000003000u64;

1732

1

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

1733

1

	ParaA::execute_with(|| {

1734

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1735

1

			parachain::RuntimeOrigin::root(),

1736

1

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

1737

1

			Some(PARAALICE.into()),

1738

1

			CurrencyPayment {

1739

1

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

1740

1

					Location::parent()

1741

1

				))),

1742

1

				// 1-1 fee-weight mapping

1743

1

				fee_amount: Some(total_weight as u128)

1744

1

},

1745

1

			utility_bytes,

1746

1

			OriginKind::SovereignAccount,

1747

1

			TransactWeights {

1748

1

				transact_required_weight_at_most: 4000000000.into(),

1749

1

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

1750

1

},

1751

1

			false

1752

1

));

1753

1

});

1754

1

1755

1

	Relay::execute_with(|| {

1756

1

		// free execution,x	 full amount received

1757

1

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

1758

1759

1

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

1760

1

});

1761

1

1762

1763

#[test]

1764

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1765

1

	MockNet::reset();

1766

1

1767

1

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

1768

1

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

1769

1

1770

1

	let asset_metadata = parachain::AssetMetadata {

1771

1

		name: b"RelayToken".to_vec(),

1772

1

		symbol: b"Relay".to_vec(),

1773

1

		decimals: 12,

1774

1

};

1775

1

1776

1

	ParaA::execute_with(|| {

1777

1

		assert_ok!(AssetManager::register_foreign_asset(

1778

1

			parachain::RuntimeOrigin::root(),

1779

1

			source_location.clone(),

1780

1

			asset_metadata,

1781

1

			1u128,

1782

1

			true

1783

1

));

1784

1

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

1785

1

});

1786

1

1787

1

	let dest: Location = AccountKey20 {

1788

1

		network: None,

1789

1

		key: PARAALICE,

1790

1

1791

1

	.into();

1792

1

	Relay::execute_with(|| {

1793

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1794

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1795

1

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

1796

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

1797

1

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

1798

1

0,

1799

1

			WeightLimit::Unlimited

1800

1

));

1801

1

});

1802

1

1803

1

	ParaA::execute_with(|| {

1804

1

		// free execution, full amount received

1805

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000009100);

1806

1

});

1807

1

1808

1

	// Register address

1809

1

	ParaA::execute_with(|| {

1810

1

		assert_ok!(XcmTransactor::register(

1811

1

			parachain::RuntimeOrigin::root(),

1812

1

			PARAALICE.into(),

1813

1

0,

1814

1

));

1815

1

});

1816

1

1817

1

	// 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

1

1829

1

	ParaA::execute_with(|| {

1830

1

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

1831

1

		// free execution, full amount received

1832

1

		assert_ok!(PolkadotXcm::transfer_assets(

1833

1

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

1834

1

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

1835

1

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

1836

1

			Box::new(VersionedAssets::V4(asset.into())),

1837

1

0,

1838

1

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

1839

1

));

1840

1

});

1841

1

1842

1

	ParaA::execute_with(|| {

1843

1

		// free execution, full amount received

1844

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 4000009000);

1845

1

});

1846

1

1847

1

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

1848

1

	// again

1849

1

	Relay::execute_with(|| {

1850

1

		// free execution,x	 full amount received

1851

1

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

1852

1

1853

1

});

1854

1

1855

1

	// We send the xcm transact operation to parent

1856

1

	let dest = Location {

1857

1

		parents: 1,

1858

1

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

1859

1

};

1860

1

1861

1

	// Encode the call. Balances transact to para_a_account

1862

1

	// First index

1863

1

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

1864

1

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

1865

1

		relay_chain::Balances,

1866

1

>()

1867

1

	.unwrap() as u8;

1868

1

1869

1

	encoded.push(index);

1870

1

1871

1

	// Then call bytes

1872

1

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

1873

1

		dest: para_a_account(),

1874

1

		value: 100u32.into(),

1875

1

1876

1

	.encode();

1877

1

	encoded.append(&mut call_bytes);

1878

1

1879

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1880

1

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

1881

1

);

1882

1

1883

1

	let total_weight = 4000009000u64;

1884

1

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

1885

1

	ParaA::execute_with(|| {

1886

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1887

1

			parachain::RuntimeOrigin::root(),

1888

1

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

1889

1

			Some(PARAALICE.into()),

1890

1

			CurrencyPayment {

1891

1

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

1892

1

					Location::parent()

1893

1

				))),

1894

1

				// 1-1 fee-weight mapping

1895

1

				fee_amount: Some(total_weight as u128)

1896

1

},

1897

1

			utility_bytes,

1898

1

			OriginKind::SovereignAccount,

1899

1

			TransactWeights {

1900

1

				transact_required_weight_at_most: 4000000000.into(),

1901

1

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

1902

1

},

1903

1

			true

1904

1

));

1905

1

});

1906

1

1907

1

	Relay::execute_with(|| {

1908

1

		// free execution,x	 full amount received

1909

1

		// 4000005186 refunded + 100 transferred = 4000005286

1910

1

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

1911

1912

1

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

1913

1

});

1914

1

1915

1916

#[test]

1917

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

1918

1

	MockNet::reset();

1919

1

1920

1

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

1921

1

	let asset_metadata = parachain::AssetMetadata {

1922

1

		name: b"RelayToken".to_vec(),

1923

1

		symbol: b"Relay".to_vec(),

1924

1

		decimals: 12,

1925

1

};

1926

1

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

1927

1

	ParaA::execute_with(|| {

1928

1

		parachain::XcmVersioner::set_version(1);

1929

1

		assert_ok!(AssetManager::register_foreign_asset(

1930

1

			parachain::RuntimeOrigin::root(),

1931

1

			source_location.clone(),

1932

1

			asset_metadata,

1933

1

			1u128,

1934

1

			true

1935

1

));

1936

1

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

1937

1

});

1938

1

1939

1

	let response = Response::Version(2);

1940

1

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

1941

1

1942

1

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

1943

1

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

1944

1

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

1945

1

		query_id: 0,

1946

1

		response,

1947

1

		max_weight: Weight::zero(),

1948

1

		querier: Some(querier),

1949

1

	}]);

1950

1

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

1951

1

	// it directly here

1952

1

	// Actually send relay asset to parachain

1953

1

	let dest: Location = AccountKey20 {

1954

1

		network: None,

1955

1

		key: PARAALICE,

1956

1

1957

1

	.into();

1958

1

1959

1

	Relay::execute_with(|| {

1960

1

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

1961

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

1962

1

			relay_chain::RuntimeOrigin::root(),

1963

1

			Some(2)

1964

1

));

1965

1966

		// Wrap version, which sets VersionedStorage

1967

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

1968

		// this is not necessary in prod

1969

1

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

1970

1

			&Parachain(1).into(),

1971

1

			mock_message

1972

1

));

1973

1974

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

1975

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1976

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1977

1

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

1978

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

1979

1

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

1980

1

0,

1981

1

			WeightLimit::Unlimited

1982

1

));

1983

1984

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

1985

1

		relay_chain::relay_roll_to(2);

1986

1

1987

1

		// queries should have been updated

1988

1

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

1989

1

});

1990

1

1991

1

	let expected_supported_version: relay_chain::RuntimeEvent =

1992

1

		pallet_xcm::Event::SupportedVersionChanged {

1993

1

			location: Location {

1994

1

				parents: 0,

1995

1

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

1996

1

},

1997

1

			version: 1,

1998

1

1999

1

		.into();

2000

1

2001

1

	Relay::execute_with(|| {

2002

1

		// Assert that the events vector contains the version change

2003

1

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

2004

1

});

2005

1

2006

1

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

2007

1

	// of the new version change

2008

1

	ParaA::execute_with(|| {

2009

1

		// Set version

2010

1

		parachain::XcmVersioner::set_version(2);

2011

1

		// Do runtime upgrade

2012

1

		parachain::on_runtime_upgrade();

2013

1

		// Initialize block, to call on_initialize and notify targets

2014

1

		parachain::para_roll_to(2);

2015

1

		// Expect the event in the parachain

2016

10

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

2017

2

e,

2018

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

2019

				result: 2,

2020

..

2021

})

2022

10

		)));

2023

1

});

2024

1

2025

1

	// This event should have been seen in the relay

2026

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2027

1

		pallet_xcm::Event::SupportedVersionChanged {

2028

1

			location: Location {

2029

1

				parents: 0,

2030

1

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

2031

1

},

2032

1

			version: 2,

2033

1

2034

1

		.into();

2035

1

2036

1

	Relay::execute_with(|| {

2037

1

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

2038

1

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

2039

1

});

2040

1

2041

2042

#[test]

2043

1

fn receive_asset_with_no_sufficients_not_possible_if_non_existent_account() {

2044

1

	MockNet::reset();

2045

1

2046

1

	let fresh_account = [2u8; 20];

2047

1

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

2048

1

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

2049

1

	let asset_metadata = parachain::AssetMetadata {

2050

1

		name: b"RelayToken".to_vec(),

2051

1

		symbol: b"Relay".to_vec(),

2052

1

		decimals: 12,

2053

1

};

2054

1

	// register relay asset in parachain A

2055

1

	ParaA::execute_with(|| {

2056

1

		assert_ok!(AssetManager::register_foreign_asset(

2057

1

			parachain::RuntimeOrigin::root(),

2058

1

			source_location.clone(),

2059

1

			asset_metadata,

2060

1

			1u128,

2061

1

			false

2062

1

));

2063

1

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

2064

1

});

2065

1

2066

1

	// Actually send relay asset to parachain

2067

1

	let dest: Location = AccountKey20 {

2068

1

		network: None,

2069

1

		key: fresh_account,

2070

1

2071

1

	.into();

2072

1

	Relay::execute_with(|| {

2073

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2074

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2075

1

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

2076

1

			Box::new(VersionedLocation::V4(dest.clone()).clone().into()),

2077

1

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

2078

1

0,

2079

1

			WeightLimit::Unlimited

2080

1

));

2081

1

});

2082

1

2083

1

	// parachain should not have received assets

2084

1

	ParaA::execute_with(|| {

2085

1

		// free execution, full amount received

2086

1

		assert_eq!(Assets::balance(source_id, &fresh_account.into()), 0);

2087

1

});

2088

1

2089

1

	// Send native token to fresh_account

2090

1

	ParaA::execute_with(|| {

2091

1

		assert_ok!(ParaBalances::transfer_allow_death(

2092

1

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

2093

1

			fresh_account.into(),

2094

1

2095

1

));

2096

1

});

2097

1

2098

1

	// Re-send tokens

2099

1

	Relay::execute_with(|| {

2100

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2101

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2102

1

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

2103

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

2104

1

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

2105

1

0,

2106

1

			WeightLimit::Unlimited

2107

1

));

2108

1

});

2109

1

2110

1

	// parachain should have received assets

2111

1

	ParaA::execute_with(|| {

2112

1

		// free execution, full amount received

2113

1

		assert_eq!(Assets::balance(source_id, &fresh_account.into()), 123);

2114

1

});

2115

1

2116

2117

#[test]

2118

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2119

1

	MockNet::reset();

2120

1

2121

1

	let fresh_account = [2u8; 20];

2122

1

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

2123

1

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

2124

1

	let asset_metadata = parachain::AssetMetadata {

2125

1

		name: b"RelayToken".to_vec(),

2126

1

		symbol: b"Relay".to_vec(),

2127

1

		decimals: 12,

2128

1

};

2129

1

	// register relay asset in parachain A

2130

1

	ParaA::execute_with(|| {

2131

1

		assert_ok!(AssetManager::register_foreign_asset(

2132

1

			parachain::RuntimeOrigin::root(),

2133

1

			source_location.clone(),

2134

1

			asset_metadata,

2135

1

			1u128,

2136

1

			true

2137

1

));

2138

1

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

2139

1

});

2140

1

2141

1

	// Actually send relay asset to parachain

2142

1

	let dest: Location = AccountKey20 {

2143

1

		network: None,

2144

1

		key: fresh_account,

2145

1

2146

1

	.into();

2147

1

	Relay::execute_with(|| {

2148

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2149

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2150

1

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

2151

1

			Box::new(VersionedLocation::V4(dest.clone()).clone().into()),

2152

1

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

2153

1

0,

2154

1

			WeightLimit::Unlimited

2155

1

));

2156

1

});

2157

1

2158

1

	// parachain should have received assets

2159

1

	ParaA::execute_with(|| {

2160

1

		// free execution, full amount received

2161

1

		assert_eq!(Assets::balance(source_id, &fresh_account.into()), 123);

2162

1

});

2163

1

2164

2165

#[test]

2166

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2167

1

	MockNet::reset();

2168

1

2169

1

	let mut sufficient_account = [0u8; 20];

2170

1

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

2171

1

2172

1

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

2173

1

2174

1

	// Evm account is self sufficient

2175

1

	ParaA::execute_with(|| {

2176

1

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

2177

1

});

2178

1

2179

1

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

2180

1

	let asset_metadata = parachain::AssetMetadata {

2181

1

		name: b"RelayToken".to_vec(),

2182

1

		symbol: b"Relay".to_vec(),

2183

1

		decimals: 12,

2184

1

};

2185

1

	// register relay asset in parachain A

2186

1

	ParaA::execute_with(|| {

2187

1

		assert_ok!(AssetManager::register_foreign_asset(

2188

1

			parachain::RuntimeOrigin::root(),

2189

1

			source_location.clone(),

2190

1

			asset_metadata,

2191

1

			1u128,

2192

1

			true

2193

1

));

2194

1

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

2195

1

});

2196

1

2197

1

	// Actually send relay asset to parachain

2198

1

	let dest: Location = AccountKey20 {

2199

1

		network: None,

2200

1

		key: sufficient_account,

2201

1

2202

1

	.into();

2203

1

	Relay::execute_with(|| {

2204

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2205

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2206

1

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

2207

1

			Box::new(VersionedLocation::V4(dest.clone()).clone().into()),

2208

1

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

2209

1

0,

2210

1

			WeightLimit::Unlimited

2211

1

));

2212

1

});

2213

1

2214

1

	// Evm account sufficient ref count increased by 1.

2215

1

	ParaA::execute_with(|| {

2216

1

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

2217

1

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

2218

1

		// will be implemented in a future release

2219

1

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

2220

1

});

2221

1

2222

1

	ParaA::execute_with(|| {

2223

1

		// Remove the account from the evm context.

2224

1

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

2225

1

		// Evm account sufficient ref count decreased by 1.

2226

1

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

2227

1

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

2228

1

		// will be implemented in a future release

2229

1

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

2230

1

});

2231

1

2232

2233

#[test]

2234

1

fn empty_account_should_not_be_reset() {

2235

1

	MockNet::reset();

2236

1

2237

1

	// Test account has nonce 1 on genesis.

2238

1

	let mut sufficient_account = [0u8; 20];

2239

1

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

2240

1

2241

1

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

2242

1

2243

1

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

2244

1

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

2245

1

	let asset_metadata = parachain::AssetMetadata {

2246

1

		name: b"RelayToken".to_vec(),

2247

1

		symbol: b"Relay".to_vec(),

2248

1

		decimals: 12,

2249

1

};

2250

1

	// register relay asset in parachain A

2251

1

	ParaA::execute_with(|| {

2252

1

		assert_ok!(AssetManager::register_foreign_asset(

2253

1

			parachain::RuntimeOrigin::root(),

2254

1

			source_location.clone(),

2255

1

			asset_metadata,

2256

1

			1u128,

2257

1

			false

2258

1

));

2259

1

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

2260

1

});

2261

1

2262

1

	// Send native token to evm_account

2263

1

	ParaA::execute_with(|| {

2264

1

		assert_ok!(ParaBalances::transfer_allow_death(

2265

1

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

2266

1

			evm_account_id,

2267

1

2268

1

));

2269

1

});

2270

1

2271

1

	// Actually send relay asset to parachain

2272

1

	let dest: Location = AccountKey20 {

2273

1

		network: None,

2274

1

		key: sufficient_account,

2275

1

2276

1

	.into();

2277

1

	Relay::execute_with(|| {

2278

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2279

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2280

1

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

2281

1

			Box::new(VersionedLocation::V4(dest.clone()).clone().into()),

2282

1

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

2283

1

0,

2284

1

			WeightLimit::Unlimited

2285

1

));

2286

1

});

2287

1

2288

1

	ParaA::execute_with(|| {

2289

1

		// Empty the assets from the account.

2290

1

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

2291

1

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

2292

1

		assert_ok!(parachain::Assets::transfer(

2293

1

			parachain::RuntimeOrigin::signed(evm_account_id),

2294

1

			source_id,

2295

1

			PARAALICE.into(),

2296

1

2297

1

));

2298

		// Verify account asset balance is Zero.

2299

1

		assert_eq!(

2300

1

			parachain::Assets::balance(source_id, &evm_account_id.into()),

2301

1

2302

1

);

2303

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

2304

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

2305

1

		assert_ok!(ParaBalances::force_set_balance(

2306

1

			parachain::RuntimeOrigin::root(),

2307

1

			evm_account_id,

2308

1

0,

2309

1

));

2310

		// Verify account native balance is Zero.

2311

1

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

2312

		// Remove the account from the evm context.

2313

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

2314

1

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

2315

1

		// Verify reference count.

2316

1

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

2317

1

		assert_eq!(account.sufficients, 0);

2318

1

		assert_eq!(account.consumers, 0);

2319

1

		assert_eq!(account.providers, 1);

2320

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

2321

1

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

2322

1

});

2323

1

2324

2325

#[test]

2326

1

fn test_statemint_like() {

2327

1

	MockNet::reset();

2328

1

2329

1

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

2330

1

2331

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2332

1

		polkadot_parachain::primitives::Sibling,

2333

1

		statemint_like::AccountId,

2334

1

	>::convert_location(&dest_para)

2335

1

	.unwrap();

2336

1

2337

1

	let statemint_asset_a_balances = Location::new(

2338

1

1,

2339

1

2340

1

			Parachain(1000),

2341

1

			PalletInstance(5),

2342

1

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

2343

1

],

2344

1

);

2345

1

	let source_location = parachain::AssetType::Xcm(

2346

1

		xcm_builder::WithLatestLocationConverter::convert(&statemint_asset_a_balances)

2347

1

			.expect("convert to v3"),

2348

1

);

2349

1

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

2350

1

2351

1

	let asset_metadata = parachain::AssetMetadata {

2352

1

		name: b"StatemintToken".to_vec(),

2353

1

		symbol: b"StatemintToken".to_vec(),

2354

1

		decimals: 12,

2355

1

};

2356

1

2357

1

	ParaA::execute_with(|| {

2358

1

		assert_ok!(AssetManager::register_foreign_asset(

2359

1

			parachain::RuntimeOrigin::root(),

2360

1

			source_location.clone(),

2361

1

			asset_metadata.clone(),

2362

1

			1u128,

2363

1

			true

2364

1

));

2365

1

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

2366

1

});

2367

1

2368

1

	Statemint::execute_with(|| {

2369

1

		// Set new prefix

2370

1

		statemint_like::PrefixChanger::set_prefix(

2371

1

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

2372

1

);

2373

1

2374

1

		assert_ok!(StatemintAssets::create(

2375

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2376

1

0,

2377

1

			RELAYALICE,

2378

1

2379

1

));

2380

2381

1

		assert_ok!(StatemintAssets::mint(

2382

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2383

1

0,

2384

1

			RELAYALICE,

2385

1

			300000000000000

2386

1

));

2387

2388

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

2389

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2390

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2391

1

			sov,

2392

1

			100000000000000

2393

1

));

2394

2395

		// Actually send relay asset to parachain

2396

1

		let dest: Location = AccountKey20 {

2397

1

			network: None,

2398

1

			key: PARAALICE,

2399

1

2400

1

		.into();

2401

1

2402

1

		// Send with new prefix

2403

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2404

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2405

1

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

2406

1

			Box::new(VersionedLocation::V4(dest).clone().into()),

2407

1

			Box::new(

2408

1

2409

1

2410

1

						xcm::latest::prelude::PalletInstance(

2411

1

							<StatemintAssets as PalletInfoAccess>::index() as u8

2412

1

),

2413

1

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

2414

1

],

2415

1

2416

1

2417

1

					.into()

2418

1

),

2419

1

0,

2420

1

			WeightLimit::Unlimited

2421

1

));

2422

1

});

2423

1

2424

1

	ParaA::execute_with(|| {

2425

1

		assert_eq!(Assets::balance(source_id, &PARAALICE.into()), 123);

2426

1

});

2427

1

2428

2429

#[test]

2430

2431

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2432

1

	MockNet::reset();

2433

1

2434

1

	// Relay asset

2435

1

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

2436

1

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

2437

1

2438

1

	let relay_asset_metadata = parachain::AssetMetadata {

2439

1

		name: b"RelayToken".to_vec(),

2440

1

		symbol: b"Relay".to_vec(),

2441

1

		decimals: 12,

2442

1

};

2443

1

2444

1

	// Statemint asset

2445

1

	let statemint_asset = Location::new(

2446

1

1,

2447

1

2448

1

			Parachain(1000u32),

2449

1

			PalletInstance(5u8),

2450

1

			GeneralIndex(10u128),

2451

1

],

2452

1

);

2453

1

	let statemint_location_asset = parachain::AssetType::Xcm(

2454

1

		xcm_builder::WithLatestLocationConverter::convert(&statemint_asset).expect("convert to v3"),

2455

1

);

2456

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

2457

1

2458

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2459

1

		name: b"USDC".to_vec(),

2460

1

		symbol: b"USDC".to_vec(),

2461

1

		decimals: 12,

2462

1

};

2463

1

2464

1

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

2465

1

2466

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2467

1

		polkadot_parachain::primitives::Sibling,

2468

1

		statemint_like::AccountId,

2469

1

	>::convert_location(&dest_para)

2470

1

	.unwrap();

2471

1

2472

1

	ParaA::execute_with(|| {

2473

1

		assert_ok!(AssetManager::register_foreign_asset(

2474

1

			parachain::RuntimeOrigin::root(),

2475

1

			relay_location.clone(),

2476

1

			relay_asset_metadata,

2477

1

			1u128,

2478

1

			true

2479

1

));

2480

1

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

2481

2482

1

		assert_ok!(AssetManager::register_foreign_asset(

2483

1

			parachain::RuntimeOrigin::root(),

2484

1

			statemint_location_asset.clone(),

2485

1

			asset_metadata_statemint_asset,

2486

1

			1u128,

2487

1

			true

2488

1

));

2489

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0u128));

2490

1

});

2491

1

2492

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2493

1

		network: None,

2494

1

		key: PARAALICE,

2495

1

2496

1

	.into();

2497

1

2498

1

	// Send relay chain asset to Alice in Parachain A

2499

1

	Relay::execute_with(|| {

2500

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2501

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2502

1

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

2503

1

			Box::new(

2504

1

				VersionedLocation::V4(parachain_beneficiary_from_relay)

2505

1

					.clone()

2506

1

					.into()

2507

1

),

2508

1

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

2509

1

0,

2510

1

			WeightLimit::Unlimited

2511

1

));

2512

1

});

2513

1

2514

1

	Statemint::execute_with(|| {

2515

1

		// Set new prefix

2516

1

		statemint_like::PrefixChanger::set_prefix(

2517

1

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

2518

1

);

2519

1

2520

1

		assert_ok!(StatemintAssets::create(

2521

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2522

1

10,

2523

1

			RELAYALICE,

2524

1

2525

1

));

2526

2527

1

		assert_ok!(StatemintAssets::mint(

2528

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2529

1

10,

2530

1

			RELAYALICE,

2531

1

			300000000000000

2532

1

));

2533

2534

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

2535

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

2536

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2537

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2538

1

			sov,

2539

1

			100000000000000

2540

1

));

2541

2542

		// Send statemint USDC asset to Alice in Parachain A

2543

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2544

1

			network: None,

2545

1

			key: PARAALICE,

2546

1

2547

1

		.into();

2548

1

2549

1

		// Send with new prefix

2550

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2551

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2552

1

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

2553

1

			Box::new(

2554

1

				VersionedLocation::V4(parachain_beneficiary_from_statemint)

2555

1

					.clone()

2556

1

					.into()

2557

1

),

2558

1

			Box::new(

2559

1

2560

1

2561

1

						xcm::latest::prelude::PalletInstance(

2562

1

							<StatemintAssets as PalletInfoAccess>::index() as u8

2563

1

),

2564

1

						GeneralIndex(10),

2565

1

],

2566

1

2567

1

2568

1

					.into()

2569

1

),

2570

1

0,

2571

1

			WeightLimit::Unlimited

2572

1

));

2573

1

});

2574

1

2575

1

	let statemint_beneficiary = Location {

2576

1

		parents: 1,

2577

1

		interior: [

2578

1

			Parachain(1000),

2579

1

			AccountId32 {

2580

1

				network: None,

2581

1

				id: RELAYBOB.into(),

2582

1

},

2583

1

2584

1

		.into(),

2585

1

};

2586

1

2587

1

	ParaA::execute_with(|| {

2588

1

		// Alice has received 125 USDC

2589

1

		assert_eq!(

2590

1

			Assets::balance(source_statemint_asset_id, &PARAALICE.into()),

2591

1

2592

1

);

2593

2594

		// Alice has received 200 Relay assets

2595

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

2596

1

});

2597

1

2598

1

	Statemint::execute_with(|| {

2599

1

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

2600

1

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

2601

1

});

2602

1

	let (chain_part, beneficiary) =

2603

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2604

1

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

2605

1

	ParaA::execute_with(|| {

2606

1

		let asset = currency_to_asset(

2607

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2608

1

			100,

2609

1

);

2610

1

		let asset_fee =

2611

1

			currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

2612

1

		let assets_to_send: XcmAssets = XcmAssets::from(vec![asset, asset_fee.clone()]);

2613

1

		assert_eq!(assets_to_send.get(0).unwrap(), &asset_fee);

2614

2615

1

		assert_ok!(PolkadotXcm::transfer_assets(

2616

1

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

2617

1

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

2618

1

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

2619

1

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

2620

1

0,

2621

1

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

2622

1

));

2623

1

});

2624

1

2625

1

	ParaA::execute_with(|| {

2626

1

		// Alice has 100 USDC less

2627

1

		assert_eq!(

2628

1

			Assets::balance(source_statemint_asset_id, &PARAALICE.into()),

2629

1

2630

1

);

2631

2632

		// Alice has 100 relay asset less

2633

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 100);

2634

1

});

2635

1

2636

1

	Statemint::execute_with(|| {

2637

1

		println!("STATEMINT EVENTS: {:?}", parachain::para_events());

2638

1

		// Check that BOB received 100 USDC on statemint

2639

1

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

2640

1

});

2641

1

2642

2643

#[test]

2644

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

2645

1

	MockNet::reset();

2646

1

2647

1

	// Relay asset

2648

1

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

2649

1

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

2650

1

2651

1

	let relay_asset_metadata = parachain::AssetMetadata {

2652

1

		name: b"RelayToken".to_vec(),

2653

1

		symbol: b"Relay".to_vec(),

2654

1

		decimals: 12,

2655

1

};

2656

1

2657

1

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

2658

1

2659

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2660

1

		polkadot_parachain::primitives::Sibling,

2661

1

		statemint_like::AccountId,

2662

1

	>::convert_location(&dest_para)

2663

1

	.unwrap();

2664

1

2665

1

	ParaA::execute_with(|| {

2666

1

		assert_ok!(AssetManager::register_foreign_asset(

2667

1

			parachain::RuntimeOrigin::root(),

2668

1

			relay_location.clone(),

2669

1

			relay_asset_metadata,

2670

1

			1u128,

2671

1

			true

2672

1

));

2673

1

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

2674

1

});

2675

1

2676

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2677

1

		network: None,

2678

1

		key: PARAALICE,

2679

1

2680

1

	.into();

2681

1

2682

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2683

1

		network: None,

2684

1

		id: RELAYALICE.into(),

2685

1

2686

1

	.into();

2687

1

2688

1

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

2689

1

	Relay::execute_with(|| {

2690

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2691

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2692

1

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

2693

1

			Box::new(

2694

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

2695

1

					.clone()

2696

1

					.into()

2697

1

),

2698

1

			Box::new(([], 200).into()),

2699

1

0,

2700

1

			WeightLimit::Unlimited

2701

1

));

2702

1

});

2703

1

2704

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2705

1

	Statemint::execute_with(|| {

2706

1

		// Check Alice received 200 tokens on AssetHub

2707

1

		assert_eq!(

2708

1

			StatemintBalances::free_balance(RELAYALICE),

2709

1

			INITIAL_BALANCE + 200

2710

1

);

2711

2712

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2713

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2714

1

			sov,

2715

1

			110000000000000

2716

1

));

2717

2718

		// Now send those tokens to ParaA

2719

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2720

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2721

1

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

2722

1

			Box::new(

2723

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

2724

1

					.clone()

2725

1

					.into()

2726

1

),

2727

1

			Box::new((Location::parent(), 200).into()),

2728

1

0,

2729

1

			WeightLimit::Unlimited

2730

1

));

2731

1

});

2732

1

2733

1

	ParaA::execute_with(|| {

2734

1

		// Alice should have received the DOTs

2735

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

2736

1

});

2737

1

2738

1

	let dest = Location::new(

2739

1

1,

2740

1

2741

1

			Parachain(1000),

2742

1

			AccountId32 {

2743

1

				network: None,

2744

1

				id: RELAYBOB.into(),

2745

1

},

2746

1

],

2747

1

);

2748

1

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

2749

1

2750

1

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

2751

1

	ParaA::execute_with(|| {

2752

1

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

2753

1

		assert_ok!(PolkadotXcm::transfer_assets(

2754

1

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

2755

1

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

2756

1

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

2757

1

			Box::new(VersionedAssets::V4(asset.into())),

2758

1

0,

2759

1

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

2760

1

));

2761

2762

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 100);

2763

1

});

2764

1

2765

1

	Statemint::execute_with(|| {

2766

1

		// Check that Bob received the tokens back in AssetHub

2767

1

		assert_eq!(

2768

1

			StatemintBalances::free_balance(RELAYBOB),

2769

1

			INITIAL_BALANCE + 100

2770

1

);

2771

1

});

2772

1

2773

1

	// Send back tokens from AH to ParaA from Bob's account

2774

1

	Statemint::execute_with(|| {

2775

1

		// Now send those tokens to ParaA

2776

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2777

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

2778

1

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

2779

1

			Box::new(

2780

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

2781

1

					.clone()

2782

1

					.into()

2783

1

),

2784

1

			Box::new((Location::parent(), 100).into()),

2785

1

0,

2786

1

			WeightLimit::Unlimited

2787

1

));

2788

2789

		// 100 DOTs were deducted from Bob's account

2790

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

2791

1

});

2792

1

2793

1

	ParaA::execute_with(|| {

2794

1

		// Alice should have received 100 DOTs

2795

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

2796

1

});

2797

1

2798

2799

#[test]

2800

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

2801

1

	MockNet::reset();

2802

1

2803

1

	// Relay asset

2804

1

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

2805

1

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

2806

1

2807

1

	let relay_asset_metadata = parachain::AssetMetadata {

2808

1

		name: b"RelayToken".to_vec(),

2809

1

		symbol: b"Relay".to_vec(),

2810

1

		decimals: 12,

2811

1

};

2812

1

2813

1

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

2814

1

2815

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2816

1

		polkadot_parachain::primitives::Sibling,

2817

1

		statemint_like::AccountId,

2818

1

	>::convert_location(&dest_para)

2819

1

	.unwrap();

2820

1

2821

1

	ParaA::execute_with(|| {

2822

1

		assert_ok!(AssetManager::register_foreign_asset(

2823

1

			parachain::RuntimeOrigin::root(),

2824

1

			relay_location.clone(),

2825

1

			relay_asset_metadata,

2826

1

			1u128,

2827

1

			true

2828

1

));

2829

1

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

2830

1

});

2831

1

2832

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2833

1

		network: None,

2834

1

		key: PARAALICE,

2835

1

2836

1

	.into();

2837

1

2838

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2839

1

		network: None,

2840

1

		id: RELAYALICE.into(),

2841

1

2842

1

	.into();

2843

1

2844

1

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

2845

1

	Relay::execute_with(|| {

2846

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2847

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2848

1

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

2849

1

			Box::new(

2850

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

2851

1

					.clone()

2852

1

					.into()

2853

1

),

2854

1

			Box::new(([], 200).into()),

2855

1

0,

2856

1

			WeightLimit::Unlimited

2857

1

));

2858

1

});

2859

1

2860

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2861

1

	Statemint::execute_with(|| {

2862

1

		// Check Alice received 200 tokens on AssetHub

2863

1

		assert_eq!(

2864

1

			StatemintBalances::free_balance(RELAYALICE),

2865

1

			INITIAL_BALANCE + 200

2866

1

);

2867

2868

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2869

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2870

1

			sov,

2871

1

			110000000000000

2872

1

));

2873

2874

		// Now send those tokens to ParaA

2875

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2876

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2877

1

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

2878

1

			Box::new(

2879

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

2880

1

					.clone()

2881

1

					.into()

2882

1

),

2883

1

			Box::new((Location::parent(), 200).into()),

2884

1

0,

2885

1

			WeightLimit::Unlimited

2886

1

));

2887

1

});

2888

1

2889

1

	ParaA::execute_with(|| {

2890

1

		// Alice should have received the DOTs

2891

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

2892

1

});

2893

1

2894

1

	let dest = Location::new(

2895

1

1,

2896

1

2897

1

			Parachain(1000),

2898

1

			AccountId32 {

2899

1

				network: None,

2900

1

				id: RELAYBOB.into(),

2901

1

},

2902

1

],

2903

1

);

2904

1

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

2905

1

2906

1

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

2907

1

	ParaA::execute_with(|| {

2908

1

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

2909

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

2910

1

		assert_ok!(PolkadotXcm::transfer_assets(

2911

1

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

2912

1

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

2913

1

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

2914

1

			Box::new(VersionedAssets::V4(vec![asset_fee, asset].into())),

2915

1

0,

2916

1

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

2917

1

));

2918

2919

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 90);

2920

1

});

2921

1

2922

1

	Statemint::execute_with(|| {

2923

1

		// Free execution: check that Bob received the tokens back in AssetHub

2924

1

		assert_eq!(

2925

1

			StatemintBalances::free_balance(RELAYBOB),

2926

1

			INITIAL_BALANCE + 110

2927

1

);

2928

1

});

2929

1

2930

1

	// Send back tokens from AH to ParaA from Bob's account

2931

1

	Statemint::execute_with(|| {

2932

1

		// Now send those tokens to ParaA

2933

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2934

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

2935

1

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

2936

1

			Box::new(

2937

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

2938

1

					.clone()

2939

1

					.into()

2940

1

),

2941

1

			Box::new((Location::parent(), 100).into()),

2942

1

0,

2943

1

			WeightLimit::Unlimited

2944

1

));

2945

2946

		// 100 DOTs were deducted from Bob's account

2947

1

		assert_eq!(

2948

1

			StatemintBalances::free_balance(RELAYBOB),

2949

1

			INITIAL_BALANCE + 10

2950

1

);

2951

1

});

2952

1

2953

1

	ParaA::execute_with(|| {

2954

1

		// Alice should have received 100 DOTs

2955

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 190);

2956

1

});

2957

1

2958

2959

#[test]

2960

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

2961

1

	MockNet::reset();

2962

1

2963

1

	// Relay asset

2964

1

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

2965

1

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

2966

1

2967

1

	let relay_asset_metadata = parachain::AssetMetadata {

2968

1

		name: b"RelayToken".to_vec(),

2969

1

		symbol: b"Relay".to_vec(),

2970

1

		decimals: 12,

2971

1

};

2972

1

2973

1

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

2974

1

2975

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2976

1

		polkadot_parachain::primitives::Sibling,

2977

1

		statemint_like::AccountId,

2978

1

	>::convert_location(&dest_para)

2979

1

	.unwrap();

2980

1

2981

1

	ParaA::execute_with(|| {

2982

1

		assert_ok!(AssetManager::register_foreign_asset(

2983

1

			parachain::RuntimeOrigin::root(),

2984

1

			relay_location.clone(),

2985

1

			relay_asset_metadata,

2986

1

			1u128,

2987

1

			true

2988

1

));

2989

1

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

2990

1

});

2991

1

2992

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2993

1

		network: None,

2994

1

		key: PARAALICE,

2995

1

2996

1

	.into();

2997

1

2998

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2999

1

		network: None,

3000

1

		id: RELAYALICE.into(),

3001

1

3002

1

	.into();

3003

1

3004

1

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

3005

1

	Relay::execute_with(|| {

3006

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3007

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3008

1

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

3009

1

			Box::new(

3010

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3011

1

					.clone()

3012

1

					.into()

3013

1

),

3014

1

			Box::new(([], 200).into()),

3015

1

0,

3016

1

			WeightLimit::Unlimited

3017

1

));

3018

1

});

3019

1

3020

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3021

1

	Statemint::execute_with(|| {

3022

1

		// Check Alice received 200 tokens on AssetHub

3023

1

		assert_eq!(

3024

1

			StatemintBalances::free_balance(RELAYALICE),

3025

1

			INITIAL_BALANCE + 200

3026

1

);

3027

3028

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3029

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3030

1

			sov,

3031

1

			110000000000000

3032

1

));

3033

3034

		// Now send those tokens to ParaA

3035

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3036

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3037

1

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

3038

1

			Box::new(

3039

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3040

1

					.clone()

3041

1

					.into()

3042

1

),

3043

1

			Box::new((Location::parent(), 200).into()),

3044

1

0,

3045

1

			WeightLimit::Unlimited

3046

1

));

3047

1

});

3048

1

3049

1

	ParaA::execute_with(|| {

3050

1

		// Alice should have received the DOTs

3051

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

3052

1

});

3053

1

3054

1

	let dest = Location::new(

3055

1

1,

3056

1

3057

1

			Parachain(1000),

3058

1

			AccountId32 {

3059

1

				network: None,

3060

1

				id: RELAYBOB.into(),

3061

1

},

3062

1

],

3063

1

);

3064

1

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

3065

1

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3066

1

	ParaA::execute_with(|| {

3067

1

		assert_ok!(PolkadotXcm::transfer_assets(

3068

1

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

3069

1

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

3070

1

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

3071

1

			Box::new(VersionedAssets::V4((Location::parent(), 100).into())),

3072

1

0,

3073

1

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

3074

1

));

3075

3076

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 100);

3077

1

});

3078

1

3079

1

	Statemint::execute_with(|| {

3080

1

		// Check that Bob received the tokens back in AssetHub

3081

1

		assert_eq!(

3082

1

			StatemintBalances::free_balance(RELAYBOB),

3083

1

			INITIAL_BALANCE + 100

3084

1

);

3085

1

});

3086

1

3087

1

	// Send back tokens from AH to ParaA from Bob's account

3088

1

	Statemint::execute_with(|| {

3089

1

		// Now send those tokens to ParaA

3090

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3091

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3092

1

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

3093

1

			Box::new(

3094

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3095

1

					.clone()

3096

1

					.into()

3097

1

),

3098

1

			Box::new((Location::parent(), 100).into()),

3099

1

0,

3100

1

			WeightLimit::Unlimited

3101

1

));

3102

3103

		// 100 DOTs were deducted from Bob's account

3104

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3105

1

});

3106

1

3107

1

	ParaA::execute_with(|| {

3108

1

		// Alice should have received 100 DOTs

3109

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

3110

1

});

3111

1

3112

3113

#[test]

3114

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3115

1

	MockNet::reset();

3116

1

3117

1

	// Relay asset

3118

1

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

3119

1

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

3120

1

3121

1

	let relay_asset_metadata = parachain::AssetMetadata {

3122

1

		name: b"RelayToken".to_vec(),

3123

1

		symbol: b"Relay".to_vec(),

3124

1

		decimals: 12,

3125

1

};

3126

1

3127

1

	// Statemint asset

3128

1

	let statemint_asset = Location::new(

3129

1

1,

3130

1

3131

1

			Parachain(1000u32),

3132

1

			PalletInstance(5u8),

3133

1

			GeneralIndex(10u128),

3134

1

],

3135

1

);

3136

1

	let statemint_location_asset = parachain::AssetType::Xcm(

3137

1

		xcm_builder::WithLatestLocationConverter::convert(&statemint_asset).expect("convert to v3"),

3138

1

);

3139

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3140

1

3141

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3142

1

		name: b"USDC".to_vec(),

3143

1

		symbol: b"USDC".to_vec(),

3144

1

		decimals: 12,

3145

1

};

3146

1

3147

1

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

3148

1

3149

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3150

1

		polkadot_parachain::primitives::Sibling,

3151

1

		statemint_like::AccountId,

3152

1

	>::convert_location(&dest_para)

3153

1

	.unwrap();

3154

1

3155

1

	ParaA::execute_with(|| {

3156

1

		assert_ok!(AssetManager::register_foreign_asset(

3157

1

			parachain::RuntimeOrigin::root(),

3158

1

			relay_location.clone(),

3159

1

			relay_asset_metadata,

3160

1

			1u128,

3161

1

			true

3162

1

));

3163

1

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

3164

1

3165

1

		assert_ok!(AssetManager::register_foreign_asset(

3166

1

			parachain::RuntimeOrigin::root(),

3167

1

			statemint_location_asset.clone(),

3168

1

			asset_metadata_statemint_asset,

3169

1

			1u128,

3170

1

			true

3171

1

));

3172

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

3173

1

});

3174

1

3175

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3176

1

		network: None,

3177

1

		key: PARAALICE,

3178

1

3179

1

	.into();

3180

1

3181

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3182

1

		network: None,

3183

1

		id: RELAYALICE.into(),

3184

1

3185

1

	.into();

3186

1

3187

1

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

3188

1

	Relay::execute_with(|| {

3189

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3190

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3191

1

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

3192

1

			Box::new(

3193

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3194

1

					.clone()

3195

1

					.into()

3196

1

),

3197

1

			Box::new(([], 200).into()),

3198

1

0,

3199

1

			WeightLimit::Unlimited

3200

1

));

3201

1

});

3202

1

3203

1

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3204

1

	Statemint::execute_with(|| {

3205

1

		// Check Alice received 200 tokens on AssetHub

3206

1

		assert_eq!(

3207

1

			StatemintBalances::free_balance(RELAYALICE),

3208

1

			INITIAL_BALANCE + 200

3209

1

);

3210

3211

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3212

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3213

1

			sov,

3214

1

			110000000000000

3215

1

));

3216

3217

1

		statemint_like::PrefixChanger::set_prefix(

3218

1

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

3219

1

);

3220

1

3221

1

		assert_ok!(StatemintAssets::create(

3222

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3223

1

10,

3224

1

			RELAYALICE,

3225

1

3226

1

));

3227

3228

1

		assert_ok!(StatemintAssets::mint(

3229

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3230

1

10,

3231

1

			RELAYALICE,

3232

1

			300000000000000

3233

1

));

3234

3235

		// Now send relay tokens to ParaA

3236

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3237

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3238

1

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

3239

1

			Box::new(

3240

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3241

1

					.clone()

3242

1

					.into()

3243

1

),

3244

1

			Box::new((Location::parent(), 200).into()),

3245

1

0,

3246

1

			WeightLimit::Unlimited

3247

1

));

3248

3249

		// Send USDC

3250

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3251

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3252

1

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

3253

1

			Box::new(

3254

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3255

1

					.clone()

3256

1

					.into()

3257

1

),

3258

1

			Box::new(

3259

1

3260

1

3261

1

						xcm::latest::prelude::PalletInstance(

3262

1

							<StatemintAssets as PalletInfoAccess>::index() as u8

3263

1

),

3264

1

						GeneralIndex(10),

3265

1

],

3266

1

3267

1

3268

1

					.into()

3269

1

),

3270

1

0,

3271

1

			WeightLimit::Unlimited

3272

1

));

3273

1

});

3274

1

3275

1

	ParaA::execute_with(|| {

3276

1

		// Alice should have received the DOTs

3277

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

3278

3279

		// Alice has received 125 USDC

3280

1

		assert_eq!(

3281

1

			Assets::balance(source_statemint_asset_id, &PARAALICE.into()),

3282

1

3283

1

);

3284

1

});

3285

1

3286

1

	let dest = Location::new(

3287

1

1,

3288

1

3289

1

			Parachain(1000),

3290

1

			AccountId32 {

3291

1

				network: None,

3292

1

				id: RELAYBOB.into(),

3293

1

},

3294

1

],

3295

1

);

3296

1

3297

1

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

3298

1

3299

1

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3300

1

	ParaA::execute_with(|| {

3301

1

		let asset_1 = currency_to_asset(

3302

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3303

1

			100,

3304

1

);

3305

1

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

3306

1

		let assets_to_send = vec![asset_1, asset_2];

3307

1

		assert_ok!(PolkadotXcm::transfer_assets(

3308

1

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

3309

1

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

3310

1

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

3311

1

			Box::new(VersionedAssets::V4(assets_to_send.into())),

3312

1

1,

3313

1

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

3314

1

));

3315

3316

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 100);

3317

1

});

3318

1

3319

1

	Statemint::execute_with(|| {

3320

1

		// Check that Bob received relay tokens back in AssetHub

3321

1

		assert_eq!(

3322

1

			StatemintBalances::free_balance(RELAYBOB),

3323

1

			INITIAL_BALANCE + 100

3324

1

);

3325

3326

		// Check that BOB received 100 USDC on AssetHub

3327

1

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

3328

1

});

3329

1

3330

1

	// Send back tokens from AH to ParaA from Bob's account

3331

1

	Statemint::execute_with(|| {

3332

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3333

1

3334

1

		// Now send those tokens to ParaA

3335

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3336

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3337

1

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

3338

1

			Box::new(

3339

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3340

1

					.clone()

3341

1

					.into()

3342

1

),

3343

1

			Box::new((Location::parent(), 100).into()),

3344

1

0,

3345

1

			WeightLimit::Unlimited

3346

1

));

3347

3348

		// 100 DOTs were deducted from Bob's account

3349

1

		assert_eq!(

3350

1

			StatemintBalances::free_balance(RELAYBOB),

3351

1

			bob_previous_balance - 100

3352

1

);

3353

1

});

3354

1

3355

1

	ParaA::execute_with(|| {

3356

1

		// Alice should have received 100 DOTs

3357

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

3358

1

});

3359

1

3360

3361

#[test]

3362

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3363

1

	MockNet::reset();

3364

1

3365

1

	// Relay asset

3366

1

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

3367

1

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

3368

1

3369

1

	let relay_asset_metadata = parachain::AssetMetadata {

3370

1

		name: b"RelayToken".to_vec(),

3371

1

		symbol: b"Relay".to_vec(),

3372

1

		decimals: 12,

3373

1

};

3374

1

3375

1

	// Statemint asset

3376

1

	let statemint_asset = Location::new(

3377

1

1,

3378

1

3379

1

			Parachain(1000u32),

3380

1

			PalletInstance(5u8),

3381

1

			GeneralIndex(10u128),

3382

1

],

3383

1

);

3384

1

	let statemint_location_asset = parachain::AssetType::Xcm(

3385

1

		xcm_builder::WithLatestLocationConverter::convert(&statemint_asset).expect("convert to v3"),

3386

1

);

3387

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3388

1

3389

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3390

1

		name: b"USDC".to_vec(),

3391

1

		symbol: b"USDC".to_vec(),

3392

1

		decimals: 12,

3393

1

};

3394

1

3395

1

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

3396

1

3397

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3398

1

		polkadot_parachain::primitives::Sibling,

3399

1

		statemint_like::AccountId,

3400

1

	>::convert_location(&dest_para)

3401

1

	.unwrap();

3402

1

3403

1

	ParaA::execute_with(|| {

3404

1

		assert_ok!(AssetManager::register_foreign_asset(

3405

1

			parachain::RuntimeOrigin::root(),

3406

1

			relay_location.clone(),

3407

1

			relay_asset_metadata,

3408

1

			1u128,

3409

1

			true

3410

1

));

3411

1

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

3412

1

3413

1

		assert_ok!(AssetManager::register_foreign_asset(

3414

1

			parachain::RuntimeOrigin::root(),

3415

1

			statemint_location_asset.clone(),

3416

1

			asset_metadata_statemint_asset,

3417

1

			1u128,

3418

1

			true

3419

1

));

3420

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

3421

1

});

3422

1

3423

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3424

1

		network: None,

3425

1

		key: PARAALICE,

3426

1

3427

1

	.into();

3428

1

3429

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3430

1

		network: None,

3431

1

		id: RELAYALICE.into(),

3432

1

3433

1

	.into();

3434

1

3435

1

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

3436

1

	Relay::execute_with(|| {

3437

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3438

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3439

1

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

3440

1

			Box::new(

3441

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3442

1

					.clone()

3443

1

					.into()

3444

1

),

3445

1

			Box::new(([], 200).into()),

3446

1

0,

3447

1

			WeightLimit::Unlimited

3448

1

));

3449

1

});

3450

1

3451

1

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3452

1

	Statemint::execute_with(|| {

3453

1

		// Check Alice received 200 tokens on AssetHub

3454

1

		assert_eq!(

3455

1

			StatemintBalances::free_balance(RELAYALICE),

3456

1

			INITIAL_BALANCE + 200

3457

1

);

3458

3459

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3460

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3461

1

			sov,

3462

1

			110000000000000

3463

1

));

3464

3465

1

		statemint_like::PrefixChanger::set_prefix(

3466

1

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

3467

1

);

3468

1

3469

1

		assert_ok!(StatemintAssets::create(

3470

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3471

1

10,

3472

1

			RELAYALICE,

3473

1

3474

1

));

3475

3476

1

		assert_ok!(StatemintAssets::mint(

3477

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3478

1

10,

3479

1

			RELAYALICE,

3480

1

			300000000000000

3481

1

));

3482

3483

		// Now send relay tokens to ParaA

3484

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3485

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3486

1

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

3487

1

			Box::new(

3488

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3489

1

					.clone()

3490

1

					.into()

3491

1

),

3492

1

			Box::new((Location::parent(), 200).into()),

3493

1

0,

3494

1

			WeightLimit::Unlimited

3495

1

));

3496

3497

		// Send USDC

3498

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3499

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3500

1

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

3501

1

			Box::new(

3502

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3503

1

					.clone()

3504

1

					.into()

3505

1

),

3506

1

			Box::new(

3507

1

3508

1

3509

1

						xcm::latest::prelude::PalletInstance(

3510

1

							<StatemintAssets as PalletInfoAccess>::index() as u8

3511

1

),

3512

1

						GeneralIndex(10),

3513

1

],

3514

1

3515

1

3516

1

					.into()

3517

1

),

3518

1

0,

3519

1

			WeightLimit::Unlimited

3520

1

));

3521

1

});

3522

1

3523

1

	ParaA::execute_with(|| {

3524

1

		// Alice should have received the DOTs

3525

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

3526

3527

		// Alice has received 125 USDC

3528

1

		assert_eq!(

3529

1

			Assets::balance(source_statemint_asset_id, &PARAALICE.into()),

3530

1

3531

1

);

3532

1

});

3533

1

3534

1

	let dest = Location::new(

3535

1

1,

3536

1

3537

1

			Parachain(1000),

3538

1

			AccountId32 {

3539

1

				network: None,

3540

1

				id: RELAYBOB.into(),

3541

1

},

3542

1

],

3543

1

);

3544

1

3545

1

	let statemint_asset_to_send = Asset {

3546

1

		id: AssetId(statemint_asset),

3547

1

		fun: Fungible(100),

3548

1

};

3549

1

3550

1

	let relay_asset_to_send = Asset {

3551

1

		id: AssetId(Location::parent()),

3552

1

		fun: Fungible(100),

3553

1

};

3554

1

3555

1

	let assets_to_send: XcmAssets =

3556

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

3557

1

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

3558

1

	// For some reason the order of the assets is inverted when creating the array above.

3559

1

	// We need to use relay asset for fees, so we pick index 0.

3560

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

3561

3562

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3563

1

	ParaA::execute_with(|| {

3564

1

		assert_ok!(PolkadotXcm::transfer_assets(

3565

1

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

3566

1

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

3567

1

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

3568

1

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

3569

1

0,

3570

1

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

3571

1

));

3572

3573

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 100);

3574

1

});

3575

1

3576

1

	Statemint::execute_with(|| {

3577

1

		// Check that Bob received relay tokens back in AssetHub

3578

1

		assert_eq!(

3579

1

			StatemintBalances::free_balance(RELAYBOB),

3580

1

			INITIAL_BALANCE + 100

3581

1

);

3582

3583

		// Check that BOB received 100 USDC on AssetHub

3584

1

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

3585

1

});

3586

1

3587

1

	// Send back tokens from AH to ParaA from Bob's account

3588

1

	Statemint::execute_with(|| {

3589

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3590

1

3591

1

		// Now send those tokens to ParaA

3592

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3593

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3594

1

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

3595

1

			Box::new(

3596

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3597

1

					.clone()

3598

1

					.into()

3599

1

),

3600

1

			Box::new((Location::parent(), 100).into()),

3601

1

0,

3602

1

			WeightLimit::Unlimited

3603

1

));

3604

3605

		// 100 DOTs were deducted from Bob's account

3606

1

		assert_eq!(

3607

1

			StatemintBalances::free_balance(RELAYBOB),

3608

1

			bob_previous_balance - 100

3609

1

);

3610

1

});

3611

1

3612

1

	ParaA::execute_with(|| {

3613

1

		// Alice should have received 100 DOTs

3614

1

		assert_eq!(Assets::balance(source_relay_id, &PARAALICE.into()), 200);

3615

1

});

3616

1

3617

3618

#[test]

3619

1

fn transact_through_signed_multilocation() {

3620

1

	MockNet::reset();

3621

1

	let mut ancestry = Location::parent();

3622

1

3623

1

	ParaA::execute_with(|| {

3624

1

		// Root can set transact info

3625

1

		assert_ok!(XcmTransactor::set_transact_info(

3626

1

			parachain::RuntimeOrigin::root(),

3627

1

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

3628

1

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

3629

1

			3000.into(),

3630

1

			20000000000.into(),

3631

1

			// 4 instructions in transact through signed

3632

1

			Some(4000.into())

3633

1

));

3634

		// Root can set transact info

3635

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3636

1

			parachain::RuntimeOrigin::root(),

3637

1

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

3638

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3639

1

));

3640

1

		ancestry = parachain::UniversalLocation::get().into();

3641

1

});

3642

1

3643

1

	// Let's construct the Junction that we will append with DescendOrigin

3644

1

	let signed_origin: Junctions = [AccountKey20 {

3645

1

		network: None,

3646

1

		key: PARAALICE,

3647

1

}]

3648

1

	.into();

3649

1

3650

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

3651

1

	descend_origin_multilocation

3652

1

		.append_with(signed_origin)

3653

1

		.unwrap();

3654

1

3655

1

	// To convert it to what the relay will see instead of us

3656

1

	descend_origin_multilocation

3657

1

		.reanchor(&Location::parent(), &ancestry.interior)

3658

1

		.unwrap();

3659

1

3660

1

	let derived = xcm_builder::Account32Hash::<

3661

1

		relay_chain::KusamaNetwork,

3662

1

		relay_chain::AccountId,

3663

1

	>::convert_location(&descend_origin_multilocation)

3664

1

	.unwrap();

3665

1

3666

1

	Relay::execute_with(|| {

3667

1

		// free execution, full amount received

3668

1

		assert_ok!(RelayBalances::transfer_allow_death(

3669

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3670

1

			derived.clone(),

3671

1

			4000004100u128,

3672

1

));

3673

		// derived account has all funds

3674

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

3675

		// sovereign account has 0 funds

3676

1

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

3677

1

});

3678

1

3679

1

	// Encode the call. Balances transact to para_a_account

3680

1

	// First index

3681

1

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

3682

1

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

3683

1

		relay_chain::Balances,

3684

1

>()

3685

1

	.unwrap() as u8;

3686

1

3687

1

	encoded.push(index);

3688

1

3689

1

	// Then call bytes

3690

1

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

3691

1

		// 100 to sovereign

3692

1

		dest: para_a_account(),

3693

1

		value: 100u32.into(),

3694

1

3695

1

	.encode();

3696

1

	encoded.append(&mut call_bytes);

3697

1

3698

1

	ParaA::execute_with(|| {

3699

1

		assert_ok!(XcmTransactor::transact_through_signed(

3700

1

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

3701

1

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

3702

1

			CurrencyPayment {

3703

1

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

3704

1

					Location::parent()

3705

1

				))),

3706

1

				fee_amount: None

3707

1

},

3708

1

			encoded,

3709

1

			// 4000000000 for transfer + 4000 for XCM

3710

1

			TransactWeights {

3711

1

				transact_required_weight_at_most: 4000000000.into(),

3712

1

				overall_weight: None

3713

1

},

3714

1

			false

3715

1

));

3716

1

});

3717

1

3718

1

	Relay::execute_with(|| {

3719

1

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

3720

3721

1

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

3722

1

});

3723

1

3724

3725

#[test]

3726

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

3727

1

	MockNet::reset();

3728

1

	let mut ancestry = Location::parent();

3729

1

3730

1

	ParaA::execute_with(|| {

3731

1

		ancestry = parachain::UniversalLocation::get().into();

3732

1

});

3733

1

3734

1

	// Let's construct the Junction that we will append with DescendOrigin

3735

1

	let signed_origin: Junctions = [AccountKey20 {

3736

1

		network: None,

3737

1

		key: PARAALICE,

3738

1

}]

3739

1

	.into();

3740

1

3741

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

3742

1

	descend_origin_multilocation

3743

1

		.append_with(signed_origin)

3744

1

		.unwrap();

3745

1

3746

1

	// To convert it to what the relay will see instead of us

3747

1

	descend_origin_multilocation

3748

1

		.reanchor(&Location::parent(), &ancestry.interior)

3749

1

		.unwrap();

3750

1

3751

1

	let derived = xcm_builder::Account32Hash::<

3752

1

		relay_chain::KusamaNetwork,

3753

1

		relay_chain::AccountId,

3754

1

	>::convert_location(&descend_origin_multilocation)

3755

1

	.unwrap();

3756

1

3757

1

	Relay::execute_with(|| {

3758

1

		// free execution, full amount received

3759

1

		assert_ok!(RelayBalances::transfer_allow_death(

3760

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3761

1

			derived.clone(),

3762

1

			4000004100u128,

3763

1

));

3764

		// derived account has all funds

3765

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

3766

		// sovereign account has 0 funds

3767

1

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

3768

1

});

3769

1

3770

1

	// Encode the call. Balances transact to para_a_account

3771

1

	// First index

3772

1

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

3773

1

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

3774

1

		relay_chain::Balances,

3775

1

>()

3776

1

	.unwrap() as u8;

3777

1

3778

1

	encoded.push(index);

3779

1

3780

1

	// Then call bytes

3781

1

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

3782

1

		// 100 to sovereign

3783

1

		dest: para_a_account(),

3784

1

		value: 100u32.into(),

3785

1

3786

1

	.encode();

3787

1

	encoded.append(&mut call_bytes);

3788

1

3789

1

	let total_weight = 4000004000u64;

3790

1

	ParaA::execute_with(|| {

3791

1

		assert_ok!(XcmTransactor::transact_through_signed(

3792

1

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

3793

1

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

3794

1

			CurrencyPayment {

3795

1

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

3796

1

					Location::parent()

3797

1

				))),

3798

1

				fee_amount: Some(total_weight as u128)

3799

1

},

3800

1

			encoded,

3801

1

			// 4000000000 for transfer + 4000 for XCM

3802

1

			TransactWeights {

3803

1

				transact_required_weight_at_most: 4000000000.into(),

3804

1

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

3805

1

},

3806

1

			false

3807

1

));

3808

1

});

3809

1

3810

1

	Relay::execute_with(|| {

3811

1

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

3812

3813

1

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

3814

1

});

3815

1

3816

3817

#[test]

3818

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

3819

1

	MockNet::reset();

3820

1

	let mut ancestry = Location::parent();

3821

1

3822

1

	ParaA::execute_with(|| {

3823

1

		ancestry = parachain::UniversalLocation::get().into();

3824

1

});

3825

1

3826

1

	// Let's construct the Junction that we will append with DescendOrigin

3827

1

	let signed_origin: Junctions = [AccountKey20 {

3828

1

		network: None,

3829

1

		key: PARAALICE,

3830

1

}]

3831

1

	.into();

3832

1

3833

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

3834

1

	descend_origin_multilocation

3835

1

		.append_with(signed_origin)

3836

1

		.unwrap();

3837

1

3838

1

	// To convert it to what the relay will see instead of us

3839

1

	descend_origin_multilocation

3840

1

		.reanchor(&Location::parent(), &ancestry.interior)

3841

1

		.unwrap();

3842

1

3843

1

	let derived = xcm_builder::Account32Hash::<

3844

1

		relay_chain::KusamaNetwork,

3845

1

		relay_chain::AccountId,

3846

1

	>::convert_location(&descend_origin_multilocation)

3847

1

	.unwrap();

3848

1

3849

1

	Relay::execute_with(|| {

3850

1

		// free execution, full amount received

3851

1

		assert_ok!(RelayBalances::transfer_allow_death(

3852

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3853

1

			derived.clone(),

3854

1

			4000009100u128,

3855

1

));

3856

		// derived account has all funds

3857

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

3858

		// sovereign account has 0 funds

3859

1

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

3860

1

});

3861

1

3862

1

	// Encode the call. Balances transact to para_a_account

3863

1

	// First index

3864

1

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

3865

1

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

3866

1

		relay_chain::Balances,

3867

1

>()

3868

1

	.unwrap() as u8;

3869

1

3870

1

	encoded.push(index);

3871

1

3872

1

	// Then call bytes

3873

1

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

3874

1

		// 100 to sovereign

3875

1

		dest: para_a_account(),

3876

1

		value: 100u32.into(),

3877

1

3878

1

	.encode();

3879

1

	encoded.append(&mut call_bytes);

3880

1

3881

1

	let total_weight = 4000009000u64;

3882

1

	ParaA::execute_with(|| {

3883

1

		assert_ok!(XcmTransactor::transact_through_signed(

3884

1

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

3885

1

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

3886

1

			CurrencyPayment {

3887

1

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

3888

1

					Location::parent()

3889

1

				))),

3890

1

				fee_amount: Some(total_weight as u128)

3891

1

},

3892

1

			encoded,

3893

1

			// 4000000000 for transfer + 9000 for XCM

3894

1

			TransactWeights {

3895

1

				transact_required_weight_at_most: 4000000000.into(),

3896

1

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

3897

1

},

3898

1

			true

3899

1

));

3900

1

});

3901

1

3902

1

	Relay::execute_with(|| {

3903

1

		// 100 transferred

3904

1

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

3905

3906

		// 4000005186 refunded

3907

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000005186);

3908

1

});

3909

1

3910

3911

#[test]

3912

1

fn transact_through_signed_multilocation_para_to_para() {

3913

1

	MockNet::reset();

3914

1

	let mut ancestry = Location::parent();

3915

1

3916

1

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

3917

1

3918

1

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

3919

1

3920

1

	ParaA::execute_with(|| {

3921

1

		// Root can set transact info

3922

1

		assert_ok!(XcmTransactor::set_transact_info(

3923

1

			parachain::RuntimeOrigin::root(),

3924

1

			// ParaB

3925

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

3926

1

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

3927

1

			3.into(),

3928

1

			20000000000.into(),

3929

1

			// 4 instructions in transact through signed

3930

1

			Some(4.into())

3931

1

));

3932

		// Root can set transact info

3933

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3934

1

			parachain::RuntimeOrigin::root(),

3935

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

3936

1

			parachain::ParaTokensPerSecond::get(),

3937

1

));

3938

1

		ancestry = parachain::UniversalLocation::get().into();

3939

1

});

3940

1

3941

1

	// Let's construct the Junction that we will append with DescendOrigin

3942

1

	let signed_origin: Junctions = [AccountKey20 {

3943

1

		network: None,

3944

1

		key: PARAALICE,

3945

1

}]

3946

1

	.into();

3947

1

3948

1

	let mut descend_origin_location = parachain::SelfLocation::get();

3949

1

	descend_origin_location.append_with(signed_origin).unwrap();

3950

1

3951

1

	// To convert it to what the paraB will see instead of us

3952

1

	descend_origin_location

3953

1

		.reanchor(&para_b_location, &ancestry.interior)

3954

1

		.unwrap();

3955

1

3956

1

	let derived = xcm_builder::HashedDescription::<

3957

1

		parachain::AccountId,

3958

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

3959

1

	>::convert_location(&descend_origin_location)

3960

1

	.unwrap();

3961

1

3962

1

	ParaB::execute_with(|| {

3963

1

		// free execution, full amount received

3964

1

		assert_ok!(ParaBalances::transfer_allow_death(

3965

1

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

3966

1

			derived.clone(),

3967

1

			4000000104u128,

3968

1

));

3969

		// derived account has all funds

3970

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

3971

		// sovereign account has 0 funds

3972

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

3973

1

});

3974

1

3975

1

	// Encode the call. Balances transact to para_a_account

3976

1

	// First index

3977

1

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

3978

1

	let index =

3979

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

3980

1

			.unwrap() as u8;

3981

1

3982

1

	encoded.push(index);

3983

1

3984

1

	// Then call bytes

3985

1

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

3986

1

		// 100 to sovereign

3987

1

		dest: para_a_account_20(),

3988

1

		value: 100u32.into(),

3989

1

3990

1

	.encode();

3991

1

	encoded.append(&mut call_bytes);

3992

1

3993

1

	ParaA::execute_with(|| {

3994

1

		assert_ok!(XcmTransactor::transact_through_signed(

3995

1

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

3996

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

3997

1

			CurrencyPayment {

3998

1

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

3999

1

					para_b_balances

4000

1

				))),

4001

1

				fee_amount: None

4002

1

},

4003

1

			encoded,

4004

1

			// 4000000000 for transfer + 4000 for XCM

4005

1

			// 1-1 to fee

4006

1

			TransactWeights {

4007

1

				transact_required_weight_at_most: 4000000000.into(),

4008

1

				overall_weight: None

4009

1

},

4010

1

			false

4011

1

));

4012

1

});

4013

1

4014

1

	ParaB::execute_with(|| {

4015

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4016

4017

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4018

1

});

4019

1

4020

4021

#[test]

4022

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4023

1

	MockNet::reset();

4024

1

	let mut ancestry = Location::parent();

4025

1

4026

1

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

4027

1

4028

1

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

4029

1

4030

1

	ParaA::execute_with(|| {

4031

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4032

1

			parachain::RuntimeOrigin::root(),

4033

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4034

1

			parachain::ParaTokensPerSecond::get(),

4035

1

));

4036

1

		ancestry = parachain::UniversalLocation::get().into();

4037

1

});

4038

1

4039

1

	// Let's construct the Junction that we will append with DescendOrigin

4040

1

	let signed_origin: Junctions = [AccountKey20 {

4041

1

		network: None,

4042

1

		key: PARAALICE,

4043

1

}]

4044

1

	.into();

4045

1

4046

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4047

1

	descend_origin_location.append_with(signed_origin).unwrap();

4048

1

4049

1

	// To convert it to what the paraB will see instead of us

4050

1

	descend_origin_location

4051

1

		.reanchor(&para_b_location, &ancestry.interior)

4052

1

		.unwrap();

4053

1

4054

1

	let derived = xcm_builder::HashedDescription::<

4055

1

		parachain::AccountId,

4056

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4057

1

	>::convert_location(&descend_origin_location)

4058

1

	.unwrap();

4059

1

4060

1

	ParaB::execute_with(|| {

4061

1

		// free execution, full amount received

4062

1

		assert_ok!(ParaBalances::transfer_allow_death(

4063

1

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

4064

1

			derived.clone(),

4065

1

			4000009100u128,

4066

1

));

4067

		// derived account has all funds

4068

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4069

		// sovereign account has 0 funds

4070

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4071

1

});

4072

1

4073

1

	// Encode the call. Balances transact to para_a_account

4074

1

	// First index

4075

1

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

4076

1

	let index =

4077

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4078

1

			.unwrap() as u8;

4079

1

4080

1

	encoded.push(index);

4081

1

4082

1

	// Then call bytes

4083

1

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

4084

1

		// 100 to sovereign

4085

1

		dest: para_a_account_20(),

4086

1

		value: 100u32.into(),

4087

1

4088

1

	.encode();

4089

1

	encoded.append(&mut call_bytes);

4090

1

4091

1

	let overall_weight = 4000009000u64;

4092

1

	ParaA::execute_with(|| {

4093

1

		assert_ok!(XcmTransactor::transact_through_signed(

4094

1

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

4095

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4096

1

			CurrencyPayment {

4097

1

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

4098

1

					para_b_balances

4099

1

				))),

4100

1

				fee_amount: Some(overall_weight as u128)

4101

1

},

4102

1

			encoded,

4103

1

			// 4000000000 for transfer + 9000 for XCM

4104

1

			TransactWeights {

4105

1

				transact_required_weight_at_most: 4000000000.into(),

4106

1

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

4107

1

},

4108

1

			true

4109

1

));

4110

1

});

4111

1

4112

1

	ParaB::execute_with(|| {

4113

1

		// Check the derived account was refunded

4114

1

		assert_eq!(ParaBalances::free_balance(&derived), 8993);

4115

4116

		// Check the transfer was executed

4117

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4118

1

});

4119

1

4120

4121

#[test]

4122

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4123

1

	MockNet::reset();

4124

1

	let mut ancestry = Location::parent();

4125

1

4126

1

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

4127

1

4128

1

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

4129

1

4130

1

	ParaA::execute_with(|| {

4131

1

		// Root can set transact info

4132

1

		assert_ok!(XcmTransactor::set_transact_info(

4133

1

			parachain::RuntimeOrigin::root(),

4134

1

			// ParaB

4135

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4136

1

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

4137

1

			3.into(),

4138

1

			20000000000.into(),

4139

1

			// 4 instructions in transact through signed

4140

1

			Some(4.into())

4141

1

));

4142

		// Root can set transact info

4143

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4144

1

			parachain::RuntimeOrigin::root(),

4145

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4146

1

			parachain::ParaTokensPerSecond::get(),

4147

1

));

4148

1

		ancestry = parachain::UniversalLocation::get().into();

4149

1

});

4150

1

4151

1

	// Let's construct the Junction that we will append with DescendOrigin

4152

1

	let signed_origin: Junctions = [AccountKey20 {

4153

1

		network: None,

4154

1

		key: PARAALICE,

4155

1

}]

4156

1

	.into();

4157

1

4158

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4159

1

	descend_origin_location.append_with(signed_origin).unwrap();

4160

1

4161

1

	// To convert it to what the paraB will see instead of us

4162

1

	descend_origin_location

4163

1

		.reanchor(&para_b_location, &ancestry.interior)

4164

1

		.unwrap();

4165

1

4166

1

	let derived = xcm_builder::HashedDescription::<

4167

1

		parachain::AccountId,

4168

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4169

1

	>::convert_location(&descend_origin_location)

4170

1

	.unwrap();

4171

1

4172

1

	let mut parachain_b_alice_balances_before = 0;

4173

1

	ParaB::execute_with(|| {

4174

1

		assert_ok!(ParaBalances::transfer_allow_death(

4175

1

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

4176

1

			derived.clone(),

4177

1

			4000000104u128,

4178

1

));

4179

		// derived account has all funds

4180

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4181

		// sovereign account has 0 funds

4182

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4183

4184

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4185

1

});

4186

1

4187

1

	// Encode the call. Balances transact to para_a_account

4188

1

	// First index

4189

1

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

4190

1

	let index =

4191

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4192

1

			.unwrap() as u8;

4193

1

4194

1

	encoded.push(index);

4195

1

4196

1

	use sp_core::U256;

4197

1

	// Let's do a EVM transfer

4198

1

	let eth_tx =

4199

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4200

1

			gas_limit: U256::from(21000),

4201

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4202

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4203

1

			value: U256::from(100),

4204

1

			input: BoundedVec::<

4205

1

u8,

4206

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4207

1

			>::try_from(vec![]).unwrap(),

4208

1

			access_list: None,

4209

1

});

4210

1

4211

1

	// Then call bytes

4212

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4213

1

		xcm_transaction: eth_tx,

4214

1

4215

1

	.encode();

4216

1

	encoded.append(&mut call_bytes);

4217

1

4218

1

	ParaA::execute_with(|| {

4219

1

		assert_ok!(XcmTransactor::transact_through_signed(

4220

1

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

4221

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4222

1

			CurrencyPayment {

4223

1

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

4224

1

					para_b_balances

4225

1

				))),

4226

1

				fee_amount: None

4227

1

},

4228

1

			encoded,

4229

1

			// 4000000000 for transfer + 4000 for XCM

4230

1

			// 1-1 to fee

4231

1

			TransactWeights {

4232

1

				transact_required_weight_at_most: 4000000000.into(),

4233

1

				overall_weight: None

4234

1

},

4235

1

			false

4236

1

));

4237

1

});

4238

1

4239

1

	ParaB::execute_with(|| {

4240

1

		// Make sure the EVM transfer went through

4241

1

		assert!(

4242

1

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

4243

1

				== parachain_b_alice_balances_before + 100

4244

1

);

4245

1

});

4246

1

4247

4248

#[test]

4249

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4250

1

	MockNet::reset();

4251

1

	let mut ancestry = Location::parent();

4252

1

4253

1

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

4254

1

4255

1

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

4256

1

4257

1

	ParaA::execute_with(|| {

4258

1

		// Root can set transact info

4259

1

		assert_ok!(XcmTransactor::set_transact_info(

4260

1

			parachain::RuntimeOrigin::root(),

4261

1

			// ParaB

4262

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4263

1

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

4264

1

			3.into(),

4265

1

			20000000000.into(),

4266

1

			// 4 instructions in transact through signed

4267

1

			Some(4.into())

4268

1

));

4269

		// Root can set transact info

4270

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4271

1

			parachain::RuntimeOrigin::root(),

4272

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4273

1

			parachain::ParaTokensPerSecond::get(),

4274

1

));

4275

1

		ancestry = parachain::UniversalLocation::get().into();

4276

1

});

4277

1

4278

1

	// Let's construct the Junction that we will append with DescendOrigin

4279

1

	let signed_origin: Junctions = [AccountKey20 {

4280

1

		network: None,

4281

1

		key: PARAALICE,

4282

1

}]

4283

1

	.into();

4284

1

4285

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4286

1

	descend_origin_location.append_with(signed_origin).unwrap();

4287

1

4288

1

	// To convert it to what the paraB will see instead of us

4289

1

	descend_origin_location

4290

1

		.reanchor(&para_b_location, &ancestry.interior)

4291

1

		.unwrap();

4292

1

4293

1

	let derived = xcm_builder::HashedDescription::<

4294

1

		parachain::AccountId,

4295

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4296

1

	>::convert_location(&descend_origin_location)

4297

1

	.unwrap();

4298

1

4299

1

	let mut parachain_b_alice_balances_before = 0;

4300

1

	ParaB::execute_with(|| {

4301

1

		assert_ok!(ParaBalances::transfer_allow_death(

4302

1

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

4303

1

			derived.clone(),

4304

1

			4000000104u128,

4305

1

));

4306

		// derived account has all funds

4307

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4308

		// sovereign account has 0 funds

4309

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4310

4311

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4312

1

});

4313

1

4314

1

	// Encode the call. Balances transact to para_a_account

4315

1

	// First index

4316

1

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

4317

1

	let index =

4318

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4319

1

			.unwrap() as u8;

4320

1

4321

1

	encoded.push(index);

4322

1

4323

1

	use sp_core::U256;

4324

1

	// Let's do a EVM transfer

4325

1

	let eth_tx =

4326

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4327

1

			gas_limit: U256::from(21000),

4328

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4329

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4330

1

			value: U256::from(100),

4331

1

			input: BoundedVec::<

4332

1

u8,

4333

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4334

1

			>::try_from(vec![]).unwrap(),

4335

1

			access_list: None,

4336

1

});

4337

1

4338

1

	// Then call bytes

4339

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4340

1

		transact_as: PARAALICE.into(),

4341

1

		xcm_transaction: eth_tx,

4342

1

4343

1

	.encode();

4344

1

	encoded.append(&mut call_bytes);

4345

1

4346

1

	ParaA::execute_with(|| {

4347

1

		assert_ok!(XcmTransactor::transact_through_signed(

4348

1

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

4349

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4350

1

			CurrencyPayment {

4351

1

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

4352

1

					para_b_balances

4353

1

				))),

4354

1

				fee_amount: None

4355

1

},

4356

1

			encoded,

4357

1

			TransactWeights {

4358

1

				transact_required_weight_at_most: 4000000000.into(),

4359

1

				overall_weight: None

4360

1

},

4361

1

			false

4362

1

));

4363

1

});

4364

1

4365

1

	ParaB::execute_with(|| {

4366

1

		// Make sure the EVM transfer wasn't executed

4367

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4368

1

});

4369

1

4370

4371

#[test]

4372

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4373

1

	MockNet::reset();

4374

1

	let mut ancestry = Location::parent();

4375

1

4376

1

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

4377

1

4378

1

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

4379

1

4380

1

	ParaA::execute_with(|| {

4381

1

		// Root can set transact info

4382

1

		assert_ok!(XcmTransactor::set_transact_info(

4383

1

			parachain::RuntimeOrigin::root(),

4384

1

			// ParaB

4385

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4386

1

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

4387

1

			3.into(),

4388

1

			20000000000.into(),

4389

1

			// 4 instructions in transact through signed

4390

1

			Some(4.into())

4391

1

));

4392

		// Root can set transact info

4393

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4394

1

			parachain::RuntimeOrigin::root(),

4395

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4396

1

			parachain::ParaTokensPerSecond::get(),

4397

1

));

4398

1

		ancestry = parachain::UniversalLocation::get().into();

4399

1

});

4400

1

4401

1

	// Let's construct the Junction that we will append with DescendOrigin

4402

1

	let signed_origin: Junctions = [AccountKey20 {

4403

1

		network: None,

4404

1

		key: PARAALICE,

4405

1

}]

4406

1

	.into();

4407

1

4408

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4409

1

	descend_origin_location.append_with(signed_origin).unwrap();

4410

1

4411

1

	// To convert it to what the paraB will see instead of us

4412

1

	descend_origin_location

4413

1

		.reanchor(&para_b_location, &ancestry.interior)

4414

1

		.unwrap();

4415

1

4416

1

	let derived = xcm_builder::HashedDescription::<

4417

1

		parachain::AccountId,

4418

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4419

1

	>::convert_location(&descend_origin_location)

4420

1

	.unwrap();

4421

1

4422

1

	let transfer_recipient = evm_account();

4423

1

	let mut transfer_recipient_balance_before = 0;

4424

1

	ParaB::execute_with(|| {

4425

1

		assert_ok!(ParaBalances::transfer_allow_death(

4426

1

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

4427

1

			derived.clone(),

4428

1

			4000000104u128,

4429

1

));

4430

		// derived account has all funds

4431

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4432

		// sovereign account has 0 funds

4433

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4434

4435

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

4436

1

4437

1

		// Add proxy ALICE  -> derived

4438

1

		let _ = parachain::Proxy::add_proxy_delegate(

4439

1

			&PARAALICE.into(),

4440

1

			derived,

4441

1

			parachain::ProxyType::Any,

4442

1

0,

4443

1

);

4444

1

});

4445

1

4446

1

	// Encode the call. Balances transact to para_a_account

4447

1

	// First index

4448

1

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

4449

1

	let index =

4450

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4451

1

			.unwrap() as u8;

4452

1

4453

1

	encoded.push(index);

4454

1

4455

1

	use sp_core::U256;

4456

1

	// Let's do a EVM transfer

4457

1

	let eth_tx =

4458

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4459

1

			gas_limit: U256::from(21000),

4460

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

4461

1

			value: U256::from(100),

4462

1

			input: BoundedVec::<

4463

1

u8,

4464

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4465

1

			>::try_from(vec![]).unwrap(),

4466

1

			access_list: None,

4467

1

});

4468

1

4469

1

	// Then call bytes

4470

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4471

1

		transact_as: PARAALICE.into(),

4472

1

		xcm_transaction: eth_tx,

4473

1

4474

1

	.encode();

4475

1

	encoded.append(&mut call_bytes);

4476

1

4477

1

	ParaA::execute_with(|| {

4478

1

		assert_ok!(XcmTransactor::transact_through_signed(

4479

1

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

4480

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4481

1

			CurrencyPayment {

4482

1

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

4483

1

					para_b_balances

4484

1

				))),

4485

1

				fee_amount: None

4486

1

},

4487

1

			encoded,

4488

1

			TransactWeights {

4489

1

				transact_required_weight_at_most: 4000000000.into(),

4490

1

				overall_weight: None

4491

1

},

4492

1

			false

4493

1

));

4494

1

});

4495

1

4496

1

	ParaB::execute_with(|| {

4497

1

		// Make sure the EVM transfer was executed

4498

1

		assert!(

4499

1

			ParaBalances::free_balance(&transfer_recipient.into())

4500

1

				== transfer_recipient_balance_before + 100

4501

1

);

4502

1

});

4503

1

4504

4505

#[test]

4506

1

fn hrmp_init_accept_through_root() {

4507

1

	MockNet::reset();

4508

1

4509

1

	Relay::execute_with(|| {

4510

1

		assert_ok!(RelayBalances::transfer_allow_death(

4511

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4512

1

			para_a_account(),

4513

1

			1000u128

4514

1

));

4515

1

		assert_ok!(RelayBalances::transfer_allow_death(

4516

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4517

1

			para_b_account(),

4518

1

			1000u128

4519

1

));

4520

1

});

4521

1

4522

1

	ParaA::execute_with(|| {

4523

1

		let total_fee = 1_000u128;

4524

1

		let total_weight: u64 = 1_000_000_000;

4525

1

		let tx_weight: u64 = 500_000_000;

4526

1

		// Root can send hrmp init channel

4527

1

		assert_ok!(XcmTransactor::hrmp_manage(

4528

1

			parachain::RuntimeOrigin::root(),

4529

1

			HrmpOperation::InitOpen(HrmpInitParams {

4530

1

				para_id: 2u32.into(),

4531

1

				proposed_max_capacity: 1,

4532

1

				proposed_max_message_size: 1

4533

1

}),

4534

1

			CurrencyPayment {

4535

1

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

4536

1

					Location::parent()

4537

1

				))),

4538

1

				fee_amount: Some(total_fee)

4539

1

},

4540

1

			TransactWeights {

4541

1

				transact_required_weight_at_most: tx_weight.into(),

4542

1

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

4543

1

4544

1

));

4545

1

});

4546

1

	Relay::execute_with(|| {

4547

1

		let expected_event: relay_chain::RuntimeEvent =

4548

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4549

1

				sender: 1u32.into(),

4550

1

				recipient: 2u32.into(),

4551

1

				proposed_max_capacity: 1u32,

4552

1

				proposed_max_message_size: 1u32,

4553

1

4554

1

			.into();

4555

1

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

4556

1

});

4557

1

	ParaB::execute_with(|| {

4558

1

		let total_fee = 1_000u128;

4559

1

		let total_weight: u64 = 1_000_000_000;

4560

1

		let tx_weight: u64 = 500_000_000;

4561

1

		// Root can send hrmp accept channel

4562

1

		assert_ok!(XcmTransactor::hrmp_manage(

4563

1

			parachain::RuntimeOrigin::root(),

4564

1

			HrmpOperation::Accept {

4565

1

				para_id: 1u32.into()

4566

1

},

4567

1

			CurrencyPayment {

4568

1

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

4569

1

					Location::parent()

4570

1

				))),

4571

1

				fee_amount: Some(total_fee)

4572

1

},

4573

1

			TransactWeights {

4574

1

				transact_required_weight_at_most: tx_weight.into(),

4575

1

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

4576

1

4577

1

));

4578

1

});

4579

1

4580

1

	Relay::execute_with(|| {

4581

1

		let expected_event: relay_chain::RuntimeEvent =

4582

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4583

1

				sender: 1u32.into(),

4584

1

				recipient: 2u32.into(),

4585

1

4586

1

			.into();

4587

1

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

4588

1

});

4589

1

4590

4591

#[test]

4592

1

fn hrmp_close_works() {

4593

1

	MockNet::reset();

4594

1

4595

1

	Relay::execute_with(|| {

4596

1

		assert_ok!(RelayBalances::transfer_allow_death(

4597

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4598

1

			para_a_account(),

4599

1

			1000u128

4600

1

));

4601

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4602

1

			relay_chain::RuntimeOrigin::root(),

4603

1

			1u32.into(),

4604

1

			2u32.into(),

4605

1

			1u32,

4606

1

			1u32

4607

1

));

4608

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4609

1

			relay_chain::RuntimeOrigin::root(),

4610

1

			1u32

4611

1

));

4612

1

});

4613

1

4614

1

	ParaA::execute_with(|| {

4615

1

		let total_fee = 1_000u128;

4616

1

		let total_weight: u64 = 1_000_000_000;

4617

1

		let tx_weight: u64 = 500_000_000;

4618

1

		// Root can send hrmp close

4619

1

		assert_ok!(XcmTransactor::hrmp_manage(

4620

1

			parachain::RuntimeOrigin::root(),

4621

1

			HrmpOperation::Close(HrmpChannelId {

4622

1

				sender: 1u32.into(),

4623

1

				recipient: 2u32.into()

4624

1

}),

4625

1

			CurrencyPayment {

4626

1

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

4627

1

					Location::parent()

4628

1

				))),

4629

1

				fee_amount: Some(total_fee)

4630

1

},

4631

1

			TransactWeights {

4632

1

				transact_required_weight_at_most: tx_weight.into(),

4633

1

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

4634

1

4635

1

));

4636

1

});

4637

1

	Relay::execute_with(|| {

4638

1

		let expected_event: relay_chain::RuntimeEvent =

4639

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4640

1

				by_parachain: 1u32.into(),

4641

1

				channel_id: HrmpChannelId {

4642

1

					sender: 1u32.into(),

4643

1

					recipient: 2u32.into(),

4644

1

},

4645

1

4646

1

			.into();

4647

1

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

4648

1

});

4649

1

4650

4651

use parity_scale_codec::{Decode, Encode};

4652

use sp_io::hashing::blake2_256;

4653

4654

// Helper to derive accountIds

4655

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4656

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4657

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4658

7