Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonriver Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{PalletInfo, PalletInfoAccess},

23

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

24

	BoundedVec,

25

};

26

use moonriver_runtime::xcm_config::AssetType;

27

use sp_core::ConstU32;

28

use sp_runtime::traits::Convert;

29

use xcm::{

30

	latest::prelude::{

31

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

32

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

33

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

34

		WeightLimit, WithdrawAsset, Xcm,

35

},

36

	IntoVersion, VersionedAssets, VersionedLocation, WrapVersion,

37

};

38

use xcm_executor::traits::ConvertLocation;

39

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

40

use xcm_mock::relay_chain;

41

use xcm_mock::*;

42

use xcm_simulator::TestExt;

43

mod common;

44

use cumulus_primitives_core::relay_chain::HrmpChannelId;

45

use pallet_xcm_transactor::{

46

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

47

};

48

use xcm_primitives::{

49

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

50

};

51

52

28

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

53

28

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

54

28

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

55

28

		.into_version(xcm::latest::VERSION)

56

28

		.map_err(|_| ())?

57

	else {

58

		return Err(());

59

};

60

	use frame_support::weights::WeightToFee as _;

61

28

	let native_amount_per_second: u128 =

62

28

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

63

28

			&Weight::from_parts(

64

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

65

28

0,

66

28

),

67

28

68

28

		.try_into()

69

28

		.map_err(|_| ())?;

70

28

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

71

28

	let relative_price: u128 = if units_per_second > 0u128 {

72

10

		native_amount_per_second

73

10

			.saturating_mul(precision_factor)

74

10

			.saturating_div(units_per_second)

75

	} else {

76

18

		0u128

77

};

78

28

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

79

28

		location_v5,

80

28

		(true, relative_price),

81

28

);

82

28

	Ok(())

83

28

84

85

25

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

86

25

	Asset {

87

25

		id: AssetId(

88

25

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

89

25

				currency_id,

90

25

91

25

			.unwrap(),

92

25

),

93

25

		fun: Fungibility::Fungible(amount),

94

25

95

25

96

97

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

98

#[test]

99

1

fn receive_relay_asset_from_relay() {

100

1

	MockNet::reset();

101

1

102

1

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

103

1

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

104

1

	let asset_metadata = parachain::AssetMetadata {

105

1

		name: b"RelayToken".to_vec(),

106

1

		symbol: b"Relay".to_vec(),

107

1

		decimals: 12,

108

1

};

109

1

	// Register relay asset in parachain A

110

1

	ParaA::execute_with(|| {

111

1

		assert_ok!(AssetManager::register_foreign_asset(

112

1

			parachain::RuntimeOrigin::root(),

113

1

			source_location.clone(),

114

1

			asset_metadata,

115

1

			1u128,

116

1

			true

117

1

));

118

1

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

119

1

});

120

1

121

1

	// Actually send relay asset to parachain

122

1

	let dest: Location = AccountKey20 {

123

1

		network: None,

124

1

		key: PARAALICE,

125

1

126

1

	.into();

127

1

	Relay::execute_with(|| {

128

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

129

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

130

1

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

131

1

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

132

1

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

133

1

0,

134

1

			WeightLimit::Unlimited

135

1

));

136

1

});

137

1

138

1

	// Verify that parachain received the asset

139

1

	ParaA::execute_with(|| {

140

1

		// free execution, full amount received

141

1

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

142

1

});

143

1

144

145

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

146

#[test]

147

1

fn send_relay_asset_to_relay() {

148

1

	MockNet::reset();

149

1

150

1

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

151

1

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

152

1

153

1

	let asset_metadata = parachain::AssetMetadata {

154

1

		name: b"RelayToken".to_vec(),

155

1

		symbol: b"Relay".to_vec(),

156

1

		decimals: 12,

157

1

};

158

1

159

1

	// Register relay asset in paraA

160

1

	ParaA::execute_with(|| {

161

1

		assert_ok!(AssetManager::register_foreign_asset(

162

1

			parachain::RuntimeOrigin::root(),

163

1

			source_location.clone(),

164

1

			asset_metadata,

165

1

			1u128,

166

1

			true

167

1

));

168

		// free execution

169

1

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

170

1

});

171

1

172

1

	let dest: Location = Junction::AccountKey20 {

173

1

		network: None,

174

1

		key: PARAALICE,

175

1

176

1

	.into();

177

1

178

1

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

179

1

	Relay::execute_with(|| {

180

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

181

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

182

1

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

183

1

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

184

1

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

185

1

0,

186

1

			WeightLimit::Unlimited

187

1

));

188

1

});

189

1

190

1

	ParaA::execute_with(|| {

191

1

		// Free execution, full amount received

192

1

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

193

1

});

194

1

195

1

	// Lets gather the balance before sending back money

196

1

	let mut balance_before_sending = 0;

197

1

	Relay::execute_with(|| {

198

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

199

1

});

200

1

201

1

	// We now send back some money to the relay

202

1

	let dest = Location {

203

1

		parents: 1,

204

1

		interior: [AccountId32 {

205

1

			network: None,

206

1

			id: RELAYALICE.into(),

207

1

}]

208

1

		.into(),

209

1

};

210

1

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

211

1

212

1

	ParaA::execute_with(|| {

213

1

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

214

1

		assert_ok!(PolkadotXcm::transfer_assets(

215

1

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

216

1

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

217

1

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

218

1

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

219

1

0,

220

1

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

221

1

));

222

1

});

223

1

224

1

	// The balances in paraAlice should have been substracted

225

1

	ParaA::execute_with(|| {

226

1

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

227

1

});

228

1

229

1

	// Balances in the relay should have been received

230

1

	Relay::execute_with(|| {

231

1

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

232

1

});

233

1

234

235

#[test]

236

1

fn send_relay_asset_to_para_b() {

237

1

	MockNet::reset();

238

1

239

1

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

240

1

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

241

1

242

1

	let asset_metadata = parachain::AssetMetadata {

243

1

		name: b"RelayToken".to_vec(),

244

1

		symbol: b"Relay".to_vec(),

245

1

		decimals: 12,

246

1

};

247

1

248

1

	// Register asset in paraA. Free execution

249

1

	ParaA::execute_with(|| {

250

1

		assert_ok!(AssetManager::register_foreign_asset(

251

1

			parachain::RuntimeOrigin::root(),

252

1

			source_location.clone(),

253

1

			asset_metadata.clone(),

254

1

			1u128,

255

1

			true

256

1

));

257

1

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

258

1

});

259

1

260

1

	// Register asset in paraB. Free execution

261

1

	ParaB::execute_with(|| {

262

1

		assert_ok!(AssetManager::register_foreign_asset(

263

1

			parachain::RuntimeOrigin::root(),

264

1

			source_location.clone(),

265

1

			asset_metadata,

266

1

			1u128,

267

1

			true

268

1

));

269

1

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

270

1

});

271

1

272

1

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

273

1

	let dest: Location = Junction::AccountKey20 {

274

1

		network: None,

275

1

		key: PARAALICE,

276

1

277

1

	.into();

278

1

	Relay::execute_with(|| {

279

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

280

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

281

1

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

282

1

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

283

1

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

284

1

0,

285

1

			WeightLimit::Unlimited

286

1

));

287

1

});

288

1

289

1

	ParaA::execute_with(|| {

290

1

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

291

1

});

292

1

293

1

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

294

1

	let dest = Location {

295

1

		parents: 1,

296

1

		interior: [

297

1

			Parachain(2),

298

1

			AccountKey20 {

299

1

				network: None,

300

1

				key: PARAALICE.into(),

301

1

},

302

1

303

1

		.into(),

304

1

};

305

1

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

306

1

307

1

	ParaA::execute_with(|| {

308

1

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

309

1

		assert_ok!(PolkadotXcm::transfer_assets(

310

1

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

311

1

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

312

1

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

313

1

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

314

1

0,

315

1

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

316

1

));

317

1

});

318

1

319

1

	// Para A balances should have been substracted

320

1

	ParaA::execute_with(|| {

321

1

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

322

1

});

323

1

324

1

	// Para B balances should have been credited

325

1

	ParaB::execute_with(|| {

326

1

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

327

1

});

328

1

329

330

#[test]

331

1

fn send_para_a_asset_to_para_b() {

332

1

	MockNet::reset();

333

1

334

1

	// This represents the asset in paraA

335

1

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

336

1

	let source_location: AssetType = para_a_balances

337

1

		.try_into()

338

1

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

339

1

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

340

1

341

1

	let asset_metadata = parachain::AssetMetadata {

342

1

		name: b"ParaAToken".to_vec(),

343

1

		symbol: b"ParaA".to_vec(),

344

1

		decimals: 18,

345

1

};

346

1

347

1

	// Register asset in paraB. Free execution

348

1

	ParaB::execute_with(|| {

349

1

		assert_ok!(AssetManager::register_foreign_asset(

350

1

			parachain::RuntimeOrigin::root(),

351

1

			source_location.clone(),

352

1

			asset_metadata,

353

1

			1u128,

354

1

			true

355

1

));

356

1

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

357

1

});

358

1

359

1

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

360

1

	let dest = Location {

361

1

		parents: 1,

362

1

		interior: [

363

1

			Parachain(2),

364

1

			AccountKey20 {

365

1

				network: None,

366

1

				key: PARAALICE.into(),

367

1

},

368

1

369

1

		.into(),

370

1

};

371

1

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

372

1

373

1

	ParaA::execute_with(|| {

374

1

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

375

1

		assert_ok!(PolkadotXcm::transfer_assets(

376

1

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

377

1

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

378

1

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

379

1

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

380

1

0,

381

1

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

382

1

));

383

1

});

384

1

385

1

	// Native token is substracted in paraA

386

1

	ParaA::execute_with(|| {

387

1

		// free execution, full amount received

388

1

		assert_eq!(

389

1

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

390

1

			INITIAL_BALANCE - 100

391

1

);

392

1

});

393

1

394

1

	// Asset is minted in paraB

395

1

	ParaB::execute_with(|| {

396

1

		// free execution, full amount received

397

1

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

398

1

});

399

1

400

401

#[test]

402

1

fn send_para_a_asset_from_para_b_to_para_c() {

403

1

	MockNet::reset();

404

1

405

1

	// Represents para A asset

406

1

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

407

1

	let source_location: AssetType = para_a_balances

408

1

		.try_into()

409

1

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

410

1

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

411

1

412

1

	let asset_metadata = parachain::AssetMetadata {

413

1

		name: b"ParaAToken".to_vec(),

414

1

		symbol: b"ParaA".to_vec(),

415

1

		decimals: 18,

416

1

};

417

1

418

1

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

419

1

	ParaB::execute_with(|| {

420

1

		assert_ok!(AssetManager::register_foreign_asset(

421

1

			parachain::RuntimeOrigin::root(),

422

1

			source_location.clone(),

423

1

			asset_metadata.clone(),

424

1

			1u128,

425

1

			true

426

1

));

427

1

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

428

1

});

429

1

430

1

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

431

1

	ParaC::execute_with(|| {

432

1

		assert_ok!(AssetManager::register_foreign_asset(

433

1

			parachain::RuntimeOrigin::root(),

434

1

			source_location.clone(),

435

1

			asset_metadata,

436

1

			1u128,

437

1

			true

438

1

));

439

1

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

440

1

});

441

1

442

1

	// Send para A asset to para B

443

1

	let dest = Location {

444

1

		parents: 1,

445

1

		interior: [

446

1

			Parachain(2),

447

1

			AccountKey20 {

448

1

				network: None,

449

1

				key: PARAALICE.into(),

450

1

},

451

1

452

1

		.into(),

453

1

};

454

1

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

455

1

456

1

	ParaA::execute_with(|| {

457

1

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

458

1

		assert_ok!(PolkadotXcm::transfer_assets(

459

1

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

460

1

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

461

1

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

462

1

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

463

1

0,

464

1

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

465

1

));

466

1

});

467

1

468

1

	// Para A balances have been substracted

469

1

	ParaA::execute_with(|| {

470

1

		assert_eq!(

471

1

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

472

1

			INITIAL_BALANCE - 100

473

1

);

474

1

});

475

1

476

1

	// Para B balances have been credited

477

1

	ParaB::execute_with(|| {

478

1

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

479

1

});

480

1

481

1

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

482

1

	let dest = Location {

483

1

		parents: 1,

484

1

		interior: [

485

1

			Parachain(3),

486

1

			AccountKey20 {

487

1

				network: None,

488

1

				key: PARAALICE.into(),

489

1

},

490

1

491

1

		.into(),

492

1

};

493

1

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

494

1

495

1

	ParaB::execute_with(|| {

496

1

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

497

1

		assert_ok!(PolkadotXcm::transfer_assets(

498

1

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

499

1

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

500

1

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

501

1

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

502

1

0,

503

1

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

504

1

));

505

1

});

506

1

507

1

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

508

1

	ParaC::execute_with(|| {

509

1

		// free execution, full amount received

510

1

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

511

1

});

512

1

513

514

#[test]

515

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

516

1

	MockNet::reset();

517

1

518

1

	// Para A asset

519

1

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

520

1

	let source_location: AssetType = para_a_balances

521

1

		.try_into()

522

1

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

523

1

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

524

1

525

1

	let asset_metadata = parachain::AssetMetadata {

526

1

		name: b"ParaAToken".to_vec(),

527

1

		symbol: b"ParaA".to_vec(),

528

1

		decimals: 18,

529

1

};

530

1

531

1

	// Register para A asset in para B

532

1

	ParaB::execute_with(|| {

533

1

		assert_ok!(AssetManager::register_foreign_asset(

534

1

			parachain::RuntimeOrigin::root(),

535

1

			source_location.clone(),

536

1

			asset_metadata,

537

1

			1u128,

538

1

			true

539

1

));

540

1

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

541

1

});

542

1

543

1

	// Send para A asset to para B

544

1

	let dest = Location {

545

1

		parents: 1,

546

1

		interior: [

547

1

			Parachain(2),

548

1

			AccountKey20 {

549

1

				network: None,

550

1

				key: PARAALICE.into(),

551

1

},

552

1

553

1

		.into(),

554

1

};

555

1

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

556

1

557

1

	ParaA::execute_with(|| {

558

1

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

559

1

		assert_ok!(PolkadotXcm::transfer_assets(

560

1

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

561

1

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

562

1

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

563

1

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

564

1

0,

565

1

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

566

1

));

567

1

});

568

1

569

1

	// Balances have been substracted

570

1

	ParaA::execute_with(|| {

571

1

		assert_eq!(

572

1

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

573

1

			INITIAL_BALANCE - 100

574

1

);

575

1

});

576

1

577

1

	// Para B balances have been credited

578

1

	ParaB::execute_with(|| {

579

1

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

580

1

});

581

1

582

1

	// Send back para A asset to para A

583

1

	let dest = Location {

584

1

		parents: 1,

585

1

		interior: [

586

1

			Parachain(1),

587

1

			AccountKey20 {

588

1

				network: None,

589

1

				key: PARAALICE.into(),

590

1

},

591

1

592

1

		.into(),

593

1

};

594

1

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

595

1

596

1

	ParaB::execute_with(|| {

597

1

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

598

1

		assert_ok!(PolkadotXcm::transfer_assets(

599

1

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

600

1

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

601

1

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

602

1

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

603

1

0,

604

1

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

605

1

));

606

1

});

607

1

608

1

	// Para A asset has been credited

609

1

	ParaA::execute_with(|| {

610

1

		// Weight used is 4

611

1

		assert_eq!(

612

1

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

613

1

			INITIAL_BALANCE - 4

614

1

);

615

1

});

616

1

617

618

#[test]

619

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

620

1

	MockNet::reset();

621

1

622

1

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

623

1

	let source_location: AssetType = para_a_balances

624

1

		.try_into()

625

1

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

626

1

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

627

1

628

1

	let asset_metadata = parachain::AssetMetadata {

629

1

		name: b"ParaAToken".to_vec(),

630

1

		symbol: b"ParaA".to_vec(),

631

1

		decimals: 18,

632

1

};

633

1

634

1

	ParaB::execute_with(|| {

635

1

		assert_ok!(AssetManager::register_foreign_asset(

636

1

			parachain::RuntimeOrigin::root(),

637

1

			source_location.clone(),

638

1

			asset_metadata,

639

1

			1u128,

640

1

			true

641

1

));

642

1

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

643

1

});

644

1

645

1

	let dest = Location {

646

1

		parents: 1,

647

1

		interior: [

648

1

			Parachain(2),

649

1

			AccountKey20 {

650

1

				network: None,

651

1

				key: PARAALICE.into(),

652

1

},

653

1

654

1

		.into(),

655

1

};

656

1

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

657

1

658

1

	ParaA::execute_with(|| {

659

1

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

660

1

		assert_ok!(PolkadotXcm::transfer_assets(

661

1

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

662

1

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

663

1

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

664

1

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

665

1

0,

666

1

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

667

1

));

668

1

});

669

1

670

1

	ParaA::execute_with(|| {

671

1

		// Free execution, full amount received

672

1

		assert_eq!(

673

1

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

674

1

			INITIAL_BALANCE - 100

675

1

);

676

1

});

677

1

678

1

	ParaB::execute_with(|| {

679

1

		// Free execution, full amount received

680

1

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

681

1

});

682

1

683

1

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

684

1

	// Message through polkadotXCM pallet

685

1

686

1

	let dest = Location {

687

1

		parents: 1,

688

1

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

689

1

};

690

1

691

1

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

692

1

693

1

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

694

1

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

695

1

		ClearOrigin,

696

1

		BuyExecution {

697

1

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

698

1

			weight_limit: Limited(80.into()),

699

1

},

700

1

		DepositAsset {

701

1

			assets: All.into(),

702

1

			beneficiary: Location::new(

703

1

0,

704

1

				[AccountKey20 {

705

1

					network: None,

706

1

					key: PARAALICE,

707

1

}],

708

1

),

709

1

},

710

1

	]));

711

1

	ParaB::execute_with(|| {

712

1

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

713

1

		// and deposit asset

714

1

		assert_ok!(ParachainPalletXcm::send(

715

1

			parachain::RuntimeOrigin::root(),

716

1

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

717

1

			Box::new(message),

718

1

));

719

1

});

720

1

721

1

	ParaB::execute_with(|| {

722

1

		// free execution, full amount received

723

1

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

724

1

});

725

1

726

1

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

727

1

	// Message through polkadotXCM pallet

728

1

729

1

	let dest = Location {

730

1

		parents: 1,

731

1

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

732

1

};

733

1

734

1

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

735

1

736

1

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

737

1

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

738

1

		ClearOrigin,

739

1

		BuyExecution {

740

1

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

741

1

			weight_limit: Limited(80.into()),

742

1

},

743

1

		DepositAsset {

744

1

			assets: All.into(),

745

1

			beneficiary: Location::new(

746

1

0,

747

1

				[AccountKey20 {

748

1

					network: None,

749

1

					key: PARAALICE,

750

1

}],

751

1

),

752

1

},

753

1

	]));

754

1

	ParaB::execute_with(|| {

755

1

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

756

1

		// and deposit asset

757

1

		assert_ok!(ParachainPalletXcm::send(

758

1

			parachain::RuntimeOrigin::root(),

759

1

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

760

1

			Box::new(message),

761

1

));

762

1

});

763

1

764

1

	ParaA::execute_with(|| {

765

1

		// Weight used is 4

766

1

		assert_eq!(

767

1

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

768

1

			INITIAL_BALANCE - 4

769

1

);

770

1

});

771

1

772

773

#[test]

774

1

fn receive_relay_asset_with_trader() {

775

1

	MockNet::reset();

776

1

777

1

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

778

1

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

779

1

780

1

	let asset_metadata = parachain::AssetMetadata {

781

1

		name: b"RelayToken".to_vec(),

782

1

		symbol: b"Relay".to_vec(),

783

1

		decimals: 12,

784

1

};

785

1

786

1

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

787

1

	// we know later we will divide by 1e12

788

1

	// Lets put 1e6 as units per second

789

1

	ParaA::execute_with(|| {

790

1

		assert_ok!(AssetManager::register_foreign_asset(

791

1

			parachain::RuntimeOrigin::root(),

792

1

			source_location.clone(),

793

1

			asset_metadata,

794

1

			1u128,

795

1

			true

796

1

));

797

1

		assert_ok!(add_supported_asset(

798

1

			source_location.clone(),

799

1

			2500000000000u128

800

1

));

801

1

});

802

1

803

1

	let dest: Location = Junction::AccountKey20 {

804

1

		network: None,

805

1

		key: PARAALICE,

806

1

807

1

	.into();

808

1

	// We are sending 100 tokens from relay.

809

1

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

810

1

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

811

1

	// Units per second should be 2_500_000_000_000_000

812

1

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

813

1

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

814

1

	Relay::execute_with(|| {

815

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

816

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

817

1

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

818

1

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

819

1

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

820

1

0,

821

1

			WeightLimit::Unlimited

822

1

));

823

1

});

824

1

825

1

	ParaA::execute_with(|| {

826

1

		// non-free execution, not full amount received

827

1

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

828

		// Fee should have been received by treasury

829

1

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

830

1

});

831

1

832

833

#[test]

834

1

fn send_para_a_asset_to_para_b_with_trader() {

835

1

	MockNet::reset();

836

1

837

1

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

838

1

	let source_location: AssetType = para_a_balances

839

1

		.try_into()

840

1

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

841

1

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

842

1

843

1

	let asset_metadata = parachain::AssetMetadata {

844

1

		name: b"ParaAToken".to_vec(),

845

1

		symbol: b"ParaA".to_vec(),

846

1

		decimals: 18,

847

1

};

848

1

849

1

	ParaB::execute_with(|| {

850

1

		assert_ok!(AssetManager::register_foreign_asset(

851

1

			parachain::RuntimeOrigin::root(),

852

1

			source_location.clone(),

853

1

			asset_metadata,

854

1

			1u128,

855

1

			true

856

1

));

857

1

		assert_ok!(add_supported_asset(

858

1

			source_location.clone(),

859

1

			2500000000000u128

860

1

));

861

1

});

862

1

863

1

	let dest = Location {

864

1

		parents: 1,

865

1

		interior: [

866

1

			Parachain(2),

867

1

			AccountKey20 {

868

1

				network: None,

869

1

				key: PARAALICE.into(),

870

1

},

871

1

872

1

		.into(),

873

1

};

874

1

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

875

1

876

1

	// In destination chain, we only need 4 weight

877

1

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

878

1

	ParaA::execute_with(|| {

879

1

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

880

1

		assert_ok!(PolkadotXcm::transfer_assets(

881

1

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

882

1

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

883

1

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

884

1

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

885

1

0,

886

1

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

887

1

));

888

1

});

889

1

	ParaA::execute_with(|| {

890

1

		// free execution, full amount received

891

1

		assert_eq!(

892

1

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

893

1

			INITIAL_BALANCE - 100

894

1

);

895

1

});

896

1

897

1

	// We are sending 100 tokens from para A.

898

1

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

899

1

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

900

1

	// Units per second should be 2_500_000_000_000_000

901

1

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

902

1

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

903

1

	// will be 4

904

1

	ParaB::execute_with(|| {

905

1

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

906

		// Fee should have been received by treasury

907

1

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

908

1

});

909

1

910

911

#[test]

912

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

913

1

	MockNet::reset();

914

1

915

1

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

916

1

	let source_location: AssetType = para_a_balances

917

1

		.try_into()

918

1

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

919

1

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

920

1

921

1

	let asset_metadata = parachain::AssetMetadata {

922

1

		name: b"ParaAToken".to_vec(),

923

1

		symbol: b"ParaA".to_vec(),

924

1

		decimals: 18,

925

1

};

926

1

927

1

	ParaB::execute_with(|| {

928

1

		assert_ok!(AssetManager::register_foreign_asset(

929

1

			parachain::RuntimeOrigin::root(),

930

1

			source_location.clone(),

931

1

			asset_metadata,

932

1

			1u128,

933

1

			true

934

1

));

935

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

936

1

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

937

1

});

938

1

939

1

	let dest = Location {

940

1

		parents: 1,

941

1

		interior: [

942

1

			Parachain(2),

943

1

			AccountKey20 {

944

1

				network: None,

945

1

				key: PARAALICE.into(),

946

1

},

947

1

948

1

		.into(),

949

1

};

950

1

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

951

1

952

1

	// we use transfer_with_fee

953

1

	ParaA::execute_with(|| {

954

1

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

955

1

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

956

1

		assert_ok!(PolkadotXcm::transfer_assets(

957

1

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

958

1

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

959

1

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

960

1

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

961

1

0,

962

1

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

963

1

));

964

1

});

965

1

	ParaA::execute_with(|| {

966

1

		// 100 tokens transferred plus 1 taken from fees

967

1

		assert_eq!(

968

1

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

969

1

			INITIAL_BALANCE - 100 - 1

970

1

);

971

1

});

972

1

973

1

	ParaB::execute_with(|| {

974

1

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

975

1

		// what it is specified

976

1

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

977

1

});

978

1

979

980

#[test]

981

1

fn error_when_not_paying_enough() {

982

1

	MockNet::reset();

983

1

984

1

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

985

1

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

986

1

987

1

	let asset_metadata = parachain::AssetMetadata {

988

1

		name: b"RelayToken".to_vec(),

989

1

		symbol: b"Relay".to_vec(),

990

1

		decimals: 12,

991

1

};

992

1

993

1

	let dest: Location = Junction::AccountKey20 {

994

1

		network: None,

995

1

		key: PARAALICE,

996

1

997

1

	.into();

998

1

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

999

1

	// we know later we will divide by 1e12

1000

1

	// Lets put 1e6 as units per second

1001

1

	ParaA::execute_with(|| {

1002

1

		assert_ok!(AssetManager::register_foreign_asset(

1003

1

			parachain::RuntimeOrigin::root(),

1004

1

			source_location.clone(),

1005

1

			asset_metadata,

1006

1

			1u128,

1007

1

			true

1008

1

));

1009

1

		assert_ok!(add_supported_asset(

1010

1

			source_location.clone(),

1011

1

			2500000000000u128

1012

1

));

1013

1

});

1014

1

1015

1

	// We are sending 100 tokens from relay.

1016

1

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

1017

1

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

1018

1

	Relay::execute_with(|| {

1019

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1020

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1021

1

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

1022

1

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

1023

1

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

1024

1

0,

1025

1

			WeightLimit::Unlimited

1026

1

));

1027

1

});

1028

1

1029

1

	ParaA::execute_with(|| {

1030

1

		// amount not received as it is not paying enough

1031

1

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

1032

1

});

1033

1

1034

1035

#[test]

1036

1

fn transact_through_derivative_multilocation() {

1037

1

	MockNet::reset();

1038

1

1039

1

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

1040

1

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

1041

1

1042

1

	let asset_metadata = parachain::AssetMetadata {

1043

1

		name: b"RelayToken".to_vec(),

1044

1

		symbol: b"Relay".to_vec(),

1045

1

		decimals: 12,

1046

1

};

1047

1

1048

1

	ParaA::execute_with(|| {

1049

1

		assert_ok!(AssetManager::register_foreign_asset(

1050

1

			parachain::RuntimeOrigin::root(),

1051

1

			source_location.clone(),

1052

1

			asset_metadata,

1053

1

			1u128,

1054

1

			true

1055

1

));

1056

1

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

1057

1058

		// Root can set transact info

1059

1

		assert_ok!(XcmTransactor::set_transact_info(

1060

1

			parachain::RuntimeOrigin::root(),

1061

1

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

1062

1

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

1063

1

			3000.into(),

1064

1

			20000000000.into(),

1065

1

			None

1066

1

));

1067

		// Root can set transact info

1068

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1069

1

			parachain::RuntimeOrigin::root(),

1070

1

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

1071

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1072

1

));

1073

1

});

1074

1

1075

1

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

1076

1

1077

1

	let dest: Location = AccountKey20 {

1078

1

		network: None,

1079

1

		key: PARAALICE,

1080

1

1081

1

	.into();

1082

1

	Relay::execute_with(|| {

1083

1

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

1084

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1085

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1086

1

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

1087

1

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

1088

1

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

1089

1

0,

1090

1

			WeightLimit::Unlimited

1091

1

));

1092

1

});

1093

1

1094

1

	ParaA::execute_with(|| {

1095

1

		// free execution, full amount received

1096

1

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

1097

1

});

1098

1

1099

1

	// Register address

1100

1

	ParaA::execute_with(|| {

1101

1

		assert_ok!(XcmTransactor::register(

1102

1

			parachain::RuntimeOrigin::root(),

1103

1

			PARAALICE.into(),

1104

1

0,

1105

1

));

1106

1

});

1107

1

1108

1

	// Send to registered address

1109

1

1110

1

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

1111

1

	let dest = Location {

1112

1

		parents: 1,

1113

1

		interior: [AccountId32 {

1114

1

			network: None,

1115

1

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

1116

1

}]

1117

1

		.into(),

1118

1

};

1119

1

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

1120

1

1121

1

	ParaA::execute_with(|| {

1122

1

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

1123

1

		// free execution, full amount received

1124

1

		assert_ok!(PolkadotXcm::transfer_assets(

1125

1

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

1126

1

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

1127

1

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

1128

1

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

1129

1

0,

1130

1

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

1131

1

));

1132

1

});

1133

1

1134

1

	ParaA::execute_with(|| {

1135

1

		// free execution, full amount received

1136

1

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

1137

1

});

1138

1

1139

1

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

1140

1

	// again

1141

1

	Relay::execute_with(|| {

1142

1

		// free execution,x	 full amount received

1143

1

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

1144

1

});

1145

1

1146

1

	// Encode the call. Balances transact to para_a_account

1147

1

	// First index

1148

1

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

1149

1

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

1150

1

		relay_chain::Balances,

1151

1

>()

1152

1

	.unwrap() as u8;

1153

1

1154

1

	encoded.push(index);

1155

1

1156

1

	// Then call bytes

1157

1

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

1158

1

		dest: para_a_account(),

1159

1

		value: 100u32.into(),

1160

1

1161

1

	.encode();

1162

1

	encoded.append(&mut call_bytes);

1163

1

1164

1

	ParaA::execute_with(|| {

1165

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1166

1

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

1167

1

			parachain::MockTransactors::Relay,

1168

1

0,

1169

1

			CurrencyPayment {

1170

1

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

1171

1

					Location::parent()

1172

1

				))),

1173

1

				fee_amount: None

1174

1

},

1175

1

			encoded,

1176

1

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

1177

1

			TransactWeights {

1178

1

				transact_required_weight_at_most: 4000000000.into(),

1179

1

				overall_weight: None

1180

1

},

1181

1

			false

1182

1

));

1183

1

});

