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

//! Moonbase Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{ConstU32, PalletInfo, PalletInfoAccess},

23

	weights::constants::WEIGHT_REF_TIME_PER_SECOND,

24

	weights::Weight,

25

	BoundedVec,

26

};

27

use moonbase_runtime::xcm_config::AssetType;

28

use pallet_xcm_transactor::{

29

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

30

};

31

use sp_runtime::traits::Convert;

32

use sp_std::boxed::Box;

33

use xcm::{

34

	latest::prelude::{

35

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

36

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

37

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

38

		WeightLimit, WithdrawAsset, Xcm,

39

},

40

	VersionedAssets,

41

};

42

use xcm::{IntoVersion, VersionedLocation, WrapVersion};

43

use xcm_executor::traits::ConvertLocation;

44

use xcm_mock::*;

45

use xcm_primitives::{

46

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

47

};

48

use xcm_simulator::TestExt;

49

mod common;

50

use cumulus_primitives_core::relay_chain::HrmpChannelId;

51

use parachain::PolkadotXcm;

52

53

28

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

54

28

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

55

28

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

56

28

		.into_version(xcm::latest::VERSION)

57

28

		.map_err(|_| ())?

58

	else {

59

		return Err(());

60

};

61

	use frame_support::weights::WeightToFee as _;

62

28

	let native_amount_per_second: u128 =

63

28

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

64

28

			&Weight::from_parts(

65

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

66

28

0,

67

28

),

68

28

69

28

		.try_into()

70

28

		.map_err(|_| ())?;

71

28

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

72

28

	let relative_price: u128 = if units_per_second > 0u128 {

73

10

		native_amount_per_second

74

10

			.saturating_mul(precision_factor)

75

10

			.saturating_div(units_per_second)

76

	} else {

77

18

		0u128

78

};

79

28

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

80

28

		location_v5,

81

28

		(true, relative_price),

82

28

);

83

28

	Ok(())

84

28

85

86

25

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

87

25

	Asset {

88

25

		id: AssetId(

89

25

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

90

25

				currency_id,

91

25

92

25

			.unwrap(),

93

25

),

94

25

		fun: Fungibility::Fungible(amount),

95

25

96

25

97

98

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

99

#[test]

100

1

fn receive_relay_asset_from_relay() {

101

1

	MockNet::reset();

102

1

103

1

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

104

1

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

105

1

	let asset_metadata = parachain::AssetMetadata {

106

1

		name: b"RelayToken".to_vec(),

107

1

		symbol: b"Relay".to_vec(),

108

1

		decimals: 12,

109

1

};

110

1

	// register relay asset in parachain A

111

1

	ParaA::execute_with(|| {

112

1

		assert_ok!(AssetManager::register_foreign_asset(

113

1

			parachain::RuntimeOrigin::root(),

114

1

			source_location.clone(),

115

1

			asset_metadata,

116

1

			1u128,

117

1

			true

118

1

));

119

1

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

120

1

});

121

1

122

1

	// Actually send relay asset to parachain

123

1

	let dest: Location = AccountKey20 {

124

1

		network: None,

125

1

		key: PARAALICE,

126

1

127

1

	.into();

128

1

	Relay::execute_with(|| {

129

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

130

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

131

1

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

132

1

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

133

1

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

134

1

0,

135

1

			WeightLimit::Unlimited

136

1

));

137

1

});

138

1

139

1

	// Verify that parachain received the asset

140

1

	ParaA::execute_with(|| {

141

1

		// free execution, full amount received

142

1

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

143

1

});

144

1

145

146

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

147

#[test]

148

1

fn send_relay_asset_to_relay() {

149

1

	MockNet::reset();

150

1

151

1

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

152

1

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

153

1

154

1

	let asset_metadata = parachain::AssetMetadata {

155

1

		name: b"RelayToken".to_vec(),

156

1

		symbol: b"Relay".to_vec(),

157

1

		decimals: 12,

158

1

};

159

1

160

1

	// Register relay asset in paraA

161

1

	ParaA::execute_with(|| {

162

1

		assert_ok!(AssetManager::register_foreign_asset(

163

1

			parachain::RuntimeOrigin::root(),

164

1

			source_location.clone(),

165

1

			asset_metadata,

166

1

			1u128,

167

1

			true

168

1

));

169

		// Free execution

170

1

		assert_ok!(add_supported_asset(source_location, 0));

171

1

});

172

1

173

1

	let dest: Location = Junction::AccountKey20 {

174

1

		network: None,

175

1

		key: PARAALICE,

176

1

177

1

	.into();

178

1

179

1

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

180

1

	Relay::execute_with(|| {

181

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

182

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

183

1

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

184

1

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

185

1

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

186

1

0,

187

1

			WeightLimit::Unlimited

188

1

));

189

1

});

190

1

191

1

	ParaA::execute_with(|| {

192

1

		// Free execution, full amount received

193

1

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

194

1

});

195

1

196

1

	// Lets gather the balance before sending back money

197

1

	let mut balance_before_sending = 0;

198

1

	Relay::execute_with(|| {

199

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

200

1

});

201

1

202

1

	// We now send back some money to the relay

203

1

	let dest = Location {

204

1

		parents: 1,

205

1

		interior: [AccountId32 {

206

1

			network: None,

207

1

			id: RELAYALICE.into(),

208

1

}]

209

1

		.into(),

210

1

};

211

1

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

212

1

213

1

	ParaA::execute_with(|| {

214

1

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

215

1

		// free execution, full amount received

216

1

		assert_ok!(PolkadotXcm::transfer_assets(

217

1

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

218

1

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

219

1

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

220

1

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

221

1

0,

222

1

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

223

1

));

224

1

});

225

1

226

1

	// The balances in paraAlice should have been substracted

227

1

	ParaA::execute_with(|| {

228

1

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

229

1

});

230

1

231

1

	// Balances in the relay should have been received

232

1

	Relay::execute_with(|| {

233

1

		// Free execution,x	 full amount received

234

1

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

235

1

});

236

1

237

238

#[test]

239

1

fn send_relay_asset_to_para_b() {

240

1

	MockNet::reset();

241

1

242

1

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

243

1

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

244

1

245

1

	let asset_metadata = parachain::AssetMetadata {

246

1

		name: b"RelayToken".to_vec(),

247

1

		symbol: b"Relay".to_vec(),

248

1

		decimals: 12,

249

1

};

250

1

251

1

	// Register asset in paraA. Free execution

252

1

	ParaA::execute_with(|| {

253

1

		assert_ok!(AssetManager::register_foreign_asset(

254

1

			parachain::RuntimeOrigin::root(),

255

1

			source_location.clone(),

256

1

			asset_metadata.clone(),

257

1

			1u128,

258

1

			true

259

1

));

260

1

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

261

1

});

262

1

263

1

	// Register asset in paraB. Free execution

264

1

	ParaB::execute_with(|| {

265

1

		assert_ok!(AssetManager::register_foreign_asset(

266

1

			parachain::RuntimeOrigin::root(),

267

1

			source_location.clone(),

268

1

			asset_metadata,

269

1

			1u128,

270

1

			true

271

1

));

272

1

		assert_ok!(add_supported_asset(source_location, 0));

273

1

});

274

1

275

1

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

276

1

	let dest: Location = Junction::AccountKey20 {

277

1

		network: None,

278

1

		key: PARAALICE,

279

1

280

1

	.into();

281

1

	Relay::execute_with(|| {

282

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

283

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

284

1

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

285

1

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

286

1

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

287

1

0,

288

1

			WeightLimit::Unlimited

289

1

));

290

1

});

291

1

292

1

	ParaA::execute_with(|| {

293

1

		// Free execution, full amount received

294

1

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

295

1

});

296

1

297

1

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

298

1

	let dest = Location {

299

1

		parents: 1,

300

1

		interior: [

301

1

			Parachain(2),

302

1

			AccountKey20 {

303

1

				network: None,

304

1

				key: PARAALICE.into(),

305

1

},

306

1

307

1

		.into(),

308

1

};

309

1

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

310

1

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(vec![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, 0));

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

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(vec![asset])),

386

1

0,

387

1

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

388

1

));

389

1

});

390

1

391

1

	// Native token is substracted in paraA

392

1

	ParaA::execute_with(|| {

393

1

		assert_eq!(

394

1

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

395

1

			INITIAL_BALANCE - 100

396

1

);

397

1

});

398

1

399

1

	// Asset is minted in paraB

400

1

	ParaB::execute_with(|| {

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(), 0));

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, 0));

444

1

});

445

1

446

1

	// Send para A asset to para B

447

