Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! 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 moonbeam_runtime::xcm_config::AssetType;

29

use pallet_xcm_transactor::{

30

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

31

};

32

use sp_core::ConstU32;

33

use sp_runtime::traits::Convert;

34

use xcm::{

35

	latest::{

36

		prelude::{

37

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

38

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

39

			WeightLimit, Xcm,

40

},

41

		Asset, AssetId, Assets as XcmAssets, Fungibility,

42

},

43

	IntoVersion, VersionedAssets, VersionedLocation, WrapVersion,

44

};

45

use xcm_executor::traits::ConvertLocation;

46

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

47

use xcm_mock::relay_chain;

48

use xcm_mock::*;

49

use xcm_primitives::{

50

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

51

};

52

use xcm_simulator::TestExt;

53

54

26

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

55

26

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

56

26

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

57

26

		.into_version(xcm::latest::VERSION)

58

26

		.map_err(|_| ())?

59

	else {

60

		return Err(());

61

};

62

	use frame_support::weights::WeightToFee as _;

63

26

	let native_amount_per_second: u128 =

64

26

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

65

26

			&Weight::from_parts(

66

26

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

67

26

0,

68

26

),

69

26

70

26

		.try_into()

71

26

		.map_err(|_| ())?;

72

26

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

73

26

	let relative_price: u128 = if units_per_second > 0u128 {

74

10

		native_amount_per_second

75

10

			.saturating_mul(precision_factor)

76

10

			.saturating_div(units_per_second)

77

	} else {

78

16

		0u128

79

};

80

26

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

81

26

		location_v5,

82

26

		(true, relative_price),

83

26

);

84

26

	Ok(())

85

26

86

87

23

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

88