1184

1

1185

1

	Relay::execute_with(|| {

1186

1

		// free execution,x	 full amount received

1187

1

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

1188

1189

1

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

1190

1

});

1191

1

1192

1193

#[test]

1194

1

fn transact_through_derivative_with_custom_fee_weight() {

1195

1

	MockNet::reset();

1196

1

1197

1

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

1198

1

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

1199

1

1200

1

	let asset_metadata = parachain::AssetMetadata {

1201

1

		name: b"RelayToken".to_vec(),

1202

1

		symbol: b"Relay".to_vec(),

1203

1

		decimals: 12,

1204

1

};

1205

1

1206

1

	ParaA::execute_with(|| {

1207

1

		assert_ok!(AssetManager::register_foreign_asset(

1208

1

			parachain::RuntimeOrigin::root(),

1209

1

			source_location.clone(),

1210

1

			asset_metadata,

1211

1

			1u128,

1212

1

			true

1213

1

));

1214

1

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

1215

1

});

1216

1

1217

1

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

1218

1

1219

1

	let dest: Location = AccountKey20 {

1220

1

		network: None,

1221

1

		key: PARAALICE,

1222

1

1223

1

	.into();

1224

1

	Relay::execute_with(|| {

1225

1

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

1226

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1227

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1228

1

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

1229

1

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

1230

1

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

1231

1

0,

1232

1

			WeightLimit::Unlimited

1233

1

));

1234

1

});

1235

1

1236

1

	ParaA::execute_with(|| {

1237

1

		// free execution, full amount received

1238

1

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

1239

1

});

1240

1

1241

1

	// Register address

1242

1

	ParaA::execute_with(|| {

1243

1

		assert_ok!(XcmTransactor::register(

1244

1

			parachain::RuntimeOrigin::root(),

1245

1

			PARAALICE.into(),

1246

1

0,

1247

1

));

1248

1

});

1249

1

1250

1

	// Send to registered address

1251

1

1252

1

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

1253

1

	let dest = Location {

1254

1

		parents: 1,

1255

1

		interior: [AccountId32 {

1256

1

			network: None,

1257

1

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

1258

1

}]

1259

1

		.into(),

1260

1

};

1261

1

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

1262

1

1263

1

	ParaA::execute_with(|| {

1264

1

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

1265

1

		// free execution, full amount received

1266

1

		assert_ok!(PolkadotXcm::transfer_assets(

1267

1

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

1268

1

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

1269

1

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

1270

1

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

1271

1

0,

1272

1

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

1273

1

));

1274

1

});

1275

1

1276

1

	ParaA::execute_with(|| {

1277

1

		// free execution, full amount received

1278

1

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

1279

1

});

1280

1

1281

1

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

1282

1

	// again

1283

1

	Relay::execute_with(|| {

1284

1

		// free execution,x	 full amount received

1285

1

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

1286

1

});

1287

1

1288

1

	// Encode the call. Balances transact to para_a_account

1289

1

	// First index

1290

1

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

1291

1

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

1292

1

		relay_chain::Balances,

1293

1

>()

1294

1

	.unwrap() as u8;

1295

1

1296

1

	encoded.push(index);

1297

1

1298

1

	// Then call bytes

1299

1

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

1300

1

		dest: para_a_account(),

1301

1

		value: 100u32.into(),

1302

1

1303

1

	.encode();

1304

1

	encoded.append(&mut call_bytes);

1305

1

1306

1

	let overall_weight = 4000003000u64;

1307

1

	ParaA::execute_with(|| {

1308

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1309

1

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

1310

1

			parachain::MockTransactors::Relay,

1311

1

0,

1312

1

			CurrencyPayment {

1313

1

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

1314

1

					Location::parent()

1315

1

				))),

1316

1

				// 1-1 fee weight mapping

1317

1

				fee_amount: Some(overall_weight as u128)

1318

1

},

1319

1

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

1320

1

			encoded,

1321