1

	let dest = Location {

448

1

		parents: 1,

449

1

		interior: [

450

1

			Parachain(2),

451

1

			AccountKey20 {

452

1

				network: None,

453

1

				key: PARAALICE.into(),

454

1

},

455

1

456

1

		.into(),

457

1

};

458

1

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

459

1

460

1

	ParaA::execute_with(|| {

461

1

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

462

1

		// free execution, full amount received

463

1

		assert_ok!(PolkadotXcm::transfer_assets(

464

1

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

465

1

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

466

1

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

467

1

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

468

1

0,

469

1

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

470

1

));

471

1

});

472

1

473

1

	// Para A balances have been substracted

474

1

	ParaA::execute_with(|| {

475

1

		assert_eq!(

476

1

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

477

1

			INITIAL_BALANCE - 100

478

1

);

479

1

});

480

1

481

1

	// Para B balances have been credited

482

1

	ParaB::execute_with(|| {

483

1

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

484

1

});

485

1

486

1

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

487

1

	let dest = Location {

488

1

		parents: 1,

489

1

		interior: [

490

1

			Parachain(3),

491

1

			AccountKey20 {

492

1

				network: None,

493

1

				key: PARAALICE.into(),

494

1

},

495

1

496

1

		.into(),

497

1

};

498

1

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

499

1

500

1

	ParaB::execute_with(|| {

501

1

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

502

1

		assert_ok!(PolkadotXcm::transfer_assets(

503

1

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

504

1

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

505

1

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

506

1

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

507

1

0,

508

1

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

509

1

));

510

1

});

511

1

512

1

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

513

1

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

514

1

	ParaC::execute_with(|| {

515

1

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

516

1

});

517

1

518

519

#[test]

520

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

521

1

	MockNet::reset();

522

1

523

1

	// Para A asset

524

1

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

525

1

	let source_location: AssetType = para_a_balances

526

1

		.try_into()

527

1

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

528

1

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

529

1

530

1

	let asset_metadata = parachain::AssetMetadata {

531

1

		name: b"ParaAToken".to_vec(),

532

1

		symbol: b"ParaA".to_vec(),

533

1

		decimals: 18,

534

1

};

535

1

536

1

	// Register para A asset in para B

537

1

	ParaB::execute_with(|| {

538

1

		assert_ok!(AssetManager::register_foreign_asset(

539

1

			parachain::RuntimeOrigin::root(),

540

1

			source_location.clone(),

541

1

			asset_metadata,

542

1

			1u128,

543

1

			true

544

1

));

545

1

		assert_ok!(add_supported_asset(source_location, 0));

546

1

});

547

1

548

1

	// Send para A asset to para B

549

1

	let dest = Location {

550

1

		parents: 1,

551

1

		interior: [

552

1

			Parachain(2),

553

1

			AccountKey20 {

554

1

				network: None,

555

1

				key: PARAALICE.into(),

556

1

},

557

1

558

1

		.into(),

559

1

};

560

1

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

561

1

562

1

	ParaA::execute_with(|| {

563

1

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

564

1

		assert_ok!(PolkadotXcm::transfer_assets(

565

1

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

566

1

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

567

1

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

568

1

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

569

1

0,

570

1

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

571

1

));

572

1

});

573

1

574

1

	// Balances have been subtracted

575

1

	ParaA::execute_with(|| {

576

1

		assert_eq!(

577

1

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

578

1

			INITIAL_BALANCE - 100

579

1

);

580

1

});

581

1

582

1

	// Para B balances have been credited

583

1

	ParaB::execute_with(|| {

584

1

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

585

1

});

586

1

587

1

	// Send back para A asset to para A

588

1

	let dest = Location {

589

1

		parents: 1,

590

1

		interior: [

591

1

			Parachain(1),

592

1

			AccountKey20 {

593

1

				network: None,

594

1

				key: PARAALICE.into(),

595

1

},

596

1

597

1

		.into(),

598

1

};

599

1

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

600

1

601

1

	ParaB::execute_with(|| {

602

1

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

603

1

		assert_ok!(PolkadotXcm::transfer_assets(

604

1

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

605

1

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

606

1

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

607

1

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

608

1

0,

609

1

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

610

1

));

611

1

});

612

1

613

1

	ParaA::execute_with(|| {

614

1

		// Weight used is 4

615

1

		assert_eq!(

616

1

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

617

1

			INITIAL_BALANCE - 4

618

1

);

619

1

});

620

1

621

622

#[test]

623

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

624

1

	MockNet::reset();

625

1

626

1

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

627

1

	let source_location: AssetType = para_a_balances

628

1

		.try_into()

629

1

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

630

1

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

631

1

632

1

	let asset_metadata = parachain::AssetMetadata {

633

1

		name: b"ParaAToken".to_vec(),

634

1

		symbol: b"ParaA".to_vec(),

635

1

		decimals: 18,

636

1

};

637

1

638

1

	ParaB::execute_with(|| {

639

1

		assert_ok!(AssetManager::register_foreign_asset(

640

1

			parachain::RuntimeOrigin::root(),

641

1

			source_location.clone(),

642

1

			asset_metadata,

643

1

			1u128,

644

1

			true

645

1

));

646

1

		assert_ok!(add_supported_asset(source_location, 0));

647

1

});

648

1

649

1

	let dest = Location {

650

1

		parents: 1,

651

1

		interior: [

652

1

			Parachain(2),

653

1

			AccountKey20 {

654

1

				network: None,

655

1

				key: PARAALICE.into(),

656

1

},

657

1

658

1

		.into(),

659

1

};

660

1

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

661

1

662

1

	ParaA::execute_with(|| {

663

1

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

664

1

		assert_ok!(PolkadotXcm::transfer_assets(

665

1

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

666

1

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

667

1

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

668

1

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

669

1

0,

670

1

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

671

1

));

672

1

});

673

1

674

1

	// Para A asset has been credited

675

1

	ParaA::execute_with(|| {

676

1

		assert_eq!(

677

1

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

678

1

			INITIAL_BALANCE - 100

679

1

);

680

1

});

681

1

682

1

	ParaB::execute_with(|| {

683

1

		// free execution, full amount received

684

1

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

685

1

});

686

1

687

1

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

688

1

	// Message through polkadotXCM pallet

689

1

690

1

	let dest = Location {

691

1

		parents: 1,

692

1

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

693

1

};

694

1

695

1

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

696

1

697

1

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

698

1

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

699

1

		ClearOrigin,

700

1

		BuyExecution {

701

1

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

702

1

			weight_limit: Limited(80.into()),

703

1

},

704

1

		DepositAsset {

705

1

			assets: All.into(),

706

1

			beneficiary: Location::new(

707

1

0,

708

1

				[AccountKey20 {

709

1

					network: None,

710

1

					key: PARAALICE,

711

1

}],

712

1

),

713

1

},

714

1

	]));

715

1

	ParaB::execute_with(|| {

716

1

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

717

1

		// and deposit asset

718

1

		assert_ok!(ParachainPalletXcm::send(

719

1

			parachain::RuntimeOrigin::root(),

720

1

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

721

1

			Box::new(message),

722

1

));

723

1

});

724

1

725

1

	ParaA::execute_with(|| {

726

1

		// Weight used is 4

727

1

		assert_eq!(

728

1

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

729

1

			INITIAL_BALANCE - 4

730

1

);

731

1

});

732

1

733

734

#[test]

735

1

fn receive_relay_asset_with_trader() {

736

1

	MockNet::reset();

737

1

738

1

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

739

1

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

740

1

741

1

	let asset_metadata = parachain::AssetMetadata {

742

1

		name: b"RelayToken".to_vec(),

743

1

		symbol: b"Relay".to_vec(),

744

1

		decimals: 12,

745

1

};

746

1

747

1

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

748

1

	// we know later we will divide by 1e12

749

1

	// Lets put 1e6 as units per second

750

1

	ParaA::execute_with(|| {

751

1

		assert_ok!(AssetManager::register_foreign_asset(

752

1

			parachain::RuntimeOrigin::root(),

753

1

			source_location.clone(),

754

1

			asset_metadata,

755

1

			1u128,

756

1

			true

757

1

));

758

1

		assert_ok!(add_supported_asset(source_location, 2_500_000_000_000));

759

1

});

760

1

761

1

	let dest: Location = Junction::AccountKey20 {

762

1

		network: None,

763

1

		key: PARAALICE,

764

1

765

1

	.into();

766

1

	// We are sending 100 tokens from relay.

767

1

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

768

1

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

769

1

	// Units per second should be 2_500_000_000_000_000

770

1

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

771

1

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

772

1

	Relay::execute_with(|| {

773

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

774

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

775

1

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

776

1

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

777

1

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

778

1

0,

779

1

			WeightLimit::Unlimited

780

1

));

781

1

});

782

1

783

1

	ParaA::execute_with(|| {

784

1

		// non-free execution, not full amount received

785

1

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

786

		// Fee should have been received by treasury

787

1

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

788

1

});

789

1

790

791

#[test]

792

1

fn send_para_a_asset_to_para_b_with_trader() {

793

1

	MockNet::reset();

794

1

795

1

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

796

1

	let source_location: AssetType = para_a_balances

797

1

		.try_into()

798

1

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

799

1

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

800

1

801

1

	let asset_metadata = parachain::AssetMetadata {

802

1

		name: b"ParaAToken".to_vec(),

803

1

		symbol: b"ParaA".to_vec(),

804

1

		decimals: 18,

805

1

};

806

1

807

1

	ParaB::execute_with(|| {

808

1

		assert_ok!(AssetManager::register_foreign_asset(

809

1

			parachain::RuntimeOrigin::root(),

810

1

			source_location.clone(),

811

1

			asset_metadata,

812

1

			1u128,

813

1

			true

814

1

));

815

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

816

1

});

817

1

818

1

	let dest = Location {

819

1

		parents: 1,

820

1

		interior: [

821

1

			Parachain(2),

822

1

			AccountKey20 {

823

1

				network: None,

824

1

				key: PARAALICE.into(),

825

1

},

826

1

827

1

		.into(),

828

1

};

829

1

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

830

1

831

1

	// In destination chain, we only need 4 weight

832

1

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

833

1

	ParaA::execute_with(|| {

834

1

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

835

1

		assert_ok!(PolkadotXcm::transfer_assets(

836

1

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

837

1

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

838

1

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

839

1

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

840

1

0,

841

1

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

842

1

));

843

1

});

844

1

	ParaA::execute_with(|| {

845

1

		// free execution, full amount received

846

1

		assert_eq!(

847

1

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

848

1

			INITIAL_BALANCE - 100

849

1

);

850

1

});

851

1

852

1

	// We are sending 100 tokens from para A.

853

1

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

854

1

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

855

1

	// Units per second should be 2_500_000_000_000_000

856

1

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

857

1

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

858

1

	// will be 4

859

1

	ParaB::execute_with(|| {

860

1

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

861

		// Fee should have been received by treasury

862

1

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

863

1

});

864

1

865

866

#[test]

867

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

868

1

	MockNet::reset();

869

1

870

1

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

871

1

	let source_location: AssetType = para_a_balances

872

1

		.try_into()

873

1

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

874

1

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

875

1

876

1

	let asset_metadata = parachain::AssetMetadata {

877

1

		name: b"ParaAToken".to_vec(),

878

1

		symbol: b"ParaA".to_vec(),

879

1

		decimals: 18,

880

1

};

881

1

882

1

	ParaB::execute_with(|| {

883

1

		assert_ok!(AssetManager::register_foreign_asset(

884

1

			parachain::RuntimeOrigin::root(),

885

1

			source_location.clone(),

886

1

			asset_metadata,

887

1

			1u128,

888

1

			true

889

1

));

890

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

891

1

		assert_ok!(add_supported_asset(source_location, 12500000));

892

1

});

893

1

894

1

	let dest = Location {

895

1

		parents: 1,

896

1

		interior: [

897

1

			Parachain(2),

898

1

			AccountKey20 {

899

1

				network: None,

900

1

				key: PARAALICE.into(),

901

1

},

902

1

903

1

		.into(),

904

1

};

905

1

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

906

1

	// we use transfer_with_fee

907

1

	ParaA::execute_with(|| {

908

1

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

909

1

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

910

1

		assert_ok!(PolkadotXcm::transfer_assets(

911

1

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

912

1

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

913

1

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

914

1

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

915

1

0,

916

1

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

917

1

));

918

1

});

919

1

	ParaA::execute_with(|| {

920

1

		// 100 tokens transferred plus 1 taken from fees

921

1

		assert_eq!(

922

1

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

923

1

			INITIAL_BALANCE - 100 - 1

924

1

);

925

1

});

926

1

927

1

	ParaB::execute_with(|| {

928

1

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

929

1

		// what it is specified

930

1

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

931

1

});

932

1

933

934

#[test]

935

1

fn error_when_not_paying_enough() {

936

1

	MockNet::reset();

937

1

938

1

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

939

1

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

940

1

941

1

	let asset_metadata = parachain::AssetMetadata {

942

1

		name: b"RelayToken".to_vec(),

943

1

		symbol: b"Relay".to_vec(),

944

1

		decimals: 12,

945

1

};

946

1

947

1

	let dest: Location = Junction::AccountKey20 {

948

1

		network: None,

949

1

		key: PARAALICE,

950

1

951

1

	.into();

952

1

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

953

1

	// we know later we will divide by 1e12

954

1

	// Lets put 1e6 as units per second

955

1

	ParaA::execute_with(|| {

956

1

		assert_ok!(AssetManager::register_foreign_asset(

957

1

			parachain::RuntimeOrigin::root(),

958

1

			source_location.clone(),

959

1

			asset_metadata,

960

1

			1u128,

961

1

			true

962

1

));

963

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

964

1

});

965

1

966

1

	ParaA::execute_with(|| {

967

1

		// amount not received as it is not paying enough

968

1

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

969

1

});

970

1

971

1

	// We are sending 100 tokens from relay.

972

1

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

973

1

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

974

1

	Relay::execute_with(|| {

975

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

976

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

977

1

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

978

1

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

979

1

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

980

1

0,

981

1

			WeightLimit::Unlimited

982

1

));

983

1

});

984

1

985

1

	ParaA::execute_with(|| {

986

1

		// amount not received as it is not paying enough

987

1

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

988

1

});

989

1

990

991

#[test]

992

1

fn transact_through_derivative_multilocation() {

993

1

	MockNet::reset();

994

1

995

1

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

996

1

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

997

1

998

1

	let asset_metadata = parachain::AssetMetadata {

999

1

		name: b"RelayToken".to_vec(),

1000

1

		symbol: b"Relay".to_vec(),

1001

1

		decimals: 12,

1002

1

};

1003

1

1004

1

	ParaA::execute_with(|| {

1005

1

		assert_ok!(AssetManager::register_foreign_asset(

1006

1

			parachain::RuntimeOrigin::root(),

1007

1

			source_location.clone(),

1008

1

			asset_metadata,

1009

1

			1u128,

1010

1

			true

1011

1

));

1012

1

		assert_ok!(add_supported_asset(source_location, 1));

1013

1014

		// Root can set transact info

1015

1

		assert_ok!(XcmTransactor::set_transact_info(

1016

1

			parachain::RuntimeOrigin::root(),

1017

1

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

1018

1

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

1019

1

			3000.into(),

1020

1

			20000000000.into(),

1021

1

			None

1022

1

));

1023

		// Root can set transact info

1024

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1025

1

			parachain::RuntimeOrigin::root(),

1026

1

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

1027

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1028

1

));

1029

1

});

1030

1

1031

1

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

1032

1

1033

1

	let dest: Location = AccountKey20 {

1034

1

		network: None,

1035

1

		key: PARAALICE,

1036

1

1037

1

	.into();

1038

1

	Relay::execute_with(|| {

1039

1

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

1040

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1041

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1042

1

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

1043

1

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

1044

1

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

1045

1

0,

1046

1

			WeightLimit::Unlimited

1047

1

));

1048

1

});

1049

1

1050

1

	ParaA::execute_with(|| {

1051

1

		// free execution, full amount received

1052

1

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

1053

1

});

1054

1

1055

1

	// Register address

1056

1

	ParaA::execute_with(|| {

1057

1

		assert_ok!(XcmTransactor::register(

1058

1

			parachain::RuntimeOrigin::root(),

1059

1

			PARAALICE.into(),

1060

1

0,

1061

1

));

1062

1

});

1063

1

1064

1

	// Send to registered address

1065

1

1066

1

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

1067

1

	let dest = Location {

1068

1

		parents: 1,

1069

1

		interior: [AccountId32 {

1070

1

			network: None,

1071

1

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

1072

1

}]

1073

1

		.into(),

1074

1

};

1075

1

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

1076

1

1077

1

	ParaA::execute_with(|| {

1078

1

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

1079

1

		// free execution, full amount received

1080

1

		assert_ok!(PolkadotXcm::transfer_assets(

1081

1

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

1082

1

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

1083

1

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

1084

1

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

1085

1

0,

1086

1

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

1087

1

));

1088

1

});

1089

1

1090

1

	ParaA::execute_with(|| {

1091

1

		// free execution, full amount received

1092

1

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

1093

1

});

1094

1

1095

1

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

1096

1

	// again

1097

1

	Relay::execute_with(|| {

1098

1

		// free execution,x	 full amount received

1099

1

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

1100

1

});

1101

1

1102

1

	// Encode the call. Balances transact to para_a_account

1103

1

	// First index

1104

1

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

1105

1

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

1106

1

		relay_chain::Balances,

1107

1

>()

1108

1

	.unwrap() as u8;

1109

1

1110

1

	encoded.push(index);

1111

1

1112

1

	// Then call bytes

1113

1

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

1114

1

		dest: para_a_account(),

1115

1

		value: 100u32.into(),

1116

1

1117

1

	.encode();

1118

1

	encoded.append(&mut call_bytes);

1119

1

1120

1

	ParaA::execute_with(|| {

1121

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1122

1

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

1123

1

			parachain::MockTransactors::Relay,

1124

1

0,

1125

1

			CurrencyPayment {

1126

1

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

1127

1

					Location::parent()

1128

1

				))),

1129

1

				fee_amount: None

1130

1

},

1131

1

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

1132

1

			encoded,

1133

1

			TransactWeights {

1134

1

				transact_required_weight_at_most: 4000000000.into(),

1135

1

				overall_weight: None

1136

1

},

1137

1

			false

1138

1

));

1139

1

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

1140

1

			.iter()

1141

14

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

1142

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

1143

..

1144

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

1145

14

				_ => None,

1146

14

});

1147

1

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

1148

1

		assert!(event_found.is_none());

1149

1

});

1150

1

1151

1

	Relay::execute_with(|| {

1152

1

		// free execution,x	 full amount received

1153

1

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

1154

1155

1

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

1156

1

});

1157

1

1158

1159

#[test]

1160

1

fn transact_through_derivative_with_custom_fee_weight() {

1161

1

	MockNet::reset();

1162

1

1163

1

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

1164

1

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

1165

1

1166

1

	let asset_metadata = parachain::AssetMetadata {

1167

1

		name: b"RelayToken".to_vec(),

1168

1

		symbol: b"Relay".to_vec(),

1169

1

		decimals: 12,

1170

1

};

1171

1

1172

1

	ParaA::execute_with(|| {

1173

1

		assert_ok!(AssetManager::register_foreign_asset(

1174

1

			parachain::RuntimeOrigin::root(),

1175

1

			source_location.clone(),

1176

1

			asset_metadata,

1177

1

			1u128,

1178

1

			true

1179

1

));

1180

1

		assert_ok!(add_supported_asset(source_location, 1));

1181

1

});

1182

1

1183

1

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

1184

1

1185

1

	let dest: Location = AccountKey20 {

1186

1

		network: None,

1187

1

		key: PARAALICE,

1188

1

1189

1

	.into();

1190

1

	Relay::execute_with(|| {

1191

1

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

1192

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1193

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1194

1

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

1195

1

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

1196

1

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

1197

1

0,

1198

1

			WeightLimit::Unlimited

1199

1

));

1200

1

});

1201

1

1202

1

	ParaA::execute_with(|| {

1203

1

		// free execution, full amount received

1204

1

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

1205

1

});

1206

1

1207

1

	// Register address

1208

1

	ParaA::execute_with(|| {

1209

1

		assert_ok!(XcmTransactor::register(

1210

1

			parachain::RuntimeOrigin::root(),

1211

1

			PARAALICE.into(),

1212

1

0,

1213

1

));

1214

1

});

1215

1

1216

1

	// Send to registered address

1217

1

1218

1

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

1219

1

	let dest = Location {

1220

1

		parents: 1,

1221

1

		interior: [AccountId32 {

1222

1

			network: None,

1223

1

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

1224

1

}]

1225

1

		.into(),

1226

1

};

1227

1

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

1228

1

1229

1

	ParaA::execute_with(|| {

1230

1

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

1231

1

		// free execution, full amount received

1232

1

		assert_ok!(PolkadotXcm::transfer_assets(

1233

1

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

1234

1

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

1235

1

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

1236

1

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

1237

1

0,

1238

1

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

1239

1

));

1240

1

});

1241

1

1242

1

	ParaA::execute_with(|| {

1243

1

		// free execution, full amount received

1244

1

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

1245

1

});

1246

1

1247

1

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

1248

1

	// again

1249

1

	Relay::execute_with(|| {

1250

1

		// free execution,x	 full amount received

1251

1

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

1252

1

});

1253

1

1254

1

	// Encode the call. Balances transact to para_a_account

1255

1

	// First index

1256

1

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

1257

1

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

1258

1

		relay_chain::Balances,

1259

1

>()

1260

1

	.unwrap() as u8;

1261

1

1262

1

	encoded.push(index);

1263

1

1264

1

	// Then call bytes

1265

1

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

1266

1

		dest: para_a_account(),

1267

1

		value: 100u32.into(),

1268

1

1269

1

	.encode();

1270

1

	encoded.append(&mut call_bytes);

1271

1

1272

1

	let overall_weight = 4000003000u64;

1273

1

	ParaA::execute_with(|| {

1274

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1275

1

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

1276

1

			parachain::MockTransactors::Relay,

1277

1

0,

1278

1

			CurrencyPayment {

1279

1

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

1280

1

					Location::parent()

1281

1

				))),

1282

1

				// 1-1 fee weight mapping

1283

1

				fee_amount: Some(overall_weight as u128)

1284

1

},

1285

1

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

1286

1

			encoded,

1287

1

			TransactWeights {

1288

1

				transact_required_weight_at_most: 4000000000.into(),

1289

1

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

1290

1

},

1291

1

			false

1292

1

));

1293

1

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

1294

1

			.iter()

1295

12

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

1296

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

1297

..

1298

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

1299

12

				_ => None,

1300

12

});

1301

1

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

1302

1

		assert!(event_found.is_none());

1303

1

});

1304

1

1305

1

	Relay::execute_with(|| {

1306

1

		// free execution,x	 full amount received

1307

1

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

1308

1309

1

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

1310

1

});

1311

1

1312

1313

#[test]

1314

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1315

1

	MockNet::reset();

1316

1

1317

1

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

1318

1

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

1319

1

1320

1

	let asset_metadata = parachain::AssetMetadata {

1321

1

		name: b"RelayToken".to_vec(),

1322

1

		symbol: b"Relay".to_vec(),

1323

1

		decimals: 12,

1324

1

};

1325

1

1326

1

	ParaA::execute_with(|| {

1327

1

		assert_ok!(AssetManager::register_foreign_asset(

1328

1

			parachain::RuntimeOrigin::root(),

1329

1

			source_location.clone(),

1330

1

			asset_metadata,

1331

1

			1u128,

1332

1

			true

1333

1

));

1334

1

		assert_ok!(add_supported_asset(source_location, 1));

1335

1

});

1336

1

1337

1

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

1338

1

1339

1

	let dest: Location = AccountKey20 {

1340

1

		network: None,

1341

1

		key: PARAALICE,

1342

1

1343

1

	.into();

1344

1

	Relay::execute_with(|| {

1345

1

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

1346

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1347

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1348

1

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

1349

1

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

1350

1

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

1351

1

0,

1352

1

			WeightLimit::Unlimited

1353

1

));

1354

1

});

1355

1

1356

1

	ParaA::execute_with(|| {

1357

1

		// free execution, full amount received

1358

1

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

1359

1

});

1360

1

1361

1

	// Register address

1362

1

	ParaA::execute_with(|| {

1363

1

		assert_ok!(XcmTransactor::register(

1364

1

			parachain::RuntimeOrigin::root(),

1365

1

			PARAALICE.into(),

1366

1

0,

1367

1

));

1368

1

});

1369

1

1370

1

	// Send to registered address

1371

1

1372

1

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

1373

1

	let dest = Location {

1374

1

		parents: 1,

1375

1

		interior: [AccountId32 {

1376

1

			network: None,

1377

1

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

1378

1

}]

1379

1

		.into(),

1380

1

};

1381

1

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

1382

1

1383

1

	ParaA::execute_with(|| {

1384

1

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

1385

1

		// free execution, full amount received

1386

1

		assert_ok!(PolkadotXcm::transfer_assets(

1387

1

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

1388

1

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

1389

1

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

1390

1

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

1391

1

0,

1392

1

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

1393

1

));

1394

1

});

1395

1

1396