23

	Asset {

89

23

		id: AssetId(

90

23

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

91

23

				currency_id,

92

23

93

23

			.unwrap(),

94

23

),

95

23

		fun: Fungibility::Fungible(amount),

96

23

97

23

98

99

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

100

#[test]

101

1

fn receive_relay_asset_from_relay() {

102

1

	MockNet::reset();

103

1

104

1

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

105

1

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

106

1

	let asset_metadata = parachain::AssetMetadata {

107

1

		name: b"RelayToken".to_vec(),

108

1

		symbol: b"Relay".to_vec(),

109

1

		decimals: 12,

110

1

};

111

1

112

1

	// Register relay asset in paraA

113

1

	ParaA::execute_with(|| {

114

1

		assert_ok!(AssetManager::register_foreign_asset(

115

1

			parachain::RuntimeOrigin::root(),

116

1

			source_location.clone(),

117

1

			asset_metadata,

118

1

			1u128,

119

1

			true

120

1

));

121

1

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

122

1

});

123

1

124

1

	// Actually send relay asset to parachain

125

1

	let dest: Location = AccountKey20 {

126

1

		network: None,

127

1

		key: PARAALICE,

128

1

129

1

	.into();

130

1

131

1

	// First send relay chain asset to Parachain

132

1

	Relay::execute_with(|| {

133

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

134

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

135

1

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

136

1

			Box::new(VersionedLocation::from(dest).clone()),

137

1

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

138

1

0,

139

1

			WeightLimit::Unlimited

140

1

));

141

1

});

142

1

143

1

	// Verify that parachain received the asset

144

1

	ParaA::execute_with(|| {

145

1

		// free execution, full amount received

146

1

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

147

1

});

148

1

149

150

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

151

#[test]

152

1

fn send_relay_asset_to_relay() {

153

1

	MockNet::reset();

154

1

155

1

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

156

1

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

157

1

158

1

	let asset_metadata = parachain::AssetMetadata {

159

1

		name: b"RelayToken".to_vec(),

160

1

		symbol: b"Relay".to_vec(),

161

1

		decimals: 12,

162

1

};

163

1

164

1

	// Register relay asset in paraA

165

1

	ParaA::execute_with(|| {

166

1

		assert_ok!(AssetManager::register_foreign_asset(

167

1

			parachain::RuntimeOrigin::root(),

168

1

			source_location.clone(),

169

1

			asset_metadata,

170

1

			1u128,

171

1

			true

172

1

));

173

		// Free execution

174

1

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

175

1

});

176

1

177

1

	let dest: Location = Junction::AccountKey20 {

178

1

		network: None,

179

1

		key: PARAALICE,

180

1

181

1

	.into();

182

1

183

1

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

184

1

	Relay::execute_with(|| {

185

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

186

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

187

1

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

188

1

			Box::new(VersionedLocation::from(dest).clone()),

189

1

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

190

1

0,

191

1

			WeightLimit::Unlimited

192

1

));

193

1

});

194

1

195

1

	ParaA::execute_with(|| {

196

1

		// Free execution, full amount received

197

1

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

198

1

});

199

1

200

1

	// Lets gather the balance before sending back money

201

1

	let mut balance_before_sending = 0;

202

1

	Relay::execute_with(|| {

203

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

204

1

});

205

1

206

1

	// We now send back some money to the relay

207

1

	let dest = Location {

208

1

		parents: 1,

209

1

		interior: [AccountId32 {

210

1

			network: None,

211

1

			id: RELAYALICE.into(),

212

1

}]

213

1

		.into(),

214

1

};

215

1

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

216

1

	ParaA::execute_with(|| {

217

1

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

218

1

		assert_ok!(PolkadotXcm::transfer_assets(

219

1

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

220

1

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

221

1

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

222

1

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

223

1

0,

224

1

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

225

1

));

226

1

});

227

1

228

1

	// The balances in paraAlice should have been substracted

229

1

	ParaA::execute_with(|| {

230

1

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

231

1

});

232

1

233

1

	// Balances in the relay should have been received

234

1

	Relay::execute_with(|| {

235

1

		// free execution,x	 full amount received

236

1

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

237

1

});

238

1

239

240

#[test]

241

1

fn send_relay_asset_to_para_b() {

242

1

	MockNet::reset();

243

1

244

1

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

245

1

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

246

1

247

1

	let asset_metadata = parachain::AssetMetadata {

248

1

		name: b"RelayToken".to_vec(),

249

1

		symbol: b"Relay".to_vec(),

250

1

		decimals: 12,

251

1

};

252

1

253

1

	// Register asset in paraA. Free execution

254

1

	ParaA::execute_with(|| {

255

1

		assert_ok!(AssetManager::register_foreign_asset(

256

1

			parachain::RuntimeOrigin::root(),

257

1

			source_location.clone(),

258

1

			asset_metadata.clone(),

259

1

			1u128,

260

1

			true

261

1

));

262

1

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

263

1

});

264

1

265

1

	// Register asset in paraB. Free execution

266

1

	ParaB::execute_with(|| {

267

1

		assert_ok!(AssetManager::register_foreign_asset(

268

1

			parachain::RuntimeOrigin::root(),

269

1

			source_location.clone(),

270

1

			asset_metadata,

271

1

			1u128,

272

1

			true

273

1

));

274

1

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

275

1

});

276

1

277

1

	let dest: Location = Junction::AccountKey20 {

278

1

		network: None,

279

1

		key: PARAALICE,

280

1

281

1

	.into();

282

1

	Relay::execute_with(|| {

283

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

284

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

285

1

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

286

1

			Box::new(VersionedLocation::from(dest).clone()),

287

1

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

288

1

0,

289

1

			WeightLimit::Unlimited

290

1

));

291

1

});

292

1

293

1

	ParaA::execute_with(|| {

294

1

		// free execution, full amount received

295

1

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

296

1

});

297

1

298

1

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

299

1

	let dest = Location {

300

1

		parents: 1,

301

1

		interior: [

302

1

			Parachain(2),

303

1

			AccountKey20 {

304

1

				network: None,

305

1

				key: PARAALICE.into(),

306

1

},

307

1

308

1

		.into(),

309

1

};

310

1

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

311

1

	ParaA::execute_with(|| {

312

1

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

313

1

		assert_ok!(PolkadotXcm::transfer_assets(

314

1

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

315

1

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

316

1

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

317

1

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

318

1

0,

319

1

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

320

1

));

321

1

});

322

1

323

1

	// Para A balances should have been substracted

324

1

	ParaA::execute_with(|| {

325

1

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

326

1

});

327

1

328

1

	// Para B balances should have been credited

329

1

	ParaB::execute_with(|| {

330

1

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

331

1

});

332

1

333

334

#[test]

335

1

fn send_para_a_asset_to_para_b() {

336

1

	MockNet::reset();

337

1

338

1

	// This represents the asset in paraA

339

1

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

340

1

	let source_location: AssetType = para_a_balances

341

1

		.try_into()

342

1

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

343

1

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

344

1

345

1

	let asset_metadata = parachain::AssetMetadata {

346

1

		name: b"ParaAToken".to_vec(),

347

1

		symbol: b"ParaA".to_vec(),

348

1

		decimals: 18,

349

1

};

350

1

351

1

	// Register asset in paraB. Free execution

352

1

	ParaB::execute_with(|| {

353

1

		assert_ok!(AssetManager::register_foreign_asset(

354

1

			parachain::RuntimeOrigin::root(),

355

1

			source_location.clone(),

356

1

			asset_metadata,

357

1

			1u128,

358

1

			true

359

1

));

360

1

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

361

1

});

362

1

363

1

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

364

1

	let dest = Location {

365

1

		parents: 1,

366

1

		interior: [

367

1

			Parachain(2),

368

1

			AccountKey20 {

369

1

				network: None,

370

1

				key: PARAALICE.into(),

371

1

},

372

1

373

1

		.into(),

374

1

};

375

1

376

1

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

377

1

	// Native token is substracted in paraA

378

1

	ParaA::execute_with(|| {

379

1

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

380

1

		// Free execution, full amount received

381

1

		assert_ok!(PolkadotXcm::transfer_assets(

382

1

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

383

1

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

384

1

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

385

1

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

386

1

0,

387

1

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

388

1

));

389

1

});

390

1

391

1

	ParaA::execute_with(|| {

392

1

		assert_eq!(

393

1

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

394

1

			INITIAL_BALANCE - 100

395

1

);

396

1

});

397

1

398

1

	// Asset is minted in paraB

399

1

	ParaB::execute_with(|| {

400

1

		// Free execution, full amount received

401

1

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

402

1

});

403

1

404

405

#[test]

406

1

fn send_para_a_asset_from_para_b_to_para_c() {

407

1

	MockNet::reset();

408

1

409

1

	// Represents para A asset

410

1

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

411

1

	let source_location: AssetType = para_a_balances

412

1

		.try_into()

413

1

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

414

1

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

415

1

416

1

	let asset_metadata = parachain::AssetMetadata {

417

1

		name: b"ParaAToken".to_vec(),

418

1

		symbol: b"ParaA".to_vec(),

419

1

		decimals: 18,

420

1

};

421

1

422

1

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

423

1

	ParaB::execute_with(|| {

424

1

		assert_ok!(AssetManager::register_foreign_asset(

425

1

			parachain::RuntimeOrigin::root(),

426

1

			source_location.clone(),

427

1

			asset_metadata.clone(),

428

1

			1u128,

429

1

			true

430

1

));

431

1

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

432

1

});

433

1

434

1

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

435

1

	ParaC::execute_with(|| {

436

1

		assert_ok!(AssetManager::register_foreign_asset(

437

1

			parachain::RuntimeOrigin::root(),

438

1

			source_location.clone(),

439

1

			asset_metadata,

440

1

			1u128,

441

1

			true

442

1

));

443

1

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

444

1

});

445

1

446

1

	let dest = Location {

447

1

		parents: 1,

448

1

		interior: [

449

1

			Parachain(2),

450

1

			AccountKey20 {

451

1

				network: None,

452

1

				key: PARAALICE.into(),

453

1

},

454

1

455

1

		.into(),

456

1

};

457

1

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

458

1

	ParaA::execute_with(|| {

459

1

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

460

1

		assert_ok!(PolkadotXcm::transfer_assets(

461

1

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

462

1

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

463

1

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

464

1

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

465

1

0,

466

1

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

467

1

));

468

1

});

469

1

470

1

	// Para A balances have been substracted

471

1

	ParaA::execute_with(|| {

472

1

		assert_eq!(

473

1

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

474

1

			INITIAL_BALANCE - 100

475

1

);

476

1

});

477

1

478

1

	// Para B balances have been credited

479

1

	ParaB::execute_with(|| {

480

1

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

481

1

});

482

1

483

1

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

484

1

	let dest = Location {

485

1

		parents: 1,

486

1

		interior: [

487

1

			Parachain(3),

488

1

			AccountKey20 {

489

1

				network: None,

490

1

				key: PARAALICE.into(),

491

1

},

492

1

493

1

		.into(),

494

1

};

495

1

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

496

1

	ParaB::execute_with(|| {

497

1

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

498

1

		assert_ok!(PolkadotXcm::transfer_assets(

499

1

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

500

1

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

501

1

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

502

1

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

503

1

0,

504

1

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

505

1

));

506

1

});

507

1

508

1

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

509

1

	ParaC::execute_with(|| {

510

1

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

511

1

});

512

1

513

514

#[test]

515

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

516

1

	MockNet::reset();

517

1

518

1

	// para A asset

519

1

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

520

1

	let source_location: AssetType = para_a_balances

521

1

		.try_into()

522

1

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

523

1

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

524

1

525

1

	let asset_metadata = parachain::AssetMetadata {

526

1

		name: b"ParaAToken".to_vec(),

527

1

		symbol: b"ParaA".to_vec(),

528

1

		decimals: 18,

529

1

};

530

1

531

1

	// Register para A asset in para B

532

1

	ParaB::execute_with(|| {

533

1

		assert_ok!(AssetManager::register_foreign_asset(

534

1

			parachain::RuntimeOrigin::root(),

535

1

			source_location.clone(),

536

1

			asset_metadata,

537

1

			1u128,

538

1

			true

539

1

));

540

1

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

541

1

});

542

1

543

1

	// Send para A asset to para B

544

1

	let dest = Location {

545

1

		parents: 1,

546

1

		interior: [

547

1

			Parachain(2),

548

1

			AccountKey20 {

549

1

				network: None,

550

1

				key: PARAALICE.into(),

551

1

},

552

1

553

1

		.into(),

554

1

};

555

1

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

556

1

	ParaA::execute_with(|| {

557

1

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

558

1

		assert_ok!(PolkadotXcm::transfer_assets(

559

1

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

560

1

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

561

1

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

562

1

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

563

1

0,

564

1

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

565

1

));

566

1

});

567

1

568

1

	// Balances have been substracted

569

1

	ParaA::execute_with(|| {

570

1

		assert_eq!(

571

1

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

572

1

			INITIAL_BALANCE - 100

573

1

);

574

1

});

575

1

576

1

	// Para B balances have been credited

577

1

	ParaB::execute_with(|| {

578

1

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

579

1

});

580

1

581

1

	// Send back para A asset to para A

582

1

	let dest = Location {

583

1

		parents: 1,

584

1

		interior: [

585

1

			Parachain(1),

586

1

			AccountKey20 {

587

1

				network: None,

588

1

				key: PARAALICE.into(),

589

1

},

590

1

591

1

		.into(),

592

1

};

593

1

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

594

1

	ParaB::execute_with(|| {

595

1

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

596

1

		assert_ok!(PolkadotXcm::transfer_assets(

597

1

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

598

1

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

599

1

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

600

1

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

601

1

0,

602

1

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

603

1

));

604

1

});

605

1

606

1

	ParaA::execute_with(|| {

607

1

		// Weight used is 4

608

1

		assert_eq!(

609

1

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

610

1

			INITIAL_BALANCE - 4

611

1

);

612

1

});

613

1

614

615

#[test]

616

1

fn receive_relay_asset_with_trader() {

617

1

	MockNet::reset();

618

1

619

1

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

620

1

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

621

1

622

1

	let asset_metadata = parachain::AssetMetadata {

623

1

		name: b"RelayToken".to_vec(),

624

1

		symbol: b"Relay".to_vec(),

625

1

		decimals: 12,

626

1

};

627

1

628

1

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

629

1

	// we know later we will divide by 1e12

630

1

	// Lets put 1e6 as units per second

631

1

	ParaA::execute_with(|| {

632

1

		assert_ok!(AssetManager::register_foreign_asset(

633

1

			parachain::RuntimeOrigin::root(),

634

1

			source_location.clone(),

635

1

			asset_metadata,

636

1

			1u128,

637

1

			true

638

1

));

639

1

		assert_ok!(add_supported_asset(

640

1

			source_location.clone(),

641

1

			2500000000000u128

642

1

));

643

1

});

644

1

645

1

	let dest: Location = Junction::AccountKey20 {

646

1

		network: None,

647

1

		key: PARAALICE,

648

1

649

1

	.into();

650

1

	// We are sending 100 tokens from relay.

651

1

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

652

1

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

653

1

	// Units per second should be 2_500_000_000_000_000

654

1

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

655

1

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

656

1

	Relay::execute_with(|| {

657

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

658

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

659

1

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

660

1

			Box::new(VersionedLocation::from(dest).clone()),

661

1

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

662

1

0,

663

1

			WeightLimit::Unlimited

664

1

));

665

1

});

666

1

667

1

	ParaA::execute_with(|| {

668

1

		// non-free execution, not full amount received

669

1

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

670

		// Fee should have been received by treasury

671

1

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

672

1

});

673

1

674

675

#[test]

676

1

fn send_para_a_asset_to_para_b_with_trader() {

677

1

	MockNet::reset();

678

1

679

1

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

680

1

	let source_location: AssetType = para_a_balances

681

1

		.try_into()

682

1

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

683

1

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

684

1

685

1

	let asset_metadata = parachain::AssetMetadata {

686

1

		name: b"ParaAToken".to_vec(),

687

1

		symbol: b"ParaA".to_vec(),

688

1

		decimals: 18,

689

1

};

690

1

691

1

	ParaB::execute_with(|| {

692

1

		assert_ok!(AssetManager::register_foreign_asset(

693

1

			parachain::RuntimeOrigin::root(),

694

1

			source_location.clone(),

695

1

			asset_metadata,

696

1

			1u128,

697

1

			true

698

1

));

699

1

		assert_ok!(add_supported_asset(

700

1

			source_location.clone(),

701

1

			2500000000000u128

702

1

));

703

1

});

704

1

705

1

	let dest = Location {

706

1

		parents: 1,

707

1

		interior: [

708

1

			Parachain(2),

709

1

			AccountKey20 {

710

1

				network: None,

711

1

				key: PARAALICE.into(),

712

1

},

713

1

714

1

		.into(),

715

1

};

716

1

717

1

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

718

1

	// In destination chain, we only need 4 weight

719

1

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

720

1

	ParaA::execute_with(|| {

721

1

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

722

1

		assert_ok!(PolkadotXcm::transfer_assets(

723

1

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

724

1

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

725

1

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

726

1

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

727

1

0,

728

1

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

729

1

));

730

1

});

731

1

	ParaA::execute_with(|| {

732

1

		// free execution, full amount received

733

1

		assert_eq!(

734

1

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

735

1

			INITIAL_BALANCE - 100

736

1

);

737

1

});

738

1

739

1

	// We are sending 100 tokens from para A.

740

1

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

741

1

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

742

1

	// Units per second should be 2_500_000_000_000_000

743

1

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

744

1

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

745

1

	// will be 4

746

1

	ParaB::execute_with(|| {

747

1

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

748

		// Fee should have been received by treasury

749

1

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

750

1

});

751

1

752

753

#[test]

754

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

755

1

	MockNet::reset();

756

1

757

1

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

758

1

	let source_location: AssetType = para_a_balances

759

1

		.try_into()

760

1

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

761

1

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

762

1

763

1

	let asset_metadata = parachain::AssetMetadata {

764

1

		name: b"ParaAToken".to_vec(),

765

1

		symbol: b"ParaA".to_vec(),

766

1

		decimals: 18,

767

1

};

768

1

769

1

	ParaB::execute_with(|| {

770

1

		assert_ok!(AssetManager::register_foreign_asset(

771

1

			parachain::RuntimeOrigin::root(),

772

1

			source_location.clone(),

773

1

			asset_metadata,

774

1

			1u128,

775

1

			true

776

1

));

777

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

778

1

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

779

1

});

780

1

781

1

	let dest = Location {

782

1

		parents: 1,

783

1

		interior: [

784

1

			Parachain(2),

785

1

			AccountKey20 {

786

1

				network: None,

787

1

				key: PARAALICE.into(),

788

1

},

789

1

790

1

		.into(),

791

1

};

792

1

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

793

1

	// we use transfer_with_fee

794

1

	ParaA::execute_with(|| {

795

1

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

796

1

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

797

1

		assert_ok!(PolkadotXcm::transfer_assets(

798

1

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

799

1

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

800

1

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

801

1

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

802

1

0,

803

1

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

804

1

));

805

1

});

806

1

	ParaA::execute_with(|| {

807

1

		// 100 tokens transferred plus 1 taken from fees

808

1

		assert_eq!(

809

1

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

810

1

			INITIAL_BALANCE - 100 - 1

811

1

);

812

1

});

813

1

814

1

	ParaB::execute_with(|| {

815

1

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

816

1

		// what it is specified

817

1

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

818

1

});

819

1

820

821

#[test]

822

1

fn error_when_not_paying_enough() {

823

1

	MockNet::reset();

824

1

825

1

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

826

1

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

827

1

828

1

	let asset_metadata = parachain::AssetMetadata {

829

1

		name: b"RelayToken".to_vec(),

830

1

		symbol: b"Relay".to_vec(),

831

1

		decimals: 12,

832

1

};

833

1

834

1

	let dest: Location = Junction::AccountKey20 {

835

1

		network: None,

836

1

		key: PARAALICE,

837

1

838

1

	.into();

839

1

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

840

1

	// we know later we will divide by 1e12

841

1

	// Lets put 1e6 as units per second

842

1

	ParaA::execute_with(|| {

843

1

		assert_ok!(AssetManager::register_foreign_asset(

844

1

			parachain::RuntimeOrigin::root(),

845

1

			source_location.clone(),

846

1

			asset_metadata,

847

1

			1u128,

848

1

			true

849

1

));

850

1

		assert_ok!(add_supported_asset(

851

1

			source_location.clone(),

852

1

			2500000000000u128

853

1

));

854

1

});

855

1

856

1

	// We are sending 100 tokens from relay.

857

1

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

858

1

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

859

1

	Relay::execute_with(|| {

860

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

861

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

862

1

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

863

1

			Box::new(VersionedLocation::from(dest).clone()),

864

1

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

865

1

0,

866

1

			WeightLimit::Unlimited

867

1

));

868

1

});

869

1

870

1

	ParaA::execute_with(|| {

871

1

		// amount not received as it is not paying enough

872

1

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

873

1

});

874

1

875

876

#[test]

877

1

fn transact_through_derivative_multilocation() {

878

1

	MockNet::reset();

879

1

880

1

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

881

1

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

882

1

883

1

	let asset_metadata = parachain::AssetMetadata {

884

1

		name: b"RelayToken".to_vec(),

885

1

		symbol: b"Relay".to_vec(),

886

1

		decimals: 12,

887

1

};

888

1

889

1

	ParaA::execute_with(|| {

890

1

		assert_ok!(AssetManager::register_foreign_asset(

891

1

			parachain::RuntimeOrigin::root(),

892

1

			source_location.clone(),

893

1

			asset_metadata,

894

1

			1u128,

895

1

			true

896

1

));

897

1

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

898

899

		// Root can set transact info

900

1

		assert_ok!(XcmTransactor::set_transact_info(

901

1

			parachain::RuntimeOrigin::root(),

902

1

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

903

1

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

904

1

			3000.into(),

905

1

			20000000000.into(),

906

1

			None

907

1

));

908

		// Root can set transact info

909

1

		assert_ok!(XcmTransactor::set_fee_per_second(

910

1

			parachain::RuntimeOrigin::root(),

911

1

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

912

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

913

1

));

914

1

});

915

1

916

1

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

917

1

918

1

	let dest: Location = AccountKey20 {

919

1

		network: None,

920

1

		key: PARAALICE,

921

1

922

1

	.into();

923

1

	Relay::execute_with(|| {

924

1

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

925

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

926

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

927

1

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

928

1

			Box::new(VersionedLocation::from(dest).clone()),

929

1

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

930

1

0,

931

1

			WeightLimit::Unlimited

932

1

));

933

1

});

934

1

935

1

	ParaA::execute_with(|| {

936

1

		// free execution, full amount received

937

1

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

938

1

});

939

1

940

1

	// Register address

941

1

	ParaA::execute_with(|| {

942

1

		assert_ok!(XcmTransactor::register(

943

1

			parachain::RuntimeOrigin::root(),

944

1

			PARAALICE.into(),

945

1

0,

946

1

));

947

1

});

948

1

949

1

	// Send to registered address

950

1

951

1

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

952

1

	let dest = Location {

953

1

		parents: 1,

954

1

		interior: [AccountId32 {

955

1

			network: None,

956

1

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

957

1

}]

958

1

		.into(),

959

1

};

960

1

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

961

1

962

1

	ParaA::execute_with(|| {

963

1

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

964

1

		// free execution, full amount received

965

1

		assert_ok!(PolkadotXcm::transfer_assets(

966

1

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

967

1

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

968

1

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

969

1

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

970

1

0,

971

1

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

972

1

));

973

1

});

974

1

975

1

	ParaA::execute_with(|| {

976

1

		// free execution, full amount received

977

1

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

978

1

});

979

1

980

1

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

981

1

	// again

982

1

	Relay::execute_with(|| {

983

1

		// free execution,x	 full amount received

984

1

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

985

1

});

986

1

987

1

	// Encode the call. Balances transact to para_a_account

988

1

	// First index

989

1

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

990

1

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

991

1

		relay_chain::Balances,

992

1

>()

993

1

	.unwrap() as u8;

994

1

995

1

	encoded.push(index);

996

1

997

1

	// Then call bytes

998

1

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

999

1

		dest: para_a_account(),

1000

1

		value: 100u32.into(),

1001

1

1002

1

	.encode();

1003

1

	encoded.append(&mut call_bytes);

1004

1

1005

1

	ParaA::execute_with(|| {

1006

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1007

1

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

1008

1

			parachain::MockTransactors::Relay,

1009

1

0,

1010

1

			CurrencyPayment {

1011

1

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

1012

1

					Location::parent()

1013

1

				))),

1014

1

				fee_amount: None

1015

1

},

1016

1

			encoded,

1017

1

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

1018

1

			TransactWeights {

1019

1

				transact_required_weight_at_most: 4000000000.into(),

1020

1

				overall_weight: None

1021

1

},

1022

1

			false

1023

1

));

1024

1

});

1025

1

1026

1

	Relay::execute_with(|| {

1027

1

		// free execution,x	 full amount received

1028

1

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

1029

1030

1

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

1031

1

});

1032

1

1033

1034

#[test]

1035

1

fn transact_through_derivative_with_custom_fee_weight() {

1036

1

	MockNet::reset();

1037

1

1038

1

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

1039

1

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

1040

1

1041

1

	let asset_metadata = parachain::AssetMetadata {

1042

1

		name: b"RelayToken".to_vec(),

1043

1

		symbol: b"Relay".to_vec(),

1044

1

		decimals: 12,

1045

1

};

1046

1

1047

1

	ParaA::execute_with(|| {

1048

1

		assert_ok!(AssetManager::register_foreign_asset(

1049

1

			parachain::RuntimeOrigin::root(),

1050

1

			source_location.clone(),

1051

1

			asset_metadata,

1052

1

			1u128,

1053

1

			true

1054

1

));

1055

1

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

1056

1

});

1057

1

1058

1

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

1059

1

1060

1

	let dest: Location = AccountKey20 {

1061

1

		network: None,

1062

1

		key: PARAALICE,

1063

1

1064

1

	.into();

1065

1

	Relay::execute_with(|| {

1066

1

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

1067

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1068

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1069

1

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

1070

1

			Box::new(VersionedLocation::from(dest).clone()),

1071

1

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

1072

1

0,

1073

1

			WeightLimit::Unlimited

1074

1

));

1075

1

});

1076

1

1077

1

	ParaA::execute_with(|| {

1078

1

		// free execution, full amount received

1079

1

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

1080

1

});

1081

1

1082

1

	// Register address

1083

1

	ParaA::execute_with(|| {

1084

1

		assert_ok!(XcmTransactor::register(

1085

1

			parachain::RuntimeOrigin::root(),

1086

1

			PARAALICE.into(),

1087

1

0,

1088

1

));

1089

1

});

1090

1

1091

1

	// Send to registered address

1092

1

1093

1

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

1094

1

	let dest = Location {

1095

1

		parents: 1,

1096

1

		interior: [AccountId32 {

1097

1

			network: None,

1098

1

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

1099

1

}]

1100

1

		.into(),

1101

1

};

1102

1

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

1103

1

1104

1

	ParaA::execute_with(|| {

1105

1

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

1106

1

		// free execution, full amount received

1107

1

		assert_ok!(PolkadotXcm::transfer_assets(

1108

1

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

1109

1

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

1110

1

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

1111

1

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

1112

1

0,

1113

1

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

1114

1

));

1115

1

});

1116

1

1117

1

	ParaA::execute_with(|| {

1118

1

		// free execution, full amount received

1119

1

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

1120

1

});

1121

1

1122

1

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

1123

1

	// again

1124

1

	Relay::execute_with(|| {

1125

1

		// free execution,x	 full amount received

1126

1

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

1127

1

});

1128

1

1129

1

	// Encode the call. Balances transact to para_a_account

1130

1

	// First index

1131

1

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

1132

1

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

1133

1

		relay_chain::Balances,

1134

1

>()

1135

1

	.unwrap() as u8;

1136

1

1137

1

	encoded.push(index);

1138

1

1139

1

	// Then call bytes

1140

1

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

1141

1

		dest: para_a_account(),

1142

1

		value: 100u32.into(),

1143

1

1144

1

	.encode();

1145

1

	encoded.append(&mut call_bytes);

1146

1

1147

1

	let overall_weight = 4000003000u64;

1148

1

	ParaA::execute_with(|| {

1149

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1150

1

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

1151

1

			parachain::MockTransactors::Relay,

1152

1

0,

1153

1

			CurrencyPayment {

1154

1

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

1155

1

					Location::parent()

1156

1

				))),

1157

1

				// 1-1 fee weight mapping

1158

1

				fee_amount: Some(overall_weight as u128)

1159

1

},

1160

1

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

1161

1

			encoded,

1162

1

			TransactWeights {

1163

1

				transact_required_weight_at_most: 4000000000.into(),

1164

1

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

1165

1

},

1166

1

			false

1167

1

));

1168

1

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

1169

1

			.iter()

1170

12

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

1171

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

1172

..

1173

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

1174

12

				_ => None,

1175

12

});

1176

1

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

1177

1

		assert!(event_found.is_none());

1178

1

});

1179

1

1180

1

	Relay::execute_with(|| {

1181

1

		// free execution,x	 full amount received

1182

1

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

1183

1184

1

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

1185

1

});

1186

1

1187

1188

#[test]

1189

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1190

1

	MockNet::reset();

1191

1

1192

1

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

1193

1

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

1194

1

1195

1

	let asset_metadata = parachain::AssetMetadata {

1196

1

		name: b"RelayToken".to_vec(),

1197

1

		symbol: b"Relay".to_vec(),

1198

1

		decimals: 12,

1199

1

};

1200

1

1201

1

	ParaA::execute_with(|| {

1202

1

		assert_ok!(AssetManager::register_foreign_asset(

1203

1

			parachain::RuntimeOrigin::root(),

1204

1

			source_location.clone(),

1205

1

			asset_metadata,

1206

1

			1u128,

1207

1

			true

1208

1

));

1209

1

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

1210

1

});