1

			TransactWeights {

1322

1

				transact_required_weight_at_most: 4000000000.into(),

1323

1

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

1324

1

},

1325

1

			false

1326

1

));

1327

1

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

1328

1

			.iter()

1329

12

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

1330

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

1331

..

1332

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

1333

12

				_ => None,

1334

12

});

1335

1

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

1336

1

		assert!(event_found.is_none());

1337

1

});

1338

1

1339

1

	Relay::execute_with(|| {

1340

1

		// free execution,x	 full amount received

1341

1

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

1342

1343

1

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

1344

1

});

1345

1

1346

1347

#[test]

1348

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1349

1

	MockNet::reset();

1350

1

1351

1

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

1352

1

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

1353

1

1354

1

	let asset_metadata = parachain::AssetMetadata {

1355

1

		name: b"RelayToken".to_vec(),

1356

1

		symbol: b"Relay".to_vec(),

1357

1

		decimals: 12,

1358

1

};

1359

1

1360

1

	ParaA::execute_with(|| {

1361

1

		assert_ok!(AssetManager::register_foreign_asset(

1362

1

			parachain::RuntimeOrigin::root(),

1363

1

			source_location.clone(),

1364

1

			asset_metadata,

1365

1

			1u128,

1366

1

			true

1367

1

));

1368

1

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

1369

1

});

1370

1

1371

1

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

1372

1

1373

1

	let dest: Location = AccountKey20 {

1374

1

		network: None,

1375

1

		key: PARAALICE,

1376

1

1377

1

	.into();

1378

1

	Relay::execute_with(|| {

1379

1

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

1380

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1381

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1382

1

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

1383

1

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

1384

1

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

1385

1

0,

1386

1

			WeightLimit::Unlimited

1387

1

));

1388

1

});

1389

1

1390

1

	ParaA::execute_with(|| {

1391

1

		// free execution, full amount received

1392

1

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

1393

1

});

1394

1

1395

1

	// Register address

1396

1

	ParaA::execute_with(|| {

1397

1

		assert_ok!(XcmTransactor::register(

1398

1

			parachain::RuntimeOrigin::root(),

1399

1

			PARAALICE.into(),

1400

1

0,

1401

1

));

1402

1

});

1403

1

1404

1

	// Send to registered address

1405

1

1406

1

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

1407

1

	let dest = Location {

1408

1

		parents: 1,

1409

1

		interior: [AccountId32 {

1410

1

			network: None,

1411

1

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

1412

1

}]

1413

1

		.into(),

1414

1

};

1415

1

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

1416

1

1417

1

	ParaA::execute_with(|| {

1418

1

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

1419

1

		// free execution, full amount received

1420

1

		assert_ok!(PolkadotXcm::transfer_assets(

1421

1

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

1422

1

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

1423

1

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

1424

1

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

1425

1

0,

1426

1

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

1427

1

));

1428

1

});

1429

1

1430

1

	ParaA::execute_with(|| {

1431

1

		// free execution, full amount received

1432

1

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

1433

1

});

1434

1

1435

1

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

1436

1

	// again

1437

1

	Relay::execute_with(|| {

1438

1

		// free execution,x	 full amount received

1439

1

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

1440

1

});

1441

1

1442

1

	// Encode the call. Balances transact to para_a_account

1443

1

	// First index

1444

1

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

1445

1

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

1446

1

		relay_chain::Balances,

1447

1

>()

1448

1

	.unwrap() as u8;

1449

1

1450

1

	encoded.push(index);

1451

1

1452

1

	// Then call bytes

1453

1

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

1454

1

		dest: para_a_account(),

1455

1

		value: 100u32.into(),

1456

1

1457

1

	.encode();

1458

1

	encoded.append(&mut call_bytes);

1459

1

1460

1

	let overall_weight = 4000009000u64;

1461

1

	ParaA::execute_with(|| {

1462

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1463

1

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

1464

1

			parachain::MockTransactors::Relay,

1465

1

0,

1466

1

			CurrencyPayment {

1467

1

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

1468

1

					Location::parent()

1469

1

				))),

1470

1

				// 1-1 fee weight mapping

1471

1

				fee_amount: Some(overall_weight as u128)

1472

1

},

1473

1

			encoded,

1474

1

			TransactWeights {

1475

1

				transact_required_weight_at_most: 4000000000.into(),

1476

1

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

1477

1

},

1478

1

			true

1479

1

));

1480

1

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

1481

1

			.iter()

1482

12

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

1483

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

1484

..

1485

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

1486

12

				_ => None,

1487

12

});

1488

1

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

1489

1

		assert!(event_found.is_none());

1490

1

});

1491

1

1492

1

	Relay::execute_with(|| {

1493

1

		// free execution,x	 full amount received

1494

1

		// 4000009000 refunded + 100 transferred = 4000009100

1495

1

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

1496

1

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

1497

1

});

1498

1

1499

1500

#[test]

1501

1

fn transact_through_sovereign() {

1502

1

	MockNet::reset();

1503

1

1504

1

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

1505

1

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

1506

1

1507

1

	let asset_metadata = parachain::AssetMetadata {

1508

1

		name: b"RelayToken".to_vec(),

1509

1

		symbol: b"Relay".to_vec(),

1510

1

		decimals: 12,

1511

1

};

1512

1

1513

1

	ParaA::execute_with(|| {

1514

1

		assert_ok!(AssetManager::register_foreign_asset(

1515

1

			parachain::RuntimeOrigin::root(),

1516

1

			source_location.clone(),

1517

1

			asset_metadata,

1518

1

			1u128,

1519

1

			true

1520

1

));

1521

1

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

1522

1523

		// Root can set transact info

1524

1

		assert_ok!(XcmTransactor::set_transact_info(

1525

1

			parachain::RuntimeOrigin::root(),

1526

1

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

1527

1

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

1528

1

			3000.into(),

1529

1

			20000000000.into(),

1530

1

			None

1531

1

));

1532

		// Root can set transact info

1533

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1534

1

			parachain::RuntimeOrigin::root(),

1535

1

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

1536

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1537

1

));

1538

1

});

1539

1

1540

1

	let dest: Location = AccountKey20 {

1541

1

		network: None,

1542

1

		key: PARAALICE,

1543

1

1544

1

	.into();

1545

1

	Relay::execute_with(|| {

1546

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1547

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1548

1

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

1549

1

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

1550

1

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

1551

1

0,

1552

1

			WeightLimit::Unlimited

1553

1

));

1554

1

});

1555

1

1556

1

	ParaA::execute_with(|| {

1557

1

		// free execution, full amount received

1558

1

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

1559

1

});

1560

1

1561

1

	// Register address

1562

1

	ParaA::execute_with(|| {

1563

1

		assert_ok!(XcmTransactor::register(

1564

1

			parachain::RuntimeOrigin::root(),

1565

1

			PARAALICE.into(),

1566

1

0,

1567

1

));

1568

1

});

1569

1

1570

1

	// Send to registered address

1571

1

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

1572

1

	let dest = Location {

1573

1

		parents: 1,

1574

1

		interior: [AccountId32 {

1575

1

			network: None,

1576

1

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

1577

1

}]

1578

1

		.into(),

1579

1

};

1580

1

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

1581

1

1582

1

	ParaA::execute_with(|| {

1583

1

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

1584

1

		// free execution, full amount received

1585

1

		assert_ok!(PolkadotXcm::transfer_assets(

1586

1

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

1587

1

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

1588

1

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

1589

1

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

1590

1

0,

1591

1

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

1592

1

));

1593

1

});

1594

1

1595

1

	ParaA::execute_with(|| {

1596

1

		// free execution, full amount received

1597

1

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

1598

1

});

1599

1

1600

1

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

1601

1

	// again

1602

1

	Relay::execute_with(|| {

1603

1

		// free execution,x	 full amount received

1604

1

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

1605

1

1606

1

});

1607

1

1608

1

	// We send the xcm transact operation to parent

1609

1

	let dest = Location {

1610

1

		parents: 1,

1611

1

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

1612

1

};

1613

1

1614

1

	// Encode the call. Balances transact to para_a_account

1615

1

	// First index

1616

1

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

1617

1

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

1618

1

		relay_chain::Balances,

1619

1

>()

1620

1

	.unwrap() as u8;

1621

1

1622

1

	encoded.push(index);

1623

1

1624

1

	// Then call bytes

1625

1

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

1626

1

		dest: para_a_account(),

1627

1

		value: 100u32.into(),

1628

1

1629

1

	.encode();

1630

1

	encoded.append(&mut call_bytes);

1631

1

1632

1

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

1633

1

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

1634

1

);

1635

1

1636

1

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

1637

1

	ParaA::execute_with(|| {

1638

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1639

1

			parachain::RuntimeOrigin::root(),

1640

1

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

1641

1

			Some(PARAALICE.into()),

1642

1

			CurrencyPayment {

1643

1

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

1644

1

					Location::parent()

1645

1

				))),

1646

1

				fee_amount: None

1647

1

},

1648

1

			utility_bytes,

1649

1

			OriginKind::SovereignAccount,

1650

1

			TransactWeights {

1651

1

				transact_required_weight_at_most: 4000000000.into(),

1652

1

				overall_weight: None

1653

1

},

1654

1

			false

1655

1

));

1656

1

});

1657

1

1658

1

	Relay::execute_with(|| {

1659

1

		// free execution,x	 full amount received

1660

1

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

1661

1662

1

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

1663

1

});

1664

1

1665

1666

#[test]

1667

1

fn transact_through_sovereign_fee_payer_none() {

1668

1

	MockNet::reset();

1669

1

1670

1

	ParaA::execute_with(|| {

1671

1

		// Root can set transact info

1672

1

		assert_ok!(XcmTransactor::set_transact_info(

1673

1

			parachain::RuntimeOrigin::root(),

1674

1

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

1675

1

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

1676

1

			3000.into(),

1677

1

			20000000000.into(),

1678

1

			None

1679

1

));

1680

		// Root can set transact info

1681

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1682

1

			parachain::RuntimeOrigin::root(),

1683

1

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

1684

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1685

1

));

1686

1

});

1687

1

1688

1

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

1689

1

1690

1

	Relay::execute_with(|| {

1691

1

		// Transfer 100 tokens to derivative_address on the relay

1692

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1693

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1694

1

			derivative_address.clone(),

1695

1

			100u128

1696

1

));

1697

1698

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

1699

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1700

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1701

1

			para_a_account(),

1702

1

			4000003000u128

1703

1

));

1704

1

});

1705

1

1706

1

	// Check balances before the transact call

1707

1

	Relay::execute_with(|| {

1708

1

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

1709

1

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

1710

1

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

1711

1

});

1712

1

1713

1

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

1714

1

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

1715

1

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

1716

1

		relay_chain::Balances,

1717

1

>()

1718

1

	.unwrap() as u8;

1719

1

1720

1

	encoded.push(index);

1721

1

1722

1

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

1723

1

		dest: RELAYBOB,

1724

1

		value: 100u32.into(),

1725

1

1726

1

	.encode();

1727

1

	encoded.append(&mut call_bytes);

1728

1

1729

1

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

1730

1

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

1731

1

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

1732

1

);

1733

1

1734

1

	// We send the xcm transact operation to parent

1735

1

	let dest = Location {

1736

1

		parents: 1,

1737

1

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

1738

1

};

1739

1

1740

1

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

1741

1

	ParaA::execute_with(|| {

1742

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1743

1

			parachain::RuntimeOrigin::root(),

1744

1

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

1745

1

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

1746

1

			None,

1747

1

			CurrencyPayment {

1748

1

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

1749

1

					Location::parent()

1750

1

				))),

1751

1

				fee_amount: None

1752

1

},

1753

1

			utility_bytes,

1754

1

			OriginKind::SovereignAccount,

1755

1

			TransactWeights {

1756

1

				transact_required_weight_at_most: 4000000000.into(),

1757

1

				overall_weight: None

1758

1

},

1759

1

			false

1760

1

));

1761

1

});

1762

1

1763

1

	// Check balances after the transact call are correct

1764

1

	Relay::execute_with(|| {

1765

1

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

1766

1

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

1767

1

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

1768

1

});

1769

1

1770

1771

#[test]

1772

1

fn transact_through_sovereign_with_custom_fee_weight() {

1773

1

	MockNet::reset();

1774

1

1775

1

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

1776

1

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

1777

1

1778

1

	let asset_metadata = parachain::AssetMetadata {

1779

1

		name: b"RelayToken".to_vec(),

1780

1

		symbol: b"Relay".to_vec(),

1781

1

		decimals: 12,

1782

1

};

1783

1

1784

1

	ParaA::execute_with(|| {

1785

1

		assert_ok!(AssetManager::register_foreign_asset(

1786

1

			parachain::RuntimeOrigin::root(),

1787

1

			source_location.clone(),

1788

1

			asset_metadata,

1789

1

			1u128,

1790

1

			true

1791

1

));

1792

1

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

1793

1

});

1794

1

1795

1

	let dest: Location = AccountKey20 {

1796

1

		network: None,

1797

1

		key: PARAALICE,

1798

1

1799

1

	.into();

1800

1

	Relay::execute_with(|| {

1801

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1802

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1803

1

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

1804

1

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

1805

1

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

1806

1

0,

1807

1

			WeightLimit::Unlimited

1808

1

));

1809

1

});

1810

1

1811

1

	ParaA::execute_with(|| {

1812

1

		// free execution, full amount received

1813

1

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

1814

1

});

1815

1

1816

1

	// Register address

1817

1

	ParaA::execute_with(|| {

1818

1

		assert_ok!(XcmTransactor::register(

1819

1

			parachain::RuntimeOrigin::root(),

1820

1

			PARAALICE.into(),

1821

1

0,

1822

1

));

1823

1

});

1824

1

1825

1

	// Send to registered address

1826

1

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

1827

1

	let dest = Location {

1828

1

		parents: 1,

1829

1

		interior: [AccountId32 {

1830

1

			network: None,

1831

1

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

1832

1

}]

1833

1

		.into(),

1834

1

};

1835

1

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

1836

1

1837

1

	ParaA::execute_with(|| {

1838

1

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

1839

1

		// free execution, full amount received

1840

1

		assert_ok!(PolkadotXcm::transfer_assets(

1841

1

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

1842

1

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

1843

1

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

1844

1

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

1845

1

0,

1846

1

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

1847

1

));

1848

1

});

1849

1

1850

1

	ParaA::execute_with(|| {

1851

1

		// free execution, full amount received

1852

1

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

1853

1

});

1854

1

1855

1

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

1856

1

	// again

1857

1

	Relay::execute_with(|| {

1858

1

		// free execution,x	 full amount received

1859

1

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

1860

1

1861

1

});

1862

1

1863

1

	// We send the xcm transact operation to parent

1864

1

	let dest = Location {

1865

1

		parents: 1,

1866

1

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

1867

1

};

1868

1

1869

1

	// Encode the call. Balances transact to para_a_account

1870

1

	// First index

1871

1

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

1872

1

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

1873

1

		relay_chain::Balances,

1874

1

>()

1875

1

	.unwrap() as u8;

1876

1

1877

1

	encoded.push(index);

1878

1

1879

1

	// Then call bytes

1880

1

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

1881

1

		dest: para_a_account(),

1882

1

		value: 100u32.into(),

1883

1

1884

1

	.encode();

1885

1

	encoded.append(&mut call_bytes);

1886

1

1887

1

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

1888

1

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

1889

1

);

1890

1

1891

1

	let total_weight = 4000003000u64;

1892

1

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

1893

1

	ParaA::execute_with(|| {

1894

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1895

1

			parachain::RuntimeOrigin::root(),

1896

1

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

1897

1

			Some(PARAALICE.into()),

1898

1

			CurrencyPayment {

1899

1

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

1900

1

					Location::parent()

1901

1

				))),

1902

1

				// 1-1 fee-weight mapping

1903

1

				fee_amount: Some(total_weight as u128)

1904

1

},

1905

1

			utility_bytes,

1906

1

			OriginKind::SovereignAccount,

1907

1

			TransactWeights {

1908

1

				transact_required_weight_at_most: 4000000000.into(),

1909

1

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

1910

1

},

1911

1

			false

1912

1

));

1913

1

});

1914

1

1915

1

	Relay::execute_with(|| {

1916

1

		// free execution,x	 full amount received

1917

1

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

1918

1919

1

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

1920

1

});

1921

1

1922

1923

#[test]

1924

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1925

1

	MockNet::reset();

1926

1

1927

1

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

1928

1

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

1929

1

1930

1

	let asset_metadata = parachain::AssetMetadata {

1931

1

		name: b"RelayToken".to_vec(),

1932

1

		symbol: b"Relay".to_vec(),

1933

1

		decimals: 12,

1934

1

};

1935

1

1936

1

	ParaA::execute_with(|| {

1937

1

		assert_ok!(AssetManager::register_foreign_asset(

1938

1

			parachain::RuntimeOrigin::root(),

1939

1

			source_location.clone(),

1940

1

			asset_metadata,

1941

1

			1u128,

1942

1

			true

1943

1

));

1944

1

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

1945

1

});

1946

1

1947

1

	let dest: Location = AccountKey20 {

1948

1

		network: None,

1949

1

		key: PARAALICE,

1950

1

1951

1

	.into();

1952

1

	Relay::execute_with(|| {

1953

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1954

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1955

1

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

1956

1

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

1957

1

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

1958

1

0,

1959

1

			WeightLimit::Unlimited

1960

1

));

1961

1

});