1

	ParaA::execute_with(|| {

1397

1

		// free execution, full amount received

1398

1

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

1399

1

});

1400

1

1401

1

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

1402

1

	// again

1403

1

	Relay::execute_with(|| {

1404

1

		// free execution,x	 full amount received

1405

1

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

1406

1

});

1407

1

1408

1

	// Encode the call. Balances transact to para_a_account

1409

1

	// First index

1410

1

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

1411

1

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

1412

1

		relay_chain::Balances,

1413

1

>()

1414

1

	.unwrap() as u8;

1415

1

1416

1

	encoded.push(index);

1417

1

1418

1

	// Then call bytes

1419

1

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

1420

1

		dest: para_a_account(),

1421

1

		value: 100u32.into(),

1422

1

1423

1

	.encode();

1424

1

	encoded.append(&mut call_bytes);

1425

1

1426

1

	let overall_weight = 4000009000u64;

1427

1

	ParaA::execute_with(|| {

1428

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1429

1

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

1430

1

			parachain::MockTransactors::Relay,

1431

1

0,

1432

1

			CurrencyPayment {

1433

1

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

1434

1

					Location::parent()

1435

1

				))),

1436

1

				// 1-1 fee weight mapping

1437

1

				fee_amount: Some(overall_weight as u128)

1438

1

},

1439

1

			encoded,

1440

1

			TransactWeights {

1441

1

				transact_required_weight_at_most: 4000000000.into(),

1442

1

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

1443

1

},

1444

1

			true

1445

1

));

1446

1

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

1447

1

			.iter()

1448

12

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

1449

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

1450

..

1451

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

1452

12

				_ => None,

1453

12

});

1454

1

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

1455

1

		assert!(event_found.is_none());

1456

1

});

1457

1

1458

1

	Relay::execute_with(|| {

1459

1

		// free execution, full amount received

1460

1

		// 4000009000 refunded + 100 transferred = 4000009100

1461

1

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

1462

1

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

1463

1

});

1464

1

1465

1466

#[test]

1467

1

fn transact_through_sovereign() {

1468

1

	MockNet::reset();

1469

1

1470

1

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

1471

1

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

1472

1

1473

1

	let asset_metadata = parachain::AssetMetadata {

1474

1

		name: b"RelayToken".to_vec(),

1475

1

		symbol: b"Relay".to_vec(),

1476

1

		decimals: 12,

1477

1

};

1478

1

1479

1

	ParaA::execute_with(|| {

1480

1

		assert_ok!(AssetManager::register_foreign_asset(

1481

1

			parachain::RuntimeOrigin::root(),

1482

1

			source_location.clone(),

1483

1

			asset_metadata,

1484

1

			1u128,

1485

1

			true

1486

1

));

1487

1

		assert_ok!(add_supported_asset(source_location, 1));

1488

1489

		// Root can set transact info

1490

1

		assert_ok!(XcmTransactor::set_transact_info(

1491

1

			parachain::RuntimeOrigin::root(),

1492

1

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

1493

1

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

1494

1

			3000.into(),

1495

1

			20000000000.into(),

1496

1

			None

1497

1

));

1498

		// Root can set transact info

1499

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1500

1

			parachain::RuntimeOrigin::root(),

1501

1

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

1502

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1503

1

));

1504

1

});

1505

1

1506

1

	let dest: Location = AccountKey20 {

1507

1

		network: None,

1508

1

		key: PARAALICE,

1509

1

1510

1

	.into();

1511

1

	Relay::execute_with(|| {

1512

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1513

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1514

1

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

1515

1

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

1516

1

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

1517

1

0,

1518

1

			WeightLimit::Unlimited

1519

1

));

1520

1

});

1521

1

1522

1

	ParaA::execute_with(|| {

1523

1

		// free execution, full amount received

1524

1

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

1525

1

});

1526

1

1527

1

	// Register address

1528

1

	ParaA::execute_with(|| {

1529

1

		assert_ok!(XcmTransactor::register(

1530

1

			parachain::RuntimeOrigin::root(),

1531

1

			PARAALICE.into(),

1532

1

0,

1533

1

));

1534

1

});

1535

1

1536

1

	// Send to registered address

1537

1

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

1538

1

	let dest = Location {

1539

1

		parents: 1,

1540

1

		interior: [AccountId32 {

1541

1

			network: None,

1542

1

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

1543

1

}]

1544

1

		.into(),

1545

1

};

1546

1

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

1547

1

1548

1

	ParaA::execute_with(|| {

1549

1

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

1550

1

		// free execution, full amount received

1551

1

		assert_ok!(PolkadotXcm::transfer_assets(

1552

1

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

1553

1

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

1554

1

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

1555

1

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

1556

1

0,

1557

1

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

1558

1

));

1559

1

});

1560

1

1561

1

	ParaA::execute_with(|| {

1562

1

		// free execution, full amount received

1563

1

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

1564

1

});

1565

1

1566

1

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

1567

1

	// again

1568

1

	Relay::execute_with(|| {

1569

1

		// free execution,x	 full amount received

1570

1

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

1571

1

1572

1

});

1573

1

1574

1

	// We send the xcm transact operation to parent

1575

1

	let dest = Location {

1576

1

		parents: 1,

1577

1

		interior: [].into(),

1578

1

};

1579

1

1580

1

	// Encode the call. Balances transact to para_a_account

1581

1

	// First index

1582

1

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

1583

1

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

1584

1

		relay_chain::Balances,

1585

1

>()

1586

1

	.unwrap() as u8;

1587

1

1588

1

	encoded.push(index);

1589

1

1590

1

	// Then call bytes

1591

1

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

1592

1

		dest: para_a_account(),

1593

1

		value: 100u32.into(),

1594

1

1595

1

	.encode();

1596

1

	encoded.append(&mut call_bytes);

1597

1

1598

1

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

1599

1

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

1600

1

);

1601

1

1602

1

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

1603

1

	ParaA::execute_with(|| {

1604

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1605

1

			parachain::RuntimeOrigin::root(),

1606

1

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

1607

1

			Some(PARAALICE.into()),

1608

1

			CurrencyPayment {

1609

1

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

1610

1

					Location::parent()

1611

1

				))),

1612

1

				fee_amount: None

1613

1

},

1614

1

			utility_bytes,

1615

1

			OriginKind::SovereignAccount,

1616

1

			TransactWeights {

1617

1

				transact_required_weight_at_most: 4000000000.into(),

1618

1

				overall_weight: None

1619

1

},

1620

1

			false

1621

1

));

1622

1

});

1623

1

1624

1

	Relay::execute_with(|| {

1625

1

		// free execution,x	 full amount received

1626

1

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

1627

1628

1

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

1629

1

});

1630

1

1631

1632

#[test]

1633

1

fn transact_through_sovereign_fee_payer_none() {

1634

1

	MockNet::reset();

1635

1

1636

1

	ParaA::execute_with(|| {

1637

1

		// Root can set transact info

1638

1

		assert_ok!(XcmTransactor::set_transact_info(

1639

1

			parachain::RuntimeOrigin::root(),

1640

1

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

1641

1

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

1642

1

			3000.into(),

1643

1

			20000000000.into(),

1644

1

			None

1645

1

));

1646

		// Root can set transact info

1647

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1648

1

			parachain::RuntimeOrigin::root(),

1649

1

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

1650

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1651

1

));

1652

1

});

1653

1

1654

1

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

1655

1

1656

1

	Relay::execute_with(|| {

1657

1

		// Transfer 100 tokens to derivative_address on the relay

1658

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1659

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1660

1

			derivative_address.clone(),

1661

1

			100u128

1662

1

));

1663

1664

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

1665

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1666

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1667

1

			para_a_account(),

1668

1

			4000003000u128

1669

1

));

1670

1

});

1671

1

1672

1

	// Check balances before the transact call

1673

1

	Relay::execute_with(|| {

1674

1

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

1675

1

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

1676

1

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

1677

1

});

1678

1

1679

1

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

1680

1

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

1681

1

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

1682

1

		relay_chain::Balances,

1683

1

>()

1684

1

	.unwrap() as u8;

1685

1

1686

1

	encoded.push(index);

1687

1

1688

1

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

1689

1

		dest: RELAYBOB,

1690

1

		value: 100u32.into(),

1691

1

1692

1

	.encode();

1693

1

	encoded.append(&mut call_bytes);

1694

1

1695

1

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

1696

1

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

1697

1

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

1698

1

);

1699

1

1700

1

	// We send the xcm transact operation to parent

1701

1

	let dest = Location {

1702

1

		parents: 1,

1703

1

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

1704

1

};

1705

1

1706

1

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

1707

1

	ParaA::execute_with(|| {

1708

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1709

1

			parachain::RuntimeOrigin::root(),

1710

1

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

1711

1

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

1712

1

			None,

1713

1

			CurrencyPayment {

1714

1

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

1715

1

					Location::parent()

1716

1

				))),

1717

1

				fee_amount: None

1718

1

},

1719

1

			utility_bytes,

1720

1

			OriginKind::SovereignAccount,

1721

1

			TransactWeights {

1722

1

				transact_required_weight_at_most: 4000000000.into(),

1723

1

				overall_weight: None

1724

1

},

1725

1

			false

1726

1

));

1727

1

});

1728

1

1729

1

	// Check balances after the transact call are correct

1730

1

	Relay::execute_with(|| {

1731

1

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

1732

1

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

1733

1

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

1734

1

});

1735

1

1736

1737

#[test]

1738

1

fn transact_through_sovereign_with_custom_fee_weight() {

1739

1

	MockNet::reset();

1740

1

1741

1

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

1742

1

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

1743

1

1744

1

	let asset_metadata = parachain::AssetMetadata {

1745

1

		name: b"RelayToken".to_vec(),

1746

1

		symbol: b"Relay".to_vec(),

1747

1

		decimals: 12,

1748

1

};

1749

1

1750

1

	ParaA::execute_with(|| {

1751

1

		assert_ok!(AssetManager::register_foreign_asset(

1752

1

			parachain::RuntimeOrigin::root(),

1753

1

			source_location.clone(),

1754

1

			asset_metadata,

1755

1

			1u128,

1756

1

			true

1757

1

));

1758

1

		assert_ok!(add_supported_asset(source_location, 1));

1759

1

});

1760

1

1761

1

	let dest: Location = AccountKey20 {

1762

1

		network: None,

1763

1

		key: PARAALICE,

1764

1

1765

1

	.into();

1766

1

	Relay::execute_with(|| {

1767

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1768

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1769

1

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

1770

1

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

1771

1

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

1772

1

0,

1773

1

			WeightLimit::Unlimited

1774

1

));

1775

1

});

1776

1

1777

1

	ParaA::execute_with(|| {

1778

1

		// free execution, full amount received

1779

1

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

1780

1

});

1781

1

1782

1

	// Register address

1783

1

	ParaA::execute_with(|| {

1784

1

		assert_ok!(XcmTransactor::register(

1785

1

			parachain::RuntimeOrigin::root(),

1786

1

			PARAALICE.into(),

1787

1

0,

1788

1

));

1789

1

});

1790

1

1791

1

	// Send to registered address

1792

1

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

1793

1

	let dest = Location {

1794

1

		parents: 1,

1795

1

		interior: [AccountId32 {

1796

1

			network: None,

1797

1

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

1798

1

}]

1799

1

		.into(),

1800

1

};

1801

1

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

1802

1

1803

1

	ParaA::execute_with(|| {

1804

1

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

1805

1

		// free execution, full amount received

1806

1

		assert_ok!(PolkadotXcm::transfer_assets(

1807

1

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

1808

1

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

1809

1

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

1810

1

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

1811

1

0,

1812

1

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

1813

1

));

1814

1

});

1815

1

1816

1

	ParaA::execute_with(|| {

1817

1

		// free execution, full amount received

1818

1

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

1819

1

});

1820

1

1821

1

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

1822

1

	// again

1823

1

	Relay::execute_with(|| {

1824

1

		// free execution,x	 full amount received

1825

1

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

1826

1

1827

1

});

1828

1

1829

1

	// We send the xcm transact operation to parent

1830

1

	let dest = Location {

1831

1

		parents: 1,

1832

1

		interior: [].into(),

1833

1

};

1834

1

1835

1

	// Encode the call. Balances transact to para_a_account

1836

1

	// First index

1837

1

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

1838

1

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

1839

1

		relay_chain::Balances,

1840

1

>()

1841

1

	.unwrap() as u8;

1842

1

1843

1

	encoded.push(index);

1844

1

1845

1

	// Then call bytes

1846

1

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

1847

1

		dest: para_a_account(),

1848

1

		value: 100u32.into(),

1849

1

1850

1

	.encode();

1851

1

	encoded.append(&mut call_bytes);

1852

1

1853

1

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

1854

1

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

1855

1

);

1856

1

1857

1

	let total_weight = 4000003000u64;

1858

1

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

1859

1

	ParaA::execute_with(|| {

1860

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1861

1

			parachain::RuntimeOrigin::root(),

1862

1

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

1863

1

			Some(PARAALICE.into()),

1864

1

			CurrencyPayment {

1865

1

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

1866

1

					Location::parent()

1867

1

				))),

1868

1

				// 1-1 fee-weight mapping

1869

1

				fee_amount: Some(total_weight as u128)

1870

1

},

1871

1

			utility_bytes,

1872

1

			OriginKind::SovereignAccount,

1873

1

			TransactWeights {

1874

1

				transact_required_weight_at_most: 4000000000.into(),

1875

1

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

1876

1

},

1877

1

			false

1878

1

));

1879

1

});

1880

1

1881

1

	Relay::execute_with(|| {

1882

1

		// free execution,x	 full amount received

1883

1

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

1884

1885

1

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

1886

1

});

1887

1

1888

1889

#[test]

1890

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1891

1

	MockNet::reset();

1892

1

1893

1

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

1894

1

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

1895

1

1896

1

	let asset_metadata = parachain::AssetMetadata {

1897

1

		name: b"RelayToken".to_vec(),

1898

1

		symbol: b"Relay".to_vec(),

1899

1

		decimals: 12,

1900

1

};

1901

1

1902

1

	ParaA::execute_with(|| {

1903

1

		assert_ok!(AssetManager::register_foreign_asset(

1904

1

			parachain::RuntimeOrigin::root(),

1905

1

			source_location.clone(),

1906

1

			asset_metadata,

1907

1

			1u128,

1908

1

			true

1909

1

));

1910

1

		assert_ok!(add_supported_asset(source_location, 1));

1911

1

});

1912

1

1913

1

	let dest: Location = AccountKey20 {

1914

1

		network: None,

1915

1

		key: PARAALICE,

1916

1

1917

1

	.into();

1918

1

	Relay::execute_with(|| {

1919

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1920

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1921

1

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

1922

1

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

1923

1

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

1924

1

0,

1925

1

			WeightLimit::Unlimited

1926

1

));

1927

1

});

1928

1

1929

1

	ParaA::execute_with(|| {

1930

1

		// free execution, full amount received

1931

1

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

1932

1

});

1933

1

1934

1

	// Register address

1935

1

	ParaA::execute_with(|| {

1936

1

		assert_ok!(XcmTransactor::register(

1937

1

			parachain::RuntimeOrigin::root(),

1938

1

			PARAALICE.into(),

1939

1

0,

1940

1

));

1941

1

});

1942

1

1943

1

	// Send to registered address

1944

1

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

1945

1

	let dest = Location {

1946

1

		parents: 1,

1947

1

		interior: [AccountId32 {

1948

1

			network: None,

1949

1

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

1950

1

}]

1951

1

		.into(),

1952

1

};

1953

1

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

1954

1

1955

1

	ParaA::execute_with(|| {

1956

1

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

1957

1

		// free execution, full amount received

1958

1

		assert_ok!(PolkadotXcm::transfer_assets(

1959

1

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

1960

1

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

1961

1

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

1962

1

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

1963

1

0,

1964

1

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

1965

1

));

1966

1

});

1967

1

1968

1

	ParaA::execute_with(|| {

1969

1

		// free execution, full amount received

1970

1

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

1971

1

});

1972

1

1973

1

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

1974

1

	// again

1975

1

	Relay::execute_with(|| {

1976

1

		// free execution,x	 full amount received

1977

1

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

1978

1

1979

1

});

1980

1

1981

1

	// We send the xcm transact operation to parent

1982

1

	let dest = Location {

1983

1

		parents: 1,

1984

1

		interior: [].into(),

1985

1

};

1986

1

1987

1

	// Encode the call. Balances transact to para_a_account

1988

1

	// First index

1989

1

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

1990

1

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

1991

1

		relay_chain::Balances,

1992

1

>()

1993

1

	.unwrap() as u8;

1994

1

1995

1

	encoded.push(index);

1996

1

1997

1

	// Then call bytes

1998

1

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

1999

1

		dest: para_a_account(),

2000

1

		value: 100u32.into(),

2001

1

2002

1

	.encode();

2003

1

	encoded.append(&mut call_bytes);

2004

1

2005