1211

1

1212

1

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

1213

1

1214

1

	let dest: Location = AccountKey20 {

1215

1

		network: None,

1216

1

		key: PARAALICE,

1217

1

1218

1

	.into();

1219

1

	Relay::execute_with(|| {

1220

1

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

1221

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1222

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1223

1

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

1224

1

			Box::new(VersionedLocation::from(dest).clone()),

1225

1

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

1226

1

0,

1227

1

			WeightLimit::Unlimited

1228

1

));

1229

1

});

1230

1

1231

1

	ParaA::execute_with(|| {

1232

1

		// free execution, full amount received

1233

1

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

1234

1

});

1235

1

1236

1

	// Register address

1237

1

	ParaA::execute_with(|| {

1238

1

		assert_ok!(XcmTransactor::register(

1239

1

			parachain::RuntimeOrigin::root(),

1240

1

			PARAALICE.into(),

1241

1

0,

1242

1

));

1243

1

});

1244

1

1245

1

	// Send to registered address

1246

1

1247

1

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

1248

1

	let dest = Location {

1249

1

		parents: 1,

1250

1

		interior: [AccountId32 {

1251

1

			network: None,

1252

1

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

1253

1

}]

1254

1

		.into(),

1255

1

};

1256

1

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

1257

1

1258

1

	ParaA::execute_with(|| {

1259

1

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

1260

1

		// free execution, full amount received

1261

1

		assert_ok!(PolkadotXcm::transfer_assets(

1262

1

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

1263

1

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

1264

1

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

1265

1

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

1266

1

0,

1267

1

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

1268

1

));

1269

1

});

1270

1

1271

1

	ParaA::execute_with(|| {

1272

1

		// free execution, full amount received

1273

1

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

1274

1

});

1275

1

1276

1

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

1277

1

	// again

1278

1

	Relay::execute_with(|| {

1279

1

		// free execution,x	 full amount received

1280

1

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

1281

1

});

1282

1

1283

1

	// Encode the call. Balances transact to para_a_account

1284

1

	// First index

1285

1

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

1286

1

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

1287

1

		relay_chain::Balances,

1288

1

>()

1289

1

	.unwrap() as u8;

1290

1

1291

1

	encoded.push(index);

1292

1

1293

1

	// Then call bytes

1294

1

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

1295

1

		dest: para_a_account(),

1296

1

		value: 100u32.into(),

1297

1

1298

1

	.encode();

1299

1

	encoded.append(&mut call_bytes);

1300

1

1301

1

	let overall_weight = 4000009000u64;

1302

1

	ParaA::execute_with(|| {

1303

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1304

1

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

1305

1

			parachain::MockTransactors::Relay,

1306

1

0,

1307

1

			CurrencyPayment {

1308

1

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

1309

1

					Location::parent()

1310

1

				))),

1311

1

				// 1-1 fee weight mapping

1312

1

				fee_amount: Some(overall_weight as u128)

1313

1

},

1314

1

			encoded,

1315

1

			TransactWeights {

1316

1

				transact_required_weight_at_most: 4000000000.into(),

1317

1

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

1318

1

},

1319

1

			true

1320

1

));

1321

1

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

1322

1

			.iter()

1323

12

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

1324

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

1325

..

1326

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

1327

12

				_ => None,

1328

12

});

1329

1

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

1330

1

		assert!(event_found.is_none());

1331

1

});

1332

1

1333

1

	Relay::execute_with(|| {

1334

1

		// free execution,x	 full amount received

1335

1

		// 4000009000 refunded + 100 transferred = 4000009100

1336

1

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

1337

1

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

1338

1

});

1339

1

1340

1341

#[test]

1342

1

fn transact_through_sovereign() {

1343

1

	MockNet::reset();

1344

1

1345

1

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

1346

1

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

1347

1

1348

1

	let asset_metadata = parachain::AssetMetadata {

1349

1

		name: b"RelayToken".to_vec(),

1350

1

		symbol: b"Relay".to_vec(),

1351

1

		decimals: 12,

1352

1

};

1353

1

1354

1

	ParaA::execute_with(|| {

1355

1

		assert_ok!(AssetManager::register_foreign_asset(

1356

1

			parachain::RuntimeOrigin::root(),

1357

1

			source_location.clone(),

1358

1

			asset_metadata,

1359

1

			1u128,

1360

1

			true

1361

1

));

1362

1

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

1363

1364

		// Root can set transact info

1365

1

		assert_ok!(XcmTransactor::set_transact_info(

1366

1

			parachain::RuntimeOrigin::root(),

1367

1

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

1368

1

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

1369

1

			3000.into(),

1370

1

			20000000000.into(),

1371

1

			None

1372

1

));

1373

		// Root can set transact info

1374

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1375

1

			parachain::RuntimeOrigin::root(),

1376

1

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

1377

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1378

1

));

1379

1

});

1380

1

1381

1

	let dest: Location = AccountKey20 {

1382

1

		network: None,

1383

1

		key: PARAALICE,

1384

1

1385

1

	.into();

1386

1

	Relay::execute_with(|| {

1387

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1388

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1389

1

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

1390

1

			Box::new(VersionedLocation::from(dest).clone()),

1391

1

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

1392

1

0,

1393

1

			WeightLimit::Unlimited

1394

1

));

1395

1

});

1396

1

1397

1

	ParaA::execute_with(|| {

1398

1

		// free execution, full amount received

1399

1

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

1400

1

});

1401

1

1402

1

	// Register address

1403

1

	ParaA::execute_with(|| {

1404

1

		assert_ok!(XcmTransactor::register(

1405

1

			parachain::RuntimeOrigin::root(),

1406

1

			PARAALICE.into(),

1407

1

0,

1408

1

));

1409

1

});

1410

1

1411

1

	// Send to registered address

1412

1

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

1413

1

	let dest = Location {

1414

1

		parents: 1,

1415

1

		interior: [AccountId32 {

1416

1

			network: None,

1417

1

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

1418

1

}]

1419

1

		.into(),

1420

1

};

1421

1

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

1422

1

1423

1

	ParaA::execute_with(|| {

1424

1

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

1425

1

		// free execution, full amount received

1426

1

		assert_ok!(PolkadotXcm::transfer_assets(

1427

1

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

1428

1

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

1429

1

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

1430

1

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

1431

1

0,

1432

1

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

1433

1

));

1434

1

});

1435

1

1436

1

	ParaA::execute_with(|| {

1437

1

		// free execution, full amount received

1438

1

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

1439

1

});

1440

1

1441

1

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

1442

1

	// again

1443

1

	Relay::execute_with(|| {

1444

1

		// free execution,x	 full amount received

1445

1

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

1446

1

1447

1

});

1448

1

1449

1

	// We send the xcm transact operation to parent

1450

1

	let dest = Location {

1451

1

		parents: 1,

1452

1

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

1453

1

};

1454

1

1455

1

	// Encode the call. Balances transact to para_a_account

1456

1

	// First index

1457

1

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

1458

1

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

1459

1

		relay_chain::Balances,

1460

1

>()

1461

1

	.unwrap() as u8;

1462

1

1463

1

	encoded.push(index);

1464

1

1465

1

	// Then call bytes

1466

1

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

1467

1

		dest: para_a_account(),

1468

1

		value: 100u32.into(),

1469

1

1470

1

	.encode();

1471

1

	encoded.append(&mut call_bytes);

1472

1

1473

1

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

1474

1

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

1475

1

);

1476

1

1477

1

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

1478

1

	ParaA::execute_with(|| {

1479

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1480

1

			parachain::RuntimeOrigin::root(),

1481

1

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

1482

1

			Some(PARAALICE.into()),

1483

1

			CurrencyPayment {

1484

1

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

1485

1

					Location::parent()

1486

1

				))),

1487

1

				fee_amount: None

1488

1

},

1489

1

			utility_bytes,

1490

1

			OriginKind::SovereignAccount,

1491

1

			TransactWeights {

1492

1

				transact_required_weight_at_most: 4000000000.into(),

1493

1

				overall_weight: None

1494

1

},

1495

1

			false

1496

1

));

1497

1

});

1498

1

1499

1

	Relay::execute_with(|| {

1500

1

		// free execution,x	 full amount received

1501

1

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

1502

1503

1

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

1504

1

});

1505

1

1506

1507

#[test]

1508

1

fn transact_through_sovereign_fee_payer_none() {

1509

1

	MockNet::reset();

1510

1

1511

1

	ParaA::execute_with(|| {

1512

1

		// Root can set transact info

1513

1

		assert_ok!(XcmTransactor::set_transact_info(

1514

1

			parachain::RuntimeOrigin::root(),

1515

1

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

1516

1

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

1517

1

			3000.into(),

1518

1

			20000000000.into(),

1519

1

			None

1520

1

));

1521

		// Root can set transact info

1522

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1523

1

			parachain::RuntimeOrigin::root(),

1524

1

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

1525

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1526

1

));

1527

1

});

1528

1

1529

1

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

1530

1

1531

1

	Relay::execute_with(|| {

1532

1

		// Transfer 100 tokens to derivative_address on the relay

1533

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1534

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1535

1

			derivative_address.clone(),

1536

1

			100u128

1537

1

));

1538

1539

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

1540

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1541

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1542

1

			para_a_account(),

1543

1

			4000003000u128

1544

1

));

1545

1

});

1546

1

1547

1

	// Check balances before the transact call

1548

1

	Relay::execute_with(|| {

1549

1

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

1550

1

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

1551

1

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

1552

1

});

1553

1

1554

1

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

1555

1

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

1556

1

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

1557

1

		relay_chain::Balances,

1558

1

>()

1559

1

	.unwrap() as u8;

1560

1

1561

1

	encoded.push(index);

1562

1

1563

1

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

1564

1

		dest: RELAYBOB,

1565

1

		value: 100u32.into(),

1566

1

1567

1

	.encode();

1568

1

	encoded.append(&mut call_bytes);

1569

1

1570

1

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

1571

1

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

1572

1

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

1573

1

);

1574

1

1575

1

	// We send the xcm transact operation to parent

1576

1

	let dest = Location {

1577

1

		parents: 1,

1578

1

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

1579

1

};

1580

1

1581

1

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

1582

1

	ParaA::execute_with(|| {

1583

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1584

1

			parachain::RuntimeOrigin::root(),

1585

1

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

1586

1

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

1587

1

			None,

1588

1

			CurrencyPayment {

1589

1

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

1590

1

					Location::parent()

1591

1

				))),

1592

1

				fee_amount: None

1593

1

},

1594

1

			utility_bytes,

1595

1

			OriginKind::SovereignAccount,

1596

1

			TransactWeights {

1597

1

				transact_required_weight_at_most: 4000000000.into(),

1598

1

				overall_weight: None

1599

1

},

1600

1

			false

1601

1

));

1602

1

});

1603

1

1604

1

	// Check balances after the transact call are correct

1605

1

	Relay::execute_with(|| {

1606

1

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

1607

1

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

1608

1

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

1609

1

});

1610

1

1611

1612

#[test]

1613

1

fn transact_through_sovereign_with_custom_fee_weight() {

1614

1

	MockNet::reset();

1615

1

1616

1

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

1617

1

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

1618

1

1619

1

	let asset_metadata = parachain::AssetMetadata {

1620

1

		name: b"RelayToken".to_vec(),

1621

1

		symbol: b"Relay".to_vec(),

1622

1

		decimals: 12,

1623

1

};

1624

1

1625

1

	ParaA::execute_with(|| {

1626

1

		assert_ok!(AssetManager::register_foreign_asset(

1627

1

			parachain::RuntimeOrigin::root(),

1628

1

			source_location.clone(),

1629

1

			asset_metadata,

1630

1

			1u128,

1631

1

			true

1632

1

));

1633

1

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

1634

1

});

1635

1

1636

1

	let dest: Location = AccountKey20 {

1637

1

		network: None,

1638

1

		key: PARAALICE,

1639

1

1640

1

	.into();

1641

1

	Relay::execute_with(|| {

1642

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1643

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1644

1

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

1645

1

			Box::new(VersionedLocation::from(dest).clone()),

1646

1

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

1647

1

0,

1648

1

			WeightLimit::Unlimited

1649

1

));

1650

1

});

1651

1

1652

1

	ParaA::execute_with(|| {

1653

1

		// free execution, full amount received

1654

1

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

1655

1

});

1656

1

1657

1

	// Register address

1658

1

	ParaA::execute_with(|| {

1659

1

		assert_ok!(XcmTransactor::register(

1660

1

			parachain::RuntimeOrigin::root(),

1661

1

			PARAALICE.into(),

1662

1

0,

1663

1

));

1664

1

});

1665

1

1666

1

	// Send to registered address

1667

1

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

1668

1

	let dest = Location {

1669

1

		parents: 1,

1670

1

		interior: [AccountId32 {

1671

1

			network: None,

1672

1

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

1673

1

}]

1674

1

		.into(),

1675

1

};

1676

1

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

1677

1

1678

1

	ParaA::execute_with(|| {

1679

1

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

1680

1

		// free execution, full amount received

1681

1

		assert_ok!(PolkadotXcm::transfer_assets(

1682

1

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

1683

1

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

1684

1

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

1685

1

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

1686

1

0,

1687

1

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

1688

1

));

1689

1

});

1690

1

1691

1

	ParaA::execute_with(|| {

1692

1

		// free execution, full amount received

1693

1

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

1694

1

});

1695

1

1696

1

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

1697

1

	// again

1698

1

	Relay::execute_with(|| {

1699

1

		// free execution,x	 full amount received

1700

1

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

1701

1

1702

1

});

1703

1

1704

1

	// We send the xcm transact operation to parent

1705

1

	let dest = Location {

1706

1

		parents: 1,

1707

1

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

1708

1

};

1709

1

1710

1

	// Encode the call. Balances transact to para_a_account

1711

1

	// First index

1712

1

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

1713

1

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

1714

1

		relay_chain::Balances,

1715

1

>()

1716

1

	.unwrap() as u8;

1717

1

1718

1

	encoded.push(index);

1719

1

1720

1

	// Then call bytes

1721

1

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

1722

1

		dest: para_a_account(),

1723

1

		value: 100u32.into(),

1724

1

1725

1

	.encode();

1726

1

	encoded.append(&mut call_bytes);

1727

1

1728

1

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

1729

1

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

1730

1

);

1731

1

1732

1

	let total_weight = 4000003000u64;

1733

1

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

1734

1

	ParaA::execute_with(|| {

1735

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1736

1

			parachain::RuntimeOrigin::root(),

1737

1

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

1738

1

			Some(PARAALICE.into()),

1739

1

			CurrencyPayment {

1740

1

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

1741

1

					Location::parent()

1742

1

				))),

1743

1

				// 1-1 fee-weight mapping

1744

1

				fee_amount: Some(total_weight as u128)

1745

1

},

1746

1

			utility_bytes,

1747

1

			OriginKind::SovereignAccount,

1748

1

			TransactWeights {

1749

1

				transact_required_weight_at_most: 4000000000.into(),

1750

1

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

1751

1

},

1752

1

			false

1753

1

));

1754

1

});

1755

1

1756

1

	Relay::execute_with(|| {

1757

1

		// free execution,x	 full amount received

1758

1

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

1759

1760

1

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

1761

1

});

1762

1

1763

1764

#[test]

1765

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1766

1

	MockNet::reset();

1767

1

1768

1

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

1769

1

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

1770

1

1771

1

	let asset_metadata = parachain::AssetMetadata {

1772

1

		name: b"RelayToken".to_vec(),

1773

1

		symbol: b"Relay".to_vec(),

1774

1

		decimals: 12,

1775

1

};

1776

1

1777