1962

1

1963

1

	ParaA::execute_with(|| {

1964

1

		// free execution, full amount received

1965

1

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

1966

1

});

1967

1

1968

1

	// Register address

1969

1

	ParaA::execute_with(|| {

1970

1

		assert_ok!(XcmTransactor::register(

1971

1

			parachain::RuntimeOrigin::root(),

1972

1

			PARAALICE.into(),

1973

1

0,

1974

1

));

1975

1

});

1976

1

1977

1

	// Send to registered address

1978

1

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

1979

1

	let dest = Location {

1980

1

		parents: 1,

1981

1

		interior: [AccountId32 {

1982

1

			network: None,

1983

1

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

1984

1

}]

1985

1

		.into(),

1986

1

};

1987

1

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

1988

1

1989

1

	ParaA::execute_with(|| {

1990

1

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

1991

1

		// free execution, full amount received

1992

1

		assert_ok!(PolkadotXcm::transfer_assets(

1993

1

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

1994

1

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

1995

1

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

1996

1

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

1997

1

0,

1998

1

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

1999

1

));

2000

1

});

2001

1

2002

1

	ParaA::execute_with(|| {

2003

1

		// free execution, full amount received

2004

1

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

2005

1

});

2006

1

2007

1

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

2008

1

	// again

2009

1

	Relay::execute_with(|| {

2010

1

		// free execution,x	 full amount received

2011

1

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

2012

1

2013

1

});

2014

1

2015

1

	// We send the xcm transact operation to parent

2016

1

	let dest = Location {

2017

1

		parents: 1,

2018

1

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

2019

1

};

2020

1

2021

1

	// Encode the call. Balances transact to para_a_account

2022

1

	// First index

2023

1

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

2024

1

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

2025

1

		relay_chain::Balances,

2026

1

>()

2027

1

	.unwrap() as u8;

2028

1

2029

1

	encoded.push(index);

2030

1

2031

1

	// Then call bytes

2032

1

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

2033

1

		dest: para_a_account(),

2034

1

		value: 100u32.into(),

2035

1

2036

1

	.encode();

2037

1

	encoded.append(&mut call_bytes);

2038

1

2039

1

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

2040

1

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

2041

1

);

2042

1

2043

1

	let total_weight = 4000009000u64;

2044

1

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

2045

1

	ParaA::execute_with(|| {

2046

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2047

1

			parachain::RuntimeOrigin::root(),

2048

1

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

2049

1

			Some(PARAALICE.into()),

2050

1

			CurrencyPayment {

2051

1

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

2052

1

					Location::parent()

2053

1

				))),

2054

1

				// 1-1 fee-weight mapping

2055

1

				fee_amount: Some(total_weight as u128)

2056

1

},

2057

1

			utility_bytes,

2058

1

			OriginKind::SovereignAccount,

2059

1

			TransactWeights {

2060

1

				transact_required_weight_at_most: 4000000000.into(),

2061

1

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

2062

1

},

2063

1

			true

2064

1

));

2065

1

});

2066

1

2067

1

	Relay::execute_with(|| {

2068

1

		// free execution, full amount received

2069

1

		// 4000009000 refunded + 100 transferred = 4000009100

2070

1

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

2071

2072

1

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

2073

1

});

2074

1

2075

2076

#[test]

2077

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2078

1

	MockNet::reset();

2079

1

2080

1

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

2081

1

	let asset_metadata = parachain::AssetMetadata {

2082

1

		name: b"RelayToken".to_vec(),

2083

1

		symbol: b"Relay".to_vec(),

2084

1

		decimals: 12,

2085

1

};

2086

1

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

2087

1

	ParaA::execute_with(|| {

2088

1

		parachain::XcmVersioner::set_version(1);

2089

1

		assert_ok!(AssetManager::register_foreign_asset(

2090

1

			parachain::RuntimeOrigin::root(),

2091

1

			source_location.clone(),

2092

1

			asset_metadata,

2093

1

			1u128,

2094

1

			true

2095

1

));

2096

1

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

2097

1

});

2098

1

2099

1

	let response = Response::Version(2);

2100

1

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

2101

1

2102

1

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

2103

1

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

2104

1

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

2105

1

		query_id: 0,

2106

1

		response,

2107

1

		max_weight: Weight::zero(),

2108

1

		querier: Some(querier),

2109

1

	}]);

2110

1

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

2111

1

	// it directly here

2112

1

	// Actually send relay asset to parachain

2113

1

	let dest: Location = AccountKey20 {

2114

1

		network: None,

2115

1

		key: PARAALICE,

2116

1

2117

1

	.into();

2118

1

2119

1

	Relay::execute_with(|| {

2120

1

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

2121

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2122

1

			relay_chain::RuntimeOrigin::root(),

2123

1

			Some(3)

2124

1

));

2125

2126

		// Wrap version, which sets VersionedStorage

2127

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

2128

		// this is not necessary in prod

2129

1

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

2130

1

			&Parachain(1).into(),

2131

1

			mock_message

2132

1

));

2133

2134

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

2135

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2136

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2137

1

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

2138

1

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

2139

1

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

2140

1

0,

2141

1

			WeightLimit::Unlimited

2142

1

));

2143

2144

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

2145

1

		relay_chain::relay_roll_to(2);

2146

1

2147

1

		// queries should have been updated

2148

1

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

2149

1

});

2150

1

2151

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2152

1

		pallet_xcm::Event::SupportedVersionChanged {

2153

1

			location: Location {

2154

1

				parents: 0,

2155

1

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

2156

1

},

2157

1

			version: 1,

2158

1

2159

1

		.into();

2160

1

2161

1

	Relay::execute_with(|| {

2162

1

		// Assert that the events vector contains the version change

2163

1

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

2164

1

});

2165

1

2166

1

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

2167

1

	// of the new version change

2168

1

	ParaA::execute_with(|| {

2169

1

		// Set version

2170

1

		parachain::XcmVersioner::set_version(2);

2171

1

		// Do runtime upgrade

2172

1

		parachain::on_runtime_upgrade();

2173

1

		// Initialize block, to call on_initialize and notify targets

2174

1

		parachain::para_roll_to(2);

2175

1

		// Expect the event in the parachain

2176

10

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

2177

2

e,

2178

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

2179

				result: 2,

2180

..

2181

})

2182

10

		)));

2183

1

});

2184

1

2185

1

	// This event should have been seen in the relay

2186

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2187

1

		pallet_xcm::Event::SupportedVersionChanged {

2188

1

			location: Location {

2189

1

				parents: 0,

2190

1

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

2191

1

},

2192

1

			version: 2,

2193

1

2194

1

		.into();

2195

1

2196

1

	Relay::execute_with(|| {

2197

1

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

2198

1

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

2199

1

});

2200

1

2201

2202

#[test]

2203

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2204

1

	MockNet::reset();

2205

1

2206

1

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

2207

1

	let source_location: AssetType = para_a_balances

2208

1

		.try_into()

2209

1

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

2210

1

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

2211

1

2212

1

	let asset_metadata = parachain::AssetMetadata {

2213

1

		name: b"ParaAToken".to_vec(),

2214

1

		symbol: b"ParaA".to_vec(),

2215

1

		decimals: 18,

2216

1

};

2217

1

	let response = Response::Version(2);

2218

1

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

2219

1

		.into();

2220

1

2221

1

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

2222

1

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

2223

1

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

2224

1

		query_id: 0,

2225

1

		response,

2226

1

		max_weight: Weight::zero(),

2227

1

		querier: Some(querier),

2228

1

	}]);

2229

1

2230

1

	ParaA::execute_with(|| {

2231

1

		// advertised version

2232

1

		parachain::XcmVersioner::set_version(2);

2233

1

});

2234

1

2235

1

	ParaB::execute_with(|| {

2236

1

		// Let's try with v0

2237

1

		parachain::XcmVersioner::set_version(0);

2238

1

2239

1

		assert_ok!(AssetManager::register_foreign_asset(

2240

1

			parachain::RuntimeOrigin::root(),

2241

1

			source_location.clone(),

2242

1

			asset_metadata,

2243

1

			1u128,

2244

1

			true

2245

1

));

2246

1

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

2247

1

});

2248

1

2249

1

	ParaA::execute_with(|| {

2250

1

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

2251

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2252

1

			parachain::RuntimeOrigin::root(),

2253

1

			Some(3)

2254

1

));

2255

		// Wrap version, which sets VersionedStorage

2256

1

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

2257

1

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

2258

1

			mock_message

2259

1

));

2260

2261

1

		parachain::para_roll_to(2);

2262

1

2263

1

		// queries should have been updated

2264

1

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

2265

1

});

2266

1

2267

1

	let expected_supported_version: parachain::RuntimeEvent =

2268

1

		pallet_xcm::Event::SupportedVersionChanged {

2269

1

			location: Location {

2270

1

				parents: 1,

2271

1

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

2272

1

},

2273

1

			version: 0,

2274

1

2275

1

		.into();

2276

1

2277

1

	ParaA::execute_with(|| {

2278

1

		// Assert that the events vector contains the version change

2279

1

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

2280

1

});

2281

1

2282

1

	// Let's ensure talking in v0 works

2283

1

	let dest = Location {

2284

1

		parents: 1,

2285

1

		interior: [

2286

1

			Parachain(2),

2287

1

			AccountKey20 {

2288

1

				network: None,

2289

1

				key: PARAALICE.into(),

2290

1

},

2291

1

2292

1

		.into(),

2293

1

};

2294

1

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

2295

1

	ParaA::execute_with(|| {

2296

1

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

2297

1

		// free execution, full amount received

2298

1

		assert_ok!(PolkadotXcm::transfer_assets(

2299

1

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

2300

1

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

2301

1

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

2302

1

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

2303

1

0,

2304

1

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

2305

1

));

2306

		// free execution, full amount received

2307

1

		assert_eq!(

2308

1

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

2309

1

			INITIAL_BALANCE - 100

2310

1

);

2311

1

});

2312

1

2313

1

	ParaB::execute_with(|| {

2314

1

		// free execution, full amount received

2315

1

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

2316

1

});

2317

1

2318

1

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

2319

1

	// of the new version change

2320

1

	ParaB::execute_with(|| {

2321

1

		// Set version

2322

1

		parachain::XcmVersioner::set_version(2);

2323

1

		// Do runtime upgrade

2324

1

		parachain::on_runtime_upgrade();

2325

1

		// Initialize block, to call on_initialize and notify targets

2326

1

		parachain::para_roll_to(2);

2327

1

		// Expect the event in the parachain

2328

10

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

2329

2

e,

2330

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

2331

				result: 2,

2332

..

2333

})

2334

10

		)));

2335

1

});

2336

1

2337

1

	// This event should have been seen in para A

2338

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2339

1

		pallet_xcm::Event::SupportedVersionChanged {

2340

1

			location: Location {

2341

1

				parents: 1,

2342

1

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

2343

1

},

2344

1

			version: 2,

2345

1

2346

1

		.into();

2347

1

2348

1

	// Para A should have received the version change

2349

1

	ParaA::execute_with(|| {

2350

1

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

2351

1

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

2352

1

});

2353

1

2354

2355

#[test]

2356

1

fn receive_asset_with_no_sufficients_not_possible_if_non_existent_account() {

2357

1

	MockNet::reset();

2358

1

2359

1

	let fresh_account = [2u8; 20];

2360

1

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

2361

1

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

2362

1

	let asset_metadata = parachain::AssetMetadata {

2363

1

		name: b"RelayToken".to_vec(),

2364

1

		symbol: b"Relay".to_vec(),

2365

1

		decimals: 12,

2366

1

};

2367

1

	// register relay asset in parachain A

2368

1

	ParaA::execute_with(|| {

2369

1

		assert_ok!(AssetManager::register_foreign_asset(

2370

1

			parachain::RuntimeOrigin::root(),

2371

1

			source_location.clone(),

2372

1

			asset_metadata,

2373

1

			1u128,

2374

1

			false

2375

1

));

2376

1

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

2377

1

});

2378

1

2379

1

	// Actually send relay asset to parachain

2380

1

	let dest: Location = AccountKey20 {

2381

1

		network: None,

2382

1

		key: fresh_account,

2383

1

2384

1

	.into();

2385

1

	Relay::execute_with(|| {

2386

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2387

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2388

1

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

2389

1

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

2390

1

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

2391

1

0,

2392

1

			WeightLimit::Unlimited

2393

1

));

2394

1

});

2395

1

2396

1

	// parachain should not have received assets

2397

1

	ParaA::execute_with(|| {

2398

1

		// free execution, full amount received

2399

1

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

2400

1

});

2401

1

2402

1

	// Send native token to fresh_account

2403

1

	ParaA::execute_with(|| {

2404

1

		assert_ok!(ParaBalances::transfer_allow_death(

2405

1

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

2406

1

			fresh_account.into(),

2407

1

2408

1

));

2409

1

});

2410

1

2411

1

	// Re-send tokens

2412

1

	Relay::execute_with(|| {

2413

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2414

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2415

1

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

2416

1

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

2417

1

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

2418

1

0,

2419

1

			WeightLimit::Unlimited

2420

1

));

2421

1

});

2422

1

2423

1

	// parachain should have received assets

2424

1

	ParaA::execute_with(|| {

2425

1

		// free execution, full amount received

2426

1

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

2427

1

});

2428

1

2429

2430

#[test]

2431

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2432

1

	MockNet::reset();

2433

1

2434

1

	let fresh_account = [2u8; 20];

2435

1

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

2436

1

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

2437

1

	let asset_metadata = parachain::AssetMetadata {

2438

1

		name: b"RelayToken".to_vec(),

2439

1

		symbol: b"Relay".to_vec(),

2440

1

		decimals: 12,

2441

1

};

2442

1

	// register relay asset in parachain A

2443

1

	ParaA::execute_with(|| {

2444

1

		assert_ok!(AssetManager::register_foreign_asset(

2445

1

			parachain::RuntimeOrigin::root(),

2446

1

			source_location.clone(),

2447

1

			asset_metadata,

2448

1

			1u128,

2449

1

			true

2450

1

));

2451

1

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

2452

1

});

2453

1

2454

1

	// Actually send relay asset to parachain

2455

1

	let dest: Location = AccountKey20 {

2456

1

		network: None,

2457

1

		key: fresh_account,

2458

1

2459

1

	.into();

2460

1

	Relay::execute_with(|| {

2461

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2462

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2463

1

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

2464

1

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

2465

1

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

2466

1

0,

2467

1

			WeightLimit::Unlimited

2468

1

));

2469

1

});

2470

1

2471

1

	// parachain should have received assets

2472

1

	ParaA::execute_with(|| {

2473

1

		// free execution, full amount received

2474

1

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

2475

1

});

2476

1

2477

2478

#[test]

2479

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2480

1

	MockNet::reset();

2481

1

2482

1

	let mut sufficient_account = [0u8; 20];

2483

1

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

2484

1

2485

1

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

2486

1

2487

1

	// Evm account is self sufficient

2488

1

	ParaA::execute_with(|| {

2489

1

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

2490

1

});

2491

1

2492

1

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

2493

1

	let asset_metadata = parachain::AssetMetadata {

2494

1

		name: b"RelayToken".to_vec(),

2495

1

		symbol: b"Relay".to_vec(),

2496

1

		decimals: 12,

2497

1

};

2498

1

	// register relay asset in parachain A

2499

1

	ParaA::execute_with(|| {

2500

1

		assert_ok!(AssetManager::register_foreign_asset(

2501

1

			parachain::RuntimeOrigin::root(),

2502

1

			source_location.clone(),

2503

1

			asset_metadata,

2504

1

			1u128,

2505

1

			true

2506

1

));

2507

1

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

2508

1

});

2509

1

2510

1

	// Actually send relay asset to parachain

2511

1

	let dest: Location = AccountKey20 {

2512

1

		network: None,

2513

1

		key: sufficient_account,

2514

1

2515

1

	.into();

2516

1

	Relay::execute_with(|| {

2517

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2518

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2519

1

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

2520

1

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

2521

1

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

2522

1

0,

2523

1

			WeightLimit::Unlimited

2524

1

));

2525

1

});

2526

1

2527

1

	// Evm account sufficient ref count increased by 1.

2528

1

	ParaA::execute_with(|| {

2529

1

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

2530

1

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

2531

1

		// will be implemented in a future release

2532

1

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

2533

1

});

2534

1

2535

1

	ParaA::execute_with(|| {

2536

1

		// Remove the account from the evm context.

2537

1

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

2538

1

		// Evm account sufficient ref count decreased by 1.

2539

1

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

2540

1

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

2541

1

		// will be implemented in a future release

2542

1

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

2543

1

});

2544

1

2545

2546

#[test]

2547

1