1

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

2006

1

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

2007

1

);

2008

1

2009

1

	let total_weight = 4000009000u64;

2010

1

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

2011

1

	ParaA::execute_with(|| {

2012

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2013

1

			parachain::RuntimeOrigin::root(),

2014

1

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

2015

1

			Some(PARAALICE.into()),

2016

1

			CurrencyPayment {

2017

1

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

2018

1

					Location::parent()

2019

1

				))),

2020

1

				// 1-1 fee-weight mapping

2021

1

				fee_amount: Some(total_weight as u128)

2022

1

},

2023

1

			utility_bytes,

2024

1

			OriginKind::SovereignAccount,

2025

1

			TransactWeights {

2026

1

				transact_required_weight_at_most: 4000000000.into(),

2027

1

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

2028

1

},

2029

1

			true

2030

1

));

2031

1

});

2032

1

2033

1

	Relay::execute_with(|| {

2034

1

		// free execution, full amount received

2035

1

		// 4000009000 refunded + 100 transferred = 4000009100

2036

1

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

2037

2038

1

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

2039

1

});

2040

1

2041

2042

#[test]

2043

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2044

1

	MockNet::reset();

2045

1

2046

1

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

2047

1

	let asset_metadata = parachain::AssetMetadata {

2048

1

		name: b"RelayToken".to_vec(),

2049

1

		symbol: b"Relay".to_vec(),

2050

1

		decimals: 12,

2051

1

};

2052

1

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

2053

1

	ParaA::execute_with(|| {

2054

1

		parachain::XcmVersioner::set_version(1);

2055

1

		assert_ok!(AssetManager::register_foreign_asset(

2056

1

			parachain::RuntimeOrigin::root(),

2057

1

			source_location.clone(),

2058

1

			asset_metadata,

2059

1

			1u128,

2060

1

			true

2061

1

));

2062

1

		assert_ok!(add_supported_asset(source_location, 0));

2063

1

});

2064

1

2065

1

	let response = Response::Version(2);

2066

1

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

2067

1

2068

1

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

2069

1

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

2070

1

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

2071

1

		query_id: 0,

2072

1

		response,

2073

1

		max_weight: Weight::zero(),

2074

1

		querier: Some(querier),

2075

1

	}]);

2076

1

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

2077

1

	// it directly here

2078

1

	// Actually send relay asset to parachain

2079

1

	let dest: Location = AccountKey20 {

2080

1

		network: None,

2081

1

		key: PARAALICE,

2082

1

2083

1

	.into();

2084

1

2085

1

	Relay::execute_with(|| {

2086

1

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

2087

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2088

1

			relay_chain::RuntimeOrigin::root(),

2089

1

			Some(3)

2090

1

));

2091

2092

		// Wrap version, which sets VersionedStorage

2093

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

2094

		// this is not necessary in prod

2095

1

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

2096

1

			&Parachain(1).into(),

2097

1

			mock_message

2098

1

));

2099

2100

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

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(([], 123).into()),

2106

1

0,

2107

1

			WeightLimit::Unlimited

2108

1

));

2109

2110

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

2111

1

		relay_chain::relay_roll_to(2);

2112

1

2113

1

		// queries should have been updated

2114

1

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

2115

1

});

2116

1

2117

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2118

1

		pallet_xcm::Event::SupportedVersionChanged {

2119

1

			location: Location {

2120

1

				parents: 0,

2121

1

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

2122

1

},

2123

1

			version: 1,

2124

1

2125

1

		.into();

2126

1

2127

1

	Relay::execute_with(|| {

2128

1

		// Assert that the events vector contains the version change

2129

1

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

2130

1

});

2131

1

2132

1

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

2133

1

	// of the new version change

2134

1

	ParaA::execute_with(|| {

2135

1

		// Set version

2136

1

		parachain::XcmVersioner::set_version(2);

2137

1

		// Do runtime upgrade

2138

1

		parachain::on_runtime_upgrade();

2139

1

		// Initialize block, to call on_initialize and notify targets

2140

1

		parachain::para_roll_to(2);

2141

1

		// Expect the event in the parachain

2142

10

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

2143

2

e,

2144

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

2145

				result: 2,

2146

..

2147

})

2148

10

		)));

2149

1

});

2150

1

2151

1

	// This event should have been seen in the relay

2152

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2153

1

		pallet_xcm::Event::SupportedVersionChanged {

2154

1

			location: Location {

2155

1

				parents: 0,

2156

1

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

2157

1

},

2158

1

			version: 2,

2159

1

2160

1

		.into();

2161

1

2162

1

	Relay::execute_with(|| {

2163

1

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

2164

1

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

2165

1

});

2166

1

2167

2168

#[test]

2169

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2170

1

	MockNet::reset();

2171

1

2172

1

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

2173

1

	let source_location: AssetType = para_a_balances

2174

1

		.try_into()

2175

1

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

2176

1

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

2177

1

2178

1

	let asset_metadata = parachain::AssetMetadata {

2179

1

		name: b"ParaAToken".to_vec(),

2180

1

		symbol: b"ParaA".to_vec(),

2181

1

		decimals: 18,

2182

1

};

2183

1

	let response = Response::Version(2);

2184

1

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

2185

1

2186

1

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

2187

1

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

2188

1

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

2189

1

		query_id: 0,

2190

1

		response,

2191

1

		max_weight: Weight::zero(),

2192

1

		querier: Some(querier),

2193

1

	}]);

2194

1

2195

1

	ParaA::execute_with(|| {

2196

1

		// advertised version

2197

1

		parachain::XcmVersioner::set_version(2);

2198

1

});

2199

1

2200

1

	ParaB::execute_with(|| {

2201

1

		// Let's try with v0

2202

1

		parachain::XcmVersioner::set_version(0);

2203

1

2204

1

		assert_ok!(AssetManager::register_foreign_asset(

2205

1

			parachain::RuntimeOrigin::root(),

2206

1

			source_location.clone(),

2207

1

			asset_metadata,

2208

1

			1u128,

2209

1

			true

2210

1

));

2211

1

		assert_ok!(add_supported_asset(source_location, 0));

2212

1

});

2213

1

2214

1

	ParaA::execute_with(|| {

2215

1

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

2216

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2217

1

			parachain::RuntimeOrigin::root(),

2218

1

			Some(3)

2219

1

));

2220

		// Wrap version, which sets VersionedStorage

2221

1

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

2222

1

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

2223

1

			mock_message

2224

1

));

2225

2226

1

		parachain::para_roll_to(2);

2227

1

2228

1

		// queries should have been updated

2229

1

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

2230

1

});

2231

1

2232

1

	let expected_supported_version: parachain::RuntimeEvent =

2233

1

		pallet_xcm::Event::SupportedVersionChanged {

2234

1

			location: Location {

2235

1

				parents: 1,

2236

1

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

2237

1

},

2238

1

			version: 0,

2239

1

2240

1

		.into();

2241

1

2242

1

	ParaA::execute_with(|| {

2243

1

		// Assert that the events vector contains the version change

2244

1

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

2245

1

});

2246

1

2247

1

	// Let's ensure talking in v0 works

2248

1

	let dest = Location {

2249

1

		parents: 1,

2250

1

		interior: [

2251

1

			Parachain(2),

2252

1

			AccountKey20 {

2253

1

				network: None,

2254

1

				key: PARAALICE.into(),

2255

1

},

2256

1

2257

1

		.into(),

2258

1

2259

1

	.into();

2260

1

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

2261

1

	ParaA::execute_with(|| {

2262

1

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

2263

1

		// free execution, full amount received

2264

1

		assert_ok!(PolkadotXcm::transfer_assets(

2265

1

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

2266

1

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

2267

1

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

2268

1

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

2269

1

0,

2270

1

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

2271

1

));

2272

		// free execution, full amount received

2273

1

		assert_eq!(

2274

1

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

2275

1

			INITIAL_BALANCE - 100

2276

1

);

2277

1

});

2278

1

2279

1

	ParaB::execute_with(|| {

2280

1

		// free execution, full amount received

2281

1

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

2282

1

});

2283

1

2284

1

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

2285

1

	// of the new version change

2286

1

	ParaB::execute_with(|| {

2287

1

		// Set version

2288

1

		parachain::XcmVersioner::set_version(2);

2289

1

		// Do runtime upgrade

2290

1

		parachain::on_runtime_upgrade();

2291

1

		// Initialize block, to call on_initialize and notify targets

2292

1

		parachain::para_roll_to(2);

2293

1

		// Expect the event in the parachain

2294

10

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

2295

2

e,

2296

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

2297

				result: 2,

2298

..

2299

})

2300

10

		)));

2301

1

});

2302

1

2303

1

	// This event should have been seen in para A

2304

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2305

1

		pallet_xcm::Event::SupportedVersionChanged {

2306

1

			location: Location {

2307

1

				parents: 1,

2308

1

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

2309

1

},

2310

1

			version: 2,

2311

1

2312

1

		.into();

2313

1

2314

1

	// Para A should have received the version change

2315

1

	ParaA::execute_with(|| {

2316

1

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

2317

1

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

2318

1

});

2319

1

2320

2321

#[test]

2322

1

fn receive_asset_with_no_sufficients_not_possible_if_non_existent_account() {

2323

1

	MockNet::reset();

2324

1

2325

1

	let fresh_account = [2u8; 20];

2326

1

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

2327

1

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

2328

1

	let asset_metadata = parachain::AssetMetadata {

2329

1

		name: b"RelayToken".to_vec(),

2330

1

		symbol: b"Relay".to_vec(),

2331

1

		decimals: 12,

2332

1

};

2333

1

	// register relay asset in parachain A

2334

1

	ParaA::execute_with(|| {

2335

1

		assert_ok!(AssetManager::register_foreign_asset(

2336

1

			parachain::RuntimeOrigin::root(),

2337

1

			source_location.clone(),

2338

1

			asset_metadata,

2339

1

			1u128,

2340

1

			false

2341

1

));

2342

1

		assert_ok!(add_supported_asset(source_location, 0));

2343

1

});

2344

1

2345

1

	// Actually send relay asset to parachain

2346

1

	let dest: Location = AccountKey20 {

2347

1

		network: None,

2348

1

		key: fresh_account,

2349

1

2350

1

	.into();

2351

1

	Relay::execute_with(|| {

2352

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2353

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2354

1

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

2355

1

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

2356

1

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

2357

1

0,

2358

1

			WeightLimit::Unlimited

2359

1

));

2360

1

});

2361

1

2362

1

	// parachain should not have received assets

2363

1

	ParaA::execute_with(|| {

2364

1

		// free execution, full amount received

2365

1

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

2366

1

});

2367

1

2368

1

	// Send native token to fresh_account

2369

1

	ParaA::execute_with(|| {

2370

1

		assert_ok!(ParaBalances::transfer_allow_death(

2371

1

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

2372

1

			fresh_account.into(),

2373

1

2374

1

));

2375

1

});

2376

1

2377

1

	// Re-send tokens

2378

1

	Relay::execute_with(|| {

2379

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2380

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2381

1

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

2382

1

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

2383

1

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

2384

1

0,

2385

1

			WeightLimit::Unlimited

2386

1

));

2387

1

});

2388

1

2389

1

	// parachain should have received assets

2390

1

	ParaA::execute_with(|| {

2391

1

		// free execution, full amount received

2392

1

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

2393

1

});

2394

1

2395

2396

#[test]

2397

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2398

1

	MockNet::reset();

2399

1

2400

1

	let fresh_account = [2u8; 20];

2401

1

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

2402

1

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

2403

1

	let asset_metadata = parachain::AssetMetadata {

2404

1

		name: b"RelayToken".to_vec(),

2405

1

		symbol: b"Relay".to_vec(),

2406

1

		decimals: 12,

2407

1

};

2408

1

	// register relay asset in parachain A

2409

1

	ParaA::execute_with(|| {

2410

1

		assert_ok!(AssetManager::register_foreign_asset(

2411

1

			parachain::RuntimeOrigin::root(),

2412

1

			source_location.clone(),

2413

1

			asset_metadata,

2414

1

			1u128,

2415

1

			true

2416

1

));

2417

1

		assert_ok!(add_supported_asset(source_location, 0));

2418

1

});

2419

1

2420

1

	// Actually send relay asset to parachain

2421

1

	let dest: Location = AccountKey20 {

2422

1

		network: None,

2423

1

		key: fresh_account,

2424

1

2425

1

	.into();

2426

1

	Relay::execute_with(|| {

2427

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2428

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2429

1

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

2430

1

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

2431

1

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

2432

1

0,

2433

1

			WeightLimit::Unlimited

2434

1

));

2435

1

});

2436

1

2437

1

	// parachain should have received assets

2438

1

	ParaA::execute_with(|| {

2439

1

		// free execution, full amount received

2440

1

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

2441

1

});

2442

1

2443

2444

#[test]

2445

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2446

1

	MockNet::reset();

2447

1

2448

1

	let mut sufficient_account = [0u8; 20];

2449

1

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

2450

1

2451

1

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

2452

1

2453

1

	// Evm account is self sufficient

2454

1

	ParaA::execute_with(|| {

2455

1

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

2456

1

});

2457

1

2458

1

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

2459

1

	let asset_metadata = parachain::AssetMetadata {

2460

1

		name: b"RelayToken".to_vec(),

2461

1

		symbol: b"Relay".to_vec(),

2462

1

		decimals: 12,

2463

1

};

2464

1

	// register relay asset in parachain A

2465

1

	ParaA::execute_with(|| {

2466

1

		assert_ok!(AssetManager::register_foreign_asset(

2467

1

			parachain::RuntimeOrigin::root(),

2468

1

			source_location.clone(),

2469

1

			asset_metadata,

2470

1

			1u128,

2471

1

			true

2472

1

));

2473

1

		assert_ok!(add_supported_asset(source_location, 0));

2474

1

});

2475

1

2476

1

	// Actually send relay asset to parachain

2477

1

	let dest: Location = AccountKey20 {

2478

1

		network: None,

2479

1

		key: sufficient_account,

2480

1

2481

1

	.into();

2482

1

	Relay::execute_with(|| {

2483

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2484

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2485

1

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

2486

1

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

2487

1

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

2488

1

0,

2489

1

			WeightLimit::Unlimited

2490

1

));

2491

1

});

2492

1

2493

1

	// Evm account sufficient ref count increased by 1.

2494

1

	ParaA::execute_with(|| {

2495

1

		// TODO: since the suicided logic was introduced the data of the smart contract is not

2496

1

		// removed, it will have to be updated in a future release when there is the ability to

2497

1

		// remove contract data

2498

1

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

2499

1

});

2500

1

2501

1

	ParaA::execute_with(|| {

2502

1

		// Remove the account from the evm context.

2503

1

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

2504

1

		// Evm account sufficient ref count decreased by 1.

2505

1

		// TODO: since the suicided logic was introduced the data of the smart contract is not

2506

1

		// removed, it will have to be updated in a future release when there is the ability to

2507

1

		// remove contract data

2508

1

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

2509

1

});

2510

1

2511

2512

#[test]

2513

1

fn empty_account_should_not_be_reset() {

2514

1

	MockNet::reset();

2515

1

2516

1

	// Test account has nonce 1 on genesis.

2517

1

	let mut sufficient_account = [0u8; 20];

2518

1

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

2519

1

2520

1

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

2521

1

2522

1

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

2523

1

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

2524

1

	let asset_metadata = parachain::AssetMetadata {

2525

1

		name: b"RelayToken".to_vec(),

2526

1

		symbol: b"Relay".to_vec(),

2527

1

		decimals: 12,

2528

1

};

2529

1

	// register relay asset in parachain A

2530

1

	ParaA::execute_with(|| {

2531

1

		assert_ok!(AssetManager::register_foreign_asset(

2532

1

			parachain::RuntimeOrigin::root(),

2533

1

			source_location.clone(),

2534

1

			asset_metadata,

2535

1

			1u128,

2536

1

			false

2537

1

));

2538

1

		assert_ok!(add_supported_asset(source_location, 0));

2539

1

});

2540

1

2541

1

	// Send native token to evm_account

2542

1

	ParaA::execute_with(|| {

2543

1

		assert_ok!(ParaBalances::transfer_allow_death(

2544

1

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

2545

1

			evm_account_id,

2546

1

2547

1

));

2548

1

});

2549

1

2550

1

	// Actually send relay asset to parachain

2551

1

	let dest: Location = AccountKey20 {

2552

1

		network: None,

2553

1

		key: sufficient_account,

2554

1

2555

1

	.into();

2556

1

	Relay::execute_with(|| {

2557

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2558

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2559

1

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

2560

1

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

2561

1

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

2562

1

0,

2563

1

			WeightLimit::Unlimited

2564

1

));

2565

1

});

2566

1

2567