1

	ParaA::execute_with(|| {

1778

1

		assert_ok!(AssetManager::register_foreign_asset(

1779

1

			parachain::RuntimeOrigin::root(),

1780

1

			source_location.clone(),

1781

1

			asset_metadata,

1782

1

			1u128,

1783

1

			true

1784

1

));

1785

1

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

1786

1

});

1787

1

1788

1

	let dest: Location = AccountKey20 {

1789

1

		network: None,

1790

1

		key: PARAALICE,

1791

1

1792

1

	.into();

1793

1

	Relay::execute_with(|| {

1794

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1795

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1796

1

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

1797

1

			Box::new(VersionedLocation::from(dest).clone()),

1798

1

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

1799

1

0,

1800

1

			WeightLimit::Unlimited

1801

1

));

1802

1

});

1803

1

1804

1

	ParaA::execute_with(|| {

1805

1

		// free execution, full amount received

1806

1

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

1807

1

});

1808

1

1809

1

	// Register address

1810

1

	ParaA::execute_with(|| {

1811

1

		assert_ok!(XcmTransactor::register(

1812

1

			parachain::RuntimeOrigin::root(),

1813

1

			PARAALICE.into(),

1814

1

0,

1815

1

));

1816

1

});

1817

1

1818

1

	// Send to registered address

1819

1

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

1820

1

	let dest = Location {

1821

1

		parents: 1,

1822

1

		interior: [AccountId32 {

1823

1

			network: None,

1824

1

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

1825

1

}]

1826

1

		.into(),

1827

1

};

1828

1

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

1829

1

1830

1

	ParaA::execute_with(|| {

1831

1

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

1832

1

		// free execution, full amount received

1833

1

		assert_ok!(PolkadotXcm::transfer_assets(

1834

1

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

1835

1

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

1836

1

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

1837

1

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

1838

1

0,

1839

1

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

1840

1

));

1841

1

});

1842

1

1843

1

	ParaA::execute_with(|| {

1844

1

		// free execution, full amount received

1845

1

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

1846

1

});

1847

1

1848

1

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

1849

1

	// again

1850

1

	Relay::execute_with(|| {

1851

1

		// free execution,x	 full amount received

1852

1

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

1853

1

1854

1

});

1855

1

1856

1

	// We send the xcm transact operation to parent

1857

1

	let dest = Location {

1858

1

		parents: 1,

1859

1

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

1860

1

};

1861

1

1862

1

	// Encode the call. Balances transact to para_a_account

1863

1

	// First index

1864

1

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

1865

1

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

1866

1

		relay_chain::Balances,

1867

1

>()

1868

1

	.unwrap() as u8;

1869

1

1870

1

	encoded.push(index);

1871

1

1872

1

	// Then call bytes

1873

1

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

1874

1

		dest: para_a_account(),

1875

1

		value: 100u32.into(),

1876

1

1877

1

	.encode();

1878

1

	encoded.append(&mut call_bytes);

1879

1

1880

1

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

1881

1

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

1882

1

);

1883

1

1884

1

	let total_weight = 4000009000u64;

1885

1

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

1886

1

	ParaA::execute_with(|| {

1887

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1888

1

			parachain::RuntimeOrigin::root(),

1889

1

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

1890

1

			Some(PARAALICE.into()),

1891

1

			CurrencyPayment {

1892

1

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

1893

1

					Location::parent()

1894

1

				))),

1895

1

				// 1-1 fee-weight mapping

1896

1

				fee_amount: Some(total_weight as u128)

1897

1

},

1898

1

			utility_bytes,

1899

1

			OriginKind::SovereignAccount,

1900

1

			TransactWeights {

1901

1

				transact_required_weight_at_most: 4000000000.into(),

1902

1

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

1903

1

},

1904

1

			true

1905

1

));

1906

1

});

1907

1

1908

1

	Relay::execute_with(|| {

1909

1

		// free execution, full amount received

1910

1

		// 4000009000 refunded + 100 transferred = 4000009100

1911

1

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

1912

1913

1

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

1914

1

});

1915

1

1916

1917

#[test]

1918

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

1919

1

	MockNet::reset();

1920

1

1921

1

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

1922

1

	let asset_metadata = parachain::AssetMetadata {

1923

1

		name: b"RelayToken".to_vec(),

1924

1

		symbol: b"Relay".to_vec(),

1925

1

		decimals: 12,

1926

1

};

1927

1

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

1928

1

	ParaA::execute_with(|| {

1929

1

		parachain::XcmVersioner::set_version(1);

1930

1

		assert_ok!(AssetManager::register_foreign_asset(

1931

1

			parachain::RuntimeOrigin::root(),

1932

1

			source_location.clone(),

1933

1

			asset_metadata,

1934

1

			1u128,

1935

1

			true

1936

1

));

1937

1

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

1938

1

});

1939

1

1940

1

	let response = Response::Version(2);

1941

1

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

1942

1

1943

1

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

1944

1

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

1945

1

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

1946

1

		query_id: 0,

1947

1

		response,

1948

1

		max_weight: Weight::zero(),

1949

1

		querier: Some(querier),

1950

1

	}]);

1951

1

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

1952

1

	// it directly here

1953

1

	// Actually send relay asset to parachain

1954

1

	let dest: Location = AccountKey20 {

1955

1

		network: None,

1956

1

		key: PARAALICE,

1957

1

1958

1

	.into();

1959

1

1960

1

	Relay::execute_with(|| {

1961

1

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

1962

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

1963

1

			relay_chain::RuntimeOrigin::root(),

1964

1

			Some(3)

1965

1

));

1966

1967

		// Wrap version, which sets VersionedStorage

1968

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

1969

		// this is not necessary in prod

1970

1

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

1971

1

			&Parachain(1).into(),

1972

1

			mock_message

1973

1

));

1974

1975

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

1976

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1977

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1978

1

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

1979

1

			Box::new(VersionedLocation::from(dest).clone()),

1980

1

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

1981

1

0,

1982

1

			WeightLimit::Unlimited

1983

1

));

1984

1985

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

1986

1

		relay_chain::relay_roll_to(2);

1987

1

1988

1

		// queries should have been updated

1989

1

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

1990

1

});

1991

1

1992

1

	let expected_supported_version: relay_chain::RuntimeEvent =

1993

1

		pallet_xcm::Event::SupportedVersionChanged {

1994

1

			location: Location {

1995

1

				parents: 0,

1996

1

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

1997

1

},

1998

1

			version: 1,

1999

1

2000

1

		.into();

2001

1

2002

1

	Relay::execute_with(|| {

2003

1

		// Assert that the events vector contains the version change

2004

1

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

2005

1

});

2006

1

2007

1

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

2008

1

	// of the new version change

2009

1

	ParaA::execute_with(|| {

2010

1

		// Set version

2011

1

		parachain::XcmVersioner::set_version(2);

2012

1

		// Do runtime upgrade

2013

1

		parachain::on_runtime_upgrade();

2014

1

		// Initialize block, to call on_initialize and notify targets

2015

1

		parachain::para_roll_to(2);

2016

1

		// Expect the event in the parachain

2017

10

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

2018

2

e,

2019

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

2020

				result: 2,

2021

..

2022

})

2023

10

		)));

2024

1

});

2025

1

2026

1

	// This event should have been seen in the relay

2027

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2028

1

		pallet_xcm::Event::SupportedVersionChanged {

2029

1

			location: Location {

2030

1

				parents: 0,

2031

1

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

2032

1

},

2033

1

			version: 2,

2034

1

2035

1

		.into();

2036

1

2037

1

	Relay::execute_with(|| {

2038

1

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

2039

1

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

2040

1

});

2041

1

2042

2043

#[test]

2044

1

fn receive_asset_with_no_sufficients_not_possible_if_non_existent_account() {

2045

1

	MockNet::reset();

2046

1

2047

1

	let fresh_account = [2u8; 20];

2048

1

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

2049

1

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

2050

1

	let asset_metadata = parachain::AssetMetadata {

2051

1

		name: b"RelayToken".to_vec(),

2052

1

		symbol: b"Relay".to_vec(),

2053

1

		decimals: 12,

2054

1

};

2055

1

	// register relay asset in parachain A

2056

1

	ParaA::execute_with(|| {

2057

1

		assert_ok!(AssetManager::register_foreign_asset(

2058

1

			parachain::RuntimeOrigin::root(),

2059

1

			source_location.clone(),

2060

1

			asset_metadata,

2061

1

			1u128,

2062

1

			false

2063

1

));

2064

1

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

2065

1

});

2066

1

2067

1

	// Actually send relay asset to parachain

2068

1

	let dest: Location = AccountKey20 {

2069

1

		network: None,

2070

1

		key: fresh_account,

2071

1

2072

1

	.into();

2073

1

	Relay::execute_with(|| {

2074

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2075

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2076

1

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

2077

1

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

2078

1

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

2079

1

0,

2080

1

			WeightLimit::Unlimited

2081

1

));

2082

1

});

2083

1

2084

1

	// parachain should not have received assets

2085

1

	ParaA::execute_with(|| {

2086

1

		// free execution, full amount received

2087

1

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

2088

1

});

2089

1

2090

1

	// Send native token to fresh_account

2091

1

	ParaA::execute_with(|| {

2092

1

		assert_ok!(ParaBalances::transfer_allow_death(

2093

1

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

2094

1

			fresh_account.into(),

2095

1

2096

1

));

2097

1

});

2098

1

2099

1

	// Re-send tokens

2100

1

	Relay::execute_with(|| {

2101

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2102

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2103

1

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

2104

1

			Box::new(VersionedLocation::from(dest).clone()),

2105

1

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

2106

1

0,

2107

1

			WeightLimit::Unlimited

2108

1

));

2109

1

});

2110

1

2111

1

	// parachain should have received assets

2112

1

	ParaA::execute_with(|| {

2113

1

		// free execution, full amount received

2114

1

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

2115

1

});

2116

1

2117

2118

#[test]

2119

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2120

1

	MockNet::reset();

2121

1

2122

1

	let fresh_account = [2u8; 20];

2123

1

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

2124

1

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

2125

1

	let asset_metadata = parachain::AssetMetadata {

2126

1

		name: b"RelayToken".to_vec(),

2127

1

		symbol: b"Relay".to_vec(),

2128

1

		decimals: 12,

2129

1

};

2130

1

	// register relay asset in parachain A

2131

1

	ParaA::execute_with(|| {

2132

1

		assert_ok!(AssetManager::register_foreign_asset(

2133

1

			parachain::RuntimeOrigin::root(),

2134

1

			source_location.clone(),

2135

1

			asset_metadata,

2136

1

			1u128,

2137

1

			true

2138

1

));

2139

1

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

2140

1

});

2141

1

2142

1

	// Actually send relay asset to parachain

2143

1

	let dest: Location = AccountKey20 {

2144

1

		network: None,

2145

1

		key: fresh_account,

2146

1

2147

1

	.into();

2148

1

	Relay::execute_with(|| {

2149

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2150

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2151

1

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

2152

1

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

2153

1

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

2154

1

0,

2155

1

			WeightLimit::Unlimited

2156

1

));

2157

1

});

2158

1

2159

1

	// parachain should have received assets

2160

1

	ParaA::execute_with(|| {

2161

1

		// free execution, full amount received

2162

1

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

2163

1

});

2164

1

2165

2166

#[test]

2167

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2168

1

	MockNet::reset();

2169

1

2170

1

	let mut sufficient_account = [0u8; 20];

2171

1

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

2172

1

2173

1

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

2174

1

2175

1

	// Evm account is self sufficient

2176

1

	ParaA::execute_with(|| {

2177

1

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

2178

1

});

2179

1

2180

1

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

2181

1

	let asset_metadata = parachain::AssetMetadata {

2182

1

		name: b"RelayToken".to_vec(),

2183

1

		symbol: b"Relay".to_vec(),

2184

1

		decimals: 12,

2185

1

};

2186

1

	// register relay asset in parachain A

2187

1

	ParaA::execute_with(|| {

2188

1

		assert_ok!(AssetManager::register_foreign_asset(

2189

1

			parachain::RuntimeOrigin::root(),

2190

1

			source_location.clone(),

2191

1

			asset_metadata,

2192

1

			1u128,

2193

1

			true

2194

1

));

2195

1

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

2196

1

});

2197

1

2198

1

	// Actually send relay asset to parachain

2199

1

	let dest: Location = AccountKey20 {

2200

1

		network: None,

2201

1

		key: sufficient_account,

2202

1

2203

1

	.into();

2204

1

	Relay::execute_with(|| {

2205

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2206

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2207

1

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

2208

1

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

2209

1

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

2210

1

0,

2211

1

			WeightLimit::Unlimited

2212

1

));

2213

1

});

2214

1

2215

1

	// Evm account sufficient ref count increased by 1.

2216

1

	ParaA::execute_with(|| {

2217

1

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

2218

1

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

2219

1

		// will be implemented in a future release

2220

1

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

2221

1

});

2222

1

2223

1

	ParaA::execute_with(|| {

2224

1

		// Remove the account from the evm context.

2225

1

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

2226

1

		// Evm account sufficient ref count decreased by 1.

2227

1

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

2228

1

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

2229

1

		// will be implemented in a future release

2230

1

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

2231

1

});

2232

1

2233

2234

#[test]

2235

1

fn empty_account_should_not_be_reset() {

2236

1

	MockNet::reset();

2237

1

2238

1

	// Test account has nonce 1 on genesis.

2239

1

	let mut sufficient_account = [0u8; 20];

2240

1

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

2241

1

2242

1

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

2243

1

2244

1

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

2245

1

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

2246

1

	let asset_metadata = parachain::AssetMetadata {

2247

1

		name: b"RelayToken".to_vec(),

2248

1

		symbol: b"Relay".to_vec(),

2249

1

		decimals: 12,

2250

1

};

2251

1

	// register relay asset in parachain A

2252

1

	ParaA::execute_with(|| {

2253

1

		assert_ok!(AssetManager::register_foreign_asset(

2254

1

			parachain::RuntimeOrigin::root(),

2255

1

			source_location.clone(),

2256

1

			asset_metadata,

2257

1

			1u128,

2258

1

			false

2259

1

));

2260

1

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

2261

1

});

2262

1

2263

1

	// Send native token to evm_account

2264

1

	ParaA::execute_with(|| {

2265

1

		assert_ok!(ParaBalances::transfer_allow_death(

2266

1

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

2267

1

			evm_account_id,

2268

1

2269

1

));

2270

1

});

2271

1

2272

1

	// Actually send relay asset to parachain

2273

1

	let dest: Location = AccountKey20 {

2274

1

		network: None,

2275

1

		key: sufficient_account,

2276

1

2277

1

	.into();

2278

1

	Relay::execute_with(|| {

2279

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2280

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2281

1

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

2282

1

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

2283

1

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

2284

1

0,

2285

1

			WeightLimit::Unlimited

2286

1

));

2287

1

});

2288

1

2289

1

	ParaA::execute_with(|| {

2290

1

		// Empty the assets from the account.

2291

1

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

2292

1

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

2293

1

		assert_ok!(parachain::Assets::transfer(

2294

1

			parachain::RuntimeOrigin::signed(evm_account_id),

2295

1

			source_id,

2296

1

			PARAALICE.into(),

2297

1

2298

1

));

2299

		// Verify account asset balance is Zero.

2300

1

		assert_eq!(

2301

1

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

2302

1

2303

1

);

2304

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

2305

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

2306

1

		assert_ok!(ParaBalances::force_set_balance(

2307

1

			parachain::RuntimeOrigin::root(),

2308

1

			evm_account_id,

2309

1

0,

2310

1

));

2311

		// Verify account native balance is Zero.

2312

1

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

2313

		// Remove the account from the evm context.

2314

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

2315

1

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

2316

1

		// Verify reference count.

2317

1

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

2318

1

		assert_eq!(account.sufficients, 0);

2319

1

		assert_eq!(account.consumers, 0);

2320

1

		assert_eq!(account.providers, 1);

2321

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

2322

1

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

2323

1

});

2324

1

2325

2326

#[test]

2327

1