fn empty_account_should_not_be_reset() {

2548

1

	MockNet::reset();

2549

1

2550

1

	// Test account has nonce 1 on genesis.

2551

1

	let mut sufficient_account = [0u8; 20];

2552

1

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

2553

1

2554

1

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

2555

1

2556

1

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

2557

1

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

2558

1

	let asset_metadata = parachain::AssetMetadata {

2559

1

		name: b"RelayToken".to_vec(),

2560

1

		symbol: b"Relay".to_vec(),

2561

1

		decimals: 12,

2562

1

};

2563

1

	// register relay asset in parachain A

2564

1

	ParaA::execute_with(|| {

2565

1

		assert_ok!(AssetManager::register_foreign_asset(

2566

1

			parachain::RuntimeOrigin::root(),

2567

1

			source_location.clone(),

2568

1

			asset_metadata,

2569

1

			1u128,

2570

1

			false

2571

1

));

2572

1

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

2573

1

});

2574

1

2575

1

	// Send native token to evm_account

2576

1

	ParaA::execute_with(|| {

2577

1

		assert_ok!(ParaBalances::transfer_allow_death(

2578

1

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

2579

1

			evm_account_id,

2580

1

2581

1

));

2582

1

});

2583

1

2584

1

	// Actually send relay asset to parachain

2585

1

	let dest: Location = AccountKey20 {

2586

1

		network: None,

2587

1

		key: sufficient_account,

2588

1

2589

1

	.into();

2590

1

	Relay::execute_with(|| {

2591

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2592

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2593

1

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

2594

1

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

2595

1

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

2596

1

0,

2597

1

			WeightLimit::Unlimited

2598

1

));

2599

1

});

2600

1

2601

1

	ParaA::execute_with(|| {

2602

1

		// Empty the assets from the account.

2603

1

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

2604

1

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

2605

1

		assert_ok!(parachain::Assets::transfer(

2606

1

			parachain::RuntimeOrigin::signed(evm_account_id),

2607

1

			source_id,

2608

1

			PARAALICE.into(),

2609

1

2610

1

));

2611

		// Verify account asset balance is Zero.

2612

1

		assert_eq!(

2613

1

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

2614

1

2615

1

);

2616

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

2617

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

2618

1

		assert_ok!(ParaBalances::force_set_balance(

2619

1

			parachain::RuntimeOrigin::root(),

2620

1

			evm_account_id,

2621

1

0,

2622

1

));

2623

		// Verify account native balance is Zero.

2624

1

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

2625

		// Remove the account from the evm context.

2626

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

2627

1

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

2628

1

		// Verify reference count.

2629

1

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

2630

1

		assert_eq!(account.sufficients, 0);

2631

1

		assert_eq!(account.consumers, 0);

2632

1

		assert_eq!(account.providers, 1);

2633

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

2634

1

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

2635

1

});

2636

1

2637

2638

#[test]

2639

1

fn test_statemine_like() {

2640

1

	MockNet::reset();

2641

1

2642

1

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

2643

1

2644

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2645

1

		polkadot_parachain::primitives::Sibling,

2646

1

		statemine_like::AccountId,

2647

1

	>::convert_location(&dest_para)

2648

1

	.unwrap();

2649

1

2650

1

	let statemine_asset_a_balances = Location::new(

2651

1

1,

2652

1

2653

1

			Parachain(1000),

2654

1

			PalletInstance(5),

2655

1

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

2656

1

],

2657

1

);

2658

1

	let source_location: AssetType = statemine_asset_a_balances

2659

1

		.try_into()

2660

1

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

2661

1

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

2662

1

2663

1

	let asset_metadata = parachain::AssetMetadata {

2664

1

		name: b"StatemineToken".to_vec(),

2665

1

		symbol: b"StatemineToken".to_vec(),

2666

1

		decimals: 12,

2667

1

};

2668

1

2669

1

	ParaA::execute_with(|| {

2670

1

		assert_ok!(AssetManager::register_foreign_asset(

2671

1

			parachain::RuntimeOrigin::root(),

2672

1

			source_location.clone(),

2673

1

			asset_metadata.clone(),

2674

1

			1u128,

2675

1

			true

2676

1

));

2677

1

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

2678

1

});

2679

1

2680

1

	Statemine::execute_with(|| {

2681

1

		// Set new prefix

2682

1

		statemine_like::PrefixChanger::set_prefix(

2683

1

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

2684

1

);

2685

1

		assert_ok!(StatemineAssets::create(

2686

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2687

1

0,

2688

1

			RELAYALICE,

2689

1

2690

1

));

2691

2692

1

		assert_ok!(StatemineAssets::mint(

2693

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2694

1

0,

2695

1

			RELAYALICE,

2696

1

			300000000000000

2697

1

));

2698

2699

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

2700

1

		assert_ok!(StatemineBalances::transfer_allow_death(

2701

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2702

1

			sov,

2703

1

			100000000000000

2704

1

));

2705

2706

		// Actually send relay asset to parachain

2707

1

		let dest: Location = AccountKey20 {

2708

1

			network: None,

2709

1

			key: PARAALICE,

2710

1

2711

1

		.into();

2712

1

2713

1

		// Send with new prefix

2714

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

2715

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2716

1

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

2717

1

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

2718

1

			Box::new(

2719

1

2720

1

2721

1

						xcm::latest::prelude::PalletInstance(

2722

1

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

2723

1

),

2724

1

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

2725

1

],

2726

1

2727

1

2728

1

					.into()

2729

1

),

2730

1

0,

2731

1

			WeightLimit::Unlimited

2732

1

));

2733

1

});

2734

1

2735

1

	ParaA::execute_with(|| {

2736

1

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

2737

1

});

2738

1

2739

2740

#[test]

2741

1

fn send_statemine_asset_from_para_a_to_statemine_with_relay_fee() {

2742

1

	MockNet::reset();

2743

1

2744

1

	// Relay asset

2745

1

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

2746

1

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

2747

1

2748

1

	let relay_asset_metadata = parachain::AssetMetadata {

2749

1

		name: b"RelayToken".to_vec(),

2750

1

		symbol: b"Relay".to_vec(),

2751

1

		decimals: 12,

2752

1

};

2753

1

2754

1

	// Statemine asset

2755

1

	let statemine_asset = Location::new(

2756

1

1,

2757

1

2758

1

			Parachain(1000u32),

2759

1

			PalletInstance(5u8),

2760

1

			GeneralIndex(10u128),

2761

1

],

2762

1

);

2763

1

	let statemine_location_asset: AssetType = statemine_asset

2764

1

		.clone()

2765

1

		.try_into()

2766

1

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

2767

1

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

2768

1

2769

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

2770

1

		name: b"USDC".to_vec(),

2771

1

		symbol: b"USDC".to_vec(),

2772

1

		decimals: 12,

2773

1

};

2774

1

2775

1

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

2776

1

2777

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2778

1

		polkadot_parachain::primitives::Sibling,

2779

1

		statemine_like::AccountId,

2780

1

	>::convert_location(&dest_para)

2781

1

	.unwrap();

2782

1

2783

1

	ParaA::execute_with(|| {

2784

1

		assert_ok!(AssetManager::register_foreign_asset(

2785

1

			parachain::RuntimeOrigin::root(),

2786

1

			relay_location.clone(),

2787

1

			relay_asset_metadata,

2788

1

			1u128,

2789

1

			true

2790

1

));

2791

1

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

2792

2793

1

		assert_ok!(AssetManager::register_foreign_asset(

2794

1

			parachain::RuntimeOrigin::root(),

2795

1

			statemine_location_asset.clone(),

2796

1

			asset_metadata_statemine_asset,

2797

1

			1u128,

2798

1

			true

2799

1

));

2800

1

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

2801

1

});

2802

1

2803

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2804

1

		network: None,

2805

1

		key: PARAALICE,

2806

1

2807

1

	.into();

2808

1

2809

1

	// Send relay chain asset to Alice in Parachain A

2810

1

	Relay::execute_with(|| {

2811

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2812

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2813

1

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

2814

1

			Box::new(

2815

1

				VersionedLocation::from(parachain_beneficiary_from_relay)

2816

1

					.clone()

2817

1

					.into()

2818

1

),

2819

1

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

2820

1

0,

2821

1

			WeightLimit::Unlimited

2822

1

));

2823

1

});

2824

1

2825

1

	Statemine::execute_with(|| {

2826

1

		// Set new prefix

2827

1

		statemine_like::PrefixChanger::set_prefix(

2828

1

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

2829

1

);

2830

1

2831

1

		assert_ok!(StatemineAssets::create(

2832

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2833

1

10,

2834

1

			RELAYALICE,

2835

1

2836

1

));

2837

2838

1

		assert_ok!(StatemineAssets::mint(

2839

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2840

1

10,

2841

1

			RELAYALICE,

2842

1

			300000000000000

2843

1

));

2844

2845

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

2846

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

2847

1

		assert_ok!(StatemineBalances::transfer_allow_death(

2848

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2849

1

			sov,

2850

1

			100000000000000

2851

1

));

2852

2853

		// Send statemine USDC asset to Alice in Parachain A

2854

1

		let parachain_beneficiary_from_statemine: Location = AccountKey20 {

2855

1

			network: None,

2856

1

			key: PARAALICE,

2857

1

2858

1

		.into();

2859

1

2860

1

		// Send with new prefix

2861

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

2862

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2863

1

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

2864

1

			Box::new(

2865

1

				VersionedLocation::from(parachain_beneficiary_from_statemine)

2866

1

					.clone()

2867

1

					.into()

2868

1

),

2869

1

			Box::new(

2870

1

2871

1

2872

1

						xcm::latest::prelude::PalletInstance(

2873

1

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

2874

1

),

2875

1

						GeneralIndex(10),

2876

1

],

2877

1

2878

1

2879

1

					.into()

2880

1

),

2881

1

0,

2882

1

			WeightLimit::Unlimited

2883

1

));

2884

1

});

2885

1

2886

1

	let statemine_beneficiary = Location {

2887

1

		parents: 1,

2888

1

		interior: [

2889

1

			Parachain(1000),

2890

1

			AccountId32 {

2891

1

				network: None,

2892

1

				id: RELAYBOB.into(),

2893

1

},

2894

1

2895

1

		.into(),

2896

1

};

2897

1

2898

1

	ParaA::execute_with(|| {

2899

1

		// Alice has received 125 USDC

2900

1

		assert_eq!(

2901

1

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

2902

1

2903

1

);

2904

2905

		// Alice has received 200 Relay assets

2906

1

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

2907

1

});

2908

1

2909

1

	Statemine::execute_with(|| {

2910

1

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

2911

1

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

2912

1

});

2913

1

	let (chain_part, beneficiary) =

2914

1

		split_location_into_chain_part_and_beneficiary(statemine_beneficiary).unwrap();

2915

1

2916

1

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

2917

1

	ParaA::execute_with(|| {

2918

1

		let asset_1 = currency_to_asset(

2919

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

2920

1

			100,

2921

1

);

2922

1

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

2923

1

		let assets_to_send = vec![asset_1, asset_2];

2924

1

		assert_ok!(PolkadotXcm::transfer_assets(

2925

1

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

2926

1

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

2927

1

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

2928

1

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

2929

1

1,

2930

1

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

2931

1

));

2932

1

});

2933

1

2934

1

	ParaA::execute_with(|| {

2935

1

		// Alice has 100 USDC less

2936

1

		assert_eq!(

2937

1

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

2938

1

2939

1

);

2940

2941

		// Alice has 100 relay asset less

2942

1

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

2943

1

});

2944

1

2945

1

	Statemine::execute_with(|| {

2946

1

		// Check that BOB received 100 USDC on statemine

2947

1

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

2948

1

});

2949

1

2950

2951

#[test]

2952

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer() {

2953

1

	MockNet::reset();

2954

1

2955

1

	// Relay asset

2956

1

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

2957

1

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

2958

1

2959

1

	let relay_asset_metadata = parachain::AssetMetadata {

2960

1

		name: b"RelayToken".to_vec(),

2961

1

		symbol: b"Relay".to_vec(),

2962

1

		decimals: 12,

2963

1

};

2964

1

2965

1

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

2966

1

2967

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2968

1

		polkadot_parachain::primitives::Sibling,

2969

1

		statemine_like::AccountId,

2970

1

	>::convert_location(&dest_para)

2971

1

	.unwrap();

2972

1

2973

1

	ParaA::execute_with(|| {

2974

1

		assert_ok!(AssetManager::register_foreign_asset(

2975

1

			parachain::RuntimeOrigin::root(),

2976

1

			relay_location.clone(),

2977

1

			relay_asset_metadata,

2978

1

			1u128,

2979

1

			true

2980

1

));

2981

1

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

2982

1

});

2983

1

2984

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2985

1

		network: None,

2986

1

		key: PARAALICE,

2987

1

2988

1

	.into();

2989

1

2990

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

2991

1

		network: None,

2992

1

		id: RELAYALICE.into(),

2993

1

2994

1

	.into();

2995

1

2996

1

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

2997

1

	Relay::execute_with(|| {

2998

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2999

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3000

1

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

3001

1

			Box::new(

3002

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3003

1

					.clone()

3004

1

					.into()

3005

1

),

3006

1

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

3007

1

0,

3008

1

			WeightLimit::Unlimited

3009

1

));

3010

1

});

3011

1

3012

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3013

1

	Statemine::execute_with(|| {

3014

1

		// Check Alice received 200 tokens on AssetHub

3015

1

		assert_eq!(

3016

1

			StatemineBalances::free_balance(RELAYALICE),

3017

1

			INITIAL_BALANCE + 200

3018

1

);

3019

3020

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3021

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3022

1

			sov,

3023

1

			110000000000000

3024

1

));

3025

3026

		// Now send those tokens to ParaA

3027

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3028

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3029

1

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

3030

1

			Box::new(

3031

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3032

1

					.clone()

3033

1

					.into()

3034

1

),

3035

1

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

3036

1

0,

3037

1

			WeightLimit::Unlimited

3038

1

));

3039

1

});

3040

1

3041

1

	ParaA::execute_with(|| {

3042

1

		// Alice should have received the DOTs

3043

1

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

3044

1

});

3045

1

3046

1

	let dest = Location::new(

3047

1

1,

3048

1

3049

1

			Parachain(1000),

3050

1

			AccountId32 {

3051

1

				network: None,

3052

1

				id: RELAYBOB.into(),

3053

1

},

3054

1

],

3055

1

);

3056

1

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

3057

1

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

3058

1

	ParaA::execute_with(|| {

3059

1

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

3060

1

		assert_ok!(PolkadotXcm::transfer_assets(

3061

1

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

3062

1

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

3063

1

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

3064

1

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

3065

1

0,

3066

1

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

3067

1

));

3068

3069

1

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

3070

1

});

3071

1

3072

1

	Statemine::execute_with(|| {

3073

1

		// Check that Bob received the tokens back in AssetHub

3074

1

		assert_eq!(

3075

1

			StatemineBalances::free_balance(RELAYBOB),

3076

1

			INITIAL_BALANCE + 100

3077

1

);

3078

1

});

3079

1

3080

1

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

3081

1

	Statemine::execute_with(|| {

3082

1

		// Now send those tokens to ParaA

3083

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3084

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3085

1

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

3086

1

			Box::new(

3087

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3088

1

					.clone()

3089

1

					.into()

3090

1

),

3091

1

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

3092

1

0,

3093

1

			WeightLimit::Unlimited

3094

1

));

3095

3096

		// 100 DOTs were deducted from Bob's account

3097

1

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

3098

1

});

3099

1

3100

1

	ParaA::execute_with(|| {

3101

1

		// Alice should have received 100 DOTs

3102

1

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

3103

1

});

3104

1

3105

3106

#[test]

3107

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_with_fee() {

3108

1

	MockNet::reset();

3109

1

3110

1

	// Relay asset

3111

1

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

3112

1

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

3113

1

3114

1

	let relay_asset_metadata = parachain::AssetMetadata {

3115

1

		name: b"RelayToken".to_vec(),

3116

1

		symbol: b"Relay".to_vec(),

3117

1

		decimals: 12,

3118

1

};

3119

1

3120

1

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

3121

1

3122

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3123

1

		polkadot_parachain::primitives::Sibling,

3124

1

		statemine_like::AccountId,

3125

1

	>::convert_location(&dest_para)

3126

1

	.unwrap();

3127

1

3128

1

	ParaA::execute_with(|| {

3129

1

		assert_ok!(AssetManager::register_foreign_asset(

3130

1

			parachain::RuntimeOrigin::root(),

3131

1

			relay_location.clone(),

3132

1

			relay_asset_metadata,

3133

1

			1u128,

3134

1

			true

3135

1

));

3136

1

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

3137

1

});

3138

1

3139

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3140

1

		network: None,

3141

1

		key: PARAALICE,

3142

1

3143

1

	.into();

3144

1

3145

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3146

1

		network: None,

3147

1

		id: RELAYALICE.into(),

3148

1

3149

1

	.into();

3150

1

3151

1

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

3152

1

	Relay::execute_with(|| {

3153

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3154

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3155

1

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

3156

1

			Box::new(

3157

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3158

1

					.clone()

3159

1

					.into()

3160

1

),

3161

1

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

3162

1

0,

3163

1

			WeightLimit::Unlimited

3164

1

));

3165

1

});

3166

1

3167

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3168

1

	Statemine::execute_with(|| {

3169

1

		// Check Alice received 200 tokens on AssetHub

3170

1

		assert_eq!(

3171

1

			StatemineBalances::free_balance(RELAYALICE),

3172

1

			INITIAL_BALANCE + 200

3173

1

);

3174

3175

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3176

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3177

1

			sov,

3178

1

			110000000000000

3179

1

));

3180

3181

		// Now send those tokens to ParaA

3182

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3183

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3184

1

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

3185

1

			Box::new(

3186

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3187

1

					.clone()

3188

1

					.into()

3189

1

),

3190

1

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

3191

1

0,

3192

1

			WeightLimit::Unlimited

3193

1

));

3194