1

	ParaA::execute_with(|| {

2568

1

		// Empty the assets from the account.

2569

1

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

2570

1

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

2571

1

		assert_ok!(parachain::Assets::transfer(

2572

1

			parachain::RuntimeOrigin::signed(evm_account_id),

2573

1

			source_id,

2574

1

			PARAALICE.into(),

2575

1

2576

1

));

2577

		// Verify account asset balance is Zero.

2578

1

		assert_eq!(

2579

1

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

2580

1

2581

1

);

2582

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

2583

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

2584

1

		assert_ok!(ParaBalances::force_set_balance(

2585

1

			parachain::RuntimeOrigin::root(),

2586

1

			evm_account_id,

2587

1

0,

2588

1

));

2589

		// Verify account native balance is Zero.

2590

1

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

2591

		// Remove the account from the evm context.

2592

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

2593

1

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

2594

1

		// Verify reference count.

2595

1

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

2596

1

		assert_eq!(account.sufficients, 0);

2597

1

		assert_eq!(account.consumers, 0);

2598

1

		assert_eq!(account.providers, 1);

2599

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

2600

1

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

2601

1

});

2602

1

2603

2604

#[test]

2605

1

fn test_statemint_like() {

2606

1

	MockNet::reset();

2607

1

2608

1

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

2609

1

2610

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2611

1

		polkadot_parachain::primitives::Sibling,

2612

1

		statemint_like::AccountId,

2613

1

	>::convert_location(&dest_para)

2614

1

	.unwrap();

2615

1

2616

1

	let statemint_asset_a_balances = Location::new(

2617

1

1,

2618

1

2619

1

			Parachain(1000),

2620

1

			PalletInstance(5),

2621

1

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

2622

1

],

2623

1

);

2624

1

	let source_location: AssetType = statemint_asset_a_balances

2625

1

		.try_into()

2626

1

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

2627

1

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

2628

1

2629

1

	let asset_metadata = parachain::AssetMetadata {

2630

1

		name: b"StatemintToken".to_vec(),

2631

1

		symbol: b"StatemintToken".to_vec(),

2632

1

		decimals: 12,

2633

1

};

2634

1

2635

1

	ParaA::execute_with(|| {

2636

1

		assert_ok!(AssetManager::register_foreign_asset(

2637

1

			parachain::RuntimeOrigin::root(),

2638

1

			source_location.clone(),

2639

1

			asset_metadata.clone(),

2640

1

			1u128,

2641

1

			true

2642

1

));

2643

1

		assert_ok!(add_supported_asset(source_location, 0));

2644

1

});

2645

1

2646

1

	Statemint::execute_with(|| {

2647

1

		// Set new prefix

2648

1

		statemint_like::PrefixChanger::set_prefix(

2649

1

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

2650

1

);

2651

1

		assert_ok!(StatemintAssets::create(

2652

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2653

1

0,

2654

1

			RELAYALICE,

2655

1

2656

1

));

2657

2658

1

		assert_ok!(StatemintAssets::mint(

2659

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2660

1

0,

2661

1

			RELAYALICE,

2662

1

			300000000000000

2663

1

));

2664

2665

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

2666

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2667

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2668

1

			sov,

2669

1

			100000000000000

2670

1

));

2671

2672

		// Actually send relay asset to parachain

2673

1

		let dest: Location = AccountKey20 {

2674

1

			network: None,

2675

1

			key: PARAALICE,

2676

1

2677

1

		.into();

2678

1

2679

1

		// Send asset with previous prefix

2680

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2681

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2682

1

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

2683

1

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

2684

1

			Box::new(

2685

1

2686

1

2687

1

						xcm::latest::prelude::PalletInstance(

2688

1

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

2689

1

),

2690

1

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

2691

1

],

2692

1

2693

1

2694

1

					.into()

2695

1

),

2696

1

0,

2697

1

			WeightLimit::Unlimited

2698

1

));

2699

1

});

2700

1

2701

1

	ParaA::execute_with(|| {

2702

1

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

2703

1

});

2704

1

2705

2706

#[test]

2707

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2708

1

	MockNet::reset();

2709

1

2710

1

	// Relay asset

2711

1

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

2712

1

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

2713

1

2714

1

	let relay_asset_metadata = parachain::AssetMetadata {

2715

1

		name: b"RelayToken".to_vec(),

2716

1

		symbol: b"Relay".to_vec(),

2717

1

		decimals: 12,

2718

1

};

2719

1

2720

1

	// Statemint asset

2721

1

	let statemint_asset = Location::new(

2722

1

1,

2723

1

2724

1

			Parachain(1000u32),

2725

1

			PalletInstance(5u8),

2726

1

			GeneralIndex(10u128),

2727

1

],

2728

1

);

2729

1

	let statemint_location_asset: AssetType = statemint_asset

2730

1

		.clone()

2731

1

		.try_into()

2732

1

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

2733

1

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

2734

1

2735

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2736

1

		name: b"USDC".to_vec(),

2737

1

		symbol: b"USDC".to_vec(),

2738

1

		decimals: 12,

2739

1

};

2740

1

2741

1

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

2742

1

2743

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2744

1

		polkadot_parachain::primitives::Sibling,

2745

1

		statemint_like::AccountId,

2746

1

	>::convert_location(&dest_para)

2747

1

	.unwrap();

2748

1

2749

1

	ParaA::execute_with(|| {

2750

1

		assert_ok!(AssetManager::register_foreign_asset(

2751

1

			parachain::RuntimeOrigin::root(),

2752

1

			relay_location.clone(),

2753

1

			relay_asset_metadata,

2754

1

			1u128,

2755

1

			true

2756

1

));

2757

1

		assert_ok!(add_supported_asset(relay_location, 0));

2758

2759

1

		assert_ok!(AssetManager::register_foreign_asset(

2760

1

			parachain::RuntimeOrigin::root(),

2761

1

			statemint_location_asset.clone(),

2762

1

			asset_metadata_statemint_asset,

2763

1

			1u128,

2764

1

			true

2765

1

));

2766

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0));

2767

1

});

2768

1

2769

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2770

1

		network: None,

2771

1

		key: PARAALICE,

2772

1

2773

1

	.into();

2774

1

2775

1

	// Send relay chain asset to Alice in Parachain A

2776

1

	Relay::execute_with(|| {

2777

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2778

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2779

1

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

2780

1

			Box::new(

2781

1

				VersionedLocation::from(parachain_beneficiary_from_relay)

2782

1

					.clone()

2783

1

					.into()

2784

1

),

2785

1

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

2786

1

0,

2787

1

			WeightLimit::Unlimited

2788

1

));

2789

1

});

2790

1

2791

1

	Statemint::execute_with(|| {

2792

1

		// Set new prefix

2793

1

		statemint_like::PrefixChanger::set_prefix(

2794

1

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

2795

1

);

2796

1

2797

1

		assert_ok!(StatemintAssets::create(

2798

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2799

1

10,

2800

1

			RELAYALICE,

2801

1

2802

1

));

2803

2804

1

		assert_ok!(StatemintAssets::mint(

2805

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2806

1

10,

2807

1

			RELAYALICE,

2808

1

			300000000000000

2809

1

));

2810

2811

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

2812

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

2813

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2814

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2815

1

			sov,

2816

1

			100000000000000

2817

1

));

2818

2819

		// Send statemint USDC asset to Alice in Parachain A

2820

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2821

1

			network: None,

2822

1

			key: PARAALICE,

2823

1

2824

1

		.into();

2825

1

2826

1

		// Send with new prefix

2827

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2828

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2829

1

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

2830

1

			Box::new(

2831

1

				VersionedLocation::from(parachain_beneficiary_from_statemint)

2832

1

					.clone()

2833

1

					.into()

2834

1

),

2835

1

			Box::new(

2836

1

2837

1

2838

1

						xcm::latest::prelude::PalletInstance(

2839

1

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

2840

1

),

2841

1

						GeneralIndex(10),

2842

1

],

2843

1

2844

1

2845

1

					.into()

2846

1

),

2847

1

0,

2848

1

			WeightLimit::Unlimited

2849

1

));

2850

1

});

2851

1

2852

1

	let statemint_beneficiary = Location {

2853

1

		parents: 1,

2854

1

		interior: [

2855

1

			Parachain(1000),

2856

1

			AccountId32 {

2857

1

				network: None,

2858

1

				id: RELAYBOB.into(),

2859

1

},

2860

1

2861

1

		.into(),

2862

1

};

2863

1

2864

1

	ParaA::execute_with(|| {

2865

1

		// Alice has received 125 USDC

2866

1

		assert_eq!(

2867

1

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

2868

1

2869

1

);

2870

2871

		// Alice has received 200 Relay assets

2872

1

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

2873

1

});

2874

1

2875

1

	Statemint::execute_with(|| {

2876

1

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

2877

1

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

2878

1

});

2879

1

2880

1

	let (chain_part, beneficiary) =

2881

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2882

1

2883

1

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

2884

1

	ParaA::execute_with(|| {

2885

1

		let asset = currency_to_asset(

2886

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2887

1

			100,

2888

1

);

2889

1

		let asset_fee =

2890

1

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

2891

1

		assert_ok!(PolkadotXcm::transfer_assets(

2892

1

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

2893

1

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

2894

1

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

2895

1

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

2896

1

0,

2897

1

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

2898

1

));

2899

1

});

2900

1

2901

1

	ParaA::execute_with(|| {

2902

1

		// Alice has 100 USDC less

2903

1

		assert_eq!(

2904

1

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

2905

1

2906

1

);

2907

2908

		// Alice has 100 relay asset less

2909

1

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

2910

1

});

2911

1

2912

1

	Statemint::execute_with(|| {

2913

1

		// Check that BOB received 100 USDC on statemint

2914

1

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

2915

1

});

2916

1

2917

2918

#[test]

2919

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

2920

1

	MockNet::reset();

2921

1

2922

1

	// Relay asset

2923

1

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

2924

1

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

2925

1

2926

1

	let relay_asset_metadata = parachain::AssetMetadata {

2927

1

		name: b"RelayToken".to_vec(),

2928

1

		symbol: b"Relay".to_vec(),

2929

1

		decimals: 12,

2930

1

};

2931

1

2932

1

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

2933

1

2934

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2935

1

		polkadot_parachain::primitives::Sibling,

2936

1

		statemint_like::AccountId,

2937

1

	>::convert_location(&dest_para)

2938

1

	.unwrap();

2939

1

2940

1

	ParaA::execute_with(|| {

2941

1

		assert_ok!(AssetManager::register_foreign_asset(

2942

1

			parachain::RuntimeOrigin::root(),

2943

1

			relay_location.clone(),

2944

1

			relay_asset_metadata,

2945

1

			1u128,

2946

1

			true

2947

1

));

2948

1

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

2949

1

});

2950

1

2951

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2952

1

		network: None,

2953

1

		key: PARAALICE,

2954

1

2955

1

	.into();

2956

1

2957

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2958

1

		network: None,

2959

1

		id: RELAYALICE.into(),

2960

1

2961

1

	.into();

2962

1

2963

1

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

2964

1

	Relay::execute_with(|| {

2965

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2966

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2967

1

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

2968

1

			Box::new(

2969

1

				VersionedLocation::from(statemint_beneficiary_absolute)

2970

1

					.clone()

2971

1

					.into()

2972

1

),

2973

1

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

2974

1

0,

2975

1

			WeightLimit::Unlimited

2976

1

));

2977

1

});

2978

1

2979

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2980

1

	Statemint::execute_with(|| {

2981

1

		// Check Alice received 200 tokens on AssetHub

2982

1

		assert_eq!(

2983

1

			StatemintBalances::free_balance(RELAYALICE),

2984

1

			INITIAL_BALANCE + 200

2985

1

);

2986

2987

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2988

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2989

1

			sov,

2990

1

			110000000000000

2991

1

));

2992

2993

		// Now send those tokens to ParaA

2994

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2995

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2996

1

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

2997

1

			Box::new(

2998

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

2999

1

					.clone()

3000

1

					.into()

3001

1

),

3002

1

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

3003

1

0,

3004

1

			WeightLimit::Unlimited

3005

1

));

3006

1

});

3007

1

3008

1

	ParaA::execute_with(|| {

3009

1

		// Alice should have received the DOTs

3010

1

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

3011

1

});

3012

1

3013

1

	let dest = Location::new(

3014

1

1,

3015

1

3016

1

			Parachain(1000),

3017

1

			AccountId32 {

3018

1

				network: None,

3019

1

				id: RELAYBOB.into(),

3020

1

},

3021

1

],

3022

1

);

3023

1

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

3024

1

3025

1

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

3026

1

	ParaA::execute_with(|| {

3027

1

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

3028

1

		assert_ok!(PolkadotXcm::transfer_assets(

3029

1

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

3030

1

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

3031

1

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

3032

1

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

3033

1

0,

3034

1

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

3035

1

));

3036

3037

1

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

3038

1

});

3039

1

3040

1

	Statemint::execute_with(|| {

3041

1

		// Check that Bob received the tokens back in AssetHub

3042

1

		assert_eq!(

3043

1

			StatemintBalances::free_balance(RELAYBOB),

3044

1

			INITIAL_BALANCE + 100

3045

1

);

3046

1

});

3047

1

3048

1

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

3049

1

	Statemint::execute_with(|| {

3050

1

		// Now send those tokens to ParaA

3051

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3052

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3053

1

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

3054

1

			Box::new(

3055

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3056

1

					.clone()

3057

1

					.into()

3058

1

),

3059

1

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

3060

1

0,

3061

1

			WeightLimit::Unlimited

3062

1

));

3063

3064

		// 100 DOTs were deducted from Bob's account

3065

1

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

3066

1

});

3067

1

3068

1

	ParaA::execute_with(|| {

3069

1

		// Alice should have received 100 DOTs

3070

1

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

3071

1

});

3072

1

3073

3074

#[test]

3075

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3076

1

	MockNet::reset();

3077

1

3078

1

	// Relay asset

3079

1

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

3080

1

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

3081

1

3082

1

	let relay_asset_metadata = parachain::AssetMetadata {

3083

1

		name: b"RelayToken".to_vec(),

3084

1

		symbol: b"Relay".to_vec(),

3085

1

		decimals: 12,

3086

1

};

3087

1

3088

1

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

3089

1

3090

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3091

1

		polkadot_parachain::primitives::Sibling,

3092

1

		statemint_like::AccountId,

3093

1

	>::convert_location(&dest_para)

3094

1

	.unwrap();

3095

1

3096

1

	ParaA::execute_with(|| {

3097

1

		assert_ok!(AssetManager::register_foreign_asset(

3098

1

			parachain::RuntimeOrigin::root(),

3099

1

			relay_location.clone(),

3100

1

			relay_asset_metadata,

3101

1

			1u128,

3102

1

			true

3103

1

));

3104

1

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

3105

1

});

3106

1

3107

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3108

1

		network: None,

3109

1

		key: PARAALICE,

3110

1

3111

1

	.into();

3112

1

3113

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3114

1

		network: None,

3115

1

		id: RELAYALICE.into(),

3116

1

3117

1

	.into();

3118

1

3119

1

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

3120

1

	Relay::execute_with(|| {

3121

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3122

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3123

1

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

3124

1

			Box::new(

3125

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3126

1

					.clone()

3127

1

					.into()

3128

1

),

3129

1

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

3130

1

0,

3131

1

			WeightLimit::Unlimited

3132

1

));

3133

1

});

3134

1

3135

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3136

1

	Statemint::execute_with(|| {

3137

1

		// Check Alice received 200 tokens on AssetHub

3138

1

		assert_eq!(

3139

1

			StatemintBalances::free_balance(RELAYALICE),

3140

1

			INITIAL_BALANCE + 200

3141

1

);

3142

3143

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3144

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3145

1

			sov,

3146

1

			110000000000000

3147

1

));

3148

3149

		// Now send those tokens to ParaA

3150

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3151

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3152

1

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

3153

1

			Box::new(

3154

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3155

1

					.clone()

3156

1

					.into()

3157

1

),

3158

1

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

3159

1

0,

3160

1

			WeightLimit::Unlimited

3161

1

));

3162

1

});

3163

1

3164

1

	ParaA::execute_with(|| {

3165

1

		// Alice should have received the DOTs

3166

1

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

3167

1

});

3168

1

3169

1

	let dest = Location::new(

3170

1

1,

3171

1

3172

1

			Parachain(1000),

3173

1

			AccountId32 {

3174

1

				network: None,

3175

1

				id: RELAYBOB.into(),

3176

1

},

3177

1

],

3178

1

);

3179

1

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

3180

1

3181

1

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

3182

1

	ParaA::execute_with(|| {

3183

1

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

3184

1

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

3185

1

		assert_ok!(PolkadotXcm::transfer_assets(

3186

1

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

3187

1

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

3188

1

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

3189

1

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

3190

1

0,

3191

1

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

3192

1

));

3193

3194

1

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

3195

1

});

3196

1

3197

1

	Statemint::execute_with(|| {

3198

1

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

3199

1

		assert_eq!(

3200

1

			StatemintBalances::free_balance(RELAYBOB),

3201

1

			INITIAL_BALANCE + 110

3202

1

);

3203

1

});