fn test_statemint_like() {

2328

1

	MockNet::reset();

2329

1

2330

1

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

2331

1

2332

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2333

1

		polkadot_parachain::primitives::Sibling,

2334

1

		statemint_like::AccountId,

2335

1

	>::convert_location(&dest_para)

2336

1

	.unwrap();

2337

1

2338

1

	let statemint_asset_a_balances = Location::new(

2339

1

1,

2340

1

2341

1

			Parachain(1000),

2342

1

			PalletInstance(5),

2343

1

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

2344

1

],

2345

1

);

2346

1

	let source_location: AssetType = statemint_asset_a_balances

2347

1

		.try_into()

2348

1

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

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::from(dest).clone()),

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: AssetType = statemint_asset

2454

1

		.clone()

2455

1

		.try_into()

2456

1

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

2457

1

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

2458

1

2459

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2460

1

		name: b"USDC".to_vec(),

2461

1

		symbol: b"USDC".to_vec(),

2462

1

		decimals: 12,

2463

1

};

2464

1

2465

1

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

2466

1

2467

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2468

1

		polkadot_parachain::primitives::Sibling,

2469

1

		statemint_like::AccountId,

2470

1

	>::convert_location(&dest_para)

2471

1

	.unwrap();

2472

1

2473

1

	ParaA::execute_with(|| {

2474

1

		assert_ok!(AssetManager::register_foreign_asset(

2475

1

			parachain::RuntimeOrigin::root(),

2476

1

			relay_location.clone(),

2477

1

			relay_asset_metadata,

2478

1

			1u128,

2479

1

			true

2480

1

));

2481

1

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

2482

2483

1

		assert_ok!(AssetManager::register_foreign_asset(

2484

1

			parachain::RuntimeOrigin::root(),

2485

1

			statemint_location_asset.clone(),

2486

1

			asset_metadata_statemint_asset,

2487

1

			1u128,

2488

1

			true

2489

1

));

2490

1

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

2491

1

});

2492

1

2493

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2494

1

		network: None,

2495

1

		key: PARAALICE,

2496

1

2497

1

	.into();

2498

1

2499

1

	// Send relay chain asset to Alice in Parachain A

2500

1

	Relay::execute_with(|| {

2501

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2502

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2503

1

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

2504

1

			Box::new(

2505

1

				VersionedLocation::from(parachain_beneficiary_from_relay)

2506

1

					.clone()

2507

1

					.into()

2508

1

),

2509

1

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

2510

1

0,

2511

1

			WeightLimit::Unlimited

2512

1

));

2513

1

});

2514

1

2515

1

	Statemint::execute_with(|| {

2516

1

		// Set new prefix

2517

1

		statemint_like::PrefixChanger::set_prefix(

2518

1

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

2519

1

);

2520

1

2521

1

		assert_ok!(StatemintAssets::create(

2522

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2523

1

10,

2524

1

			RELAYALICE,

2525

1

2526

1

));

2527

2528

1

		assert_ok!(StatemintAssets::mint(

2529

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2530

1

10,

2531

1

			RELAYALICE,

2532

1

			300000000000000

2533

1

));

2534

2535

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

2536

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

2537

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2538

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2539

1

			sov,

2540

1

			100000000000000

2541

1

));

2542

2543

		// Send statemint USDC asset to Alice in Parachain A

2544

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2545

1

			network: None,

2546

1

			key: PARAALICE,

2547

1

2548

1

		.into();

2549

1

2550

1

		// Send with new prefix

2551

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2552

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2553

1

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

2554

1

			Box::new(

2555

1

				VersionedLocation::from(parachain_beneficiary_from_statemint)

2556

1

					.clone()

2557

1

					.into()

2558

1

),

2559

1

			Box::new(

2560

1

2561

1

2562

1

						xcm::latest::prelude::PalletInstance(

2563

1

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

2564

1

),

2565

1

						GeneralIndex(10),

2566

1

],

2567

1

2568

1

2569

1

					.into()

2570

1

),

2571

1

0,

2572

1

			WeightLimit::Unlimited

2573

1

));

2574

1

});

2575

1

2576

1

	let statemint_beneficiary = Location {

2577

1

		parents: 1,

2578

1

		interior: [

2579

1

			Parachain(1000),

2580

1

			AccountId32 {

2581

1

				network: None,

2582

1

				id: RELAYBOB.into(),

2583

1

},

2584

1

2585

1

		.into(),

2586

1

};

2587

1

2588

1

	ParaA::execute_with(|| {

2589

1

		// Alice has received 125 USDC

2590

1

		assert_eq!(

2591

1

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

2592

1

2593

1

);

2594

2595

		// Alice has received 200 Relay assets

2596

1

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

2597

1

});

2598

1

2599

1

	Statemint::execute_with(|| {

2600

1

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

2601

1

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

2602

1

});

2603

1

	let (chain_part, beneficiary) =

2604

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2605

1

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

2606

1

	ParaA::execute_with(|| {

2607

1

		let asset = currency_to_asset(

2608

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2609

1

			100,

2610

1

);

2611

1

		let asset_fee =

2612

1

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

2613

1

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

2614

1

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

2615

2616

1

		assert_ok!(PolkadotXcm::transfer_assets(

2617

1

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

2618

1

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

2619

1

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

2620

1

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

2621

1

0,

2622

1

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

2623

1

));

2624

1

});

2625

1

2626

1

	ParaA::execute_with(|| {

2627

1

		// Alice has 100 USDC less

2628

1

		assert_eq!(

2629

1

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

2630

1

2631

1

);

2632

2633

		// Alice has 100 relay asset less

2634

1

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

2635

1

});

2636

1

2637

1

	Statemint::execute_with(|| {

2638

1

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

2639

1

		// Check that BOB received 100 USDC on statemint

2640

1

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

2641

1

});

2642

1

2643

2644

#[test]

2645

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

2646

1

	MockNet::reset();

2647

1

2648

1

	// Relay asset

2649

1

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

2650

1

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

2651

1

2652

1

	let relay_asset_metadata = parachain::AssetMetadata {

2653

1

		name: b"RelayToken".to_vec(),

2654

1

		symbol: b"Relay".to_vec(),

2655

1

		decimals: 12,

2656

1

};

2657

1

2658

1

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

2659

1

2660

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2661

1

		polkadot_parachain::primitives::Sibling,

2662

1

		statemint_like::AccountId,

2663

1

	>::convert_location(&dest_para)

2664

1

	.unwrap();

2665

1

2666

1

	ParaA::execute_with(|| {

2667

1

		assert_ok!(AssetManager::register_foreign_asset(

2668

1

			parachain::RuntimeOrigin::root(),

2669

1

			relay_location.clone(),

2670

1

			relay_asset_metadata,

2671

1

			1u128,

2672

1

			true

2673

1

));

2674

1

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

2675

1

});

2676

1

2677

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2678

1

		network: None,

2679

1

		key: PARAALICE,

2680

1

2681

1

	.into();

2682

1

2683

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2684

1

		network: None,

2685

1

		id: RELAYALICE.into(),

2686

1

2687

1

	.into();

2688

1

2689

1

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

2690

1

	Relay::execute_with(|| {

2691

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2692

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2693

1

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

2694

1

			Box::new(

2695

1

				VersionedLocation::from(statemint_beneficiary_absolute)

2696

1

					.clone()

2697

1

					.into()

2698

1

),

2699

1

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

2700

1

0,

2701

1

			WeightLimit::Unlimited

2702

1

));

2703

1

});

2704

1

2705

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2706

1

	Statemint::execute_with(|| {

2707

1

		// Check Alice received 200 tokens on AssetHub

2708

1

		assert_eq!(

2709

1

			StatemintBalances::free_balance(RELAYALICE),

2710

1

			INITIAL_BALANCE + 200

2711

1

);

2712

2713

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2714

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2715

1

			sov,

2716

1

			110000000000000

2717

1

));

2718

2719

		// Now send those tokens to ParaA

2720

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2721

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2722

1

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

2723

1

			Box::new(

2724

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

2725

1

					.clone()

2726

1

					.into()

2727

1

),

2728

1

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

2729

1

0,

2730

1

			WeightLimit::Unlimited

2731

1

));

2732

1

});

2733

1

2734

1

	ParaA::execute_with(|| {

2735

1

		// Alice should have received the DOTs

2736

1

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

2737

1

});

2738

1

2739

1

	let dest = Location::new(

2740

1

1,

2741

1

2742

1

			Parachain(1000),

2743

1

			AccountId32 {

2744

1

				network: None,

2745

1

				id: RELAYBOB.into(),

2746

1

},

2747

1

],

2748

1

);

2749

1

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

2750

1

2751

1

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

2752

1

	ParaA::execute_with(|| {

2753

1

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

2754

1

		assert_ok!(PolkadotXcm::transfer_assets(

2755

1

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

2756

1

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

2757

1

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

2758

1

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

2759

1

0,

2760

1

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

2761

1

));

2762

2763

1

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

2764

1

});

2765

1

2766

1

	Statemint::execute_with(|| {

2767

1

		// Check that Bob received the tokens back in AssetHub

2768

1

		assert_eq!(

2769

1

			StatemintBalances::free_balance(RELAYBOB),

2770

1

			INITIAL_BALANCE + 100

2771

1

);

2772

1

});

2773

1

2774

1

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

2775

1

	Statemint::execute_with(|| {

2776

1

		// Now send those tokens to ParaA

2777

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2778

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

2779

1

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

2780

1

			Box::new(

2781

1

				VersionedLocation::from(parachain_beneficiary_absolute)

2782

1

					.clone()

2783

1

					.into()

2784

1

),

2785

1

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

2786

1

0,

2787

1

			WeightLimit::Unlimited

2788

1

));

2789

2790

		// 100 DOTs were deducted from Bob's account

2791

1

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

2792

1

});

2793

1

2794

1

	ParaA::execute_with(|| {

2795

1

		// Alice should have received 100 DOTs

2796

1

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

2797

1

});

2798

1

2799

2800

#[test]

2801

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

2802

1

	MockNet::reset();

2803

1

2804

1

	// Relay asset

2805

1

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

2806

1

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

2807

1

2808

1

	let relay_asset_metadata = parachain::AssetMetadata {

2809

1

		name: b"RelayToken".to_vec(),

2810

1

		symbol: b"Relay".to_vec(),

2811

1

		decimals: 12,

2812

1

};

2813

1

2814

1

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

2815

1

2816

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2817

1

		polkadot_parachain::primitives::Sibling,

2818

1

		statemint_like::AccountId,

2819

1

	>::convert_location(&dest_para)

2820

1

	.unwrap();

2821

1

2822

1

	ParaA::execute_with(|| {

2823

1

		assert_ok!(AssetManager::register_foreign_asset(

2824

1

			parachain::RuntimeOrigin::root(),

2825

1

			relay_location.clone(),

2826

1

			relay_asset_metadata,

2827

1

			1u128,

2828

1

			true

2829

1

));

2830

1

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

2831

1

});

2832

1

2833

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2834

1

		network: None,

2835

1

		key: PARAALICE,

2836

1

2837

1

	.into();

2838

1

2839

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2840

1

		network: None,

2841

1

		id: RELAYALICE.into(),

2842

1

2843

1

	.into();

2844

1

2845

1

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

2846

1

	Relay::execute_with(|| {

2847

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2848

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2849

1

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

2850

1

			Box::new(

2851

1

				VersionedLocation::from(statemint_beneficiary_absolute)

2852

1

					.clone()

2853

1

					.into()

2854

1

),

2855

1

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

2856

1

0,

2857

1

			WeightLimit::Unlimited

2858

1

));

2859

1

});

2860

1

2861

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2862

1

	Statemint::execute_with(|| {

2863

1

		// Check Alice received 200 tokens on AssetHub

2864

1

		assert_eq!(

2865

1

			StatemintBalances::free_balance(RELAYALICE),

2866

1

			INITIAL_BALANCE + 200

2867

1

);

2868

2869

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2870

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2871

1

			sov,

2872

1

			110000000000000

2873

1

));

2874

2875

		// Now send those tokens to ParaA

2876

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2877

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2878

1

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

2879

1

			Box::new(

2880

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

2881

1

					.clone()

2882

1

					.into()

2883

1

),

2884

1

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

2885

1

0,

2886

1

			WeightLimit::Unlimited

2887

1

));

2888

1

});

2889

1

2890

1

	ParaA::execute_with(|| {

2891

1

		// Alice should have received the DOTs

2892

1

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

2893

1

});

2894

1

2895

1

	let dest = Location::new(

2896

1

1,

2897

1

2898

1

			Parachain(1000),

2899

1

			AccountId32 {

2900

1

				network: None,

2901

1

				id: RELAYBOB.into(),

2902

1

},

2903

1

],

2904

1

);

2905

1

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

2906

1

2907

1

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

2908

1

	ParaA::execute_with(|| {

2909

1

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

2910

1

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

2911

1

		assert_ok!(PolkadotXcm::transfer_assets(

2912

1

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

2913

1

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

2914

1

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

2915

1

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

2916

1

0,

2917

1

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

2918

1

));

2919

2920

1

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

2921

1

});

2922

1

2923

1

	Statemint::execute_with(|| {

2924

1

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

2925

1

		assert_eq!(

2926

1

			StatemintBalances::free_balance(RELAYBOB),

2927

1

			INITIAL_BALANCE + 110

2928

1

);

2929

1

});

2930

1

2931

1

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

2932

1

	Statemint::execute_with(|| {

2933

1

		// Now send those tokens to ParaA

2934

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2935

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

2936

1

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

2937

1

			Box::new(

2938

1

				VersionedLocation::from(parachain_beneficiary_absolute)

2939

1

					.clone()

2940

1

					.into()

2941

1

),

2942

1

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

2943

1

0,

2944

1

			WeightLimit::Unlimited

2945

1

));

2946

2947

		// 100 DOTs were deducted from Bob's account

2948

1

		assert_eq!(

2949

1

			StatemintBalances::free_balance(RELAYBOB),

2950

1

			INITIAL_BALANCE + 10

2951

1

);

2952

1

});

2953

1

2954

1

	ParaA::execute_with(|| {

2955

1

		// Alice should have received 100 DOTs

2956

1

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

2957

1

});

2958

1

2959

2960

#[test]

2961

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

2962

1

	MockNet::reset();

2963

1

2964

1

	// Relay asset

2965

1

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

2966

1

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

2967

1

2968

1

	let relay_asset_metadata = parachain::AssetMetadata {

2969

1

		name: b"RelayToken".to_vec(),

2970

1

		symbol: b"Relay".to_vec(),

2971

1

		decimals: 12,

2972

1

};

2973

1

2974

1

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

2975

1

2976

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2977

1

		polkadot_parachain::primitives::Sibling,

2978

1

		statemint_like::AccountId,

2979

1

	>::convert_location(&dest_para)

2980

1

	.unwrap();

2981

1

2982

1

	ParaA::execute_with(|| {

2983

1

		assert_ok!(AssetManager::register_foreign_asset(

2984

1

			parachain::RuntimeOrigin::root(),

2985

1

			relay_location.clone(),

2986

1

			relay_asset_metadata,

2987

1

			1u128,

2988

1

			true

2989

1

));

2990

1

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

2991

1

});

2992

1

2993

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2994

1

		network: None,

2995

1

		key: PARAALICE,

2996

1

2997

1

	.into();

2998

1

2999

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3000

1

		network: None,

3001

1

		id: RELAYALICE.into(),

3002

1

3003

1

	.into();

3004

1

3005

1

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

3006

1

	Relay::execute_with(|| {

3007

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3008

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3009

1

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

3010

1

			Box::new(

3011

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3012

1

					.clone()

3013

1

					.into()

3014

1

),

3015

1

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

3016

1

0,

3017

1

			WeightLimit::Unlimited

3018

1

));

3019

1

});

3020

1

3021

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3022