1

});

3195

1

3196

1

	ParaA::execute_with(|| {

3197

1

		// Alice should have received the DOTs

3198

1

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

3199

1

});

3200

1

3201

1

	let dest = Location::new(

3202

1

1,

3203

1

3204

1

			Parachain(1000),

3205

1

			AccountId32 {

3206

1

				network: None,

3207

1

				id: RELAYBOB.into(),

3208

1

},

3209

1

],

3210

1

);

3211

1

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

3212

1

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

3213

1

	ParaA::execute_with(|| {

3214

1

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

3215

1

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

3216

1

		assert_ok!(PolkadotXcm::transfer_assets(

3217

1

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

3218

1

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

3219

1

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

3220

1

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

3221

1

0,

3222

1

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

3223

1

));

3224

3225

1

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

3226

1

});

3227

1

3228

1

	Statemine::execute_with(|| {

3229

1

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

3230

1

		assert_eq!(

3231

1

			StatemineBalances::free_balance(RELAYBOB),

3232

1

			INITIAL_BALANCE + 110

3233

1

);

3234

1

});

3235

1

3236

1

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

3237

1

	Statemine::execute_with(|| {

3238

1

		// Now send those tokens to ParaA

3239

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3240

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3241

1

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

3242

1

			Box::new(

3243

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3244

1

					.clone()

3245

1

					.into()

3246

1

),

3247

1

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

3248

1

0,

3249

1

			WeightLimit::Unlimited

3250

1

));

3251

3252

		// 100 DOTs were deducted from Bob's account

3253

1

		assert_eq!(

3254

1

			StatemineBalances::free_balance(RELAYBOB),

3255

1

			INITIAL_BALANCE + 10

3256

1

);

3257

1

});

3258

1

3259

1

	ParaA::execute_with(|| {

3260

1

		// Alice should have received 100 DOTs

3261

1

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

3262

1

});

3263

1

3264

3265

#[test]

3266

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiasset() {

3267

1

	MockNet::reset();

3268

1

3269

1

	// Relay asset

3270

1

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

3271

1

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

3272

1

3273

1

	let relay_asset_metadata = parachain::AssetMetadata {

3274

1

		name: b"RelayToken".to_vec(),

3275

1

		symbol: b"Relay".to_vec(),

3276

1

		decimals: 12,

3277

1

};

3278

1

3279

1

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

3280

1

3281

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3282

1

		polkadot_parachain::primitives::Sibling,

3283

1

		statemine_like::AccountId,

3284

1

	>::convert_location(&dest_para)

3285

1

	.unwrap();

3286

1

3287

1

	ParaA::execute_with(|| {

3288

1

		assert_ok!(AssetManager::register_foreign_asset(

3289

1

			parachain::RuntimeOrigin::root(),

3290

1

			relay_location.clone(),

3291

1

			relay_asset_metadata,

3292

1

			1u128,

3293

1

			true

3294

1

));

3295

1

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

3296

1

});

3297

1

3298

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3299

1

		network: None,

3300

1

		key: PARAALICE,

3301

1

3302

1

	.into();

3303

1

3304

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3305

1

		network: None,

3306

1

		id: RELAYALICE.into(),

3307

1

3308

1

	.into();

3309

1

3310

1

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

3311

1

	Relay::execute_with(|| {

3312

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3313

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3314

1

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

3315

1

			Box::new(

3316

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3317

1

					.clone()

3318

1

					.into()

3319

1

),

3320

1

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

3321

1

0,

3322

1

			WeightLimit::Unlimited

3323

1

));

3324

1

});

3325

1

3326

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3327

1

	Statemine::execute_with(|| {

3328

1

		// Check Alice received 200 tokens on AssetHub

3329

1

		assert_eq!(

3330

1

			StatemineBalances::free_balance(RELAYALICE),

3331

1

			INITIAL_BALANCE + 200

3332

1

);

3333

3334

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3335

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3336

1

			sov,

3337

1

			110000000000000

3338

1

));

3339

3340

		// Now send those tokens to ParaA

3341

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3342

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3343

1

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

3344

1

			Box::new(

3345

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3346

1

					.clone()

3347

1

					.into()

3348

1

),

3349

1

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

3350

1

0,

3351

1

			WeightLimit::Unlimited

3352

1

));

3353

1

});

3354

1

3355

1

	ParaA::execute_with(|| {

3356

1

		// Alice should have received the DOTs

3357

1

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

3358

1

});

3359

1

3360

1

	let dest = Location::new(

3361

1

1,

3362

1

3363

1

			Parachain(1000),

3364

1

			AccountId32 {

3365

1

				network: None,

3366

1

				id: RELAYBOB.into(),

3367

1

},

3368

1

],

3369

1

);

3370

1

3371

1

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

3372

1

3373

1

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

3374

1

	ParaA::execute_with(|| {

3375

1

		assert_ok!(PolkadotXcm::transfer_assets(

3376

1

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

3377

1

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

3378

1

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

3379

1

			Box::new(VersionedAssets::from(

3380

1

				vec![(Location::parent(), 100).into()]

3381

1

)),

3382

1

0,

3383

1

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

3384

1

));

3385

3386

1

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

3387

1

});

3388

1

3389

1

	Statemine::execute_with(|| {

3390

1

		// Check that Bob received the tokens back in AssetHub

3391

1

		assert_eq!(

3392

1

			StatemineBalances::free_balance(RELAYBOB),

3393

1

			INITIAL_BALANCE + 100

3394

1

);

3395

1

});

3396

1

3397

1

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

3398

1

	Statemine::execute_with(|| {

3399

1

		// Now send those tokens to ParaA

3400

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3401

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3402

1

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

3403

1

			Box::new(

3404

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3405

1

					.clone()

3406

1

					.into()

3407

1

),

3408

1

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

3409

1

0,

3410

1

			WeightLimit::Unlimited

3411

1

));

3412

3413

		// 100 DOTs were deducted from Bob's account

3414

1

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

3415

1

});

3416

1

3417

1

	ParaA::execute_with(|| {

3418

1

		// Alice should have received 100 DOTs

3419

1

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

3420

1

});

3421

1

3422

3423

#[test]

3424

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multicurrencies() {

3425

1

	MockNet::reset();

3426

1

3427

1

	// Relay asset

3428

1

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

3429

1

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

3430

1

3431

1

	let relay_asset_metadata = parachain::AssetMetadata {

3432

1

		name: b"RelayToken".to_vec(),

3433

1

		symbol: b"Relay".to_vec(),

3434

1

		decimals: 12,

3435

1

};

3436

1

3437

1

	// Statemine asset

3438

1

	let statemine_asset = Location::new(

3439

1

1,

3440

1

3441

1

			Parachain(1000u32),

3442

1

			PalletInstance(5u8),

3443

1

			GeneralIndex(10u128),

3444

1

],

3445

1

);

3446

1

	let statemine_location_asset: AssetType = statemine_asset

3447

1

		.clone()

3448

1

		.try_into()

3449

1

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

3450

1

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

3451

1

3452

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3453

1

		name: b"USDC".to_vec(),

3454

1

		symbol: b"USDC".to_vec(),

3455

1

		decimals: 12,

3456

1

};

3457

1

3458

1

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

3459

1

3460

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3461

1

		polkadot_parachain::primitives::Sibling,

3462

1

		statemine_like::AccountId,

3463

1

	>::convert_location(&dest_para)

3464

1

	.unwrap();

3465

1

3466

1

	ParaA::execute_with(|| {

3467

1

		assert_ok!(AssetManager::register_foreign_asset(

3468

1

			parachain::RuntimeOrigin::root(),

3469

1

			relay_location.clone(),

3470

1

			relay_asset_metadata,

3471

1

			1u128,

3472

1

			true

3473

1

));

3474

1

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

3475

1

3476

1

		assert_ok!(AssetManager::register_foreign_asset(

3477

1

			parachain::RuntimeOrigin::root(),

3478

1

			statemine_location_asset.clone(),

3479

1

			asset_metadata_statemine_asset,

3480

1

			1u128,

3481

1

			true

3482

1

));

3483

1

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

3484

1

});

3485

1

3486

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3487

1

		network: None,

3488

1

		key: PARAALICE,

3489

1

3490

1

	.into();

3491

1

3492

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3493

1

		network: None,

3494

1

		id: RELAYALICE.into(),

3495

1

3496

1

	.into();

3497

1

3498

1

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

3499

1

	Relay::execute_with(|| {

3500

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3501

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3502

1

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

3503

1

			Box::new(

3504

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3505

1

					.clone()

3506

1

					.into()

3507

1

),

3508

1

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

3509

1

0,

3510

1

			WeightLimit::Unlimited

3511

1

));

3512

1

});

3513

1

3514

1

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

3515

1

	Statemine::execute_with(|| {

3516

1

		// Check Alice received 200 tokens on AssetHub

3517

1

		assert_eq!(

3518

1

			StatemineBalances::free_balance(RELAYALICE),

3519

1

			INITIAL_BALANCE + 200

3520

1

);

3521

3522

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3523

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3524

1

			sov,

3525

1

			110000000000000

3526

1

));

3527

3528

1

		statemine_like::PrefixChanger::set_prefix(

3529

1

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

3530

1

);

3531

1

3532

1

		assert_ok!(StatemineAssets::create(

3533

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3534

1

10,

3535

1

			RELAYALICE,

3536

1

3537

1

));

3538

3539

1

		assert_ok!(StatemineAssets::mint(

3540

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3541

1

10,

3542

1

			RELAYALICE,

3543

1

			300000000000000

3544

1

));

3545

3546

		// Now send relay tokens to ParaA

3547

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3548

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3549

1

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

3550

1

			Box::new(

3551

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3552

1

					.clone()

3553

1

					.into()

3554

1

),

3555

1

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

3556

1

0,

3557

1

			WeightLimit::Unlimited

3558

1

));

3559

3560

		// Send USDC

3561

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3562

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3563

1

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

3564

1

			Box::new(

3565

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3566

1

					.clone()

3567

1

					.into()

3568

1

),

3569

1

			Box::new(

3570

1

3571

1

3572

1

						xcm::latest::prelude::PalletInstance(

3573

1

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

3574

1

),

3575

1

						GeneralIndex(10),

3576

1

],

3577

1

3578

1

3579

1

					.into()

3580

1

),

3581

1

0,

3582

1

			WeightLimit::Unlimited

3583

1

));

3584

1

});

3585

1

3586

1

	ParaA::execute_with(|| {

3587

1

		// Alice should have received the DOTs

3588

1

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

3589

3590

		// Alice has received 125 USDC

3591

1

		assert_eq!(

3592

1

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

3593

1

3594

1

);

3595

1

});

3596

1

3597

1

	let dest = Location::new(

3598

1

1,

3599

1

3600

1

			Parachain(1000),

3601

1

			AccountId32 {

3602

1

				network: None,

3603

1

				id: RELAYBOB.into(),

3604

1

},

3605

1

],

3606

1

);

3607

1

3608

1

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

3609

1

3610

1

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

3611

1

	ParaA::execute_with(|| {

3612

1

		let asset_1 = currency_to_asset(

3613

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3614

1

			100,

3615

1

);

3616

1

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

3617

1

		assert_ok!(PolkadotXcm::transfer_assets(

3618

1

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

3619

1

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

3620

1

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

3621

1

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

3622

1

1,

3623

1

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

3624

1

));

3625

3626

1

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

3627

1

});

3628

1

3629

1

	Statemine::execute_with(|| {

3630

1

		// Check that Bob received relay tokens back in AssetHub

3631

1

		// (100 - MinXcmFee)

3632

1

		assert_eq!(

3633

1

			StatemineBalances::free_balance(RELAYBOB),

3634

1

			INITIAL_BALANCE + 100

3635

1

);

3636

3637

		// Check that BOB received 100 USDC on AssetHub

3638

1

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

3639

1

});

3640

1

3641

1

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

3642

1

	Statemine::execute_with(|| {

3643

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

3644

1

3645

1

		// Now send those tokens to ParaA

3646

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3647

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3648

1

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

3649

1

			Box::new(

3650

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3651

1

					.clone()

3652

1

					.into()

3653

1

),

3654

1

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

3655

1

0,

3656

1

			WeightLimit::Unlimited

3657

1

));

3658

3659

		// 100 DOTs were deducted from Bob's account

3660

1

		assert_eq!(

3661

1

			StatemineBalances::free_balance(RELAYBOB),

3662

1

			bob_previous_balance - 100

3663

1

);

3664

1

});

3665

1

3666

1

	ParaA::execute_with(|| {

3667

1

		// Alice should have received 100 DOTs

3668

1

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

3669

1

});

3670

1

3671

3672

#[test]

3673

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiassets() {

3674

1

	MockNet::reset();

3675

1

3676

1

	// Relay asset

3677

1

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

3678

1

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

3679

1

3680

1

	let relay_asset_metadata = parachain::AssetMetadata {

3681

1

		name: b"RelayToken".to_vec(),

3682

1

		symbol: b"Relay".to_vec(),

3683

1

		decimals: 12,

3684

1

};

3685

1

3686

1

	// Statemine asset

3687

1

	let statemine_asset = Location::new(

3688

1

1,

3689

1

3690

1

			Parachain(1000u32),

3691

1

			PalletInstance(5u8),

3692

1

			GeneralIndex(10u128),

3693

1

],

3694

1

);

3695

1

	let statemine_location_asset: AssetType = statemine_asset

3696

1

		.clone()

3697

1

		.try_into()

3698

1

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

3699

1

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

3700

1

3701

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3702

1

		name: b"USDC".to_vec(),

3703

1

		symbol: b"USDC".to_vec(),

3704

1

		decimals: 12,

3705

1

};

3706

1

3707

1

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

3708

1

3709

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3710

1

		polkadot_parachain::primitives::Sibling,

3711

1

		statemine_like::AccountId,

3712

1

	>::convert_location(&dest_para)

3713

1

	.unwrap();

3714

1

3715

1

	ParaA::execute_with(|| {

3716

1

		assert_ok!(AssetManager::register_foreign_asset(

3717

1

			parachain::RuntimeOrigin::root(),

3718

1

			relay_location.clone(),

3719

1

			relay_asset_metadata,

3720

1

			1u128,

3721

1

			true

3722

1

));

3723

1

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

3724

1

3725

1

		assert_ok!(AssetManager::register_foreign_asset(

3726

1

			parachain::RuntimeOrigin::root(),

3727

1

			statemine_location_asset.clone(),

3728

1

			asset_metadata_statemine_asset,

3729

1

			1u128,

3730

1

			true

3731

1

));

3732

1

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

3733

1

});

3734

1

3735

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3736

1

		network: None,

3737

1

		key: PARAALICE,

3738

1

3739

1

	.into();

3740

1

3741

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3742

1

		network: None,

3743

1

		id: RELAYALICE.into(),

3744

1

3745

1

	.into();

3746

1

3747

1

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

3748

1

	Relay::execute_with(|| {

3749

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3750

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3751

1

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

3752

1

			Box::new(

3753

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3754

1

					.clone()

3755

1

					.into()

3756

1

),

3757

1

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

3758

1

0,

3759

1

			WeightLimit::Unlimited

3760

1

));

3761

1

});

3762

1

3763

1

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

3764

1

	Statemine::execute_with(|| {

3765

1

		// Check Alice received 200 tokens on AssetHub

3766

1

		assert_eq!(

3767

1

			StatemineBalances::free_balance(RELAYALICE),

3768

1

			INITIAL_BALANCE + 200

3769

1

);

3770

3771

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3772

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3773

1

			sov,

3774

1

			110000000000000

3775

1

));

3776

3777

1

		statemine_like::PrefixChanger::set_prefix(

3778

1

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

3779

1

);

3780

1

3781

1

		assert_ok!(StatemineAssets::create(

3782

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3783

1

10,

3784

1

			RELAYALICE,

3785

1

3786

1

));

3787

3788

1

		assert_ok!(StatemineAssets::mint(

3789

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3790

1

10,

3791

1

			RELAYALICE,

3792

1

			300000000000000

3793

1

));

3794

3795

		// Now send relay tokens to ParaA

3796

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3797

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3798

1

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

3799

1

			Box::new(

3800

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3801

1

					.clone()

3802

1

					.into()

3803

1

),

3804

1

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

3805

1

0,

3806

1

			WeightLimit::Unlimited

3807

1

));

3808

3809

		// Send USDC

3810

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3811

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3812

1

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

3813

1

			Box::new(

3814

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3815

1

					.clone()

3816

1

					.into()

3817

1

),

3818

1

			Box::new(

3819

1

3820

1

3821

1

						xcm::latest::prelude::PalletInstance(

3822

1

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

3823

1

),

3824

1

						GeneralIndex(10),

3825

1

],

3826

1

3827

1

3828

1

					.into()

3829

1

),

3830

1

0,

3831

1

			WeightLimit::Unlimited

3832

1

));

3833

1

});

3834

1

3835

1

	ParaA::execute_with(|| {

3836

1

		// Alice should have received the DOTs

3837

1

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

3838

3839

		// Alice has received 125 USDC

3840

1

		assert_eq!(

3841

1

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

3842

1

3843

1

);

3844

1

});

3845

1

3846

1

	let dest = Location::new(

3847

1

1,

3848

1

3849

1

			Parachain(1000),

3850

1

			AccountId32 {

3851

1

				network: None,

3852

1

				id: RELAYBOB.into(),

3853

1

},

3854

1

],