3204

1

3205

1

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

3206

1

	Statemint::execute_with(|| {

3207

1

		// Now send those tokens to ParaA

3208

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3209

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3210

1

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

3211

1

			Box::new(

3212

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3213

1

					.clone()

3214

1

					.into()

3215

1

),

3216

1

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

3217

1

0,

3218

1

			WeightLimit::Unlimited

3219

1

));

3220

3221

		// 100 DOTs were deducted from Bob's account

3222

1

		assert_eq!(

3223

1

			StatemintBalances::free_balance(RELAYBOB),

3224

1

			INITIAL_BALANCE + 10

3225

1

);

3226

1

});

3227

1

3228

1

	ParaA::execute_with(|| {

3229

1

		// Alice should have received 100 DOTs

3230

1

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

3231

1

});

3232

1

3233

3234

#[test]

3235

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3236

1

	MockNet::reset();

3237

1

3238

1

	// Relay asset

3239

1

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

3240

1

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

3241

1

3242

1

	let relay_asset_metadata = parachain::AssetMetadata {

3243

1

		name: b"RelayToken".to_vec(),

3244

1

		symbol: b"Relay".to_vec(),

3245

1

		decimals: 12,

3246

1

};

3247

1

3248

1

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

3249

1

3250

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3251

1

		polkadot_parachain::primitives::Sibling,

3252

1

		statemint_like::AccountId,

3253

1

	>::convert_location(&dest_para)

3254

1

	.unwrap();

3255

1

3256

1

	ParaA::execute_with(|| {

3257

1

		assert_ok!(AssetManager::register_foreign_asset(

3258

1

			parachain::RuntimeOrigin::root(),

3259

1

			relay_location.clone(),

3260

1

			relay_asset_metadata,

3261

1

			1u128,

3262

1

			true

3263

1

));

3264

1

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

3265

1

});

3266

1

3267

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3268

1

		network: None,

3269

1

		key: PARAALICE,

3270

1

3271

1

	.into();

3272

1

3273

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3274

1

		network: None,

3275

1

		id: RELAYALICE.into(),

3276

1

3277

1

	.into();

3278

1

3279

1

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

3280

1

	Relay::execute_with(|| {

3281

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3282

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3283

1

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

3284

1

			Box::new(

3285

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3286

1

					.clone()

3287

1

					.into()

3288

1

),

3289

1

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

3290

1

0,

3291

1

			WeightLimit::Unlimited

3292

1

));

3293

1

});

3294

1

3295

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3296

1

	Statemint::execute_with(|| {

3297

1

		// Check Alice received 200 tokens on AssetHub

3298

1

		assert_eq!(

3299

1

			StatemintBalances::free_balance(RELAYALICE),

3300

1

			INITIAL_BALANCE + 200

3301

1

);

3302

3303

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3304

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3305

1

			sov,

3306

1

			110000000000000

3307

1

));

3308

3309

		// Now send those tokens to ParaA

3310

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3311

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3312

1

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

3313

1

			Box::new(

3314

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3315

1

					.clone()

3316

1

					.into()

3317

1

),

3318

1

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

3319

1

0,

3320

1

			WeightLimit::Unlimited

3321

1

));

3322

1

});

3323

1

3324

1

	ParaA::execute_with(|| {

3325

1

		// Alice should have received the DOTs

3326

1

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

3327

1

});

3328

1

3329

1

	let dest = Location::new(

3330

1

1,

3331

1

3332

1

			Parachain(1000),

3333

1

			AccountId32 {

3334

1

				network: None,

3335

1

				id: RELAYBOB.into(),

3336

1

},

3337

1

],

3338

1

);

3339

1

3340

1

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

3341

1

	let asset = Asset {

3342

1

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

3343

1

		fun: Fungibility::Fungible(100),

3344

1

};

3345

1

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

3346

1

	ParaA::execute_with(|| {

3347

1

		assert_ok!(PolkadotXcm::transfer_assets(

3348

1

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

3349

1

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

3350

1

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

3351

1

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

3352

1

0,

3353

1

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

3354

1

));

3355

3356

1

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

3357

1

});

3358

1

3359

1

	Statemint::execute_with(|| {

3360

1

		// Check that Bob received the tokens back in AssetHub

3361

1

		assert_eq!(

3362

1

			StatemintBalances::free_balance(RELAYBOB),

3363

1

			INITIAL_BALANCE + 100

3364

1

);

3365

1

});

3366

1

3367

1

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

3368

1

	Statemint::execute_with(|| {

3369

1

		// Now send those tokens to ParaA

3370

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3371

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3372

1

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

3373

1

			Box::new(

3374

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3375

1

					.clone()

3376

1

					.into()

3377

1

),

3378

1

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

3379

1

0,

3380

1

			WeightLimit::Unlimited

3381

1

));

3382

3383

		// 100 DOTs were deducted from Bob's account

3384

1

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

3385

1

});

3386

1

3387

1

	ParaA::execute_with(|| {

3388

1

		// Alice should have received 100 DOTs

3389

1

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

3390

1

});

3391

1

3392

3393

#[test]

3394

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3395

1

	MockNet::reset();

3396

1

3397

1

	// Relay asset

3398

1

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

3399

1

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

3400

1

3401

1

	let relay_asset_metadata = parachain::AssetMetadata {

3402

1

		name: b"RelayToken".to_vec(),

3403

1

		symbol: b"Relay".to_vec(),

3404

1

		decimals: 12,

3405

1

};

3406

1

3407

1

	// Statemint asset

3408

1

	let statemint_asset = Location::new(

3409

1

1,

3410

1

3411

1

			Parachain(1000u32),

3412

1

			PalletInstance(5u8),

3413

1

			GeneralIndex(10u128),

3414

1

],

3415

1

);

3416

1

	let statemint_location_asset: AssetType = statemint_asset

3417

1

		.clone()

3418

1

		.try_into()

3419

1

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

3420

1

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

3421

1

3422

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3423

1

		name: b"USDC".to_vec(),

3424

1

		symbol: b"USDC".to_vec(),

3425

1

		decimals: 12,

3426

1

};

3427

1

3428

1

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

3429

1

3430

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3431

1

		polkadot_parachain::primitives::Sibling,

3432

1

		statemint_like::AccountId,

3433

1

	>::convert_location(&dest_para)

3434

1

	.unwrap();

3435

1

3436

1

	ParaA::execute_with(|| {

3437

1

		assert_ok!(AssetManager::register_foreign_asset(

3438

1

			parachain::RuntimeOrigin::root(),

3439

1

			relay_location.clone(),

3440

1

			relay_asset_metadata,

3441

1

			1u128,

3442

1

			true

3443

1

));

3444

1

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

3445

1

3446

1

		assert_ok!(AssetManager::register_foreign_asset(

3447

1

			parachain::RuntimeOrigin::root(),

3448

1

			statemint_location_asset.clone(),

3449

1

			asset_metadata_statemint_asset,

3450

1

			1u128,

3451

1

			true

3452

1

));

3453

1

		XcmWeightTrader::set_asset_price(statemint_asset, 0u128);

3454

1

});

3455

1

3456

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3457

1

		network: None,

3458

1

		key: PARAALICE,

3459

1

3460

1

	.into();

3461

1

3462

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3463

1

		network: None,

3464

1

		id: RELAYALICE.into(),

3465

1

3466

1

	.into();

3467

1

3468

1

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

3469

1

	Relay::execute_with(|| {

3470

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3471

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3472

1

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

3473

1

			Box::new(

3474

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3475

1

					.clone()

3476

1

					.into()

3477

1

),

3478

1

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

3479

1

0,

3480

1

			WeightLimit::Unlimited

3481

1

));

3482

1

});

3483

1

3484

1

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

3485

1

	Statemint::execute_with(|| {

3486

1

		// Check Alice received 200 tokens on AssetHub

3487

1

		assert_eq!(

3488

1

			StatemintBalances::free_balance(RELAYALICE),

3489

1

			INITIAL_BALANCE + 200

3490

1

);

3491

3492

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3493

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3494

1

			sov,

3495

1

			110000000000000

3496

1

));

3497

3498

1

		statemint_like::PrefixChanger::set_prefix(

3499

1

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

3500

1

);

3501

1

3502

1

		assert_ok!(StatemintAssets::create(

3503

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3504

1

10,

3505

1

			RELAYALICE,

3506

1

3507

1

));

3508

3509

1

		assert_ok!(StatemintAssets::mint(

3510

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3511

1

10,

3512

1

			RELAYALICE,

3513

1

			300000000000000

3514

1

));

3515

3516

		// Now send relay tokens to ParaA

3517

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3518

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3519

1

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

3520

1

			Box::new(

3521

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3522

1

					.clone()

3523

1

					.into()

3524

1

),

3525

1

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

3526

1

0,

3527

1

			WeightLimit::Unlimited

3528

1

));

3529

3530

		// Send USDC

3531

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3532

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3533

1

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

3534

1

			Box::new(

3535

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3536

1

					.clone()

3537

1

					.into()

3538

1

),

3539

1

			Box::new(

3540

1

3541

1

3542

1

						xcm::latest::prelude::PalletInstance(

3543

1

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

3544

1

),

3545

1

						GeneralIndex(10),

3546

1

],

3547

1

3548

1

3549

1

					.into()

3550

1

),

3551

1

0,

3552

1

			WeightLimit::Unlimited

3553

1

));

3554

1

});

3555

1

3556

1

	ParaA::execute_with(|| {

3557

1

		// Alice should have received the DOTs

3558

1

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

3559

3560

		// Alice has received 125 USDC

3561

1

		assert_eq!(

3562

1

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

3563

1

3564

1

);

3565

1

});

3566

1

3567

1

	let dest = Location::new(

3568

1

1,

3569

1

3570

1

			Parachain(1000),

3571

1

			AccountId32 {

3572

1

				network: None,

3573

1

				id: RELAYBOB.into(),

3574

1

},

3575

1

],

3576

1

);

3577

1

3578

1

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

3579

1

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

3580

1

	ParaA::execute_with(|| {

3581

1

		let asset = currency_to_asset(

3582

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3583

1

			100,

3584

1

);

3585

1

		let asset_fee =

3586

1

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

3587

1

		assert_ok!(PolkadotXcm::transfer_assets(

3588

1

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

3589

1

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

3590

1

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

3591

1

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

3592

1

0,

3593

1

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

3594

1

));

3595

3596

1

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

3597

1

});

3598

1

3599

1

	Statemint::execute_with(|| {

3600

1

		// Check that Bob received relay tokens back in AssetHub

3601

1

		assert_eq!(

3602

1

			StatemintBalances::free_balance(RELAYBOB),

3603

1

			INITIAL_BALANCE + 100

3604

1

);

3605

3606

		// Check that BOB received 100 USDC on AssetHub

3607

1

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

3608

1

});

3609

1

3610

1

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

3611

1

	Statemint::execute_with(|| {

3612

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3613

1

3614

1

		// Now send those tokens to ParaA

3615

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3616

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3617

1

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

3618

1

			Box::new(

3619

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3620

1

					.clone()

3621

1

					.into()

3622

1

),

3623

1

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

3624

1

0,

3625

1

			WeightLimit::Unlimited

3626

1

));

3627

3628

		// 100 DOTs were deducted from Bob's account

3629

1

		assert_eq!(

3630

1

			StatemintBalances::free_balance(RELAYBOB),

3631

1

			bob_previous_balance - 100

3632

1

);

3633

1

});

3634

1

3635

1

	ParaA::execute_with(|| {

3636

1

		// Alice should have received 100 DOTs

3637

1

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

3638

1

});

3639

1

3640

3641

#[test]

3642

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3643

1

	MockNet::reset();

3644

1

3645

1

	// Relay asset

3646

1

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

3647

1

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

3648

1

3649

1

	let relay_asset_metadata = parachain::AssetMetadata {

3650

1

		name: b"RelayToken".to_vec(),

3651

1

		symbol: b"Relay".to_vec(),

3652

1

		decimals: 12,

3653

1

};

3654

1

3655

1

	// Statemint asset

3656

1

	let statemint_asset = Location::new(

3657

1

1,

3658

1

3659

1

			Parachain(1000u32),

3660

1

			PalletInstance(5u8),

3661

1

			GeneralIndex(10u128),

3662

1

],

3663

1

);

3664

1

	let statemint_location_asset: AssetType = statemint_asset

3665

1

		.clone()

3666

1

		.try_into()

3667

1

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

3668

1

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

3669

1

3670

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3671

1

		name: b"USDC".to_vec(),

3672

1

		symbol: b"USDC".to_vec(),

3673

1

		decimals: 12,

3674

1

};

3675

1

3676

1

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

3677

1

3678

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3679

1

		polkadot_parachain::primitives::Sibling,

3680

1

		statemint_like::AccountId,

3681

1

	>::convert_location(&dest_para)

3682

1

	.unwrap();

3683

1

3684

1

	ParaA::execute_with(|| {

3685

1

		assert_ok!(AssetManager::register_foreign_asset(

3686

1

			parachain::RuntimeOrigin::root(),

3687

1

			relay_location.clone(),

3688

1

			relay_asset_metadata,

3689

1

			1u128,

3690

1

			true

3691

1

));

3692

1

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

3693

1

3694

1

		assert_ok!(AssetManager::register_foreign_asset(

3695

1

			parachain::RuntimeOrigin::root(),

3696

1

			statemint_location_asset.clone(),

3697

1

			asset_metadata_statemint_asset,

3698

1

			1u128,

3699

1

			true

3700

1

));

3701

1

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

3702

1

});

3703

1

3704

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3705

1

		network: None,

3706

1

		key: PARAALICE,

3707

1

3708

1

	.into();

3709

1

3710

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3711

1

		network: None,

3712

1

		id: RELAYALICE.into(),

3713

1

3714

1

	.into();

3715

1

3716

1

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

3717

1

	Relay::execute_with(|| {

3718

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3719

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3720

1

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

3721

1

			Box::new(

3722

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3723

1

					.clone()

3724

1

					.into()

3725

1

),

3726

1

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

3727

1

0,

3728

1

			WeightLimit::Unlimited

3729

1

));

3730

1

});

3731

1

3732

1

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

3733

1

	Statemint::execute_with(|| {

3734

1

		// Check Alice received 200 tokens on AssetHub

3735

1

		assert_eq!(

3736

1

			StatemintBalances::free_balance(RELAYALICE),

3737

1

			INITIAL_BALANCE + 200

3738

1

);

3739

3740

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3741

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3742

1

			sov,

3743

1

			110000000000000

3744

1

));

3745

3746

1

		statemint_like::PrefixChanger::set_prefix(

3747

1

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

3748

1

);

3749

1

3750

1

		assert_ok!(StatemintAssets::create(

3751

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3752

1

10,

3753

1

			RELAYALICE,

3754

1

3755

1

));

3756

3757

1

		assert_ok!(StatemintAssets::mint(

3758

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3759

1

10,

3760

1

			RELAYALICE,

3761

1

			300000000000000

3762

1

));

3763

3764

		// Now send relay tokens to ParaA

3765

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3766

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3767

1

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

3768

1

			Box::new(

3769

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3770

1

					.clone()

3771

1

					.into()

3772

1

),

3773

1

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

3774

1

0,

3775

1

			WeightLimit::Unlimited

3776

1

));

3777

3778

		// Send USDC

3779

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3780

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3781

1

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

3782

1

			Box::new(

3783

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3784

1

					.clone()

3785

1

					.into()

3786

1

),

3787

1

			Box::new(

3788

1

3789

1

3790

1

						xcm::latest::prelude::PalletInstance(

3791

1

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

3792

1

),

3793

1

						GeneralIndex(10),

3794

1

],

3795

1

3796

1

3797

1

					.into()

3798

1

),

3799

1

0,

3800

1

			WeightLimit::Unlimited

3801

1

));

3802

1

});

3803

1

3804

1

	ParaA::execute_with(|| {

3805

1

		// Alice should have received the DOTs

3806

1

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

3807

3808

		// Alice has received 125 USDC

3809

1

		assert_eq!(

3810

1

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

3811

1

3812

1

);

3813

1

});

3814

1

3815

1

	let dest = Location::new(

3816

1

1,

3817

1

3818

1

			Parachain(1000),

3819

1

			AccountId32 {

3820

1

				network: None,

3821

1

				id: RELAYBOB.into(),

3822

1

},

3823

1

],

3824

1

);

3825

1

3826

1

	let statemint_asset_to_send = Asset {

3827

1

		id: AssetId(statemint_asset),

3828

1

		fun: Fungibility::Fungible(100),

3829

1

};

3830

1

3831

1

	let relay_asset_to_send = Asset {

3832

1

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

3833

1

		fun: Fungibility::Fungible(100),

3834

1

};

3835

1

3836

1

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

3837

1

	let assets_to_send: XcmAssets =

3838

1

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

3839

1

3840

1

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

3841

1

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

3842

1

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