1

	Statemint::execute_with(|| {

3023

1

		// Check Alice received 200 tokens on AssetHub

3024

1

		assert_eq!(

3025

1

			StatemintBalances::free_balance(RELAYALICE),

3026

1

			INITIAL_BALANCE + 200

3027

1

);

3028

3029

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3030

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3031

1

			sov,

3032

1

			110000000000000

3033

1

));

3034

3035

		// Now send those tokens to ParaA

3036

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3037

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3038

1

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

3039

1

			Box::new(

3040

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3041

1

					.clone()

3042

1

					.into()

3043

1

),

3044

1

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

3045

1

0,

3046

1

			WeightLimit::Unlimited

3047

1

));

3048

1

});

3049

1

3050

1

	ParaA::execute_with(|| {

3051

1

		// Alice should have received the DOTs

3052

1

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

3053

1

});

3054

1

3055

1

	let dest = Location::new(

3056

1

1,

3057

1

3058

1

			Parachain(1000),

3059

1

			AccountId32 {

3060

1

				network: None,

3061

1

				id: RELAYBOB.into(),

3062

1

},

3063

1

],

3064

1

);

3065

1

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

3066

1

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

3067

1

	ParaA::execute_with(|| {

3068

1

		assert_ok!(PolkadotXcm::transfer_assets(

3069

1

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

3070

1

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

3071

1

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

3072

1

			Box::new(VersionedAssets::from((Location::parent(), 100))),

3073

1

0,

3074

1

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

3075

1

));

3076

3077

1

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

3078

1

});

3079

1

3080

1

	Statemint::execute_with(|| {

3081

1

		// Check that Bob received the tokens back in AssetHub

3082

1

		assert_eq!(

3083

1

			StatemintBalances::free_balance(RELAYBOB),

3084

1

			INITIAL_BALANCE + 100

3085

1

);

3086

1

});

3087

1

3088

1

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

3089

1

	Statemint::execute_with(|| {

3090

1

		// Now send those tokens to ParaA

3091

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3092

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3093

1

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

3094

1

			Box::new(

3095

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3096

1

					.clone()

3097

1

					.into()

3098

1

),

3099

1

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

3100

1

0,

3101

1

			WeightLimit::Unlimited

3102

1

));

3103

3104

		// 100 DOTs were deducted from Bob's account

3105

1

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

3106

1

});

3107

1

3108

1

	ParaA::execute_with(|| {

3109

1

		// Alice should have received 100 DOTs

3110

1

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

3111

1

});

3112

1

3113

3114

#[test]

3115

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3116

1

	MockNet::reset();

3117

1

3118

1

	// Relay asset

3119

1

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

3120

1

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

3121

1

3122

1

	let relay_asset_metadata = parachain::AssetMetadata {

3123

1

		name: b"RelayToken".to_vec(),

3124

1

		symbol: b"Relay".to_vec(),

3125

1

		decimals: 12,

3126

1

};

3127

1

3128

1

	// Statemint asset

3129

1

	let statemint_asset = Location::new(

3130

1

1,

3131

1

3132

1

			Parachain(1000u32),

3133

1

			PalletInstance(5u8),

3134

1

			GeneralIndex(10u128),

3135

1

],

3136

1

);

3137

1

	let statemint_location_asset: AssetType = statemint_asset

3138

1

		.clone()

3139

1

		.try_into()

3140

1

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

3141

1

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

3142

1

3143

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3144

1

		name: b"USDC".to_vec(),

3145

1

		symbol: b"USDC".to_vec(),

3146

1

		decimals: 12,

3147

1

};

3148

1

3149

1

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

3150

1

3151

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3152

1

		polkadot_parachain::primitives::Sibling,

3153

1

		statemint_like::AccountId,

3154

1

	>::convert_location(&dest_para)

3155

1

	.unwrap();

3156

1

3157

1

	ParaA::execute_with(|| {

3158

1

		assert_ok!(AssetManager::register_foreign_asset(

3159

1

			parachain::RuntimeOrigin::root(),

3160

1

			relay_location.clone(),

3161

1

			relay_asset_metadata,

3162

1

			1u128,

3163

1

			true

3164

1

));

3165

1

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

3166

1

3167

1

		assert_ok!(AssetManager::register_foreign_asset(

3168

1

			parachain::RuntimeOrigin::root(),

3169

1

			statemint_location_asset.clone(),

3170

1

			asset_metadata_statemint_asset,

3171

1

			1u128,

3172

1

			true

3173

1

));

3174

1

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

3175

1

});

3176

1

3177

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3178

1

		network: None,

3179

1

		key: PARAALICE,

3180

1

3181

1

	.into();

3182

1

3183

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3184

1

		network: None,

3185

1

		id: RELAYALICE.into(),

3186

1

3187

1

	.into();

3188

1

3189

1

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

3190

1

	Relay::execute_with(|| {

3191

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3192

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3193

1

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

3194

1

			Box::new(

3195

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3196

1

					.clone()

3197

1

					.into()

3198

1

),

3199

1

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

3200

1

0,

3201

1

			WeightLimit::Unlimited

3202

1

));

3203

1

});

3204

1

3205

1

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

3206

1

	Statemint::execute_with(|| {

3207

1

		// Check Alice received 200 tokens on AssetHub

3208

1

		assert_eq!(

3209

1

			StatemintBalances::free_balance(RELAYALICE),

3210

1

			INITIAL_BALANCE + 200

3211

1

);

3212

3213

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3214

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3215

1

			sov,

3216

1

			110000000000000

3217

1

));

3218

3219

1

		statemint_like::PrefixChanger::set_prefix(

3220

1

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

3221

1

);

3222

1

3223

1

		assert_ok!(StatemintAssets::create(

3224

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3225

1

10,

3226

1

			RELAYALICE,

3227

1

3228

1

));

3229

3230

1

		assert_ok!(StatemintAssets::mint(

3231

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3232

1

10,

3233

1

			RELAYALICE,

3234

1

			300000000000000

3235

1

));

3236

3237

		// Now send relay tokens to ParaA

3238

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3239

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3240

1

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

3241

1

			Box::new(

3242

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3243

1

					.clone()

3244

1

					.into()

3245

1

),

3246

1

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

3247

1

0,

3248

1

			WeightLimit::Unlimited

3249

1

));

3250

3251

		// Send USDC

3252

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3253

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3254

1

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

3255

1

			Box::new(

3256

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3257

1

					.clone()

3258

1

					.into()

3259

1

),

3260

1

			Box::new(

3261

1

3262

1

3263

1

						xcm::latest::prelude::PalletInstance(

3264

1

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

3265

1

),

3266

1

						GeneralIndex(10),

3267

1

],

3268

1

3269

1

3270

1

					.into()

3271

1

),

3272

1

0,

3273

1

			WeightLimit::Unlimited

3274

1

));

3275

1

});

3276

1

3277

1

	ParaA::execute_with(|| {

3278

1

		// Alice should have received the DOTs

3279

1

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

3280

3281

		// Alice has received 125 USDC

3282

1

		assert_eq!(

3283

1

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

3284

1

3285

1

);

3286

1

});

3287

1

3288

1

	let dest = Location::new(

3289

1

1,

3290

1

3291

1

			Parachain(1000),

3292

1

			AccountId32 {

3293

1

				network: None,

3294

1

				id: RELAYBOB.into(),

3295

1

},

3296

1

],

3297

1

);

3298

1

3299

1

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

3300

1

3301

1

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

3302

1

	ParaA::execute_with(|| {

3303

1

		let asset_1 = currency_to_asset(

3304

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3305

1

			100,

3306

1

);

3307

1

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

3308

1

		let assets_to_send = vec![asset_1, asset_2];

3309

1

		assert_ok!(PolkadotXcm::transfer_assets(

3310

1

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

3311

1

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

3312

1

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

3313

1

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

3314

1

1,

3315

1

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

3316

1

));

3317

3318

1

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

3319

1

});

3320

1

3321

1

	Statemint::execute_with(|| {

3322

1

		// Check that Bob received relay tokens back in AssetHub

3323

1

		assert_eq!(

3324

1

			StatemintBalances::free_balance(RELAYBOB),

3325

1

			INITIAL_BALANCE + 100

3326

1

);

3327

3328

		// Check that BOB received 100 USDC on AssetHub

3329

1

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

3330

1

});

3331

1

3332

1

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

3333

1

	Statemint::execute_with(|| {

3334

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3335

1

3336

1

		// Now send those tokens to ParaA

3337

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3338

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3339

1

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

3340

1

			Box::new(

3341

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3342

1

					.clone()

3343

1

					.into()

3344

1

),

3345

1

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

3346

1

0,

3347

1

			WeightLimit::Unlimited

3348

1

));

3349

3350

		// 100 DOTs were deducted from Bob's account

3351

1

		assert_eq!(

3352

1

			StatemintBalances::free_balance(RELAYBOB),

3353

1

			bob_previous_balance - 100

3354

1

);

3355

1

});

3356

1

3357

1

	ParaA::execute_with(|| {

3358

1

		// Alice should have received 100 DOTs

3359

1

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

3360

1

});

3361

1

3362

3363

#[test]

3364

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3365

1

	MockNet::reset();

3366

1

3367

1

	// Relay asset

3368

1

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

3369

1

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

3370

1

3371

1

	let relay_asset_metadata = parachain::AssetMetadata {

3372

1

		name: b"RelayToken".to_vec(),

3373

1

		symbol: b"Relay".to_vec(),

3374

1

		decimals: 12,

3375

1

};

3376

1

3377

1

	// Statemint asset

3378

1

	let statemint_asset = Location::new(

3379

1

1,

3380

1

3381

1

			Parachain(1000u32),

3382

1

			PalletInstance(5u8),

3383

1

			GeneralIndex(10u128),

3384

1

],

3385

1

);

3386

1

	let statemint_location_asset: AssetType = statemint_asset

3387

1

		.clone()

3388

1

		.try_into()

3389

1

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

3390

1

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

3391

1

3392

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3393

1

		name: b"USDC".to_vec(),

3394

1

		symbol: b"USDC".to_vec(),

3395

1

		decimals: 12,

3396

1

};

3397

1

3398

1

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

3399

1

3400

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3401

1

		polkadot_parachain::primitives::Sibling,

3402

1

		statemint_like::AccountId,

3403

1

	>::convert_location(&dest_para)

3404

1

	.unwrap();

3405

1

3406

1

	ParaA::execute_with(|| {

3407

1

		assert_ok!(AssetManager::register_foreign_asset(

3408

1

			parachain::RuntimeOrigin::root(),

3409

1

			relay_location.clone(),

3410

1

			relay_asset_metadata,

3411

1

			1u128,

3412

1

			true

3413

1

));

3414

1

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

3415

1

3416

1

		assert_ok!(AssetManager::register_foreign_asset(

3417

1

			parachain::RuntimeOrigin::root(),

3418

1

			statemint_location_asset.clone(),

3419

1

			asset_metadata_statemint_asset,

3420

1

			1u128,

3421

1

			true

3422

1

));

3423

1

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

3424

1

});

3425

1

3426

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3427

1

		network: None,

3428

1

		key: PARAALICE,

3429

1

3430

1

	.into();

3431

1

3432

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3433

1

		network: None,

3434

1

		id: RELAYALICE.into(),

3435

1

3436

1

	.into();

3437

1

3438

1

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

3439

1

	Relay::execute_with(|| {

3440

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3441

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3442

1

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

3443

1

			Box::new(

3444

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3445

1

					.clone()

3446

1

					.into()

3447

1

),

3448

1

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

3449

1

0,

3450

1

			WeightLimit::Unlimited

3451

1

));

3452

1

});

3453

1

3454

1

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

3455

1

	Statemint::execute_with(|| {

3456

1

		// Check Alice received 200 tokens on AssetHub

3457

1

		assert_eq!(

3458

1

			StatemintBalances::free_balance(RELAYALICE),

3459

1

			INITIAL_BALANCE + 200

3460

1

);

3461

3462

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3463

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3464

1

			sov,

3465

1

			110000000000000

3466

1

));

3467

3468

1

		statemint_like::PrefixChanger::set_prefix(

3469

1

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

3470

1

);

3471

1

3472

1

		assert_ok!(StatemintAssets::create(

3473

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3474

1

10,

3475

1

			RELAYALICE,

3476

1

3477

1

));

3478

3479

1

		assert_ok!(StatemintAssets::mint(

3480

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3481

1

10,

3482

1

			RELAYALICE,

3483

1

			300000000000000

3484

1

));

3485

3486

		// Now send relay tokens to ParaA

3487

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3488

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3489

1

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

3490

1

			Box::new(

3491

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3492

1

					.clone()

3493

1

					.into()

3494

1

),

3495

1

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

3496

1

0,

3497

1

			WeightLimit::Unlimited

3498

1

));

3499

3500

		// Send USDC

3501

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3502

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3503

1

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

3504

1

			Box::new(

3505

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3506

1

					.clone()

3507

1

					.into()

3508

1

),

3509

1

			Box::new(

3510

1

3511

1

3512

1

						xcm::latest::prelude::PalletInstance(

3513

1

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

3514

1

),

3515

1

						GeneralIndex(10),

3516

1

],

3517

1

3518

1

3519

1

					.into()

3520

1

),

3521

1

0,

3522

1

			WeightLimit::Unlimited

3523

1

));

3524

1

});

3525

1

3526

1

	ParaA::execute_with(|| {

3527

1

		// Alice should have received the DOTs

3528

1

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

3529

3530

		// Alice has received 125 USDC

3531

1

		assert_eq!(

3532

1

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

3533

1

3534

1

);

3535

1

});

3536

1

3537

1

	let dest = Location::new(

3538

1

1,

3539

1

3540

1

			Parachain(1000),

3541

1

			AccountId32 {

3542

1

				network: None,

3543

1

				id: RELAYBOB.into(),

3544

1

},

3545

1

],

3546

1

);

3547

1

3548

1

	let statemint_asset_to_send = Asset {

3549

1

		id: AssetId(statemint_asset),

3550

1

		fun: Fungible(100),

3551

1

};

3552

1

3553

1

	let relay_asset_to_send = Asset {

3554

1

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

3555

1

		fun: Fungible(100),

3556

1

};

3557

1

3558

1

	let assets_to_send: XcmAssets =

3559

1

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

3560

1

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

3561

1

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

3562

1

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

3563

1

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

3564

3565

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

3566

1

	ParaA::execute_with(|| {

3567

1

		assert_ok!(PolkadotXcm::transfer_assets(

3568

1

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

3569

1

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

3570

1

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

3571

1

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

3572

1

0,

3573

1

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

3574

1

));

3575

3576

1

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

3577

1

});

3578

1

3579

1

	Statemint::execute_with(|| {

3580

1

		// Check that Bob received relay tokens back in AssetHub

3581

1

		assert_eq!(

3582

1

			StatemintBalances::free_balance(RELAYBOB),

3583

1

			INITIAL_BALANCE + 100

3584

1

);

3585

3586

		// Check that BOB received 100 USDC on AssetHub

3587

1

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

3588

1

});

3589

1

3590

1

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

3591

1

	Statemint::execute_with(|| {

3592

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3593

1

3594

1

		// Now send those tokens to ParaA

3595

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3596

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3597

1

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

3598

1

			Box::new(

3599

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3600

1

					.clone()

3601

1

					.into()

3602

1

),

3603

1

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

3604

1

0,

3605

1

			WeightLimit::Unlimited

3606

1

));

3607

3608

		// 100 DOTs were deducted from Bob's account

3609

1

		assert_eq!(

3610

1

			StatemintBalances::free_balance(RELAYBOB),

3611

1

			bob_previous_balance - 100

3612

1

);

3613

1

});

3614

1

3615

1

	ParaA::execute_with(|| {

3616

1

		// Alice should have received 100 DOTs

3617

1

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

3618

1

});

3619

1

3620

3621

#[test]

3622

1