3855

1

);

3856

1

3857

1

	let statemine_asset_to_send = Asset {

3858

1

		id: AssetId(statemine_asset),

3859

1

		fun: Fungibility::Fungible(100),

3860

1

};

3861

1

3862

1

	let relay_asset_to_send = Asset {

3863

1

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

3864

1

		fun: Fungibility::Fungible(100),

3865

1

};

3866

1

3867

1

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

3868

1

	let assets_to_send: XcmAssets =

3869

1

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

3870

1

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

3871

1

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

3872

1

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

3873

3874

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

3875

1

	ParaA::execute_with(|| {

3876

1

		assert_ok!(PolkadotXcm::transfer_assets(

3877

1

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

3878

1

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

3879

1

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

3880

1

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

3881

1

0,

3882

1

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

3883

1

));

3884

3885

1

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

3886

1

});

3887

1

3888

1

	Statemine::execute_with(|| {

3889

1

		// Check that Bob received relay tokens back in AssetHub

3890

1

		// (100 - MinXcmFee)

3891

1

		assert_eq!(

3892

1

			StatemineBalances::free_balance(RELAYBOB),

3893

1

			INITIAL_BALANCE + 100

3894

1

);

3895

3896

		// Check that BOB received 100 USDC on AssetHub

3897

1

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

3898

1

});

3899

1

3900

1

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

3901

1

	Statemine::execute_with(|| {

3902

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

3903

1

3904

1

		// Now send those tokens to ParaA

3905

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3906

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3907

1

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

3908

1

			Box::new(

3909

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3910

1

					.clone()

3911

1

					.into()

3912

1

),

3913

1

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

3914

1

0,

3915

1

			WeightLimit::Unlimited

3916

1

));

3917

3918

		// 100 DOTs were deducted from Bob's account

3919

1

		assert_eq!(

3920

1

			StatemineBalances::free_balance(RELAYBOB),

3921

1

			bob_previous_balance - 100

3922

1

);

3923

1

});

3924

1

3925

1

	ParaA::execute_with(|| {

3926

1

		// Alice should have received 100 DOTs

3927

1

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

3928

1

});

3929

1

3930

3931

#[test]

3932

1

fn transact_through_signed_multilocation() {

3933

1

	MockNet::reset();

3934

1

	let mut ancestry = Location::parent();

3935

1

3936

1

	ParaA::execute_with(|| {

3937

1

		// Root can set transact info

3938

1

		assert_ok!(XcmTransactor::set_transact_info(

3939

1

			parachain::RuntimeOrigin::root(),

3940

1

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

3941

1

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

3942

1

			3000.into(),

3943

1

			20000000000.into(),

3944

1

			// 4 instructions in transact through signed

3945

1

			Some(4000.into())

3946

1

));

3947

		// Root can set transact info

3948

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3949

1

			parachain::RuntimeOrigin::root(),

3950

1

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

3951

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3952

1

));

3953

1

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

3954

1

});

3955

1

3956

1

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

3957

1

	let signed_origin: Junctions = [AccountKey20 {

3958

1

		network: None,

3959

1

		key: PARAALICE,

3960

1

}]

3961

1

	.into();

3962

1

3963

1

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

3964

1

	descend_origin_multilocation

3965

1

		.append_with(signed_origin)

3966

1

		.unwrap();

3967

1

3968

1

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

3969

1

	descend_origin_multilocation

3970

1

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

3971

1

		.unwrap();

3972

1

3973

1

	let derived = xcm_builder::Account32Hash::<

3974

1

		relay_chain::KusamaNetwork,

3975

1

		relay_chain::AccountId,

3976

1

	>::convert_location(&descend_origin_multilocation)

3977

1

	.unwrap();

3978

1

3979

1

	Relay::execute_with(|| {

3980

1

		// free execution, full amount received

3981

1

		assert_ok!(RelayBalances::transfer_allow_death(

3982

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3983

1

			derived.clone(),

3984

1

			4000004100u128,

3985

1

));

3986

		// derived account has all funds

3987

1

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

3988

		// sovereign account has 0 funds

3989

1

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

3990

1

});

3991

1

3992

1

	// Encode the call. Balances transact to para_a_account

3993

1

	// First index

3994

1

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

3995

1

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

3996

1

		relay_chain::Balances,

3997

1

>()

3998

1

	.unwrap() as u8;

3999

1

4000

1

	encoded.push(index);

4001

1

4002

1

	// Then call bytes

4003

1

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

4004

1

		// 100 to sovereign

4005

1

		dest: para_a_account(),

4006

1

		value: 100u32.into(),

4007

1

4008

1

	.encode();

4009

1

	encoded.append(&mut call_bytes);

4010

1

4011

1

	ParaA::execute_with(|| {

4012

1

		assert_ok!(XcmTransactor::transact_through_signed(

4013

1

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

4014

1

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

4015

1

			CurrencyPayment {

4016

1

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

4017

1

					Location::parent()

4018

1

				))),

4019

1

				fee_amount: None

4020

1

},

4021

1

			encoded,

4022

1

			// 4000000000 for transfer + 4000 for XCM

4023

1

			// 1-1 to fee

4024

1

			TransactWeights {

4025

1

				transact_required_weight_at_most: 4000000000.into(),

4026

1

				overall_weight: None

4027

1

},

4028

1

			false

4029

1

));

4030

1

});

4031

1

4032

1

	Relay::execute_with(|| {

4033

1

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

4034

4035

1

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

4036

1

});

4037

1

4038

4039

#[test]

4040

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4041

1

	MockNet::reset();

4042

1

	let mut ancestry = Location::parent();

4043

1

4044

1

	ParaA::execute_with(|| {

4045

1

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

4046

1

});

4047

1

4048

1

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

4049

1

	let signed_origin: Junctions = [AccountKey20 {

4050

1

		network: None,

4051

1

		key: PARAALICE,

4052

1

}]

4053

1

	.into();

4054

1

4055

1

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

4056

1

	descend_origin_multilocation

4057

1

		.append_with(signed_origin)

4058

1

		.unwrap();

4059

1

4060

1

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

4061

1

	descend_origin_multilocation

4062

1

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

4063

1

		.unwrap();

4064

1

4065

1

	let derived = xcm_builder::Account32Hash::<

4066

1

		relay_chain::KusamaNetwork,

4067

1

		relay_chain::AccountId,

4068

1

	>::convert_location(&descend_origin_multilocation)

4069

1

	.unwrap();

4070

1

4071

1

	Relay::execute_with(|| {

4072

1

		// free execution, full amount received

4073

1

		assert_ok!(RelayBalances::transfer_allow_death(

4074

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4075

1

			derived.clone(),

4076

1

			4000004100u128,

4077

1

));

4078

		// derived account has all funds

4079

1

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

4080

		// sovereign account has 0 funds

4081

1

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

4082

1

});

4083

1

4084

1

	// Encode the call. Balances transact to para_a_account

4085

1

	// First index

4086

1

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

4087

1

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

4088

1

		relay_chain::Balances,

4089

1

>()

4090

1

	.unwrap() as u8;

4091

1

4092

1

	encoded.push(index);

4093

1

4094

1

	// Then call bytes

4095

1

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

4096

1

		// 100 to sovereign

4097

1

		dest: para_a_account(),

4098

1

		value: 100u32.into(),

4099

1

4100

1

	.encode();

4101

1

	encoded.append(&mut call_bytes);

4102

1

4103

1

	let total_weight = 4000004000u64;

4104

1

	ParaA::execute_with(|| {

4105

1

		assert_ok!(XcmTransactor::transact_through_signed(

4106

1

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

4107

1

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

4108

1

			CurrencyPayment {

4109

1

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

4110

1

					Location::parent()

4111

1

				))),

4112

1

				fee_amount: Some(total_weight as u128)

4113

1

},

4114

1

			encoded,

4115

1

			// 4000000000 for transfer + 4000 for XCM

4116

1

			TransactWeights {

4117

1

				transact_required_weight_at_most: 4000000000.into(),

4118

1

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

4119

1

},

4120

1

			false

4121

1

));

4122

1

});

4123

1

4124

1

	Relay::execute_with(|| {

4125

1

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

4126

4127

1

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

4128

1

});

4129

1

4130

4131

#[test]

4132

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4133

1

	MockNet::reset();

4134

1

	let mut ancestry = Location::parent();

4135

1

4136

1

	ParaA::execute_with(|| {

4137

1

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

4138

1

});

4139

1

4140

1

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

4141

1

	let signed_origin: Junctions = [AccountKey20 {

4142

1

		network: None,

4143

1

		key: PARAALICE,

4144

1

}]

4145

1

	.into();

4146

1

4147

1

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

4148

1

	descend_origin_multilocation

4149

1

		.append_with(signed_origin)

4150

1

		.unwrap();

4151

1

4152

1

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

4153

1

	descend_origin_multilocation

4154

1

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

4155

1

		.unwrap();

4156

1

4157

1

	let derived = xcm_builder::Account32Hash::<

4158

1

		relay_chain::KusamaNetwork,

4159

1

		relay_chain::AccountId,

4160

1

	>::convert_location(&descend_origin_multilocation)

4161

1

	.unwrap();

4162

1

4163

1

	Relay::execute_with(|| {

4164

1

		// free execution, full amount received

4165

1

		assert_ok!(RelayBalances::transfer_allow_death(

4166

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4167

1

			derived.clone(),

4168

1

			4000009100u128,

4169

1

));

4170

		// derived account has all funds

4171

1

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

4172

		// sovereign account has 0 funds

4173

1

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

4174

1

});

4175

1

4176

1

	// Encode the call. Balances transact to para_a_account

4177

1

	// First index

4178

1

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

4179

1

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

4180

1

		relay_chain::Balances,

4181

1

>()

4182

1

	.unwrap() as u8;

4183

1

4184

1

	encoded.push(index);

4185

1

4186

1

	// Then call bytes

4187

1

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

4188

1

		// 100 to sovereign

4189

1

		dest: para_a_account(),

4190

1

		value: 100u32.into(),

4191

1

4192

1

	.encode();

4193

1

	encoded.append(&mut call_bytes);

4194

1

4195

1

	let total_weight = 4000009000u64;

4196

1

	ParaA::execute_with(|| {

4197

1

		assert_ok!(XcmTransactor::transact_through_signed(

4198

1

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

4199

1

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

4200

1

			CurrencyPayment {

4201

1

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

4202

1

					Location::parent()

4203

1

				))),

4204

1

				fee_amount: Some(total_weight as u128)

4205

1

},

4206

1

			encoded,

4207

1

			// 4000000000 for transfer + 9000 for XCM

4208

1

			TransactWeights {

4209

1

				transact_required_weight_at_most: 4000000000.into(),

4210

1

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

4211

1

},

4212

1

			true

4213

1

));

4214

1

});

4215

1

4216

1

	Relay::execute_with(|| {

4217

1

		// 100 transferred

4218

1

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

4219

4220

		// 4000009000 refunded

4221

1

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

4222

1

});

4223

1

4224

4225

#[test]

4226

1

fn transact_through_signed_multilocation_para_to_para() {

4227

1

	MockNet::reset();

4228

1

	let mut ancestry = Location::parent();

4229

1

4230

1

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

4231

1

4232

1

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

4233

1

4234

1

	ParaA::execute_with(|| {

4235

1

		// Root can set transact info

4236

1

		assert_ok!(XcmTransactor::set_transact_info(

4237

1

			parachain::RuntimeOrigin::root(),

4238

1

			// ParaB

4239

1

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

4240

1

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

4241

1

			3.into(),

4242

1

			20000000000.into(),

4243

1

			// 4 instructions in transact through signed

4244

1

			Some(4.into())

4245

1

));

4246

		// Root can set transact info

4247

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4248

1

			parachain::RuntimeOrigin::root(),

4249

1

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

4250

1

			parachain::ParaTokensPerSecond::get(),

4251

1

));

4252

1

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

4253

1

});

4254

1

4255

1

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

4256

1

	let signed_origin: Junctions = [AccountKey20 {

4257

1

		network: None,

4258

1

		key: PARAALICE,

4259

1

}]

4260

1

	.into();

4261

1

4262

1

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

4263

1

	descend_origin_location.append_with(signed_origin).unwrap();

4264

1

4265

1

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

4266

1

	descend_origin_location

4267

1

		.reanchor(&para_b_location, &ancestry.interior)

4268

1

		.unwrap();

4269

1

4270

1

	let derived = xcm_builder::HashedDescription::<

4271

1

		parachain::AccountId,

4272

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4273

1

	>::convert_location(&descend_origin_location)

4274

1

	.unwrap();

4275

1

4276

1

	ParaB::execute_with(|| {

4277

1

		// free execution, full amount received

4278

1

		assert_ok!(ParaBalances::transfer_allow_death(

4279

1

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

4280

1

			derived.clone(),

4281

1

			4000000104u128,

4282

1

));

4283

		// derived account has all funds

4284

1

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

4285

		// sovereign account has 0 funds

4286

1

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

4287

1

});

4288

1

4289

1

	// Encode the call. Balances transact to para_a_account

4290

1

	// First index

4291

1

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

4292

1

	let index =

4293

1

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

4294

1

			.unwrap() as u8;

4295

1

4296

1

	encoded.push(index);

4297

1

4298

1

	// Then call bytes

4299

1

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

4300

1

		// 100 to sovereign

4301

1

		dest: para_a_account_20(),

4302

1

		value: 100u32.into(),

4303

1

4304

1

	.encode();

4305

1

	encoded.append(&mut call_bytes);

4306

1

4307

1

	ParaA::execute_with(|| {

4308

1

		assert_ok!(XcmTransactor::transact_through_signed(

4309

1

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

4310

1

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

4311

1

			CurrencyPayment {

4312

1

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

4313

1

					para_b_balances

4314

1

				))),

4315

1

				fee_amount: None

4316

1

},

4317

1

			encoded,

4318

1

			// 4000000000 for transfer + 4000 for XCM

4319

1

			// 1-1 to fee

4320

1

			TransactWeights {

4321

1

				transact_required_weight_at_most: 4000000000.into(),

4322

1

				overall_weight: None

4323

1

},

4324

1

			false

4325

1

));

4326

1

});

4327

1

4328

1

	ParaB::execute_with(|| {

4329

1

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

4330

4331

1

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

4332

1

});

4333

1

4334

4335

#[test]

4336

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4337

1

	MockNet::reset();

4338

1

	let mut ancestry = Location::parent();

4339

1

4340

1

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

4341

1

4342

1

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

4343

1

4344

1

	ParaA::execute_with(|| {

4345

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4346

1

			parachain::RuntimeOrigin::root(),

4347

1

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

4348

1

			parachain::ParaTokensPerSecond::get(),

4349

1

));

4350

1

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

4351

1

});

4352

1

4353

1

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

4354

1

	let signed_origin: Junctions = [AccountKey20 {

4355

1

		network: None,

4356

1

		key: PARAALICE,

4357

1

}]

4358

1

	.into();

4359

1

4360

1

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

4361

1

	descend_origin_location.append_with(signed_origin).unwrap();

4362

1

4363

1

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

4364

1

	descend_origin_location

4365

1

		.reanchor(&para_b_location, &ancestry.interior)

4366

1

		.unwrap();

4367

1

4368

1

	let derived = xcm_builder::HashedDescription::<

4369

1

		parachain::AccountId,

4370

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4371

1

	>::convert_location(&descend_origin_location)

4372

1

	.unwrap();

4373

1

4374

1

	ParaB::execute_with(|| {

4375

1

		// free execution, full amount received

4376

1

		assert_ok!(ParaBalances::transfer_allow_death(

4377

1

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

4378

1

			derived.clone(),

4379

1

			4000009100u128,

4380

1

));

4381

		// derived account has all funds

4382

1

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

4383

		// sovereign account has 0 funds

4384

1

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

4385

1

});

4386

1

4387

1

	// Encode the call. Balances transact to para_a_account

4388

1

	// First index

4389

1

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

4390

1

	let index =

4391

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4392

1

			.unwrap() as u8;

4393

1

4394

1

	encoded.push(index);

4395

1

4396

1

	// Then call bytes

4397

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4398

1

		// 100 to sovereign

4399

1

		dest: para_a_account_20(),

4400

1

		value: 100u32.into(),

4401

1

4402

1

	.encode();

4403

1

	encoded.append(&mut call_bytes);

4404

1

4405

1

	let overall_weight = 4000009000u64;

4406

1

	ParaA::execute_with(|| {

4407

1

		assert_ok!(XcmTransactor::transact_through_signed(

4408

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4409

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4410

1

			CurrencyPayment {

4411

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4412

1

					para_b_balances

4413

1

				))),

4414

1

				fee_amount: Some(overall_weight as u128)

4415

1

},

4416

1

			encoded,

4417

1

			// 4000000000 for transfer + 9000 for XCM

4418

1

			TransactWeights {

4419

1

				transact_required_weight_at_most: 4000000000.into(),

4420

1

				overall_weight: Some(Limited(overall_weight.into()))

4421

1

},

4422

1

			true

4423

1

));

4424

1

});

4425

1

4426

1

	ParaB::execute_with(|| {

4427

1

		// Check the derived account was refunded

4428

1

		assert_eq!(ParaBalances::free_balance(&derived), 3823903993);

4429

4430

		// Check the transfer was executed

4431

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4432

1

});

4433

1

4434