3843

3844

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

3845

1

	ParaA::execute_with(|| {

3846

1

		assert_ok!(PolkadotXcm::transfer_assets(

3847

1

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

3848

1

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

3849

1

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

3850

1

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

3851

1

0,

3852

1

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

3853

1

));

3854

3855

1

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

3856

1

});

3857

1

3858

1

	Statemint::execute_with(|| {

3859

1

		// Check that Bob received relay tokens back in AssetHub

3860

1

		assert_eq!(

3861

1

			StatemintBalances::free_balance(RELAYBOB),

3862

1

			INITIAL_BALANCE + 100

3863

1

);

3864

3865

		// Check that BOB received 100 USDC on AssetHub

3866

1

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

3867

1

});

3868

1

3869

1

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

3870

1

	Statemint::execute_with(|| {

3871

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3872

1

3873

1

		// Now send those tokens to ParaA

3874

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3875

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3876

1

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

3877

1

			Box::new(

3878

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3879

1

					.clone()

3880

1

					.into()

3881

1

),

3882

1

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

3883

1

0,

3884

1

			WeightLimit::Unlimited

3885

1

));

3886

3887

		// 100 DOTs were deducted from Bob's account

3888

1

		assert_eq!(

3889

1

			StatemintBalances::free_balance(RELAYBOB),

3890

1

			bob_previous_balance - 100

3891

1

);

3892

1

});

3893

1

3894

1

	ParaA::execute_with(|| {

3895

1

		// Alice should have received 100 DOTs

3896

1

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

3897

1

});

3898

1

3899

3900

#[test]

3901

1

fn transact_through_signed_multilocation() {

3902

1

	MockNet::reset();

3903

1

	let mut ancestry = Location::parent();

3904

1

3905

1

	ParaA::execute_with(|| {

3906

1

		// Root can set transact info

3907

1

		assert_ok!(XcmTransactor::set_transact_info(

3908

1

			parachain::RuntimeOrigin::root(),

3909

1

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

3910

1

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

3911

1

			3000.into(),

3912

1

			20000000000.into(),

3913

1

			// 4 instructions in transact through signed

3914

1

			Some(4000.into())

3915

1

));

3916

		// Root can set transact info

3917

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3918

1

			parachain::RuntimeOrigin::root(),

3919

1

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

3920

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3921

1

));

3922

1

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

3923

1

});

3924

1

3925

1

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

3926

1

	let signed_origin: Junctions = [AccountKey20 {

3927

1

		network: None,

3928

1

		key: PARAALICE,

3929

1

}]

3930

1

	.into();

3931

1

3932

1

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

3933

1

	descend_origin_multilocation

3934

1

		.append_with(signed_origin)

3935

1

		.unwrap();

3936

1

3937

1

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

3938

1

	descend_origin_multilocation

3939

1

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

3940

1

		.unwrap();

3941

1

3942

1

	let derived = xcm_builder::Account32Hash::<

3943

1

		relay_chain::KusamaNetwork,

3944

1

		relay_chain::AccountId,

3945

1

	>::convert_location(&descend_origin_multilocation)

3946

1

	.unwrap();

3947

1

3948

1

	Relay::execute_with(|| {

3949

1

		// free execution, full amount received

3950

1

		assert_ok!(RelayBalances::transfer_allow_death(

3951

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3952

1

			derived.clone(),

3953

1

			4000004100u128,

3954

1

));

3955

		// derived account has all funds

3956

1

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

3957

		// sovereign account has 0 funds

3958

1

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

3959

1

});

3960

1

3961

1

	// Encode the call. Balances transact to para_a_account

3962

1

	// First index

3963

1

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

3964

1

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

3965

1

		relay_chain::Balances,

3966

1

>()

3967

1

	.unwrap() as u8;

3968

1

3969

1

	encoded.push(index);

3970

1

3971

1

	// Then call bytes

3972

1

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

3973

1

		// 100 to sovereign

3974

1

		dest: para_a_account(),

3975

1

		value: 100u32.into(),

3976

1

3977

1

	.encode();

3978

1

	encoded.append(&mut call_bytes);

3979

1

3980

1

	ParaA::execute_with(|| {

3981

1

		assert_ok!(XcmTransactor::transact_through_signed(

3982

1

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

3983

1

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

3984

1

			CurrencyPayment {

3985

1

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

3986

1

					Location::parent()

3987

1

				))),

3988

1

				fee_amount: None

3989

1

},

3990

1

			encoded,

3991

1

			// 4000000000 for transfer + 4000 for XCM

3992

1

			TransactWeights {

3993

1

				transact_required_weight_at_most: 4000000000.into(),

3994

1

				overall_weight: None

3995

1

},

3996

1

			false

3997

1

));

3998

1

});

3999

1

4000

1

	Relay::execute_with(|| {

4001

1

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

4002

4003

1

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

4004

1

});

4005

1

4006

4007

#[test]

4008

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4009

1

	MockNet::reset();

4010

1

	let mut ancestry = Location::parent();

4011

1

4012

1

	ParaA::execute_with(|| {

4013

1

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

4014

1

});

4015

1

4016

1

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

4017

1

	let signed_origin: Junctions = [AccountKey20 {

4018

1

		network: None,

4019

1

		key: PARAALICE,

4020

1

}]

4021

1

	.into();

4022

1

4023

1

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

4024

1

	descend_origin_multilocation

4025

1

		.append_with(signed_origin)

4026

1

		.unwrap();

4027

1

4028

1

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

4029

1

	descend_origin_multilocation

4030

1

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

4031

1

		.unwrap();

4032

1

4033

1

	let derived = xcm_builder::Account32Hash::<

4034

1

		relay_chain::KusamaNetwork,

4035

1

		relay_chain::AccountId,

4036

1

	>::convert_location(&descend_origin_multilocation)

4037

1

	.unwrap();

4038

1

4039

1

	Relay::execute_with(|| {

4040

1

		// free execution, full amount received

4041

1

		assert_ok!(RelayBalances::transfer_allow_death(

4042

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4043

1

			derived.clone(),

4044

1

			4000004100u128,

4045

1

));

4046

		// derived account has all funds

4047

1

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

4048

		// sovereign account has 0 funds

4049

1

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

4050

1

});

4051

1

4052

1

	// Encode the call. Balances transact to para_a_account

4053

1

	// First index

4054

1

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

4055

1

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

4056

1

		relay_chain::Balances,

4057

1

>()

4058

1

	.unwrap() as u8;

4059

1

4060

1

	encoded.push(index);

4061

1

4062

1

	// Then call bytes

4063

1

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

4064

1

		// 100 to sovereign

4065

1

		dest: para_a_account(),

4066

1

		value: 100u32.into(),

4067

1

4068

1

	.encode();

4069

1

	encoded.append(&mut call_bytes);

4070

1

4071

1

	let total_weight = 4000004000u64;

4072

1

	ParaA::execute_with(|| {

4073

1

		assert_ok!(XcmTransactor::transact_through_signed(

4074

1

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

4075

1

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

4076

1

			CurrencyPayment {

4077

1

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

4078

1

					Location::parent()

4079

1

				))),

4080

1

				fee_amount: Some(total_weight as u128)

4081

1

},

4082

1

			encoded,

4083

1

			// 4000000000 for transfer + 4000 for XCM

4084

1

			TransactWeights {

4085

1

				transact_required_weight_at_most: 4000000000.into(),

4086

1

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

4087

1

},

4088

1

			false

4089

1

));

4090

1

});

4091

1

4092

1

	Relay::execute_with(|| {

4093

1

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

4094

4095

1

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

4096

1

});

4097

1

4098

4099

#[test]

4100

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4101

1

	MockNet::reset();

4102

1

	let mut ancestry = Location::parent();

4103

1

4104

1

	ParaA::execute_with(|| {

4105

1

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

4106

1

});

4107

1

4108

1

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

4109

1

	let signed_origin: Junctions = [AccountKey20 {

4110

1

		network: None,

4111

1

		key: PARAALICE,

4112

1

}]

4113

1

	.into();

4114

1

4115

1

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

4116

1

	descend_origin_multilocation

4117

1

		.append_with(signed_origin)

4118

1

		.unwrap();

4119

1

4120

1

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

4121

1

	descend_origin_multilocation

4122

1

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

4123

1

		.unwrap();

4124

1

4125

1

	let derived = xcm_builder::Account32Hash::<

4126

1

		relay_chain::KusamaNetwork,

4127

1

		relay_chain::AccountId,

4128

1

	>::convert_location(&descend_origin_multilocation)

4129

1

	.unwrap();

4130

1

4131

1

	Relay::execute_with(|| {

4132

1

		// free execution, full amount received

4133

1

		assert_ok!(RelayBalances::transfer_allow_death(

4134

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4135

1

			derived.clone(),

4136

1

			4000009100u128,

4137

1

));

4138

		// derived account has all funds

4139

1

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

4140

		// sovereign account has 0 funds

4141

1

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

4142

1

});

4143

1

4144

1

	// Encode the call. Balances transact to para_a_account

4145

1

	// First index

4146

1

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

4147

1

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

4148

1

		relay_chain::Balances,

4149

1

>()

4150

1

	.unwrap() as u8;

4151

1

4152

1

	encoded.push(index);

4153

1

4154

1

	// Then call bytes

4155

1

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

4156

1

		// 100 to sovereign

4157

1

		dest: para_a_account(),

4158

1

		value: 100u32.into(),

4159

1

4160

1

	.encode();

4161

1

	encoded.append(&mut call_bytes);

4162

1

4163

1

	let total_weight = 4000009000u64;

4164

1

	ParaA::execute_with(|| {

4165

1

		assert_ok!(XcmTransactor::transact_through_signed(

4166

1

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

4167

1

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

4168

1

			CurrencyPayment {

4169

1

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

4170

1

					Location::parent()

4171

1

				))),

4172

1

				fee_amount: Some(total_weight as u128)

4173

1

},

4174

1

			encoded,

4175

1

			// 4000000000 for transfer + 9000 for XCM

4176

1

			TransactWeights {

4177

1

				transact_required_weight_at_most: 4000000000.into(),

4178

1

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

4179

1

},

4180

1

			true

4181

1

));

4182

1

});

4183

1

4184

1

	Relay::execute_with(|| {

4185

1

		// 100 transferred

4186

1

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

4187

4188

		// 4000009000 refunded

4189

1

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

4190

1

});

4191

1

4192

4193

#[test]

4194

1

fn transact_through_signed_multilocation_para_to_para() {

4195

1

	MockNet::reset();

4196

1

	let mut ancestry = Location::parent();

4197

1

4198

1

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

4199

1

4200

1

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

4201

1

4202

1

	ParaA::execute_with(|| {

4203

1

		// Root can set transact info

4204

1

		assert_ok!(XcmTransactor::set_transact_info(

4205

1

			parachain::RuntimeOrigin::root(),

4206

1

			// ParaB

4207

1

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

4208

1

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

4209

1

			3.into(),

4210

1

			20000000000.into(),

4211

1

			// 4 instructions in transact through signed

4212

1

			Some(4.into())

4213

1

));

4214

		// Root can set transact info

4215

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4216

1

			parachain::RuntimeOrigin::root(),

4217

1

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

4218

1

			parachain::ParaTokensPerSecond::get(),

4219

1

));

4220

1

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

4221

1

});

4222

1

4223

1

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

4224

1

	let signed_origin: Junctions = [AccountKey20 {

4225

1

		network: None,

4226

1

		key: PARAALICE,

4227

1

}]

4228

1

	.into();

4229

1

4230

1

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

4231

1

	descend_origin_multilocation

4232

1

		.append_with(signed_origin)

4233

1

		.unwrap();

4234

1

4235

1

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

4236

1

	descend_origin_multilocation

4237

1

		.reanchor(&para_b_location, &ancestry.interior)

4238

1

		.unwrap();

4239

1

4240

1

	let derived = xcm_builder::HashedDescription::<

4241

1

		parachain::AccountId,

4242

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4243

1

	>::convert_location(&descend_origin_multilocation)

4244

1

	.unwrap();

4245

1

4246

1

	ParaB::execute_with(|| {

4247

1

		// free execution, full amount received

4248

1

		assert_ok!(ParaBalances::transfer_allow_death(

4249

1

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

4250

1

			derived.clone(),

4251

1

			4000000104u128,

4252

1

));

4253

		// derived account has all funds

4254

1

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

4255

		// sovereign account has 0 funds

4256

1

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

4257

1

});

4258

1

4259

1

	// Encode the call. Balances transact to para_a_account

4260

1

	// First index

4261

1

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

4262

1

	let index =

4263

1

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

4264

1

			.unwrap() as u8;

4265

1

4266

1

	encoded.push(index);

4267

1

4268

1

	// Then call bytes

4269

1

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

4270

1

		// 100 to sovereign

4271

1

		dest: para_a_account_20(),

4272

1

		value: 100u32.into(),

4273

1

4274

1

	.encode();

4275

1

	encoded.append(&mut call_bytes);

4276

1

4277

1

	ParaA::execute_with(|| {

4278

1

		assert_ok!(XcmTransactor::transact_through_signed(

4279

1

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

4280

1

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

4281

1

			CurrencyPayment {

4282

1

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

4283

1

					para_b_balances

4284

1

				))),

4285

1

				fee_amount: None

4286

1

},

4287

1

			encoded,

4288

1

			// 4000000000 for transfer + 4000 for XCM

4289

1

			// 1-1 to fee

4290

1

			TransactWeights {

4291

1

				transact_required_weight_at_most: 4000000000.into(),

4292

1

				overall_weight: None

4293

1

},

4294

1

			false

4295

1

));

4296

1

});

4297

1

4298

1

	ParaB::execute_with(|| {

4299

1

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

4300

4301

1

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

4302

1

});

4303

1

4304

4305

#[test]

4306

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4307

1

	MockNet::reset();

4308

1

	let mut ancestry = Location::parent();

4309

1

4310

1

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

4311

1

4312

1

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

4313

1

4314

1

	ParaA::execute_with(|| {

4315

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4316

1

			parachain::RuntimeOrigin::root(),

4317

1

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

4318

1

			parachain::ParaTokensPerSecond::get(),

4319

1

));

4320

1

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

4321

1

});

4322

1

4323

1

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

4324

1

	let signed_origin: Junctions = [AccountKey20 {

4325

1

		network: None,

4326

1

		key: PARAALICE,

4327

1

}]

4328

1

	.into();

4329

1

4330

1

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

4331

1

	descend_origin_multilocation

4332

1

		.append_with(signed_origin)

4333

1

		.unwrap();

4334

1

4335

1

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

4336

1

	descend_origin_multilocation

4337

1

		.reanchor(&para_b_location, &ancestry.interior)

4338

1

		.unwrap();

4339

1

4340

1

	let derived = xcm_builder::HashedDescription::<

4341

1

		parachain::AccountId,

4342

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4343

1

	>::convert_location(&descend_origin_multilocation)

4344

1

	.unwrap();

4345

1

4346

1

	ParaB::execute_with(|| {

4347

1

		// free execution, full amount received

4348

1

		assert_ok!(ParaBalances::transfer_allow_death(

4349

1

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

4350

1

			derived.clone(),

4351

1

			4000009100u128,

4352

1

));

4353

		// derived account has all funds

4354

1

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

4355

		// sovereign account has 0 funds

4356

1

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

4357

1

});

4358

1

4359

1

	// Encode the call. Balances transact to para_a_account

4360

1

	// First index

4361

1

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

4362

1

	let index =

4363

1

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

4364

1

			.unwrap() as u8;

4365

1

4366

1

	encoded.push(index);

4367

1

4368

1

	// Then call bytes

4369

1

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

4370

1

		// 100 to sovereign

4371

1

		dest: para_a_account_20(),

4372

1

		value: 100u32.into(),

4373

1

4374

1

	.encode();

4375

1

	encoded.append(&mut call_bytes);

4376

1

4377

1

	let overall_weight = 4000009000u64;

4378

1

	ParaA::execute_with(|| {

4379

1

		assert_ok!(XcmTransactor::transact_through_signed(

4380

1

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

4381

1

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

4382

1

			CurrencyPayment {

4383

1

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

4384

1

					para_b_balances

4385

1

				))),

4386

1

				fee_amount: Some(overall_weight as u128)

4387

1

},

4388

1

			encoded,

4389

1

			// 4000000000 for transfer + 9000 for XCM

4390

1

			TransactWeights {

4391

1

				transact_required_weight_at_most: 4000000000.into(),

4392

1

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

4393

1

},

4394

1

			true

4395

1

));

4396

1

});

4397

1

4398

1

	ParaB::execute_with(|| {

4399

1

		// Check the derived account was refunded

4400

1

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

4401

4402

		// Check the transfer was executed

4403

1

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

4404

1

});

4405

1

4406

4407

#[test]

4408

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4409

1

	MockNet::reset();

4410

1

	let mut ancestry = Location::parent();

4411

1

4412

1

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

4413

1

4414

1

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