fn transact_through_signed_multilocation() {

3623

1

	MockNet::reset();

3624

1

	let mut ancestry = Location::parent();

3625

1

3626

1

	ParaA::execute_with(|| {

3627

1

		// Root can set transact info

3628

1

		assert_ok!(XcmTransactor::set_transact_info(

3629

1

			parachain::RuntimeOrigin::root(),

3630

1

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

3631

1

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

3632

1

			3000.into(),

3633

1

			20000000000.into(),

3634

1

			// 4 instructions in transact through signed

3635

1

			Some(4000.into())

3636

1

));

3637

		// Root can set transact info

3638

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3639

1

			parachain::RuntimeOrigin::root(),

3640

1

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

3641

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3642

1

));

3643

1

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

3644

1

});

3645

1

3646

1

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

3647

1

	let signed_origin: Junctions = [AccountKey20 {

3648

1

		network: None,

3649

1

		key: PARAALICE,

3650

1

}]

3651

1

	.into();

3652

1

3653

1

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

3654

1

	descend_origin_multilocation

3655

1

		.append_with(signed_origin)

3656

1

		.unwrap();

3657

1

3658

1

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

3659

1

	descend_origin_multilocation

3660

1

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

3661

1

		.unwrap();

3662

1

3663

1

	let derived = xcm_builder::Account32Hash::<

3664

1

		relay_chain::KusamaNetwork,

3665

1

		relay_chain::AccountId,

3666

1

	>::convert_location(&descend_origin_multilocation)

3667

1

	.unwrap();

3668

1

3669

1

	Relay::execute_with(|| {

3670

1

		// free execution, full amount received

3671

1

		assert_ok!(RelayBalances::transfer_allow_death(

3672

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3673

1

			derived.clone(),

3674

1

			4000004100u128,

3675

1

));

3676

		// derived account has all funds

3677

1

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

3678

		// sovereign account has 0 funds

3679

1

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

3680

1

});

3681

1

3682

1

	// Encode the call. Balances transact to para_a_account

3683

1

	// First index

3684

1

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

3685

1

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

3686

1

		relay_chain::Balances,

3687

1

>()

3688

1

	.unwrap() as u8;

3689

1

3690

1

	encoded.push(index);

3691

1

3692

1

	// Then call bytes

3693

1

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

3694

1

		// 100 to sovereign

3695

1

		dest: para_a_account(),

3696

1

		value: 100u32.into(),

3697

1

3698

1

	.encode();

3699

1

	encoded.append(&mut call_bytes);

3700

1

3701

1

	ParaA::execute_with(|| {

3702

1

		assert_ok!(XcmTransactor::transact_through_signed(

3703

1

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

3704

1

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

3705

1

			CurrencyPayment {

3706

1

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

3707

1

					Location::parent()

3708

1

				))),

3709

1

				fee_amount: None

3710

1

},

3711

1

			encoded,

3712

1

			// 4000000000 for transfer + 4000 for XCM

3713

1

			TransactWeights {

3714

1

				transact_required_weight_at_most: 4000000000.into(),

3715

1

				overall_weight: None

3716

1

},

3717

1

			false

3718

1

));

3719

1

});

3720

1

3721

1

	Relay::execute_with(|| {

3722

1

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

3723

3724

1

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

3725

1

});

3726

1

3727

3728

#[test]

3729

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

3730

1

	MockNet::reset();

3731

1

	let mut ancestry = Location::parent();

3732

1

3733

1

	ParaA::execute_with(|| {

3734

1

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

3735

1

});

3736

1

3737

1

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

3738

1

	let signed_origin: Junctions = [AccountKey20 {

3739

1

		network: None,

3740

1

		key: PARAALICE,

3741

1

}]

3742

1

	.into();

3743

1

3744

1

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

3745

1

	descend_origin_multilocation

3746

1

		.append_with(signed_origin)

3747

1

		.unwrap();

3748

1

3749

1

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

3750

1

	descend_origin_multilocation

3751

1

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

3752

1

		.unwrap();

3753

1

3754

1

	let derived = xcm_builder::Account32Hash::<

3755

1

		relay_chain::KusamaNetwork,

3756

1

		relay_chain::AccountId,

3757

1

	>::convert_location(&descend_origin_multilocation)

3758

1

	.unwrap();

3759

1

3760

1

	Relay::execute_with(|| {

3761

1

		// free execution, full amount received

3762

1

		assert_ok!(RelayBalances::transfer_allow_death(

3763

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3764

1

			derived.clone(),

3765

1

			4000004100u128,

3766

1

));

3767

		// derived account has all funds

3768

1

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

3769

		// sovereign account has 0 funds

3770

1

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

3771

1

});

3772

1

3773

1

	// Encode the call. Balances transact to para_a_account

3774

1

	// First index

3775

1

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

3776

1

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

3777

1

		relay_chain::Balances,

3778

1

>()

3779

1

	.unwrap() as u8;

3780

1

3781

1

	encoded.push(index);

3782

1

3783

1

	// Then call bytes

3784

1

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

3785

1

		// 100 to sovereign

3786

1

		dest: para_a_account(),

3787

1

		value: 100u32.into(),

3788

1

3789

1

	.encode();

3790

1

	encoded.append(&mut call_bytes);

3791

1

3792

1

	let total_weight = 4000004000u64;

3793

1

	ParaA::execute_with(|| {

3794

1

		assert_ok!(XcmTransactor::transact_through_signed(

3795

1

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

3796

1

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

3797

1

			CurrencyPayment {

3798

1

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

3799

1

					Location::parent()

3800

1

				))),

3801

1

				fee_amount: Some(total_weight as u128)

3802

1

},

3803

1

			encoded,

3804

1

			// 4000000000 for transfer + 4000 for XCM

3805

1

			TransactWeights {

3806

1

				transact_required_weight_at_most: 4000000000.into(),

3807

1

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

3808

1

},

3809

1

			false

3810

1

));

3811

1

});

3812

1

3813

1

	Relay::execute_with(|| {

3814

1

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

3815

3816

1

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

3817

1

});

3818

1

3819

3820

#[test]

3821

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

3822

1

	MockNet::reset();

3823

1

	let mut ancestry = Location::parent();

3824

1

3825

1

	ParaA::execute_with(|| {

3826

1

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

3827

1

});

3828

1

3829

1

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

3830

1

	let signed_origin: Junctions = [AccountKey20 {

3831

1

		network: None,

3832

1

		key: PARAALICE,

3833

1

}]

3834

1

	.into();

3835

1

3836

1

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

3837

1

	descend_origin_multilocation

3838

1

		.append_with(signed_origin)

3839

1

		.unwrap();

3840

1

3841

1

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

3842

1

	descend_origin_multilocation

3843

1

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

3844

1

		.unwrap();

3845

1

3846

1

	let derived = xcm_builder::Account32Hash::<

3847

1

		relay_chain::KusamaNetwork,

3848

1

		relay_chain::AccountId,

3849

1

	>::convert_location(&descend_origin_multilocation)

3850

1

	.unwrap();

3851

1

3852

1

	Relay::execute_with(|| {

3853

1

		// free execution, full amount received

3854

1

		assert_ok!(RelayBalances::transfer_allow_death(

3855

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3856

1

			derived.clone(),

3857

1

			4000009100u128,

3858

1

));

3859

		// derived account has all funds

3860

1

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

3861

		// sovereign account has 0 funds

3862

1

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

3863

1

});

3864

1

3865

1

	// Encode the call. Balances transact to para_a_account

3866

1

	// First index

3867

1

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

3868

1

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

3869

1

		relay_chain::Balances,

3870

1

>()

3871

1

	.unwrap() as u8;

3872

1

3873

1

	encoded.push(index);

3874

1

3875

1

	// Then call bytes

3876

1

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

3877

1

		// 100 to sovereign

3878

1

		dest: para_a_account(),

3879

1

		value: 100u32.into(),

3880

1

3881

1

	.encode();

3882

1

	encoded.append(&mut call_bytes);

3883

1

3884

1

	let total_weight = 4000009000u64;

3885

1

	ParaA::execute_with(|| {

3886

1

		assert_ok!(XcmTransactor::transact_through_signed(

3887

1

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

3888

1

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

3889

1

			CurrencyPayment {

3890

1

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

3891

1

					Location::parent()

3892

1

				))),

3893

1

				fee_amount: Some(total_weight as u128)

3894

1

},

3895

1

			encoded,

3896

1

			// 4000000000 for transfer + 9000 for XCM

3897

1

			TransactWeights {

3898

1

				transact_required_weight_at_most: 4000000000.into(),

3899

1

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

3900

1

},

3901

1

			true

3902

1

));

3903

1

});

3904

1

3905

1

	Relay::execute_with(|| {

3906

1

		// 100 transferred

3907

1

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

3908

3909

		// 4000009000 refunded

3910

1

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

3911

1

});

3912

1

3913

3914

#[test]

3915

1

fn transact_through_signed_multilocation_para_to_para() {

3916

1

	MockNet::reset();

3917

1

	let mut ancestry = Location::parent();

3918

1

3919

1

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

3920

1

3921

1

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

3922

1

3923

1

	ParaA::execute_with(|| {

3924

1

		// Root can set transact info

3925

1

		assert_ok!(XcmTransactor::set_transact_info(

3926

1

			parachain::RuntimeOrigin::root(),

3927

1

			// ParaB

3928

1

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

3929

1

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

3930

1

			3.into(),

3931

1

			20000000000.into(),

3932

1

			// 4 instructions in transact through signed

3933

1

			Some(4.into())

3934

1

));

3935

		// Root can set transact info

3936

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3937

1

			parachain::RuntimeOrigin::root(),

3938

1

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

3939

1

			parachain::ParaTokensPerSecond::get(),

3940

1

));

3941

1

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

3942

1

});

3943

1

3944

1

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

3945

1

	let signed_origin: Junctions = [AccountKey20 {

3946

1

		network: None,

3947

1

		key: PARAALICE,

3948

1

}]

3949

1

	.into();

3950

1

3951

1

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

3952

1

	descend_origin_location.append_with(signed_origin).unwrap();

3953

1

3954

1

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

3955

1

	descend_origin_location

3956

1

		.reanchor(&para_b_location, &ancestry.interior)

3957

1

		.unwrap();

3958

1

3959

1

	let derived = xcm_builder::HashedDescription::<

3960

1

		parachain::AccountId,

3961

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

3962

1

	>::convert_location(&descend_origin_location)

3963

1

	.unwrap();

3964

1

3965

1

	ParaB::execute_with(|| {

3966

1

		// free execution, full amount received

3967

1

		assert_ok!(ParaBalances::transfer_allow_death(

3968

1

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

3969

1

			derived.clone(),

3970

1

			4000000104u128,

3971

1

));

3972

		// derived account has all funds

3973

1

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

3974

		// sovereign account has 0 funds

3975

1

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

3976

1

});

3977

1

3978

1

	// Encode the call. Balances transact to para_a_account

3979

1

	// First index

3980

1

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

3981

1

	let index =

3982

1

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

3983

1

			.unwrap() as u8;

3984

1

3985

1

	encoded.push(index);

3986

1

3987

1

	// Then call bytes

3988

1

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

3989

1

		// 100 to sovereign

3990

1

		dest: para_a_account_20(),

3991

1

		value: 100u32.into(),

3992

1

3993

1

	.encode();

3994

1

	encoded.append(&mut call_bytes);

3995

1

3996

1

	ParaA::execute_with(|| {

3997

1

		assert_ok!(XcmTransactor::transact_through_signed(

3998

1

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

3999

1

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

4000

1

			CurrencyPayment {

4001

1

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

4002

1

					para_b_balances

4003

1

				))),

4004

1

				fee_amount: None

4005

1

},

4006

1

			encoded,

4007

1

			// 4000000000 for transfer + 4000 for XCM

4008

1

			// 1-1 to fee

4009

1

			TransactWeights {

4010

1

				transact_required_weight_at_most: 4000000000.into(),

4011

1

				overall_weight: None

4012

1

},

4013

1

			false

4014

1

));

4015

1

});

4016

1

4017

1

	ParaB::execute_with(|| {

4018

1

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

4019

4020

1

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

4021

1

});

4022

1

4023

4024

#[test]

4025

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4026

1

	MockNet::reset();

4027

1

	let mut ancestry = Location::parent();

4028

1

4029

1

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

4030

1

4031

1

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

4032

1

4033

1

	ParaA::execute_with(|| {

4034

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4035

1

			parachain::RuntimeOrigin::root(),

4036

1

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

4037

1

			parachain::ParaTokensPerSecond::get(),

4038

1

));

4039

1

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

4040

1

});

4041

1

4042

1

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

4043

1

	let signed_origin: Junctions = [AccountKey20 {

4044

1

		network: None,

4045

1

		key: PARAALICE,

4046

1

}]

4047

1

	.into();

4048

1

4049

1

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

4050

1

	descend_origin_location.append_with(signed_origin).unwrap();

4051

1

4052

1

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

4053

1

	descend_origin_location

4054

1

		.reanchor(&para_b_location, &ancestry.interior)

4055

1

		.unwrap();

4056

1

4057

1

	let derived = xcm_builder::HashedDescription::<

4058

1

		parachain::AccountId,

4059

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4060

1

	>::convert_location(&descend_origin_location)

4061

1

	.unwrap();

4062

1

4063

1

	ParaB::execute_with(|| {

4064

1

		// free execution, full amount received

4065

1

		assert_ok!(ParaBalances::transfer_allow_death(

4066

1

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

4067

1

			derived.clone(),

4068

1

			4000009100u128,

4069

1

));

4070

		// derived account has all funds

4071

1

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

4072

		// sovereign account has 0 funds

4073

1

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

4074

1

});

4075

1

4076

1

	// Encode the call. Balances transact to para_a_account

4077

1

	// First index

4078

1

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

4079

1

	let index =

4080

1

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

4081

1

			.unwrap() as u8;

4082

1

4083

1

	encoded.push(index);

4084

1

4085

1

	// Then call bytes

4086

1

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

4087

1

		// 100 to sovereign

4088

1

		dest: para_a_account_20(),

4089

1

		value: 100u32.into(),

4090

1

4091

1

	.encode();

4092

1

	encoded.append(&mut call_bytes);

4093

1

4094

1

	let overall_weight = 4000009000u64;

4095

1

	ParaA::execute_with(|| {

4096

1

		assert_ok!(XcmTransactor::transact_through_signed(

4097

1

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

4098

1

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

4099

1

			CurrencyPayment {

4100

1

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

4101

1

					para_b_balances

4102

1

				))),

4103

1

				fee_amount: Some(overall_weight as u128)

4104

1

},

4105

1

			encoded,

4106

1

			// 4000000000 for transfer + 9000 for XCM

4107

1

			TransactWeights {

4108

1

				transact_required_weight_at_most: 4000000000.into(),

4109

1

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

4110

1

},

4111

1

			true

4112

1

));

4113

1

});

4114

1

4115

1

	ParaB::execute_with(|| {

4116

1

		// Check the derived account was refunded

4117

1

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

4118

4119

		// Check the transfer was executed

4120

1

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

4121

1

});

4122

1

4123

4124

#[test]

4125

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4126

1

	MockNet::reset();

4127

1

	let mut ancestry = Location::parent();

4128

1

4129

1

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

4130

1

4131

1

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

4132

1

4133

1

	ParaA::execute_with(|| {

4134

1

		// Root can set transact info

4135

1

		assert_ok!(XcmTransactor::set_transact_info(

4136

1

			parachain::RuntimeOrigin::root(),

4137

1

			// ParaB

4138

1

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

4139

1

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

4140

1

			3.into(),

4141

1

			20000000000.into(),

4142

1

			// 4 instructions in transact through signed

4143

1

			Some(4.into())

4144

1

));

4145

		// Root can set transact info

4146

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4147

1

			parachain::RuntimeOrigin::root(),

4148

1

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

4149

1

			parachain::ParaTokensPerSecond::get(),

4150

1

));

4151

1

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

4152

1

});

4153

1

4154

1

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

4155