4435

#[test]

4436

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4437

1

	MockNet::reset();

4438

1

	let mut ancestry = Location::parent();

4439

1

4440

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4441

1

4442

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4443

1

4444

1

	ParaA::execute_with(|| {

4445

1

		// Root can set transact info

4446

1

		assert_ok!(XcmTransactor::set_transact_info(

4447

1

			parachain::RuntimeOrigin::root(),

4448

1

			// ParaB

4449

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4450

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4451

1

			3.into(),

4452

1

			20000000000.into(),

4453

1

			// 4 instructions in transact through signed

4454

1

			Some(4.into())

4455

1

));

4456

		// Root can set transact info

4457

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4458

1

			parachain::RuntimeOrigin::root(),

4459

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4460

1

			parachain::ParaTokensPerSecond::get(),

4461

1

));

4462

1

		ancestry = parachain::UniversalLocation::get().into();

4463

1

});

4464

1

4465

1

	// Let's construct the Junction that we will append with DescendOrigin

4466

1

	let signed_origin: Junctions = [AccountKey20 {

4467

1

		network: None,

4468

1

		key: PARAALICE,

4469

1

}]

4470

1

	.into();

4471

1

4472

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4473

1

	descend_origin_location.append_with(signed_origin).unwrap();

4474

1

4475

1

	// To convert it to what the paraB will see instead of us

4476

1

	descend_origin_location

4477

1

		.reanchor(&para_b_location, &ancestry.interior)

4478

1

		.unwrap();

4479

1

4480

1

	let derived = xcm_builder::HashedDescription::<

4481

1

		parachain::AccountId,

4482

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4483

1

	>::convert_location(&descend_origin_location)

4484

1

	.unwrap();

4485

1

4486

1

	let mut parachain_b_alice_balances_before = 0;

4487

1

	ParaB::execute_with(|| {

4488

1

		assert_ok!(ParaBalances::transfer_allow_death(

4489

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4490

1

			derived.clone(),

4491

1

			4000000104u128,

4492

1

));

4493

		// derived account has all funds

4494

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4495

		// sovereign account has 0 funds

4496

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4497

4498

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4499

1

});

4500

1

4501

1

	// Encode the call. Balances transact to para_a_account

4502

1

	// First index

4503

1

	let mut encoded: Vec<u8> = Vec::new();

4504

1

	let index =

4505

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4506

1

			.unwrap() as u8;

4507

1

4508

1

	encoded.push(index);

4509

4510

	use sp_core::U256;

4511

	// Let's do a EVM transfer

4512

1

	let eth_tx =

4513

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4514

1

			gas_limit: U256::from(21000),

4515

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4516

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4517

1

			value: U256::from(100),

4518

1

			input: BoundedVec::<

4519

1

u8,

4520

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4521

1

			>::try_from(vec![]).unwrap(),

4522

1

			access_list: None,

4523

1

});

4524

1

4525

1

	// Then call bytes

4526

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4527

1

		xcm_transaction: eth_tx,

4528

1

4529

1

	.encode();

4530

1

	encoded.append(&mut call_bytes);

4531

1

4532

1

	ParaA::execute_with(|| {

4533

1

		assert_ok!(XcmTransactor::transact_through_signed(

4534

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4535

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4536

1

			CurrencyPayment {

4537

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4538

1

					para_b_balances

4539

1

				))),

4540

1

				fee_amount: None

4541

1

},

4542

1

			encoded,

4543

1

			// 4000000000 for transfer + 4000 for XCM

4544

1

			// 1-1 to fee

4545

1

			TransactWeights {

4546

1

				transact_required_weight_at_most: 4000000000.into(),

4547

1

				overall_weight: None

4548

1

},

4549

1

			false

4550

1

));

4551

1

});

4552

1

4553

1

	ParaB::execute_with(|| {

4554

1

		// Make sure the EVM transfer went through

4555

1

		assert!(

4556

1

			ParaBalances::free_balance(&PARAALICE.into())

4557

1

				== parachain_b_alice_balances_before + 100

4558

1

);

4559

1

});

4560

1

4561

4562

#[test]

4563

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4564

1

	MockNet::reset();

4565

1

	let mut ancestry = Location::parent();

4566

1

4567

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4568

1

4569

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4570

1

4571

1

	ParaA::execute_with(|| {

4572

1

		// Root can set transact info

4573

1

		assert_ok!(XcmTransactor::set_transact_info(

4574

1

			parachain::RuntimeOrigin::root(),

4575

1

			// ParaB

4576

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4577

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4578

1

			3.into(),

4579

1

			20000000000.into(),

4580

1

			// 4 instructions in transact through signed

4581

1

			Some(4.into())

4582

1

));

4583

		// Root can set transact info

4584

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4585

1

			parachain::RuntimeOrigin::root(),

4586

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4587

1

			parachain::ParaTokensPerSecond::get(),

4588

1

));

4589

1

		ancestry = parachain::UniversalLocation::get().into();

4590

1

});

4591

1

4592

1

	// Let's construct the Junction that we will append with DescendOrigin

4593

1

	let signed_origin: Junctions = [AccountKey20 {

4594

1

		network: None,

4595

1

		key: PARAALICE,

4596

1

}]

4597

1

	.into();

4598

1

4599

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4600

1

	descend_origin_location.append_with(signed_origin).unwrap();

4601

1

4602

1

	// To convert it to what the paraB will see instead of us

4603

1

	descend_origin_location

4604

1

		.reanchor(&para_b_location, &ancestry.interior)

4605

1

		.unwrap();

4606

1

4607

1

	let derived = xcm_builder::HashedDescription::<

4608

1

		parachain::AccountId,

4609

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4610

1

	>::convert_location(&descend_origin_location)

4611

1

	.unwrap();

4612

1

4613

1

	let mut parachain_b_alice_balances_before = 0;

4614

1

	ParaB::execute_with(|| {

4615

1

		assert_ok!(ParaBalances::transfer_allow_death(

4616

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4617

1

			derived.clone(),

4618

1

			4000000104u128,

4619

1

));

4620

		// derived account has all funds

4621

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4622

		// sovereign account has 0 funds

4623

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4624

4625

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4626

1

});

4627

1

4628

1

	// Encode the call. Balances transact to para_a_account

4629

1

	// First index

4630

1

	let mut encoded: Vec<u8> = Vec::new();

4631

1

	let index =

4632

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4633

1

			.unwrap() as u8;

4634

1

4635

1

	encoded.push(index);

4636

4637

	use sp_core::U256;

4638

	// Let's do a EVM transfer

4639

1

	let eth_tx =

4640

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4641

1

			gas_limit: U256::from(21000),

4642

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4643

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4644

1

			value: U256::from(100),

4645

1

			input: BoundedVec::<

4646

1

u8,

4647

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4648

1

			>::try_from(vec![]).unwrap(),

4649

1

			access_list: None,

4650

1

});

4651

1

4652

1

	// Then call bytes

4653

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4654

1

		transact_as: PARAALICE.into(),

4655

1

		xcm_transaction: eth_tx,

4656

1

4657

1

	.encode();

4658

1

	encoded.append(&mut call_bytes);

4659

1

4660

1

	ParaA::execute_with(|| {

4661

1

		assert_ok!(XcmTransactor::transact_through_signed(

4662

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4663

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4664

1

			CurrencyPayment {

4665

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4666

1

					para_b_balances

4667

1

				))),

4668

1

				fee_amount: None

4669

1

},

4670

1

			encoded,

4671

1

			TransactWeights {

4672

1

				transact_required_weight_at_most: 4000000000.into(),

4673

1

				overall_weight: None

4674

1

},

4675

1

			false

4676

1

));

4677

1

});

4678

1

4679

1

	ParaB::execute_with(|| {

4680

1

		// Make sure the EVM transfer wasn't executed

4681

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4682

1

});

4683

1

4684

4685

#[test]

4686

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4687

1

	MockNet::reset();

4688

1

	let mut ancestry = Location::parent();

4689

1

4690

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4691

1

4692

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4693

1

4694

1

	ParaA::execute_with(|| {

4695

1

		// Root can set transact info

4696

1

		assert_ok!(XcmTransactor::set_transact_info(

4697

1

			parachain::RuntimeOrigin::root(),

4698

1

			// ParaB

4699

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4700

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4701

1

			3.into(),

4702

1

			20000000000.into(),

4703

1

			// 4 instructions in transact through signed

4704

1

			Some(4.into())

4705

1

));

4706

		// Root can set transact info

4707

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4708

1

			parachain::RuntimeOrigin::root(),

4709

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4710

1

			parachain::ParaTokensPerSecond::get(),

4711

1

));

4712

1

		ancestry = parachain::UniversalLocation::get().into();

4713

1

});

4714

1

4715

1

	// Let's construct the Junction that we will append with DescendOrigin

4716

1

	let signed_origin: Junctions = [AccountKey20 {

4717

1

		network: None,

4718

1

		key: PARAALICE,

4719

1

}]

4720

1

	.into();

4721

1

4722

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4723

1

	descend_origin_location.append_with(signed_origin).unwrap();

4724

1

4725

1

	// To convert it to what the paraB will see instead of us

4726

1

	descend_origin_location

4727

1

		.reanchor(&para_b_location, &ancestry.interior)

4728

1

		.unwrap();

4729

1

4730

1

	let derived = xcm_builder::HashedDescription::<

4731

1

		parachain::AccountId,

4732

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4733

1

	>::convert_location(&descend_origin_location)

4734

1

	.unwrap();

4735

1

4736

1

	let transfer_recipient = evm_account();

4737

1

	let mut transfer_recipient_balance_before = 0;

4738

1

	ParaB::execute_with(|| {

4739

1

		assert_ok!(ParaBalances::transfer_allow_death(

4740

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4741

1

			derived.clone(),

4742

1

			4000000104u128,

4743

1

));

4744

		// derived account has all funds

4745

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4746

		// sovereign account has 0 funds

4747

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4748

4749

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

4750

1

4751

1

		// Add proxy ALICE  -> derived

4752

1

		let _ = parachain::Proxy::add_proxy_delegate(

4753

1

			&PARAALICE.into(),

4754

1

			derived,

4755

1

			parachain::ProxyType::Any,

4756

1

0,

4757

1

);

4758

1

});

4759

1

4760

1

	// Encode the call. Balances transact to para_a_account

4761

1

	// First index

4762

1

	let mut encoded: Vec<u8> = Vec::new();

4763

1

	let index =

4764

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4765

1

			.unwrap() as u8;

4766

1

4767

1

	encoded.push(index);

4768

4769

	use sp_core::U256;

4770

	// Let's do a EVM transfer

4771

1

	let eth_tx =

4772

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4773

1

			gas_limit: U256::from(21000),

4774

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

4775

1

			value: U256::from(100),

4776

1

			input: BoundedVec::<

4777

1

u8,

4778

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4779

1

			>::try_from(vec![]).unwrap(),

4780

1

			access_list: None,

4781

1

});

4782

1

4783

1

	// Then call bytes

4784

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4785

1

		transact_as: PARAALICE.into(),

4786

1

		xcm_transaction: eth_tx,

4787

1

4788

1

	.encode();

4789

1

	encoded.append(&mut call_bytes);

4790

1

4791

1

	ParaA::execute_with(|| {

4792

1

		assert_ok!(XcmTransactor::transact_through_signed(

4793

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4794

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4795

1

			CurrencyPayment {

4796

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4797

1

					para_b_balances

4798

1

				))),

4799

1

				fee_amount: None

4800

1

},

4801

1

			encoded,

4802

1

			TransactWeights {

4803

1

				transact_required_weight_at_most: 4000000000.into(),

4804

1

				overall_weight: None

4805

1

},

4806

1

			false

4807

1

));

4808

1

});

4809

1

4810

1

	ParaB::execute_with(|| {

4811

1

		// Make sure the EVM transfer was executed

4812

1

		assert!(

4813

1

			ParaBalances::free_balance(&transfer_recipient.into())

4814

1

				== transfer_recipient_balance_before + 100

4815

1

);

4816

1

});

4817

1

4818

4819

#[test]

4820

1

fn hrmp_init_accept_through_root() {

4821

1

	MockNet::reset();

4822

1

4823

1

	Relay::execute_with(|| {

4824

1

		assert_ok!(RelayBalances::transfer_allow_death(

4825

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4826

1

			para_a_account(),

4827

1

			1000u128

4828

1

));

4829

1

		assert_ok!(RelayBalances::transfer_allow_death(

4830

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4831

1

			para_b_account(),

4832

1

			1000u128

4833

1

));

4834

1

});

4835

1

4836

1

	ParaA::execute_with(|| {

4837

1

		let total_fee = 1_000u128;

4838

1

		let total_weight: u64 = 1_000_000_000;

4839

1

		let tx_weight: u64 = 500_000_000;

4840

1

		// Root can send hrmp init channel

4841

1

		assert_ok!(XcmTransactor::hrmp_manage(

4842

1

			parachain::RuntimeOrigin::root(),

4843

1

			HrmpOperation::InitOpen(HrmpInitParams {

4844

1

				para_id: 2u32.into(),

4845

1

				proposed_max_capacity: 1,

4846

1

				proposed_max_message_size: 1

4847

1

}),

4848

1

			CurrencyPayment {

4849

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4850

1

					Location::parent()

4851

1

				))),

4852

1

				fee_amount: Some(total_fee)

4853

1

},

4854

1

			TransactWeights {

4855

1

				transact_required_weight_at_most: tx_weight.into(),

4856

1

				overall_weight: Some(Limited(total_weight.into()))

4857

1

4858

1

));

4859

1

});

4860

1

	Relay::execute_with(|| {

4861

1

		let expected_event: relay_chain::RuntimeEvent =

4862

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4863

1

				sender: 1u32.into(),

4864

1

				recipient: 2u32.into(),

4865

1

				proposed_max_capacity: 1u32,

4866

1

				proposed_max_message_size: 1u32,

4867

1

4868

1

			.into();

4869

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4870

1

});

4871

1

	ParaB::execute_with(|| {

4872

1

		let total_fee = 1_000u128;

4873

1

		let total_weight: u64 = 1_000_000_000;

4874

1

		let tx_weight: u64 = 500_000_000;

4875

1

		// Root can send hrmp accept channel

4876

1

		assert_ok!(XcmTransactor::hrmp_manage(

4877

1

			parachain::RuntimeOrigin::root(),

4878

1

			HrmpOperation::Accept {

4879

1

				para_id: 1u32.into()

4880

1

},

4881

1

			CurrencyPayment {

4882

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4883

1

					Location::parent()

4884

1

				))),

4885

1

				fee_amount: Some(total_fee)

4886

1

},

4887

1

			TransactWeights {

4888

1

				transact_required_weight_at_most: tx_weight.into(),

4889

1

				overall_weight: Some(Limited(total_weight.into()))

4890

1

4891

1

));

4892

1

});

4893

1

4894

1

	Relay::execute_with(|| {

4895

1

		let expected_event: relay_chain::RuntimeEvent =

4896

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4897

1

				sender: 1u32.into(),

4898

1

				recipient: 2u32.into(),

4899

1

4900

1

			.into();

4901

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4902

1

});

4903

1

4904

4905

#[test]

4906

1

fn hrmp_close_works() {

4907

1

	MockNet::reset();

4908

1

4909

1

	Relay::execute_with(|| {

4910

1

		assert_ok!(RelayBalances::transfer_allow_death(

4911

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4912

1

			para_a_account(),

4913

1

			1000u128

4914

1

));

4915

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4916

1

			relay_chain::RuntimeOrigin::root(),

4917

1

			1u32.into(),

4918

1

			2u32.into(),

4919

1

			1u32,

4920

1

			1u32

4921

1

));

4922

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4923

1

			relay_chain::RuntimeOrigin::root(),

4924

1

			1u32

4925

1

));

4926

1

});

4927

1

4928

1

	ParaA::execute_with(|| {

4929

1

		let total_fee = 1_000u128;

4930

1

		let total_weight: u64 = 1_000_000_000;

4931

1

		let tx_weight: u64 = 500_000_000;

4932

1

		// Root can send hrmp close

4933

1

		assert_ok!(XcmTransactor::hrmp_manage(

4934

1

			parachain::RuntimeOrigin::root(),

4935

1

			HrmpOperation::Close(HrmpChannelId {

4936

1

				sender: 1u32.into(),

4937

1

				recipient: 2u32.into()

4938

1

}),

4939

1

			CurrencyPayment {

4940

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4941

1

					Location::parent()

4942

1

				))),

4943

1

				fee_amount: Some(total_fee)

4944

1

},

4945

1

			TransactWeights {

4946

1

				transact_required_weight_at_most: tx_weight.into(),

4947

1

				overall_weight: Some(Limited(total_weight.into()))

4948

1

4949

1

));

4950

1

});

4951

1

	Relay::execute_with(|| {

4952

1

		let expected_event: relay_chain::RuntimeEvent =

4953

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4954

1

				by_parachain: 1u32.into(),

4955

1

				channel_id: HrmpChannelId {

4956

1

					sender: 1u32.into(),

4957

1

					recipient: 2u32.into(),

4958

1

},

4959

1

4960

1

			.into();

4961

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4962

1

});

4963

1

4964

4965

use parity_scale_codec::{Decode, Encode};

4966

use sp_io::hashing::blake2_256;

4967

4968

// Helper to derive accountIds

4969

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4970

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4971

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4972

7