4415

1

4416

1

	ParaA::execute_with(|| {

4417

1

		// Root can set transact info

4418

1

		assert_ok!(XcmTransactor::set_transact_info(

4419

1

			parachain::RuntimeOrigin::root(),

4420

1

			// ParaB

4421

1

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

4422

1

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

4423

1

			3.into(),

4424

1

			20000000000.into(),

4425

1

			// 4 instructions in transact through signed

4426

1

			Some(4.into())

4427

1

));

4428

		// Root can set transact info

4429

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4430

1

			parachain::RuntimeOrigin::root(),

4431

1

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

4432

1

			parachain::ParaTokensPerSecond::get(),

4433

1

));

4434

1

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

4435

1

});

4436

1

4437

1

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

4438

1

	let signed_origin: Junctions = [AccountKey20 {

4439

1

		network: None,

4440

1

		key: PARAALICE,

4441

1

}]

4442

1

	.into();

4443

1

4444

1

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

4445

1

	descend_origin_multilocation

4446

1

		.append_with(signed_origin)

4447

1

		.unwrap();

4448

1

4449

1

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

4450

1

	descend_origin_multilocation

4451

1

		.reanchor(&para_b_location, &ancestry.interior)

4452

1

		.unwrap();

4453

1

4454

1

	let derived = xcm_builder::HashedDescription::<

4455

1

		parachain::AccountId,

4456

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4457

1

	>::convert_location(&descend_origin_multilocation)

4458

1

	.unwrap();

4459

1

4460

1

	let mut parachain_b_alice_balances_before = 0;

4461

1

	ParaB::execute_with(|| {

4462

1

		assert_ok!(ParaBalances::transfer_allow_death(

4463

1

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

4464

1

			derived.clone(),

4465

1

			4000000104u128,

4466

1

));

4467

		// derived account has all funds

4468

1

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

4469

		// sovereign account has 0 funds

4470

1

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

4471

4472

1

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

4473

1

});

4474

1

4475

1

	// Encode the call. Balances transact to para_a_account

4476

1

	// First index

4477

1

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

4478

1

	let index =

4479

1

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

4480

1

			.unwrap() as u8;

4481

1

4482

1

	encoded.push(index);

4483

4484

	use sp_core::U256;

4485

	// Let's do a EVM transfer

4486

1

	let eth_tx =

4487

1

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

4488

1

			gas_limit: U256::from(21000),

4489

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4490

1

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

4491

1

			value: U256::from(100),

4492

1

			input: BoundedVec::<

4493

1

u8,

4494

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4495

1

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

4496

1

			access_list: None,

4497

1

});

4498

1

4499

1

	// Then call bytes

4500

1

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

4501

1

		xcm_transaction: eth_tx,

4502

1

4503

1

	.encode();

4504

1

	encoded.append(&mut call_bytes);

4505

1

4506

1

	ParaA::execute_with(|| {

4507

1

		assert_ok!(XcmTransactor::transact_through_signed(

4508

1

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

4509

1

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

4510

1

			CurrencyPayment {

4511

1

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

4512

1

					para_b_balances

4513

1

				))),

4514

1

				fee_amount: None

4515

1

},

4516

1

			encoded,

4517

1

			// 4000000000 for transfer + 4000 for XCM

4518

1

			// 1-1 to fee

4519

1

			TransactWeights {

4520

1

				transact_required_weight_at_most: 4000000000.into(),

4521

1

				overall_weight: None

4522

1

},

4523

1

			false

4524

1

));

4525

1

});

4526

1

4527

1

	ParaB::execute_with(|| {

4528

1

		// Make sure the EVM transfer went through

4529

1

		assert!(

4530

1

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

4531

1

				== parachain_b_alice_balances_before + 100

4532

1

);

4533

1

});

4534

1

4535

4536

#[test]

4537

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4538

1

	MockNet::reset();

4539

1

	let mut ancestry = Location::parent();

4540

1

4541

1

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

4542

1

4543

1

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

4544

1

4545

1

	ParaA::execute_with(|| {

4546

1

		// Root can set transact info

4547

1

		assert_ok!(XcmTransactor::set_transact_info(

4548

1

			parachain::RuntimeOrigin::root(),

4549

1

			// ParaB

4550

1

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

4551

1

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

4552

1

			3.into(),

4553

1

			20000000000.into(),

4554

1

			// 4 instructions in transact through signed

4555

1

			Some(4.into())

4556

1

));

4557

		// Root can set transact info

4558

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4559

1

			parachain::RuntimeOrigin::root(),

4560

1

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

4561

1

			parachain::ParaTokensPerSecond::get(),

4562

1

));

4563

1

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

4564

1

});

4565

1

4566

1

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

4567

1

	let signed_origin: Junctions = [AccountKey20 {

4568

1

		network: None,

4569

1

		key: PARAALICE,

4570

1

}]

4571

1

	.into();

4572

1

4573

1

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

4574

1

	descend_origin_multilocation

4575

1

		.append_with(signed_origin)

4576

1

		.unwrap();

4577

1

4578

1

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

4579

1

	descend_origin_multilocation

4580

1

		.reanchor(&para_b_location, &ancestry.interior)

4581

1

		.unwrap();

4582

1

4583

1

	let derived = xcm_builder::HashedDescription::<

4584

1

		parachain::AccountId,

4585

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4586

1

	>::convert_location(&descend_origin_multilocation)

4587

1

	.unwrap();

4588

1

4589

1

	let mut parachain_b_alice_balances_before = 0;

4590

1

	ParaB::execute_with(|| {

4591

1

		assert_ok!(ParaBalances::transfer_allow_death(

4592

1

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

4593

1

			derived.clone(),

4594

1

			4000000104u128,

4595

1

));

4596

		// derived account has all funds

4597

1

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

4598

		// sovereign account has 0 funds

4599

1

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

4600

4601

1

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

4602

1

});

4603

1

4604

1

	// Encode the call. Balances transact to para_a_account

4605

1

	// First index

4606

1

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

4607

1

	let index =

4608

1

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

4609

1

			.unwrap() as u8;

4610

1

4611

1

	encoded.push(index);

4612

4613

	use sp_core::U256;

4614

	// Let's do a EVM transfer

4615

1

	let eth_tx =

4616

1

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

4617

1

			gas_limit: U256::from(21000),

4618

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4619

1

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

4620

1

			value: U256::from(100),

4621

1

			input: BoundedVec::<

4622

1

u8,

4623

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4624

1

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

4625

1

			access_list: None,

4626

1

});

4627

1

4628

1

	// Then call bytes

4629

1

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

4630

1

		transact_as: PARAALICE.into(),

4631

1

		xcm_transaction: eth_tx,

4632

1

4633

1

	.encode();

4634

1

	encoded.append(&mut call_bytes);

4635

1

4636

1

	ParaA::execute_with(|| {

4637

1

		assert_ok!(XcmTransactor::transact_through_signed(

4638

1

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

4639

1

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

4640

1

			CurrencyPayment {

4641

1

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

4642

1

					para_b_balances

4643

1

				))),

4644

1

				fee_amount: None

4645

1

},

4646

1

			encoded,

4647

1

			TransactWeights {

4648

1

				transact_required_weight_at_most: 4000000000.into(),

4649

1

				overall_weight: None

4650

1

},

4651

1

			false

4652

1

));

4653

1

});

4654

1

4655

1

	ParaB::execute_with(|| {

4656

1

		// Make sure the EVM transfer wasn't executed

4657

1

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

4658

1

});

4659

1

4660

4661

#[test]

4662

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4663

1

	MockNet::reset();

4664

1

	let mut ancestry = Location::parent();

4665

1

4666

1

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

4667

1

4668

1

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

4669

1

4670

1

	ParaA::execute_with(|| {

4671

1

		// Root can set transact info

4672

1

		assert_ok!(XcmTransactor::set_transact_info(

4673

1

			parachain::RuntimeOrigin::root(),

4674

1

			// ParaB

4675

1

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

4676

1

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

4677

1

			3.into(),

4678

1

			20000000000.into(),

4679

1

			// 4 instructions in transact through signed

4680

1

			Some(4.into())

4681

1

));

4682

		// Root can set transact info

4683

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4684

1

			parachain::RuntimeOrigin::root(),

4685

1

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

4686

1

			parachain::ParaTokensPerSecond::get(),

4687

1

));

4688

1

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

4689

1

});

4690

1

4691

1

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

4692

1

	let signed_origin: Junctions = [AccountKey20 {

4693

1

		network: None,

4694

1

		key: PARAALICE,

4695

1

}]

4696

1

	.into();

4697

1

4698

1

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

4699

1

	descend_origin_multilocation

4700

1

		.append_with(signed_origin)

4701

1

		.unwrap();

4702

1

4703

1

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

4704

1

	descend_origin_multilocation

4705

1

		.reanchor(&para_b_location, &ancestry.interior)

4706

1

		.unwrap();

4707

1

4708

1

	let derived = xcm_builder::HashedDescription::<

4709

1

		parachain::AccountId,

4710

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4711

1

	>::convert_location(&descend_origin_multilocation)

4712

1

	.unwrap();

4713

1

4714

1

	let transfer_recipient = evm_account();

4715

1

	let mut transfer_recipient_balance_before = 0;

4716

1

	ParaB::execute_with(|| {

4717

1

		assert_ok!(ParaBalances::transfer_allow_death(

4718

1

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

4719

1

			derived.clone(),

4720

1

			4000000104u128,

4721

1

));

4722

		// derived account has all funds

4723

1

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

4724

		// sovereign account has 0 funds

4725

1

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

4726

4727

1

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

4728

1

4729

1

		// Add proxy ALICE  -> derived

4730

1

		let _ = parachain::Proxy::add_proxy_delegate(

4731

1

			&PARAALICE.into(),

4732

1

			derived,

4733

1

			parachain::ProxyType::Any,

4734

1

0,

4735

1

);

4736

1

});

4737

1

4738

1

	// Encode the call. Balances transact to para_a_account

4739

1

	// First index

4740

1

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

4741

1

	let index =

4742

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4743

1

			.unwrap() as u8;

4744

1

4745

1

	encoded.push(index);

4746

4747

	use sp_core::U256;

4748

	// Let's do a EVM transfer

4749

1

	let eth_tx =

4750

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4751

1

			gas_limit: U256::from(21000),

4752

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

4753

1

			value: U256::from(100),

4754

1

			input: BoundedVec::<

4755

1

u8,

4756

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4757

1

			>::try_from(vec![]).unwrap(),

4758

1

			access_list: None,

4759

1

});

4760

1

4761

1

	// Then call bytes

4762

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4763

1

		transact_as: PARAALICE.into(),

4764

1

		xcm_transaction: eth_tx,

4765

1

4766

1

	.encode();

4767

1

	encoded.append(&mut call_bytes);

4768

1

4769

1

	ParaA::execute_with(|| {

4770

1

		assert_ok!(XcmTransactor::transact_through_signed(

4771

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4772

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4773

1

			CurrencyPayment {

4774

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4775

1

					para_b_balances

4776

1

				))),

4777

1

				fee_amount: None

4778

1

},

4779

1

			encoded,

4780

1

			TransactWeights {

4781

1

				transact_required_weight_at_most: 4000000000.into(),

4782

1

				overall_weight: None

4783

1

},

4784

1

			false

4785

1

));

4786

1

});

4787

1

4788

1

	ParaB::execute_with(|| {

4789

1

		// Make sure the EVM transfer was executed

4790

1

		assert!(

4791

1

			ParaBalances::free_balance(&transfer_recipient.into())

4792

1

				== transfer_recipient_balance_before + 100

4793

1

);

4794

1

});

4795

1

4796

4797

#[test]

4798

1

fn hrmp_init_accept_through_root() {

4799

1

	MockNet::reset();

4800

1

4801

1

	Relay::execute_with(|| {

4802

1

		assert_ok!(RelayBalances::transfer_allow_death(

4803

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4804

1

			para_a_account(),

4805

1

			1000u128

4806

1

));

4807

1

		assert_ok!(RelayBalances::transfer_allow_death(

4808

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4809

1

			para_b_account(),

4810

1

			1000u128

4811

1

));

4812

1

});

4813

1

4814

1

	ParaA::execute_with(|| {

4815

1

		let total_fee = 1_000u128;

4816

1

		let total_weight: u64 = 1_000_000_000;

4817

1

		let tx_weight: u64 = 500_000_000;

4818

1

		// Root can send hrmp init channel

4819

1

		assert_ok!(XcmTransactor::hrmp_manage(

4820

1

			parachain::RuntimeOrigin::root(),

4821

1

			HrmpOperation::InitOpen(HrmpInitParams {

4822

1

				para_id: 2u32.into(),

4823

1

				proposed_max_capacity: 1,

4824

1

				proposed_max_message_size: 1

4825

1

}),

4826

1

			CurrencyPayment {

4827

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4828

1

					Location::parent()

4829

1

				))),

4830

1

				fee_amount: Some(total_fee)

4831

1

},

4832

1

			TransactWeights {

4833

1

				transact_required_weight_at_most: tx_weight.into(),

4834

1

				overall_weight: Some(Limited(total_weight.into()))

4835

1

4836

1

));

4837

1

});

4838

1

	Relay::execute_with(|| {

4839

1

		let expected_event: relay_chain::RuntimeEvent =

4840

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4841

1

				sender: 1u32.into(),

4842

1

				recipient: 2u32.into(),

4843

1

				proposed_max_capacity: 1u32,

4844

1

				proposed_max_message_size: 1u32,

4845

1

4846

1

			.into();

4847

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4848

1

});

4849

1

	ParaB::execute_with(|| {

4850

1

		let total_fee = 1_000u128;

4851

1

		let total_weight: u64 = 1_000_000_000;

4852

1

		let tx_weight: u64 = 500_000_000;

4853

1

		// Root can send hrmp accept channel

4854

1

		assert_ok!(XcmTransactor::hrmp_manage(

4855

1

			parachain::RuntimeOrigin::root(),

4856

1

			HrmpOperation::Accept {

4857

1

				para_id: 1u32.into()

4858

1

},

4859

1

			CurrencyPayment {

4860

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4861

1

					Location::parent()

4862

1

				))),

4863

1

				fee_amount: Some(total_fee)

4864

1

},

4865

1

			TransactWeights {

4866

1

				transact_required_weight_at_most: tx_weight.into(),

4867

1

				overall_weight: Some(Limited(total_weight.into()))

4868

1

4869

1

));

4870

1

});

4871

1

4872

1

	Relay::execute_with(|| {

4873

1

		let expected_event: relay_chain::RuntimeEvent =

4874

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4875

1

				sender: 1u32.into(),

4876

1

				recipient: 2u32.into(),

4877

1

4878

1

			.into();

4879

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4880

1

});

4881

1

4882

4883

#[test]

4884

1

fn hrmp_close_works() {

4885

1

	MockNet::reset();

4886

1

4887

1

	Relay::execute_with(|| {

4888

1

		assert_ok!(RelayBalances::transfer_allow_death(

4889

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4890

1

			para_a_account(),

4891

1

			1000u128

4892

1

));

4893

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4894

1

			relay_chain::RuntimeOrigin::root(),

4895

1

			1u32.into(),

4896

1

			2u32.into(),

4897

1

			1u32,

4898

1

			1u32

4899

1

));

4900

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4901

1

			relay_chain::RuntimeOrigin::root(),

4902

1

			1u32

4903

1

));

4904

1

});

4905

1

4906

1

	ParaA::execute_with(|| {

4907

1

		let total_fee = 1_000u128;

4908

1

		let total_weight: u64 = 1_000_000_000;

4909

1

		let tx_weight: u64 = 500_000_000;

4910

1

		assert_ok!(XcmTransactor::hrmp_manage(

4911

1

			parachain::RuntimeOrigin::root(),

4912

1

			HrmpOperation::Close(HrmpChannelId {

4913

1

				sender: 1u32.into(),

4914

1

				recipient: 2u32.into()

4915

1

}),

4916

1

			CurrencyPayment {

4917

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4918

1

					Location::parent()

4919

1

				))),

4920

1

				fee_amount: Some(total_fee)

4921

1

},

4922

1

			TransactWeights {

4923

1

				transact_required_weight_at_most: tx_weight.into(),

4924

1

				overall_weight: Some(Limited(total_weight.into()))

4925

1

4926

1

));

4927

1

});

4928

1

	Relay::execute_with(|| {

4929

1

		let expected_event: relay_chain::RuntimeEvent =

4930

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4931

1

				by_parachain: 1u32.into(),

4932

1

				channel_id: HrmpChannelId {

4933

1

					sender: 1u32.into(),

4934

1

					recipient: 2u32.into(),

4935

1

},

4936

1

4937

1

			.into();

4938

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4939

1

});

4940

1

4941

4942

use parity_scale_codec::{Decode, Encode};

4943

use sp_io::hashing::blake2_256;

4944

4945

// Helper to derive accountIds

4946

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4947

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4948

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4949

7