1

	let signed_origin: Junctions = [AccountKey20 {

4156

1

		network: None,

4157

1

		key: PARAALICE,

4158

1

}]

4159

1

	.into();

4160

1

4161

1

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

4162

1

	descend_origin_location.append_with(signed_origin).unwrap();

4163

1

4164

1

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

4165

1

	descend_origin_location

4166

1

		.reanchor(&para_b_location, &ancestry.interior)

4167

1

		.unwrap();

4168

1

4169

1

	let derived = xcm_builder::HashedDescription::<

4170

1

		parachain::AccountId,

4171

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4172

1

	>::convert_location(&descend_origin_location)

4173

1

	.unwrap();

4174

1

4175

1

	let mut parachain_b_alice_balances_before = 0;

4176

1

	ParaB::execute_with(|| {

4177

1

		assert_ok!(ParaBalances::transfer_allow_death(

4178

1

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

4179

1

			derived.clone(),

4180

1

			4000000104u128,

4181

1

));

4182

		// derived account has all funds

4183

1

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

4184

		// sovereign account has 0 funds

4185

1

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

4186

4187

1

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

4188

1

});

4189

1

4190

1

	// Encode the call. Balances transact to para_a_account

4191

1

	// First index

4192

1

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

4193

1

	let index =

4194

1

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

4195

1

			.unwrap() as u8;

4196

1

4197

1

	encoded.push(index);

4198

4199

	use sp_core::U256;

4200

	// Let's do a EVM transfer

4201

1

	let eth_tx =

4202

1

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

4203

1

			gas_limit: U256::from(21000),

4204

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4205

1

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

4206

1

			value: U256::from(100),

4207

1

			input: BoundedVec::<

4208

1

u8,

4209

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4210

1

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

4211

1

			access_list: None,

4212

1

});

4213

1

4214

1

	// Then call bytes

4215

1

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

4216

1

		xcm_transaction: eth_tx,

4217

1

4218

1

	.encode();

4219

1

	encoded.append(&mut call_bytes);

4220

1

4221

1

	ParaA::execute_with(|| {

4222

1

		assert_ok!(XcmTransactor::transact_through_signed(

4223

1

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

4224

1

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

4225

1

			CurrencyPayment {

4226

1

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

4227

1

					para_b_balances

4228

1

				))),

4229

1

				fee_amount: None

4230

1

},

4231

1

			encoded,

4232

1

			// 4000000000 for transfer + 4000 for XCM

4233

1

			// 1-1 to fee

4234

1

			TransactWeights {

4235

1

				transact_required_weight_at_most: 4000000000.into(),

4236

1

				overall_weight: None

4237

1

},

4238

1

			false

4239

1

));

4240

1

});

4241

1

4242

1

	ParaB::execute_with(|| {

4243

1

		// Make sure the EVM transfer went through

4244

1

		assert!(

4245

1

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

4246

1

				== parachain_b_alice_balances_before + 100

4247

1

);

4248

1

});

4249

1

4250

4251

#[test]

4252

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4253

1

	MockNet::reset();

4254

1

	let mut ancestry = Location::parent();

4255

1

4256

1

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

4257

1

4258

1

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

4259

1

4260

1

	ParaA::execute_with(|| {

4261

1

		// Root can set transact info

4262

1

		assert_ok!(XcmTransactor::set_transact_info(

4263

1

			parachain::RuntimeOrigin::root(),

4264

1

			// ParaB

4265

1

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

4266

1

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

4267

1

			3.into(),

4268

1

			20000000000.into(),

4269

1

			// 4 instructions in transact through signed

4270

1

			Some(4.into())

4271

1

));

4272

		// Root can set transact info

4273

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4274

1

			parachain::RuntimeOrigin::root(),

4275

1

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

4276

1

			parachain::ParaTokensPerSecond::get(),

4277

1

));

4278

1

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

4279

1

});

4280

1

4281

1

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

4282

1

	let signed_origin: Junctions = [AccountKey20 {

4283

1

		network: None,

4284

1

		key: PARAALICE,

4285

1

}]

4286

1

	.into();

4287

1

4288

1

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

4289

1

	descend_origin_location.append_with(signed_origin).unwrap();

4290

1

4291

1

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

4292

1

	descend_origin_location

4293

1

		.reanchor(&para_b_location, &ancestry.interior)

4294

1

		.unwrap();

4295

1

4296

1

	let derived = xcm_builder::HashedDescription::<

4297

1

		parachain::AccountId,

4298

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4299

1

	>::convert_location(&descend_origin_location)

4300

1

	.unwrap();

4301

1

4302

1

	let mut parachain_b_alice_balances_before = 0;

4303

1

	ParaB::execute_with(|| {

4304

1

		assert_ok!(ParaBalances::transfer_allow_death(

4305

1

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

4306

1

			derived.clone(),

4307

1

			4000000104u128,

4308

1

));

4309

		// derived account has all funds

4310

1

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

4311

		// sovereign account has 0 funds

4312

1

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

4313

4314

1

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

4315

1

});

4316

1

4317

1

	// Encode the call. Balances transact to para_a_account

4318

1

	// First index

4319

1

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

4320

1

	let index =

4321

1

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

4322

1

			.unwrap() as u8;

4323

1

4324

1

	encoded.push(index);

4325

4326

	use sp_core::U256;

4327

	// Let's do a EVM transfer

4328

1

	let eth_tx =

4329

1

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

4330

1

			gas_limit: U256::from(21000),

4331

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4332

1

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

4333

1

			value: U256::from(100),

4334

1

			input: BoundedVec::<

4335

1

u8,

4336

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4337

1

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

4338

1

			access_list: None,

4339

1

});

4340

1

4341

1

	// Then call bytes

4342

1

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

4343

1

		transact_as: PARAALICE.into(),

4344

1

		xcm_transaction: eth_tx,

4345

1

4346

1

	.encode();

4347

1

	encoded.append(&mut call_bytes);

4348

1

4349

1

	ParaA::execute_with(|| {

4350

1

		assert_ok!(XcmTransactor::transact_through_signed(

4351

1

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

4352

1

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

4353

1

			CurrencyPayment {

4354

1

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

4355

1

					para_b_balances

4356

1

				))),

4357

1

				fee_amount: None

4358

1

},

4359

1

			encoded,

4360

1

			TransactWeights {

4361

1

				transact_required_weight_at_most: 4000000000.into(),

4362

1

				overall_weight: None

4363

1

},

4364

1

			false

4365

1

));

4366

1

});

4367

1

4368

1

	ParaB::execute_with(|| {

4369

1

		// Make sure the EVM transfer wasn't executed

4370

1

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

4371

1

});

4372

1

4373

4374

#[test]

4375

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4376

1

	MockNet::reset();

4377

1

	let mut ancestry = Location::parent();

4378

1

4379

1

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

4380

1

4381

1

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

4382

1

4383

1

	ParaA::execute_with(|| {

4384

1

		// Root can set transact info

4385

1

		assert_ok!(XcmTransactor::set_transact_info(

4386

1

			parachain::RuntimeOrigin::root(),

4387

1

			// ParaB

4388

1

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

4389

1

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

4390

1

			3.into(),

4391

1

			20000000000.into(),

4392

1

			// 4 instructions in transact through signed

4393

1

			Some(4.into())

4394

1

));

4395

		// Root can set transact info

4396

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4397

1

			parachain::RuntimeOrigin::root(),

4398

1

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

4399

1

			parachain::ParaTokensPerSecond::get(),

4400

1

));

4401

1

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

4402

1

});

4403

1

4404

1

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

4405

1

	let signed_origin: Junctions = [AccountKey20 {

4406

1

		network: None,

4407

1

		key: PARAALICE,

4408

1

}]

4409

1

	.into();

4410

1

4411

1

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

4412

1

	descend_origin_location.append_with(signed_origin).unwrap();

4413

1

4414

1

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

4415

1

	descend_origin_location

4416

1

		.reanchor(&para_b_location, &ancestry.interior)

4417

1

		.unwrap();

4418

1

4419

1

	let derived = xcm_builder::HashedDescription::<

4420

1

		parachain::AccountId,

4421

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4422

1

	>::convert_location(&descend_origin_location)

4423

1

	.unwrap();

4424

1

4425

1

	let transfer_recipient = evm_account();

4426

1

	let mut transfer_recipient_balance_before = 0;

4427

1

	ParaB::execute_with(|| {

4428

1

		assert_ok!(ParaBalances::transfer_allow_death(

4429

1

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

4430

1

			derived.clone(),

4431

1

			4000000104u128,

4432

1

));

4433

		// derived account has all funds

4434

1

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

4435

		// sovereign account has 0 funds

4436

1

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

4437

4438

1

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

4439

1

4440

1

		// Add proxy ALICE  -> derived

4441

1

		let _ = parachain::Proxy::add_proxy_delegate(

4442

1

			&PARAALICE.into(),

4443

1

			derived,

4444

1

			parachain::ProxyType::Any,

4445

1

0,

4446

1

);

4447

1

});

4448

1

4449

1

	// Encode the call. Balances transact to para_a_account

4450

1

	// First index

4451

1

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

4452

1

	let index =

4453

1

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

4454

1

			.unwrap() as u8;

4455

1

4456

1

	encoded.push(index);

4457

4458

	use sp_core::U256;

4459

	// Let's do a EVM transfer

4460

1

	let eth_tx =

4461

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4462

1

			gas_limit: U256::from(21000),

4463

1

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

4464

1

			value: U256::from(100),

4465

1

			input: BoundedVec::<

4466

1

u8,

4467

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4468

1

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

4469

1

			access_list: None,

4470

1

});

4471

1

4472

1

	// Then call bytes

4473

1

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

4474

1

		transact_as: PARAALICE.into(),

4475

1

		xcm_transaction: eth_tx,

4476

1

4477

1

	.encode();

4478

1

	encoded.append(&mut call_bytes);

4479

1

4480

1

	ParaA::execute_with(|| {

4481

1

		assert_ok!(XcmTransactor::transact_through_signed(

4482

1

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

4483

1

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

4484

1

			CurrencyPayment {

4485

1

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

4486

1

					para_b_balances

4487

1

				))),

4488

1

				fee_amount: None

4489

1

},

4490

1

			encoded,

4491

1

			TransactWeights {

4492

1

				transact_required_weight_at_most: 4000000000.into(),

4493

1

				overall_weight: None

4494

1

},

4495

1

			false

4496

1

));

4497

1

});

4498

1

4499

1

	ParaB::execute_with(|| {

4500

1

		// Make sure the EVM transfer was executed

4501

1

		assert!(

4502

1

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

4503

1

				== transfer_recipient_balance_before + 100

4504

1

);

4505

1

});

4506

1

4507

4508

#[test]

4509

1

fn hrmp_init_accept_through_root() {

4510

1

	MockNet::reset();

4511

1

4512

1

	Relay::execute_with(|| {

4513

1

		assert_ok!(RelayBalances::transfer_allow_death(

4514

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4515

1

			para_a_account(),

4516

1

			1000u128

4517

1

));

4518

1

		assert_ok!(RelayBalances::transfer_allow_death(

4519

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4520

1

			para_b_account(),

4521

1

			1000u128

4522

1

));

4523

1

});

4524

1

4525

1

	ParaA::execute_with(|| {

4526

1

		let total_fee = 1_000u128;

4527

1

		let total_weight: u64 = 1_000_000_000;

4528

1

		let tx_weight: u64 = 500_000_000;

4529

1

		// Root can send hrmp init channel

4530

1

		assert_ok!(XcmTransactor::hrmp_manage(

4531

1

			parachain::RuntimeOrigin::root(),

4532

1

			HrmpOperation::InitOpen(HrmpInitParams {

4533

1

				para_id: 2u32.into(),

4534

1

				proposed_max_capacity: 1,

4535

1

				proposed_max_message_size: 1

4536

1

}),

4537

1

			CurrencyPayment {

4538

1

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

4539

1

					Location::parent()

4540

1

				))),

4541

1

				fee_amount: Some(total_fee)

4542

1

},

4543

1

			TransactWeights {

4544

1

				transact_required_weight_at_most: tx_weight.into(),

4545

1

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

4546

1

4547

1

));

4548

1

});

4549

1

	Relay::execute_with(|| {

4550

1

		let expected_event: relay_chain::RuntimeEvent =

4551

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4552

1

				sender: 1u32.into(),

4553

1

				recipient: 2u32.into(),

4554

1

				proposed_max_capacity: 1u32,

4555

1

				proposed_max_message_size: 1u32,

4556

1

4557

1

			.into();

4558

1

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

4559

1

});

4560

1

	ParaB::execute_with(|| {

4561

1

		let total_fee = 1_000u128;

4562

1

		let total_weight: u64 = 1_000_000_000;

4563

1

		let tx_weight: u64 = 500_000_000;

4564

1

		// Root can send hrmp accept channel

4565

1

		assert_ok!(XcmTransactor::hrmp_manage(

4566

1

			parachain::RuntimeOrigin::root(),

4567

1

			HrmpOperation::Accept {

4568

1

				para_id: 1u32.into()

4569

1

},

4570

1

			CurrencyPayment {

4571

1

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

4572

1

					Location::parent()

4573

1

				))),

4574

1

				fee_amount: Some(total_fee)

4575

1

},

4576

1

			TransactWeights {

4577

1

				transact_required_weight_at_most: tx_weight.into(),

4578

1

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

4579

1

4580

1

));

4581

1

});

4582

1

4583

1

	Relay::execute_with(|| {

4584

1

		let expected_event: relay_chain::RuntimeEvent =

4585

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4586

1

				sender: 1u32.into(),

4587

1

				recipient: 2u32.into(),

4588

1

4589

1

			.into();

4590

1

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

4591

1

});

4592

1

4593

4594

#[test]

4595

1

fn hrmp_close_works() {

4596

1

	MockNet::reset();

4597

1

4598

1

	Relay::execute_with(|| {

4599

1

		assert_ok!(RelayBalances::transfer_allow_death(

4600

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4601

1

			para_a_account(),

4602

1

			1000u128

4603

1

));

4604

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4605

1

			relay_chain::RuntimeOrigin::root(),

4606

1

			1u32.into(),

4607

1

			2u32.into(),

4608

1

			1u32,

4609

1

			1u32

4610

1

));

4611

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4612

1

			relay_chain::RuntimeOrigin::root(),

4613

1

			1u32

4614

1

));

4615

1

});

4616

1

4617

1

	ParaA::execute_with(|| {

4618

1

		let total_fee = 1_000u128;

4619

1

		let total_weight: u64 = 1_000_000_000;

4620

1

		let tx_weight: u64 = 500_000_000;

4621

1

		// Root can send hrmp close

4622

1

		assert_ok!(XcmTransactor::hrmp_manage(

4623

1

			parachain::RuntimeOrigin::root(),

4624

1

			HrmpOperation::Close(HrmpChannelId {

4625

1

				sender: 1u32.into(),

4626

1

				recipient: 2u32.into()

4627

1

}),

4628

1

			CurrencyPayment {

4629

1

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

4630

1

					Location::parent()

4631

1

				))),

4632

1

				fee_amount: Some(total_fee)

4633

1

},

4634

1

			TransactWeights {

4635

1

				transact_required_weight_at_most: tx_weight.into(),

4636

1

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

4637

1

4638

1

));

4639

1

});

4640

1

	Relay::execute_with(|| {

4641

1

		let expected_event: relay_chain::RuntimeEvent =

4642

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4643

1

				by_parachain: 1u32.into(),

4644

1

				channel_id: HrmpChannelId {

4645

1

					sender: 1u32.into(),

4646

1

					recipient: 2u32.into(),

4647

1

},

4648

1

4649

1

			.into();

4650

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4651

1

});

4652

1

4653

4654

use parity_scale_codec::{Decode, Encode};

4655

use sp_io::hashing::blake2_256;

4656

4657

// Helper to derive accountIds

4658

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4659

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4660

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4661

7