Grcov report - xcm

1

// Copyright 2019-2022 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonbase Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{ConstU32, PalletInfo, PalletInfoAccess},

23

	weights::constants::WEIGHT_REF_TIME_PER_SECOND,

24

	weights::Weight,

25

	BoundedVec,

26

};

27

use pallet_xcm_transactor::{

28

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

29

};

30

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

31

use sp_std::boxed::Box;

32

use xcm::{

33

	latest::prelude::{

34

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

35

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

36

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

37

		WeightLimit, WithdrawAsset, Xcm,

38

},

39

	VersionedAssets,

40

};

41

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

42

use xcm_executor::traits::ConvertLocation;

43

use xcm_mock::*;

44

use xcm_primitives::{

45

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

46

};

47

use xcm_simulator::TestExt;

48

mod common;

49

use cumulus_primitives_core::relay_chain::HrmpChannelId;

50

use parachain::PolkadotXcm;

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::V4(location_v4) = VersionedLocation::V3(location_v3)

55

28

		.into_version(4)

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_v4,

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

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

132

1

			Box::new(([], 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, 0));

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

184

1

			Box::new(([], 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

		// free execution, full amount received

215

1

		assert_ok!(PolkadotXcm::transfer_assets(

216

1

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

217

1

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

218

1

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

219

1

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

220

1

0,

221

1

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

222

1

));

223

1

});

224

1

225

1

	// The balances in paraAlice should have been substracted

226

1

	ParaA::execute_with(|| {

227

1

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

228

1

});

229

1

230

1

	// Balances in the relay should have been received

231

1

	Relay::execute_with(|| {

232

1

		// Free execution,x	 full amount received

233

1

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

234

1

});

235

1

236

237

#[test]

238

1

fn send_relay_asset_to_para_b() {

239

1

	MockNet::reset();

240

1

241

1

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

242

1

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

243

1

244

1

	let asset_metadata = parachain::AssetMetadata {

245

1

		name: b"RelayToken".to_vec(),

246

1

		symbol: b"Relay".to_vec(),

247

1

		decimals: 12,

248

1

};

249

1

250

1

	// Register asset in paraA. Free execution

251

1

	ParaA::execute_with(|| {

252

1

		assert_ok!(AssetManager::register_foreign_asset(

253

1

			parachain::RuntimeOrigin::root(),

254

1

			source_location.clone(),

255

1

			asset_metadata.clone(),

256

1

			1u128,

257

1

			true

258

1

));

259

1

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

260

1

});

261

1

262

1

	// Register asset in paraB. Free execution

263

1

	ParaB::execute_with(|| {

264

1

		assert_ok!(AssetManager::register_foreign_asset(

265

1

			parachain::RuntimeOrigin::root(),

266

1

			source_location.clone(),

267

1

			asset_metadata,

268

1

			1u128,

269

1

			true

270

1

));

271

1

		assert_ok!(add_supported_asset(source_location, 0));

272

1

});

273

1

274

1

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

275

1

	let dest: Location = Junction::AccountKey20 {

276

1

		network: None,

277

1

		key: PARAALICE,

278

1

279

1

	.into();

280

1

	Relay::execute_with(|| {

281

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

282

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

283

1

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

284

1

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

285

1

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

286

1

0,

287

1

			WeightLimit::Unlimited

288

1

));

289

1

});

290

1

291

1

	ParaA::execute_with(|| {

292

1

		// Free execution, full amount received

293

1

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

294

1

});

295

1

296

1

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

297

1

	let dest = Location {

298

1

		parents: 1,

299

1

		interior: [

300

1

			Parachain(2),

301

1

			AccountKey20 {

302

1

				network: None,

303

1

				key: PARAALICE.into(),

304

1

},

305

1

306

1

		.into(),

307

1

};

308

1

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

309

1

310

1

	ParaA::execute_with(|| {

311

1

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

312

1

		assert_ok!(PolkadotXcm::transfer_assets(

313

1

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

314

1

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

315

1

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

316

1

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

317

1

0,

318

1

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

319

1

));

320

1

});

321

1

322

1

	// Para A balances should have been substracted

323

1

	ParaA::execute_with(|| {

324

1

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

325

1

});

326

1

327

1

	// Para B balances should have been credited

328

1

	ParaB::execute_with(|| {

329

1

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

330

1

});

331

1

332

333

#[test]

334

1

fn send_para_a_asset_to_para_b() {

335

1

	MockNet::reset();

336

1

337

1

	// this represents the asset in paraA

338

1

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

339

1

	let source_location = parachain::AssetType::Xcm(

340

1

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

341

1

);

342

1

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

343

1

344

1

	let asset_metadata = parachain::AssetMetadata {

345

1

		name: b"ParaAToken".to_vec(),

346

1

		symbol: b"ParaA".to_vec(),

347

1

		decimals: 18,

348

1

};

349

1

350

1

	// Register asset in paraB. Free execution

351

1

	ParaB::execute_with(|| {

352

1

		assert_ok!(AssetManager::register_foreign_asset(

353

1

			parachain::RuntimeOrigin::root(),

354

1

			source_location.clone(),

355

1

			asset_metadata,

356

1

			1u128,

357

1

			true

358

1

));

359

1

		assert_ok!(add_supported_asset(source_location, 0));

360

1

});

361

1

362

1

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

363

1

	let dest = Location {

364

1

		parents: 1,

365

1

		interior: [

366

1

			Parachain(2),

367

1

			AccountKey20 {

368

1

				network: None,

369

1

				key: PARAALICE.into(),

370

1

},

371

1

372

1

		.into(),

373

1

};

374

1

375

1

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

376

1

377

1

	ParaA::execute_with(|| {

378

1

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

379

1

		// Free execution, full amount received

380

1

		assert_ok!(PolkadotXcm::transfer_assets(

381

1

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

382

1

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

383

1

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

384

1

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

385

1

0,

386

1

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

387

1

));

388

1

});

389

1

390

1

	// Native token is substracted in paraA

391

1

	ParaA::execute_with(|| {

392

1

		assert_eq!(

393

1

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

394

1

			INITIAL_BALANCE - 100

395

1

);

396

1

});

397

1

398

1

	// Asset is minted in paraB

399

1

	ParaB::execute_with(|| {

400

1

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

401

1

});

402

1

403

404

#[test]

405

1

fn send_para_a_asset_from_para_b_to_para_c() {

406

1

	MockNet::reset();

407

1

408

1

	// Represents para A asset

409

1

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

410

1

	let source_location = parachain::AssetType::Xcm(

411

1

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

412

1

);

413

1

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

414

1

415

1

	let asset_metadata = parachain::AssetMetadata {

416

1

		name: b"ParaAToken".to_vec(),

417

1

		symbol: b"ParaA".to_vec(),

418

1

		decimals: 18,

419

1

};

420

1

421

1

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

422

1

	ParaB::execute_with(|| {

423

1

		assert_ok!(AssetManager::register_foreign_asset(

424

1

			parachain::RuntimeOrigin::root(),

425

1

			source_location.clone(),

426

1

			asset_metadata.clone(),

427

1

			1u128,

428

1

			true

429

1

));

430

1

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

431

1

});

432

1

433

1

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

434

1

	ParaC::execute_with(|| {

435

1

		assert_ok!(AssetManager::register_foreign_asset(

436

1

			parachain::RuntimeOrigin::root(),

437

1

			source_location.clone(),

438

1

			asset_metadata,

439

1

			1u128,

440

1

			true

441

1

));

442

1

		assert_ok!(add_supported_asset(source_location, 0));

443

1

});

444

1

445

1

	// Send para A asset to para B

446

1

	let dest = Location {

447

1

		parents: 1,

448

1

		interior: [

449

1

			Parachain(2),

450

1

			AccountKey20 {

451

1

				network: None,

452

1

				key: PARAALICE.into(),

453

1

},

454

1

455

1

		.into(),

456

1

};

457

1

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

458

1

459

1

	ParaA::execute_with(|| {

460

1

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

461

1

		// free execution, full amount received

462

1

		assert_ok!(PolkadotXcm::transfer_assets(

463

1

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

464

1

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

465

1

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

466

1

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

467

1

0,

468

1

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

469

1

));

470

1

});

471

1

472

1

	// Para A balances have been substracted

473

1

	ParaA::execute_with(|| {

474

1

		assert_eq!(

475

1

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

476

1

			INITIAL_BALANCE - 100

477

1

);

478

1

});

479

1

480

1

	// Para B balances have been credited

481

1

	ParaB::execute_with(|| {

482

1

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

483

1

});

484

1

485

1

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

486

1

	let dest = Location {

487

1

		parents: 1,

488

1

		interior: [

489

1

			Parachain(3),

490

1

			AccountKey20 {

491

1

				network: None,

492

1

				key: PARAALICE.into(),

493

1

},

494

1

495

1

		.into(),

496

1

};

497

1

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

498

1

499

1

	ParaB::execute_with(|| {

500

1

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

501

1

		assert_ok!(PolkadotXcm::transfer_assets(

502

1

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

503

1

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

504

1

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

505

1

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

506

1

0,

507

1

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

508

1

));

509

1

});

510

1

511

1

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

512

1

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

513

1

	ParaC::execute_with(|| {

514

1

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

515

1

});

516

1

517

518

#[test]

519

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

520

1

	MockNet::reset();

521

1

522

1

	// Para A asset

523

1

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

524

1

	let source_location = parachain::AssetType::Xcm(

525

1

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

526

1

);

527

1

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

528

1

529

1

	let asset_metadata = parachain::AssetMetadata {

530

1

		name: b"ParaAToken".to_vec(),

531

1

		symbol: b"ParaA".to_vec(),

532

1

		decimals: 18,

533

1

};

534

1

535

1

	// Register para A asset in para B

536

1

	ParaB::execute_with(|| {

537

1

		assert_ok!(AssetManager::register_foreign_asset(

538

1

			parachain::RuntimeOrigin::root(),

539

1

			source_location.clone(),

540

1

			asset_metadata,

541

1

			1u128,

542

1

			true

543

1

));

544

1

		assert_ok!(add_supported_asset(source_location, 0));

545

1

});

546

1

547

1

	// Send para A asset to para B

548

1

	let dest = Location {

549

1

		parents: 1,

550

1

		interior: [

551

1

			Parachain(2),

552

1

			AccountKey20 {

553

1

				network: None,

554

1

				key: PARAALICE.into(),

555

1

},

556

1

557

1

		.into(),

558

1

};

559

1

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

560

1

561

1

	ParaA::execute_with(|| {

562

1

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

563

1

		assert_ok!(PolkadotXcm::transfer_assets(

564

1

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

565

1

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

566

1

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

567

1

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

568

1

0,

569

1

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

570

1

));

571

1

});

572

1

573

1

	// Balances have been substracted

574

1

	ParaA::execute_with(|| {

575

1

		assert_eq!(

576

1

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

577

1

			INITIAL_BALANCE - 100

578

1

);

579

1

});

580

1

581

1

	// Para B balances have been credited

582

1

	ParaB::execute_with(|| {

583

1

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

584

1

});

585

1

586

1

	// Send back para A asset to para A

587

1

	let dest = Location {

588

1

		parents: 1,

589

1

		interior: [

590

1

			Parachain(1),

591

1

			AccountKey20 {

592

1

				network: None,

593

1

				key: PARAALICE.into(),

594

1

},

595

1

596

1

		.into(),

597

1

};

598

1

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

599

1

600

1

	ParaB::execute_with(|| {

601

1

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

602

1

		assert_ok!(PolkadotXcm::transfer_assets(

603

1

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

604

1

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

605

1

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

606

1

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

607

1

0,

608

1

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

609

1

));

610

1

});

611

1

612

1

	ParaA::execute_with(|| {

613

1

		// Weight used is 4

614

1

		assert_eq!(

615

1

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

616

1

			INITIAL_BALANCE - 4

617

1

);

618

1

});

619

1

620

621

#[test]

622

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

623

1

	MockNet::reset();

624

1

625

1

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

626

1

	let source_location = parachain::AssetType::Xcm(

627

1

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

628

1

);

629

1

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

630

1

631

1

	let asset_metadata = parachain::AssetMetadata {

632

1

		name: b"ParaAToken".to_vec(),

633

1

		symbol: b"ParaA".to_vec(),

634

1

		decimals: 18,

635

1

};

636

1

637

1

	ParaB::execute_with(|| {

638

1

		assert_ok!(AssetManager::register_foreign_asset(

639

1

			parachain::RuntimeOrigin::root(),

640

1

			source_location.clone(),

641

1

			asset_metadata,

642

1

			1u128,

643

1

			true

644

1

));

645

1

		assert_ok!(add_supported_asset(source_location, 0));

646

1

});

647

1

648

1

	let dest = Location {

649

1

		parents: 1,

650

1

		interior: [

651

1

			Parachain(2),

652

1

			AccountKey20 {

653

1

				network: None,

654

1

				key: PARAALICE.into(),

655

1

},

656

1

657

1

		.into(),

658

1

};

659

1

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

660

1

661

1

	ParaA::execute_with(|| {

662

1

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

663

1

		assert_ok!(PolkadotXcm::transfer_assets(

664

1

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

665

1

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

666

1

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

667

1

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

668

1

0,

669

1

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

670

1

));

671

1

});

672

1

673

1

	// Para A asset has been credited

674

1

	ParaA::execute_with(|| {

675

1

		assert_eq!(

676

1

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

677

1

			INITIAL_BALANCE - 100

678

1

);

679

1

});

680

1

681

1

	ParaB::execute_with(|| {

682

1

		// free execution, full amount received

683

1

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

684

1

});

685

1

686

1

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

687

1

	// Message through polkadotXCM pallet

688

1

689

1

	let dest = Location {

690

1

		parents: 1,

691

1

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

692

1

};

693

1

694

1

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

695

1

696

1

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

697

1

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

698

1

		ClearOrigin,

699

1

		BuyExecution {

700

1

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

701

1

			weight_limit: Limited(80.into()),

702

1

},

703

1

		DepositAsset {

704

1

			assets: All.into(),

705

1

			beneficiary: Location::new(

706

1

0,

707

1

				[AccountKey20 {

708

1

					network: None,

709

1

					key: PARAALICE,

710

1

}],

711

1

),

712

1

},

713

1

	]));

714

1

	ParaB::execute_with(|| {

715

1

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

716

1

		// and deposit asset

717

1

		assert_ok!(ParachainPalletXcm::send(

718

1

			parachain::RuntimeOrigin::root(),

719

1

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

720

1

			Box::new(message),

721

1

));

722

1

});

723

1

724

1

	ParaA::execute_with(|| {

725

1

		// Weight used is 4

726

1

		assert_eq!(

727

1

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

728

1

			INITIAL_BALANCE - 4

729

1

);

730

1

});

731

1

732

733

#[test]

734

1

fn receive_relay_asset_with_trader() {

735

1

	MockNet::reset();

736

1

737

1

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

738

1

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

739

1

740

1

	let asset_metadata = parachain::AssetMetadata {

741

1

		name: b"RelayToken".to_vec(),

742

1

		symbol: b"Relay".to_vec(),

743

1

		decimals: 12,

744

1

};

745

1

746

1

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

747

1

	// we know later we will divide by 1e12

748

1

	// Lets put 1e6 as units per second

749

1

	ParaA::execute_with(|| {

750

1

		assert_ok!(AssetManager::register_foreign_asset(

751

1

			parachain::RuntimeOrigin::root(),

752

1

			source_location.clone(),

753

1

			asset_metadata,

754

1

			1u128,

755

1

			true

756

1

));

757

1

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

758

1

});

759

1

760

1

	let dest: Location = Junction::AccountKey20 {

761

1

		network: None,

762

1

		key: PARAALICE,

763

1

764

1

	.into();

765

1

	// We are sending 100 tokens from relay.

766

1

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

767

1

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

768

1

	// Units per second should be 2_500_000_000_000_000

769

1

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

770

1

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

771

1

	Relay::execute_with(|| {

772

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

773

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

774

1

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

775

1

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

776

1

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

777

1

0,

778

1

			WeightLimit::Unlimited

779

1

));

780

1

});

781

1

782

1

	ParaA::execute_with(|| {

783

1

		// non-free execution, not full amount received

784

1

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

785

		// Fee should have been received by treasury

786

1

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

787

1

});

788

1

789

790

#[test]

791

1

fn send_para_a_asset_to_para_b_with_trader() {

792

1

	MockNet::reset();

793

1

794

1

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

795

1

	let source_location = parachain::AssetType::Xcm(

796

1

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

797

1

);

798

1

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

799

1

800

1

	let asset_metadata = parachain::AssetMetadata {

801

1

		name: b"ParaAToken".to_vec(),

802

1

		symbol: b"ParaA".to_vec(),

803

1

		decimals: 18,

804

1

};

805

1

806

1

	ParaB::execute_with(|| {

807

1

		assert_ok!(AssetManager::register_foreign_asset(

808

1

			parachain::RuntimeOrigin::root(),

809

1

			source_location.clone(),

810

1

			asset_metadata,

811

1

			1u128,

812

1

			true

813

1

));

814

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

815

1

});

816

1

817

1

	let dest = Location {

818

1

		parents: 1,

819

1

		interior: [

820

1

			Parachain(2),

821

1

			AccountKey20 {

822

1

				network: None,

823

1

				key: PARAALICE.into(),

824

1

},

825

1

826

1

		.into(),

827

1

};

828

1

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

829

1

830

1

	// In destination chain, we only need 4 weight

831

1

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

832

1

	ParaA::execute_with(|| {

833

1

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

834

1

		assert_ok!(PolkadotXcm::transfer_assets(

835

1

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

836

1

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

837

1

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

838

1

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

839

1

0,

840

1

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

841

1

));

842

1

});

843

1

	ParaA::execute_with(|| {

844

1

		// free execution, full amount received

845

1

		assert_eq!(

846

1

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

847

1

			INITIAL_BALANCE - 100

848

1

);

849

1

});

850

1

851

1

	// We are sending 100 tokens from para A.

852

1

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

853

1

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

854

1

	// Units per second should be 2_500_000_000_000_000

855

1

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

856

1

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

857

1

	// will be 4

858

1

	ParaB::execute_with(|| {

859

1

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

860

		// Fee should have been received by treasury

861

1

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

862

1

});

863

1

864

865

#[test]

866

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

867

1

	MockNet::reset();

868

1

869

1

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

870

1

	let source_location = parachain::AssetType::Xcm(

871

1

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

872

1

);

873

1

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

874

1

875

1

	let asset_metadata = parachain::AssetMetadata {

876

1

		name: b"ParaAToken".to_vec(),

877

1

		symbol: b"ParaA".to_vec(),

878

1

		decimals: 18,

879

1

};

880

1

881

1

	ParaB::execute_with(|| {

882

1

		assert_ok!(AssetManager::register_foreign_asset(

883

1

			parachain::RuntimeOrigin::root(),

884

1

			source_location.clone(),

885

1

			asset_metadata,

886

1

			1u128,

887

1

			true

888

1

));

889

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

890

1

		assert_ok!(add_supported_asset(source_location, 12500000));

891

1

});

892

1

893

1

	let dest = Location {

894

1

		parents: 1,

895

1

		interior: [

896

1

			Parachain(2),

897

1

			AccountKey20 {

898

1

				network: None,

899

1

				key: PARAALICE.into(),

900

1

},

901

1

902

1

		.into(),

903

1

};

904

1

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

905

1

	// we use transfer_with_fee

906

1

	ParaA::execute_with(|| {

907

1

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

908

1

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

909

1

		assert_ok!(PolkadotXcm::transfer_assets(

910

1

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

911

1

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

912

1

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

913

1

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

914

1

0,

915

1

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

916

1

));

917

1

});

918

1

	ParaA::execute_with(|| {

919

1

		// 100 tokens transferred plus 1 taken from fees

920

1

		assert_eq!(

921

1

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

922

1

			INITIAL_BALANCE - 100 - 1

923

1

);

924

1

});

925

1

926

1

	ParaB::execute_with(|| {

927

1

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

928

1

		// what it is specified

929

1

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

930

1

});

931

1

932

933

#[test]

934

1

fn error_when_not_paying_enough() {

935

1

	MockNet::reset();

936

1

937

1

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

938

1

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

939

1

940

1

	let asset_metadata = parachain::AssetMetadata {

941

1

		name: b"RelayToken".to_vec(),

942

1

		symbol: b"Relay".to_vec(),

943

1

		decimals: 12,

944

1

};

945

1

946

1

	let dest: Location = Junction::AccountKey20 {

947

1

		network: None,

948

1

		key: PARAALICE,

949

1

950

1

	.into();

951

1

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

952

1

	// we know later we will divide by 1e12

953

1

	// Lets put 1e6 as units per second

954

1

	ParaA::execute_with(|| {

955

1

		assert_ok!(AssetManager::register_foreign_asset(

956

1

			parachain::RuntimeOrigin::root(),

957

1

			source_location.clone(),

958

1

			asset_metadata,

959

1

			1u128,

960

1

			true

961

1

));

962

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

963

1

});

964

1

965

1

	ParaA::execute_with(|| {

966

1

		// amount not received as it is not paying enough

967

1

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

968

1

});

969

1

970

1

	// We are sending 100 tokens from relay.

971

1

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

972

1

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

973

1

	Relay::execute_with(|| {

974

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

975

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

976

1

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

977

1

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

978

1

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

979

1

0,

980

1

			WeightLimit::Unlimited

981

1

));

982

1

});

983

1

984

1

	ParaA::execute_with(|| {

985

1

		// amount not received as it is not paying enough

986

1

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

987

1

});

988

1

989

990

#[test]

991

1

fn transact_through_derivative_multilocation() {

992

1

	MockNet::reset();

993

1

994

1

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

995

1

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

996

1

997

1

	let asset_metadata = parachain::AssetMetadata {

998

1

		name: b"RelayToken".to_vec(),

999

1

		symbol: b"Relay".to_vec(),

1000

1

		decimals: 12,

1001

1

};

1002

1

1003

1

	ParaA::execute_with(|| {

1004

1

		assert_ok!(AssetManager::register_foreign_asset(

1005

1

			parachain::RuntimeOrigin::root(),

1006

1

			source_location.clone(),

1007

1

			asset_metadata,

1008

1

			1u128,

1009

1

			true

1010

1

));

1011

1

		assert_ok!(add_supported_asset(source_location, 1));

1012

1013

		// Root can set transact info

1014

1

		assert_ok!(XcmTransactor::set_transact_info(

1015

1

			parachain::RuntimeOrigin::root(),

1016

1

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

1017

1

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

1018

1

			3000.into(),

1019

1

			20000000000.into(),

1020

1

			None

1021

1

));

1022

		// Root can set transact info

1023

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1024

1

			parachain::RuntimeOrigin::root(),

1025

1

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

1026

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1027

1

));

1028

1

});

1029

1

1030

1

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

1031

1

1032

1

	let dest: Location = AccountKey20 {

1033

1

		network: None,

1034

1

		key: PARAALICE,

1035

1

1036

1

	.into();

1037

1

	Relay::execute_with(|| {

1038

1

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

1039

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1040

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1041

1

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

1042

1

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

1043

1

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

1044

1

0,

1045

1

			WeightLimit::Unlimited

1046

1

));

1047

1

});

1048

1

1049

1

	ParaA::execute_with(|| {

1050

1

		// free execution, full amount received

1051

1

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

1052

1

});

1053

1

1054

1

	// Register address

1055

1

	ParaA::execute_with(|| {

1056

1

		assert_ok!(XcmTransactor::register(

1057

1

			parachain::RuntimeOrigin::root(),

1058

1

			PARAALICE.into(),

1059

1

0,

1060

1

));

1061

1

});

1062

1

1063

1

	// Send to registered address

1064

1

1065

1

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

1066

1

	let dest = Location {

1067

1

		parents: 1,

1068

1

		interior: [AccountId32 {

1069

1

			network: None,

1070

1

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

1071

1

}]

1072

1

		.into(),

1073

1

};

1074

1

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

1075

1

1076

1

	ParaA::execute_with(|| {

1077

1

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

1078

1

		// free execution, full amount received

1079

1

		assert_ok!(PolkadotXcm::transfer_assets(

1080

1

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

1081

1

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

1082

1

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

1083

1

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

1084

1

0,

1085

1

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

1086

1

));

1087

1

});

1088

1

1089

1

	ParaA::execute_with(|| {

1090

1

		// free execution, full amount received

1091

1

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

1092

1

});

1093

1

1094

1

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

1095

1

	// again

1096

1

	Relay::execute_with(|| {

1097

1

		// free execution,x	 full amount received

1098

1

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

1099

1

});

1100

1

1101

1

	// Encode the call. Balances transact to para_a_account

1102

1

	// First index

1103

1

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

1104

1

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

1105

1

		relay_chain::Balances,

1106

1

>()

1107

1

	.unwrap() as u8;

1108

1

1109

1

	encoded.push(index);

1110

1

1111

1

	// Then call bytes

1112

1

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

1113

1

		dest: para_a_account(),

1114

1

		value: 100u32.into(),

1115

1

1116

1

	.encode();

1117

1

	encoded.append(&mut call_bytes);

1118

1

1119

1

	ParaA::execute_with(|| {

1120

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1121

1

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

1122

1

			parachain::MockTransactors::Relay,

1123

1

0,

1124

1

			CurrencyPayment {

1125

1

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

1126

1

					Location::parent()

1127

1

				))),

1128

1

				fee_amount: None

1129

1

},

1130

1

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

1131

1

			encoded,

1132

1

			TransactWeights {

1133

1

				transact_required_weight_at_most: 4000000000.into(),

1134

1

				overall_weight: None

1135

1

},

1136

1

			false

1137

1

));

1138

1

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

1139

1

			.iter()

1140

14

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

1141

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

1142

..

1143

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

1144

14

				_ => None,

1145

14

});

1146

1

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

1147

1

		assert!(event_found.is_none());

1148

1

});

1149

1

1150

1

	Relay::execute_with(|| {

1151

1

		// free execution,x	 full amount received

1152

1

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

1153

1154

1

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

1155

1

});

1156

1

1157

1158

#[test]

1159

1

fn transact_through_derivative_with_custom_fee_weight() {

1160

1

	MockNet::reset();

1161

1

1162

1

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

1163

1

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

1164

1

1165

1

	let asset_metadata = parachain::AssetMetadata {

1166

1

		name: b"RelayToken".to_vec(),

1167

1

		symbol: b"Relay".to_vec(),

1168

1

		decimals: 12,

1169

1

};

1170

1

1171

1

	ParaA::execute_with(|| {

1172

1

		assert_ok!(AssetManager::register_foreign_asset(

1173

1

			parachain::RuntimeOrigin::root(),

1174

1

			source_location.clone(),

1175

1

			asset_metadata,

1176

1

			1u128,

1177

1

			true

1178

1

));

1179

1

		assert_ok!(add_supported_asset(source_location, 1));

1180

1

});

1181

1

1182

1

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

1183

1

1184

1

	let dest: Location = AccountKey20 {

1185

1

		network: None,

1186

1

		key: PARAALICE,

1187

1

1188

1

	.into();

1189

1

	Relay::execute_with(|| {

1190

1

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

1191

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1192

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1193

1

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

1194

1

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

1195

1

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

1196

1

0,

1197

1

			WeightLimit::Unlimited

1198

1

));

1199

1

});

1200

1

1201

1

	ParaA::execute_with(|| {

1202

1

		// free execution, full amount received

1203

1

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

1204

1

});

1205

1

1206

1

	// Register address

1207

1

	ParaA::execute_with(|| {

1208

1

		assert_ok!(XcmTransactor::register(

1209

1

			parachain::RuntimeOrigin::root(),

1210

1

			PARAALICE.into(),

1211

1

0,

1212

1

));

1213

1

});

1214

1

1215

1

	// Send to registered address

1216

1

1217

1

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

1218

1

	let dest = Location {

1219

1

		parents: 1,

1220

1

		interior: [AccountId32 {

1221

1

			network: None,

1222

1

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

1223

1

}]

1224

1

		.into(),

1225

1

};

1226

1

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

1227

1

1228

1

	ParaA::execute_with(|| {

1229

1

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

1230

1

		// free execution, full amount received

1231

1

		assert_ok!(PolkadotXcm::transfer_assets(

1232

1

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

1233

1

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

1234

1

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

1235

1

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

1236

1

0,

1237

1

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

1238

1

));

1239

1

});

1240

1

1241

1

	ParaA::execute_with(|| {

1242

1

		// free execution, full amount received

1243

1

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

1244

1

});

1245

1

1246

1

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

1247

1

	// again

1248

1

	Relay::execute_with(|| {

1249

1

		// free execution,x	 full amount received

1250

1

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

1251

1

});

1252

1

1253

1

	// Encode the call. Balances transact to para_a_account

1254

1

	// First index

1255

1

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

1256

1

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

1257

1

		relay_chain::Balances,

1258

1

>()

1259

1

	.unwrap() as u8;

1260

1

1261

1

	encoded.push(index);

1262

1

1263

1

	// Then call bytes

1264

1

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

1265

1

		dest: para_a_account(),

1266

1

		value: 100u32.into(),

1267

1

1268

1

	.encode();

1269

1

	encoded.append(&mut call_bytes);

1270

1

1271

1

	let overall_weight = 4000003000u64;

1272

1

	ParaA::execute_with(|| {

1273

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1274

1

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

1275

1

			parachain::MockTransactors::Relay,

1276

1

0,

1277

1

			CurrencyPayment {

1278

1

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

1279

1

					Location::parent()

1280

1

				))),

1281

1

				// 1-1 fee weight mapping

1282

1

				fee_amount: Some(overall_weight as u128)

1283

1

},

1284

1

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

1285

1

			encoded,

1286

1

			TransactWeights {

1287

1

				transact_required_weight_at_most: 4000000000.into(),

1288

1

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

1289

1

},

1290

1

			false

1291

1

));

1292

1

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

1293

1

			.iter()

1294

12

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

1295

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

1296

..

1297

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

1298

12

				_ => None,

1299

12

});

1300

1

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

1301

1

		assert!(event_found.is_none());

1302

1

});

1303

1

1304

1

	Relay::execute_with(|| {

1305

1

		// free execution,x	 full amount received

1306

1

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

1307

1308

1

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

1309

1

});

1310

1

1311

1312

#[test]

1313

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1314

1

	MockNet::reset();

1315

1

1316

1

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

1317

1

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

1318

1

1319

1

	let asset_metadata = parachain::AssetMetadata {

1320

1

		name: b"RelayToken".to_vec(),

1321

1

		symbol: b"Relay".to_vec(),

1322

1

		decimals: 12,

1323

1

};

1324

1

1325

1

	ParaA::execute_with(|| {

1326

1

		assert_ok!(AssetManager::register_foreign_asset(

1327

1

			parachain::RuntimeOrigin::root(),

1328

1

			source_location.clone(),

1329

1

			asset_metadata,

1330

1

			1u128,

1331

1

			true

1332

1

));

1333

1

		assert_ok!(add_supported_asset(source_location, 1));

1334

1

});

1335

1

1336

1

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

1337

1

1338

1

	let dest: Location = AccountKey20 {

1339

1

		network: None,

1340

1

		key: PARAALICE,

1341

1

1342

1

	.into();

1343

1

	Relay::execute_with(|| {

1344

1

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

1345

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1346

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1347

1

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

1348

1

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

1349

1

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

1350

1

0,

1351

1

			WeightLimit::Unlimited

1352

1

));

1353

1

});

1354

1

1355

1

	ParaA::execute_with(|| {

1356

1

		// free execution, full amount received

1357

1

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

1358

1

});

1359

1

1360

1

	// Register address

1361

1

	ParaA::execute_with(|| {

1362

1

		assert_ok!(XcmTransactor::register(

1363

1

			parachain::RuntimeOrigin::root(),

1364

1

			PARAALICE.into(),

1365

1

0,

1366

1

));

1367

1

});

1368

1

1369

1

	// Send to registered address

1370

1

1371

1

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

1372

1

	let dest = Location {

1373

1

		parents: 1,

1374

1

		interior: [AccountId32 {

1375

1

			network: None,

1376

1

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

1377

1

}]

1378

1

		.into(),

1379

1

};

1380

1

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

1381

1

1382

1

	ParaA::execute_with(|| {

1383

1

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

1384

1

		// free execution, full amount received

1385

1

		assert_ok!(PolkadotXcm::transfer_assets(

1386

1

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

1387

1

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

1388

1

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

1389

1

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

1390

1

0,

1391

1

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

1392

1

));

1393

1

});

1394

1

1395

1

	ParaA::execute_with(|| {

1396

1

		// free execution, full amount received

1397

1

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

1398

1

});

1399

1

1400

1

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

1401

1

	// again

1402

1

	Relay::execute_with(|| {

1403

1

		// free execution,x	 full amount received

1404

1

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

1405

1

});

1406

1

1407

1

	// Encode the call. Balances transact to para_a_account

1408

1

	// First index

1409

1

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

1410

1

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

1411

1

		relay_chain::Balances,

1412

1

>()

1413

1

	.unwrap() as u8;

1414

1

1415

1

	encoded.push(index);

1416

1

1417

1

	// Then call bytes

1418

1

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

1419

1

		dest: para_a_account(),

1420

1

		value: 100u32.into(),

1421

1

1422

1

	.encode();

1423

1

	encoded.append(&mut call_bytes);

1424

1

1425

1

	let overall_weight = 4000009000u64;

1426

1

	ParaA::execute_with(|| {

1427

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1428

1

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

1429

1

			parachain::MockTransactors::Relay,

1430

1

0,

1431

1

			CurrencyPayment {

1432

1

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

1433

1

					Location::parent()

1434

1

				))),

1435

1

				// 1-1 fee weight mapping

1436

1

				fee_amount: Some(overall_weight as u128)

1437

1

},

1438

1

			encoded,

1439

1

			TransactWeights {

1440

1

				transact_required_weight_at_most: 4000000000.into(),

1441

1

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

1442

1

},

1443

1

			true

1444

1

));

1445

1

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

1446

1

			.iter()

1447

12

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

1448

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

1449

..

1450

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

1451

12

				_ => None,

1452

12

});

1453

1

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

1454

1

		assert!(event_found.is_none());

1455

1

});

1456

1

1457

1

	Relay::execute_with(|| {

1458

1

		// free execution,x	 full amount received

1459

1

		// 4000005186 refunded + 100 transferred = 4000005286

1460

1

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

1461

1

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

1462

1

});

1463

1

1464

1465

#[test]

1466

1

fn transact_through_sovereign() {

1467

1

	MockNet::reset();

1468

1

1469

1

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

1470

1

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

1471

1

1472

1

	let asset_metadata = parachain::AssetMetadata {

1473

1

		name: b"RelayToken".to_vec(),

1474

1

		symbol: b"Relay".to_vec(),

1475

1

		decimals: 12,

1476

1

};

1477

1

1478

1

	ParaA::execute_with(|| {

1479

1

		assert_ok!(AssetManager::register_foreign_asset(

1480

1

			parachain::RuntimeOrigin::root(),

1481

1

			source_location.clone(),

1482

1

			asset_metadata,

1483

1

			1u128,

1484

1

			true

1485

1

));

1486

1

		assert_ok!(add_supported_asset(source_location, 1));

1487

1488

		// Root can set transact info

1489

1

		assert_ok!(XcmTransactor::set_transact_info(

1490

1

			parachain::RuntimeOrigin::root(),

1491

1

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

1492

1

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

1493

1

			3000.into(),

1494

1

			20000000000.into(),

1495

1

			None

1496

1

));

1497

		// Root can set transact info

1498

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1499

1

			parachain::RuntimeOrigin::root(),

1500

1

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

1501

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1502

1

));

1503

1

});

1504

1

1505

1

	let dest: Location = AccountKey20 {

1506

1

		network: None,

1507

1

		key: PARAALICE,

1508

1

1509

1

	.into();

1510

1

	Relay::execute_with(|| {

1511

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1512

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1513

1

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

1514

1

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

1515

1

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

1516

1

0,

1517

1

			WeightLimit::Unlimited

1518

1

));

1519

1

});

1520

1

1521

1

	ParaA::execute_with(|| {

1522

1

		// free execution, full amount received

1523

1

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

1524

1

});

1525

1

1526

1

	// Register address

1527

1

	ParaA::execute_with(|| {

1528

1

		assert_ok!(XcmTransactor::register(

1529

1

			parachain::RuntimeOrigin::root(),

1530

1

			PARAALICE.into(),

1531

1

0,

1532

1

));

1533

1

});

1534

1

1535

1

	// Send to registered address

1536

1

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

1537

1

	let dest = Location {

1538

1

		parents: 1,

1539

1

		interior: [AccountId32 {

1540

1

			network: None,

1541

1

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

1542

1

}]

1543

1

		.into(),

1544

1

};

1545

1

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

1546

1

1547

1

	ParaA::execute_with(|| {

1548

1

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

1549

1

		// free execution, full amount received

1550

1

		assert_ok!(PolkadotXcm::transfer_assets(

1551

1

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

1552

1

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

1553

1

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

1554

1

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

1555

1

0,

1556

1

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

1557

1

));

1558

1

});

1559

1

1560

1

	ParaA::execute_with(|| {

1561

1

		// free execution, full amount received

1562

1

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

1563

1

});

1564

1

1565

1

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

1566

1

	// again

1567

1

	Relay::execute_with(|| {

1568

1

		// free execution,x	 full amount received

1569

1

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

1570

1

1571

1

});

1572

1

1573

1

	// We send the xcm transact operation to parent

1574

1

	let dest = Location {

1575

1

		parents: 1,

1576

1

		interior: [].into(),

1577

1

};

1578

1

1579

1

	// Encode the call. Balances transact to para_a_account

1580

1

	// First index

1581

1

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

1582

1

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

1583

1

		relay_chain::Balances,

1584

1

>()

1585

1

	.unwrap() as u8;

1586

1

1587

1

	encoded.push(index);

1588

1

1589

1

	// Then call bytes

1590

1

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

1591

1

		dest: para_a_account(),

1592

1

		value: 100u32.into(),

1593

1

1594

1

	.encode();

1595

1

	encoded.append(&mut call_bytes);

1596

1

1597

1

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

1598

1

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

1599

1

);

1600

1

1601

1

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

1602

1

	ParaA::execute_with(|| {

1603

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1604

1

			parachain::RuntimeOrigin::root(),

1605

1

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

1606

1

			Some(PARAALICE.into()),

1607

1

			CurrencyPayment {

1608

1

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

1609

1

					Location::parent()

1610

1

				))),

1611

1

				fee_amount: None

1612

1

},

1613

1

			utility_bytes,

1614

1

			OriginKind::SovereignAccount,

1615

1

			TransactWeights {

1616

1

				transact_required_weight_at_most: 4000000000.into(),

1617

1

				overall_weight: None

1618

1

},

1619

1

			false

1620

1

));

1621

1

});

1622

1

1623

1

	Relay::execute_with(|| {

1624

1

		// free execution,x	 full amount received

1625

1

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

1626

1627

1

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

1628

1

});

1629

1

1630

1631

#[test]

1632

1

fn transact_through_sovereign_fee_payer_none() {

1633

1

	MockNet::reset();

1634

1

1635

1

	ParaA::execute_with(|| {

1636

1

		// Root can set transact info

1637

1

		assert_ok!(XcmTransactor::set_transact_info(

1638

1

			parachain::RuntimeOrigin::root(),

1639

1

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

1640

1

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

1641

1

			3000.into(),

1642

1

			20000000000.into(),

1643

1

			None

1644

1

));

1645

		// Root can set transact info

1646

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1647

1

			parachain::RuntimeOrigin::root(),

1648

1

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

1649

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1650

1

));

1651

1

});

1652

1

1653

1

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

1654

1

1655

1

	Relay::execute_with(|| {

1656

1

		// Transfer 100 tokens to derivative_address on the relay

1657

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1658

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1659

1

			derivative_address.clone(),

1660

1

			100u128

1661

1

));

1662

1663

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

1664

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1665

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1666

1

			para_a_account(),

1667

1

			4000003000u128

1668

1

));

1669

1

});

1670

1

1671

1

	// Check balances before the transact call

1672

1

	Relay::execute_with(|| {

1673

1

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

1674

1

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

1675

1

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

1676

1

});

1677

1

1678

1

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

1679

1

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

1680

1

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

1681

1

		relay_chain::Balances,

1682

1

>()

1683

1

	.unwrap() as u8;

1684

1

1685

1

	encoded.push(index);

1686

1

1687

1

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

1688

1

		dest: RELAYBOB,

1689

1

		value: 100u32.into(),

1690

1

1691

1

	.encode();

1692

1

	encoded.append(&mut call_bytes);

1693

1

1694

1

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

1695

1

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

1696

1

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

1697

1

);

1698

1

1699

1

	// We send the xcm transact operation to parent

1700

1

	let dest = Location {

1701

1

		parents: 1,

1702

1

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

1703

1

};

1704

1

1705

1

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

1706

1

	ParaA::execute_with(|| {

1707

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1708

1

			parachain::RuntimeOrigin::root(),

1709

1

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

1710

1

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

1711

1

			None,

1712

1

			CurrencyPayment {

1713

1

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

1714

1

					Location::parent()

1715

1

				))),

1716

1

				fee_amount: None

1717

1

},

1718

1

			utility_bytes,

1719

1

			OriginKind::SovereignAccount,

1720

1

			TransactWeights {

1721

1

				transact_required_weight_at_most: 4000000000.into(),

1722

1

				overall_weight: None

1723

1

},

1724

1

			false

1725

1

));

1726

1

});

1727

1

1728

1

	// Check balances after the transact call are correct

1729

1

	Relay::execute_with(|| {

1730

1

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

1731

1

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

1732

1

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

1733

1

});

1734

1

1735

1736

#[test]

1737

1

fn transact_through_sovereign_with_custom_fee_weight() {

1738

1

	MockNet::reset();

1739

1

1740

1

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

1741

1

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

1742

1

1743

1

	let asset_metadata = parachain::AssetMetadata {

1744

1

		name: b"RelayToken".to_vec(),

1745

1

		symbol: b"Relay".to_vec(),

1746

1

		decimals: 12,

1747

1

};

1748

1

1749

1

	ParaA::execute_with(|| {

1750

1

		assert_ok!(AssetManager::register_foreign_asset(

1751

1

			parachain::RuntimeOrigin::root(),

1752

1

			source_location.clone(),

1753

1

			asset_metadata,

1754

1

			1u128,

1755

1

			true

1756

1

));

1757

1

		assert_ok!(add_supported_asset(source_location, 1));

1758

1

});

1759

1

1760

1

	let dest: Location = AccountKey20 {

1761

1

		network: None,

1762

1

		key: PARAALICE,

1763

1

1764

1

	.into();

1765

1

	Relay::execute_with(|| {

1766

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1767

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1768

1

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

1769

1

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

1770

1

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

1771

1

0,

1772

1

			WeightLimit::Unlimited

1773

1

));

1774

1

});

1775

1

1776

1

	ParaA::execute_with(|| {

1777

1

		// free execution, full amount received

1778

1

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

1779

1

});

1780

1

1781

1

	// Register address

1782

1

	ParaA::execute_with(|| {

1783

1

		assert_ok!(XcmTransactor::register(

1784

1

			parachain::RuntimeOrigin::root(),

1785

1

			PARAALICE.into(),

1786

1

0,

1787

1

));

1788

1

});

1789

1

1790

1

	// Send to registered address

1791

1

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

1792

1

	let dest = Location {

1793

1

		parents: 1,

1794

1

		interior: [AccountId32 {

1795

1

			network: None,

1796

1

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

1797

1

}]

1798

1

		.into(),

1799

1

};

1800

1

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

1801

1

1802

1

	ParaA::execute_with(|| {

1803

1

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

1804

1

		// free execution, full amount received

1805

1

		assert_ok!(PolkadotXcm::transfer_assets(

1806

1

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

1807

1

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

1808

1

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

1809

1

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

1810

1

0,

1811

1

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

1812

1

));

1813

1

});

1814

1

1815

1

	ParaA::execute_with(|| {

1816

1

		// free execution, full amount received

1817

1

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

1818

1

});

1819

1

1820

1

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

1821

1

	// again

1822

1

	Relay::execute_with(|| {

1823

1

		// free execution,x	 full amount received

1824

1

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

1825

1

1826

1

});

1827

1

1828

1

	// We send the xcm transact operation to parent

1829

1

	let dest = Location {

1830

1

		parents: 1,

1831

1

		interior: [].into(),

1832

1

};

1833

1

1834

1

	// Encode the call. Balances transact to para_a_account

1835

1

	// First index

1836

1

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

1837

1

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

1838

1

		relay_chain::Balances,

1839

1

>()

1840

1

	.unwrap() as u8;

1841

1

1842

1

	encoded.push(index);

1843

1

1844

1

	// Then call bytes

1845

1

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

1846

1

		dest: para_a_account(),

1847

1

		value: 100u32.into(),

1848

1

1849

1

	.encode();

1850

1

	encoded.append(&mut call_bytes);

1851

1

1852

1

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

1853

1

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

1854

1

);

1855

1

1856

1

	let total_weight = 4000003000u64;

1857

1

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

1858

1

	ParaA::execute_with(|| {

1859

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1860

1

			parachain::RuntimeOrigin::root(),

1861

1

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

1862

1

			Some(PARAALICE.into()),

1863

1

			CurrencyPayment {

1864

1

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

1865

1

					Location::parent()

1866

1

				))),

1867

1

				// 1-1 fee-weight mapping

1868

1

				fee_amount: Some(total_weight as u128)

1869

1

},

1870

1

			utility_bytes,

1871

1

			OriginKind::SovereignAccount,

1872

1

			TransactWeights {

1873

1

				transact_required_weight_at_most: 4000000000.into(),

1874

1

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

1875

1

},

1876

1

			false

1877

1

));

1878

1

});

1879

1

1880

1

	Relay::execute_with(|| {

1881

1

		// free execution,x	 full amount received

1882

1

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

1883

1884

1

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

1885

1

});

1886

1

1887

1888

#[test]

1889

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1890

1

	MockNet::reset();

1891

1

1892

1

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

1893

1

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

1894

1

1895

1

	let asset_metadata = parachain::AssetMetadata {

1896

1

		name: b"RelayToken".to_vec(),

1897

1

		symbol: b"Relay".to_vec(),

1898

1

		decimals: 12,

1899

1

};

1900

1

1901

1

	ParaA::execute_with(|| {

1902

1

		assert_ok!(AssetManager::register_foreign_asset(

1903

1

			parachain::RuntimeOrigin::root(),

1904

1

			source_location.clone(),

1905

1

			asset_metadata,

1906

1

			1u128,

1907

1

			true

1908

1

));

1909

1

		assert_ok!(add_supported_asset(source_location, 1));

1910

1

});

1911

1

1912

1

	let dest: Location = AccountKey20 {

1913

1

		network: None,

1914

1

		key: PARAALICE,

1915

1

1916

1

	.into();

1917

1

	Relay::execute_with(|| {

1918

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1919

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1920

1

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

1921

1

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

1922

1

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

1923

1

0,

1924

1

			WeightLimit::Unlimited

1925

1

));

1926

1

});

1927

1

1928

1

	ParaA::execute_with(|| {

1929

1

		// free execution, full amount received

1930

1

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

1931

1

});

1932

1

1933

1

	// Register address

1934

1

	ParaA::execute_with(|| {

1935

1

		assert_ok!(XcmTransactor::register(

1936

1

			parachain::RuntimeOrigin::root(),

1937

1

			PARAALICE.into(),

1938

1

0,

1939

1

));

1940

1

});

1941

1

1942

1

	// Send to registered address

1943

1

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

1944

1

	let dest = Location {

1945

1

		parents: 1,

1946

1

		interior: [AccountId32 {

1947

1

			network: None,

1948

1

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

1949

1

}]

1950

1

		.into(),

1951

1

};

1952

1

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

1953

1

1954

1

	ParaA::execute_with(|| {

1955

1

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

1956

1

		// free execution, full amount received

1957

1

		assert_ok!(PolkadotXcm::transfer_assets(

1958

1

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

1959

1

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

1960

1

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

1961

1

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

1962

1

0,

1963

1

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

1964

1

));

1965

1

});

1966

1

1967

1

	ParaA::execute_with(|| {

1968

1

		// free execution, full amount received

1969

1

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

1970

1

});

1971

1

1972

1

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

1973

1

	// again

1974

1

	Relay::execute_with(|| {

1975

1

		// free execution,x	 full amount received

1976

1

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

1977

1

1978

1

});

1979

1

1980

1

	// We send the xcm transact operation to parent

1981

1

	let dest = Location {

1982

1

		parents: 1,

1983

1

		interior: [].into(),

1984

1

};

1985

1

1986

1

	// Encode the call. Balances transact to para_a_account

1987

1

	// First index

1988

1

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

1989

1

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

1990

1

		relay_chain::Balances,

1991

1

>()

1992

1

	.unwrap() as u8;

1993

1

1994

1

	encoded.push(index);

1995

1

1996

1

	// Then call bytes

1997

1

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

1998

1

		dest: para_a_account(),

1999

1

		value: 100u32.into(),

2000

1

2001

1

	.encode();

2002

1

	encoded.append(&mut call_bytes);

2003

1

2004

1

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

2005

1

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

2006

1

);

2007

1

2008

1

	let total_weight = 4000009000u64;

2009

1

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

2010

1

	ParaA::execute_with(|| {

2011

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2012

1

			parachain::RuntimeOrigin::root(),

2013

1

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

2014

1

			Some(PARAALICE.into()),

2015

1

			CurrencyPayment {

2016

1

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

2017

1

					Location::parent()

2018

1

				))),

2019

1

				// 1-1 fee-weight mapping

2020

1

				fee_amount: Some(total_weight as u128)

2021

1

},

2022

1

			utility_bytes,

2023

1

			OriginKind::SovereignAccount,

2024

1

			TransactWeights {

2025

1

				transact_required_weight_at_most: 4000000000.into(),

2026

1

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

2027

1

},

2028

1

			true

2029

1

));

2030

1

});

2031

1

2032

1

	Relay::execute_with(|| {

2033

1

		// free execution,x	 full amount received

2034

1

		// 4000005186 refunded + 100 transferred = 4000005286

2035

1

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

2036

2037

1

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

2038

1

});

2039

1

2040

2041

#[test]

2042

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2043

1

	MockNet::reset();

2044

1

2045

1

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

2046

1

	let asset_metadata = parachain::AssetMetadata {

2047

1

		name: b"RelayToken".to_vec(),

2048

1

		symbol: b"Relay".to_vec(),

2049

1

		decimals: 12,

2050

1

};

2051

1

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

2052

1

	ParaA::execute_with(|| {

2053

1

		parachain::XcmVersioner::set_version(1);

2054

1

		assert_ok!(AssetManager::register_foreign_asset(

2055

1

			parachain::RuntimeOrigin::root(),

2056

1

			source_location.clone(),

2057

1

			asset_metadata,

2058

1

			1u128,

2059

1

			true

2060

1

));

2061

1

		assert_ok!(add_supported_asset(source_location, 0));

2062

1

});

2063

1

2064

1

	let response = Response::Version(2);

2065

1

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

2066

1

2067

1

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

2068

1

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

2069

1

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

2070

1

		query_id: 0,

2071

1

		response,

2072

1

		max_weight: Weight::zero(),

2073

1

		querier: Some(querier),

2074

1

	}]);

2075

1

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

2076

1

	// it directly here

2077

1

	// Actually send relay asset to parachain

2078

1

	let dest: Location = AccountKey20 {

2079

1

		network: None,

2080

1

		key: PARAALICE,

2081

1

2082

1

	.into();

2083

1

2084

1

	Relay::execute_with(|| {

2085

1

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

2086

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2087

1

			relay_chain::RuntimeOrigin::root(),

2088

1

			Some(2)

2089

1

));

2090

2091

		// Wrap version, which sets VersionedStorage

2092

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

2093

		// this is not necessary in prod

2094

1

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

2095

1

			&Parachain(1).into(),

2096

1

			mock_message

2097

1

));

2098

2099

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

2100

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2101

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2102

1

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

2103

1

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

2104

1

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

2105

1

0,

2106

1

			WeightLimit::Unlimited

2107

1

));

2108

2109

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

2110

1

		relay_chain::relay_roll_to(2);

2111

1

2112

1

		// queries should have been updated

2113

1

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

2114

1

});

2115

1

2116

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2117

1

		pallet_xcm::Event::SupportedVersionChanged {

2118

1

			location: Location {

2119

1

				parents: 0,

2120

1

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

2121

1

},

2122

1

			version: 1,

2123

1

2124

1

		.into();

2125

1

2126

1

	Relay::execute_with(|| {

2127

1

		// Assert that the events vector contains the version change

2128

1

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

2129

1

});

2130

1

2131

1

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

2132

1

	// of the new version change

2133

1

	ParaA::execute_with(|| {

2134

1

		// Set version

2135

1

		parachain::XcmVersioner::set_version(2);

2136

1

		// Do runtime upgrade

2137

1

		parachain::on_runtime_upgrade();

2138

1

		// Initialize block, to call on_initialize and notify targets

2139

1

		parachain::para_roll_to(2);

2140

1

		// Expect the event in the parachain

2141

10

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

2142

2

e,

2143

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

2144

				result: 2,

2145

..

2146

})

2147

10

		)));

2148

1

});

2149

1

2150

1

	// This event should have been seen in the relay

2151

1

	let expected_supported_version_2: 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: 2,

2158

1

2159

1

		.into();

2160

1

2161

1

	Relay::execute_with(|| {

2162

1

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

2163

1

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

2164

1

});

2165

1

2166

2167

#[test]

2168

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2169

1

	MockNet::reset();

2170

1

2171

1

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

2172

1

	let source_location = parachain::AssetType::Xcm(

2173

1

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

2174

1

);

2175

1

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

2176

1

2177

1

	let asset_metadata = parachain::AssetMetadata {

2178

1

		name: b"ParaAToken".to_vec(),

2179

1

		symbol: b"ParaA".to_vec(),

2180

1

		decimals: 18,

2181

1

};

2182

1

	let response = Response::Version(2);

2183

1

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

2184

1

2185

1

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

2186

1

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

2187

1

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

2188

1

		query_id: 0,

2189

1

		response,

2190

1

		max_weight: Weight::zero(),

2191

1

		querier: Some(querier),

2192

1

	}]);

2193

1

2194

1

	ParaA::execute_with(|| {

2195

1

		// advertised version

2196

1

		parachain::XcmVersioner::set_version(2);

2197

1

});

2198

1

2199

1

	ParaB::execute_with(|| {

2200

1

		// Let's try with v0

2201

1

		parachain::XcmVersioner::set_version(0);

2202

1

2203

1

		assert_ok!(AssetManager::register_foreign_asset(

2204

1

			parachain::RuntimeOrigin::root(),

2205

1

			source_location.clone(),

2206

1

			asset_metadata,

2207

1

			1u128,

2208

1

			true

2209

1

));

2210

1

		assert_ok!(add_supported_asset(source_location, 0));

2211

1

});

2212

1

2213

1

	ParaA::execute_with(|| {

2214

1

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

2215

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2216

1

			parachain::RuntimeOrigin::root(),

2217

1

			Some(2)

2218

1

));

2219

		// Wrap version, which sets VersionedStorage

2220

1

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

2221

1

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

2222

1

			mock_message

2223

1

));

2224

2225

1

		parachain::para_roll_to(2);

2226

1

2227

1

		// queries should have been updated

2228

1

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

2229

1

});

2230

1

2231

1

	let expected_supported_version: parachain::RuntimeEvent =

2232

1

		pallet_xcm::Event::SupportedVersionChanged {

2233

1

			location: Location {

2234

1

				parents: 1,

2235

1

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

2236

1

},

2237

1

			version: 0,

2238

1

2239

1

		.into();

2240

1

2241

1

	ParaA::execute_with(|| {

2242

1

		// Assert that the events vector contains the version change

2243

1

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

2244

1

});

2245

1

2246

1

	// Let's ensure talking in v0 works

2247

1

	let dest = Location {

2248

1

		parents: 1,

2249

1

		interior: [

2250

1

			Parachain(2),

2251

1

			AccountKey20 {

2252

1

				network: None,

2253

1

				key: PARAALICE.into(),

2254

1

},

2255

1

2256

1

		.into(),

2257

1

2258

1

	.into();

2259

1

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

2260

1

	ParaA::execute_with(|| {

2261

1

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

2262

1

		// free execution, full amount received

2263

1

		assert_ok!(PolkadotXcm::transfer_assets(

2264

1

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

2265

1

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

2266

1

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

2267

1

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

2268

1

0,

2269

1

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

2270

1

));

2271

		// free execution, full amount received

2272

1

		assert_eq!(

2273

1

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

2274

1

			INITIAL_BALANCE - 100

2275

1

);

2276

1

});

2277

1

2278

1

	ParaB::execute_with(|| {

2279

1

		// free execution, full amount received

2280

1

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

2281

1

});

2282

1

2283

1

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

2284

1

	// of the new version change

2285

1

	ParaB::execute_with(|| {

2286

1

		// Set version

2287

1

		parachain::XcmVersioner::set_version(2);

2288

1

		// Do runtime upgrade

2289

1

		parachain::on_runtime_upgrade();

2290

1

		// Initialize block, to call on_initialize and notify targets

2291

1

		parachain::para_roll_to(2);

2292

1

		// Expect the event in the parachain

2293

10

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

2294

2

e,

2295

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

2296

				result: 2,

2297

..

2298

})

2299

10

		)));

2300

1

});

2301

1

2302

1

	// This event should have been seen in para A

2303

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2304

1

		pallet_xcm::Event::SupportedVersionChanged {

2305

1

			location: Location {

2306

1

				parents: 1,

2307

1

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

2308

1

},

2309

1

			version: 2,

2310

1

2311

1

		.into();

2312

1

2313

1

	// Para A should have received the version change

2314

1

	ParaA::execute_with(|| {

2315

1

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

2316

1

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

2317

1

});

2318

1

2319

2320

#[test]

2321

1

fn receive_asset_with_no_sufficients_not_possible_if_non_existent_account() {

2322

1

	MockNet::reset();

2323

1

2324

1

	let fresh_account = [2u8; 20];

2325

1

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

2326

1

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

2327

1

	let asset_metadata = parachain::AssetMetadata {

2328

1

		name: b"RelayToken".to_vec(),

2329

1

		symbol: b"Relay".to_vec(),

2330

1

		decimals: 12,

2331

1

};

2332

1

	// register relay asset in parachain A

2333

1

	ParaA::execute_with(|| {

2334

1

		assert_ok!(AssetManager::register_foreign_asset(

2335

1

			parachain::RuntimeOrigin::root(),

2336

1

			source_location.clone(),

2337

1

			asset_metadata,

2338

1

			1u128,

2339

1

			false

2340

1

));

2341

1

		assert_ok!(add_supported_asset(source_location, 0));

2342

1

});

2343

1

2344

1

	// Actually send relay asset to parachain

2345

1

	let dest: Location = AccountKey20 {

2346

1

		network: None,

2347

1

		key: fresh_account,

2348

1

2349

1

	.into();

2350

1

	Relay::execute_with(|| {

2351

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2352

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2353

1

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

2354

1

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

2355

1

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

2356

1

0,

2357

1

			WeightLimit::Unlimited

2358

1

));

2359

1

});

2360

1

2361

1

	// parachain should not have received assets

2362

1

	ParaA::execute_with(|| {

2363

1

		// free execution, full amount received

2364

1

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

2365

1

});

2366

1

2367

1

	// Send native token to fresh_account

2368

1

	ParaA::execute_with(|| {

2369

1

		assert_ok!(ParaBalances::transfer_allow_death(

2370

1

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

2371

1

			fresh_account.into(),

2372

1

2373

1

));

2374

1

});

2375

1

2376

1

	// Re-send tokens

2377

1

	Relay::execute_with(|| {

2378

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2379

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2380

1

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

2381

1

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

2382

1

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

2383

1

0,

2384

1

			WeightLimit::Unlimited

2385

1

));

2386

1

});

2387

1

2388

1

	// parachain should have received assets

2389

1

	ParaA::execute_with(|| {

2390

1

		// free execution, full amount received

2391

1

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

2392

1

});

2393

1

2394

2395

#[test]

2396

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2397

1

	MockNet::reset();

2398

1

2399

1

	let fresh_account = [2u8; 20];

2400

1

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

2401

1

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

2402

1

	let asset_metadata = parachain::AssetMetadata {

2403

1

		name: b"RelayToken".to_vec(),

2404

1

		symbol: b"Relay".to_vec(),

2405

1

		decimals: 12,

2406

1

};

2407

1

	// register relay asset in parachain A

2408

1

	ParaA::execute_with(|| {

2409

1

		assert_ok!(AssetManager::register_foreign_asset(

2410

1

			parachain::RuntimeOrigin::root(),

2411

1

			source_location.clone(),

2412

1

			asset_metadata,

2413

1

			1u128,

2414

1

			true

2415

1

));

2416

1

		assert_ok!(add_supported_asset(source_location, 0));

2417

1

});

2418

1

2419

1

	// Actually send relay asset to parachain

2420

1

	let dest: Location = AccountKey20 {

2421

1

		network: None,

2422

1

		key: fresh_account,

2423

1

2424

1

	.into();

2425

1

	Relay::execute_with(|| {

2426

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2427

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2428

1

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

2429

1

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

2430

1

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

2431

1

0,

2432

1

			WeightLimit::Unlimited

2433

1

));

2434

1

});

2435

1

2436

1

	// parachain should have received assets

2437

1

	ParaA::execute_with(|| {

2438

1

		// free execution, full amount received

2439

1

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

2440

1

});

2441

1

2442

2443

#[test]

2444

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2445

1

	MockNet::reset();

2446

1

2447

1

	let mut sufficient_account = [0u8; 20];

2448

1

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

2449

1

2450

1

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

2451

1

2452

1

	// Evm account is self sufficient

2453

1

	ParaA::execute_with(|| {

2454

1

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

2455

1

});

2456

1

2457

1

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

2458

1

	let asset_metadata = parachain::AssetMetadata {

2459

1

		name: b"RelayToken".to_vec(),

2460

1

		symbol: b"Relay".to_vec(),

2461

1

		decimals: 12,

2462

1

};

2463

1

	// register relay asset in parachain A

2464

1

	ParaA::execute_with(|| {

2465

1

		assert_ok!(AssetManager::register_foreign_asset(

2466

1

			parachain::RuntimeOrigin::root(),

2467

1

			source_location.clone(),

2468

1

			asset_metadata,

2469

1

			1u128,

2470

1

			true

2471

1

));

2472

1

		assert_ok!(add_supported_asset(source_location, 0));

2473

1

});

2474

1

2475

1

	// Actually send relay asset to parachain

2476

1

	let dest: Location = AccountKey20 {

2477

1

		network: None,

2478

1

		key: sufficient_account,

2479

1

2480

1

	.into();

2481

1

	Relay::execute_with(|| {

2482

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2483

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2484

1

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

2485

1

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

2486

1

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

2487

1

0,

2488

1

			WeightLimit::Unlimited

2489

1

));

2490

1

});

2491

1

2492

1

	// Evm account sufficient ref count increased by 1.

2493

1

	ParaA::execute_with(|| {

2494

1

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

2495

1

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

2496

1

		// remove contract data

2497

1

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

2498

1

});

2499

1

2500

1

	ParaA::execute_with(|| {

2501

1

		// Remove the account from the evm context.

2502

1

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

2503

1

		// Evm account sufficient ref count decreased by 1.

2504

1

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

2505

1

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

2506

1

		// remove contract data

2507

1

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

2508

1

});

2509

1

2510

2511

#[test]

2512

1

fn empty_account_should_not_be_reset() {

2513

1

	MockNet::reset();

2514

1

2515

1

	// Test account has nonce 1 on genesis.

2516

1

	let mut sufficient_account = [0u8; 20];

2517

1

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

2518

1

2519

1

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

2520

1

2521

1

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

2522

1

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

2523

1

	let asset_metadata = parachain::AssetMetadata {

2524

1

		name: b"RelayToken".to_vec(),

2525

1

		symbol: b"Relay".to_vec(),

2526

1

		decimals: 12,

2527

1

};

2528

1

	// register relay asset in parachain A

2529

1

	ParaA::execute_with(|| {

2530

1

		assert_ok!(AssetManager::register_foreign_asset(

2531

1

			parachain::RuntimeOrigin::root(),

2532

1

			source_location.clone(),

2533

1

			asset_metadata,

2534

1

			1u128,

2535

1

			false

2536

1

));

2537

1

		assert_ok!(add_supported_asset(source_location, 0));

2538

1

});

2539

1

2540

1

	// Send native token to evm_account

2541

1

	ParaA::execute_with(|| {

2542

1

		assert_ok!(ParaBalances::transfer_allow_death(

2543

1

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

2544

1

			evm_account_id,

2545

1

2546

1

));

2547

1

});

2548

1

2549

1

	// Actually send relay asset to parachain

2550

1

	let dest: Location = AccountKey20 {

2551

1

		network: None,

2552

1

		key: sufficient_account,

2553

1

2554

1

	.into();

2555

1

	Relay::execute_with(|| {

2556

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2557

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2558

1

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

2559

1

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

2560

1

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

2561

1

0,

2562

1

			WeightLimit::Unlimited

2563

1

));

2564

1

});

2565

1

2566

1

	ParaA::execute_with(|| {

2567

1

		// Empty the assets from the account.

2568

1

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

2569

1

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

2570

1

		assert_ok!(parachain::Assets::transfer(

2571

1

			parachain::RuntimeOrigin::signed(evm_account_id),

2572

1

			source_id,

2573

1

			PARAALICE.into(),

2574

1

2575

1

));

2576

		// Verify account asset balance is Zero.

2577

1

		assert_eq!(

2578

1

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

2579

1

2580

1

);

2581

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

2582

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

2583

1

		assert_ok!(ParaBalances::force_set_balance(

2584

1

			parachain::RuntimeOrigin::root(),

2585

1

			evm_account_id,

2586

1

0,

2587

1

));

2588

		// Verify account native balance is Zero.

2589

1

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

2590

		// Remove the account from the evm context.

2591

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

2592

1

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

2593

1

		// Verify reference count.

2594

1

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

2595

1

		assert_eq!(account.sufficients, 0);

2596

1

		assert_eq!(account.consumers, 0);

2597

1

		assert_eq!(account.providers, 1);

2598

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

2599

1

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

2600

1

});

2601

1

2602

2603

#[test]

2604

1

fn test_statemint_like() {

2605

1

	MockNet::reset();

2606

1

2607

1

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

2608

1

2609

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2610

1

		polkadot_parachain::primitives::Sibling,

2611

1

		statemint_like::AccountId,

2612

1

	>::convert_location(&dest_para)

2613

1

	.unwrap();

2614

1

2615

1

	let statemint_asset_a_balances = Location::new(

2616

1

1,

2617

1

2618

1

			Parachain(1000),

2619

1

			PalletInstance(5),

2620

1

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

2621

1

],

2622

1

);

2623

1

	let source_location = parachain::AssetType::Xcm(

2624

1

		xcm_builder::WithLatestLocationConverter::convert(&statemint_asset_a_balances)

2625

1

			.expect("convert to v3"),

2626

1

);

2627

1

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

2628

1

2629

1

	let asset_metadata = parachain::AssetMetadata {

2630

1

		name: b"StatemintToken".to_vec(),

2631

1

		symbol: b"StatemintToken".to_vec(),

2632

1

		decimals: 12,

2633

1

};

2634

1

2635

1

	ParaA::execute_with(|| {

2636

1

		assert_ok!(AssetManager::register_foreign_asset(

2637

1

			parachain::RuntimeOrigin::root(),

2638

1

			source_location.clone(),

2639

1

			asset_metadata.clone(),

2640

1

			1u128,

2641

1

			true

2642

1

));

2643

1

		assert_ok!(add_supported_asset(source_location, 0));

2644

1

});

2645

1

2646

1

	Statemint::execute_with(|| {

2647

1

		// Set new prefix

2648

1

		statemint_like::PrefixChanger::set_prefix(

2649

1

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

2650

1

);

2651

1

		assert_ok!(StatemintAssets::create(

2652

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2653

1

0,

2654

1

			RELAYALICE,

2655

1

2656

1

));

2657

2658

1

		assert_ok!(StatemintAssets::mint(

2659

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2660

1

0,

2661

1

			RELAYALICE,

2662

1

			300000000000000

2663

1

));

2664

2665

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

2666

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2667

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2668

1

			sov,

2669

1

			100000000000000

2670

1

));

2671

2672

		// Actually send relay asset to parachain

2673

1

		let dest: Location = AccountKey20 {

2674

1

			network: None,

2675

1

			key: PARAALICE,

2676

1

2677

1

		.into();

2678

1

2679

1

		// Send asset with previous prefix

2680

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2681

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2682

1

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

2683

1

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

2684

1

			Box::new(

2685

1

2686

1

2687

1

						xcm::latest::prelude::PalletInstance(

2688

1

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

2689

1

),

2690

1

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

2691

1

],

2692

1

2693

1

2694

1

					.into()

2695

1

),

2696

1

0,

2697

1

			WeightLimit::Unlimited

2698

1

));

2699

1

});

2700

1

2701

1

	ParaA::execute_with(|| {

2702

1

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

2703

1

});

2704

1

2705

2706

#[test]

2707

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2708

1

	MockNet::reset();

2709

1

2710

1

	// Relay asset

2711

1

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

2712

1

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

2713

1

2714

1

	let relay_asset_metadata = parachain::AssetMetadata {

2715

1

		name: b"RelayToken".to_vec(),

2716

1

		symbol: b"Relay".to_vec(),

2717

1

		decimals: 12,

2718

1

};

2719

1

2720

1

	// Statemint asset

2721

1

	let statemint_asset = Location::new(

2722

1

1,

2723

1

2724

1

			Parachain(1000u32),

2725

1

			PalletInstance(5u8),

2726

1

			GeneralIndex(10u128),

2727

1

],

2728

1

);

2729

1

	let statemint_location_asset = parachain::AssetType::Xcm(

2730

1

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

2731

1

);

2732

1

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

2733

1

2734

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2735

1

		name: b"USDC".to_vec(),

2736

1

		symbol: b"USDC".to_vec(),

2737

1

		decimals: 12,

2738

1

};

2739

1

2740

1

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

2741

1

2742

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2743

1

		polkadot_parachain::primitives::Sibling,

2744

1

		statemint_like::AccountId,

2745

1

	>::convert_location(&dest_para)

2746

1

	.unwrap();

2747

1

2748

1

	ParaA::execute_with(|| {

2749

1

		assert_ok!(AssetManager::register_foreign_asset(

2750

1

			parachain::RuntimeOrigin::root(),

2751

1

			relay_location.clone(),

2752

1

			relay_asset_metadata,

2753

1

			1u128,

2754

1

			true

2755

1

));

2756

1

		assert_ok!(add_supported_asset(relay_location, 0));

2757

2758

1

		assert_ok!(AssetManager::register_foreign_asset(

2759

1

			parachain::RuntimeOrigin::root(),

2760

1

			statemint_location_asset.clone(),

2761

1

			asset_metadata_statemint_asset,

2762

1

			1u128,

2763

1

			true

2764

1

));

2765

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0));

2766

1

});

2767

1

2768

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2769

1

		network: None,

2770

1

		key: PARAALICE,

2771

1

2772

1

	.into();

2773

1

2774

1

	// Send relay chain asset to Alice in Parachain A

2775

1

	Relay::execute_with(|| {

2776

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2777

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2778

1

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

2779

1

			Box::new(

2780

1

				VersionedLocation::V4(parachain_beneficiary_from_relay)

2781

1

					.clone()

2782

1

					.into()

2783

1

),

2784

1

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

2785

1

0,

2786

1

			WeightLimit::Unlimited

2787

1

));

2788

1

});

2789

1

2790

1

	Statemint::execute_with(|| {

2791

1

		// Set new prefix

2792

1

		statemint_like::PrefixChanger::set_prefix(

2793

1

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

2794

1

);

2795

1

2796

1

		assert_ok!(StatemintAssets::create(

2797

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2798

1

10,

2799

1

			RELAYALICE,

2800

1

2801

1

));

2802

2803

1

		assert_ok!(StatemintAssets::mint(

2804

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2805

1

10,

2806

1

			RELAYALICE,

2807

1

			300000000000000

2808

1

));

2809

2810

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

2811

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

2812

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2813

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2814

1

			sov,

2815

1

			100000000000000

2816

1

));

2817

2818

		// Send statemint USDC asset to Alice in Parachain A

2819

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2820

1

			network: None,

2821

1

			key: PARAALICE,

2822

1

2823

1

		.into();

2824

1

2825

1

		// Send with new prefix

2826

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2827

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2828

1

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

2829

1

			Box::new(

2830

1

				VersionedLocation::V4(parachain_beneficiary_from_statemint)

2831

1

					.clone()

2832

1

					.into()

2833

1

),

2834

1

			Box::new(

2835

1

2836

1

2837

1

						xcm::latest::prelude::PalletInstance(

2838

1

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

2839

1

),

2840

1

						GeneralIndex(10),

2841

1

],

2842

1

2843

1

2844

1

					.into()

2845

1

),

2846

1

0,

2847

1

			WeightLimit::Unlimited

2848

1

));

2849

1

});

2850

1

2851

1

	let statemint_beneficiary = Location {

2852

1

		parents: 1,

2853

1

		interior: [

2854

1

			Parachain(1000),

2855

1

			AccountId32 {

2856

1

				network: None,

2857

1

				id: RELAYBOB.into(),

2858

1

},

2859

1

2860

1

		.into(),

2861

1

};

2862

1

2863

1

	ParaA::execute_with(|| {

2864

1

		// Alice has received 125 USDC

2865

1

		assert_eq!(

2866

1

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

2867

1

2868

1

);

2869

2870

		// Alice has received 200 Relay assets

2871

1

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

2872

1

});

2873

1

2874

1

	Statemint::execute_with(|| {

2875

1

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

2876

1

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

2877

1

});

2878

1

2879

1

	let (chain_part, beneficiary) =

2880

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2881

1

2882

1

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

2883

1

	ParaA::execute_with(|| {

2884

1

		let asset = currency_to_asset(

2885

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2886

1

			100,

2887

1

);

2888

1

		let asset_fee =

2889

1

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

2890

1

		assert_ok!(PolkadotXcm::transfer_assets(

2891

1

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

2892

1

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

2893

1

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

2894

1

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

2895

1

0,

2896

1

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

2897

1

));

2898

1

});

2899

1

2900

1

	ParaA::execute_with(|| {

2901

1

		// Alice has 100 USDC less

2902

1

		assert_eq!(

2903

1

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

2904

1

2905

1

);

2906

2907

		// Alice has 100 relay asset less

2908

1

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

2909

1

});

2910

1

2911

1

	Statemint::execute_with(|| {

2912

1

		// Check that BOB received 100 USDC on statemint

2913

1

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

2914

1

});

2915

1

2916

2917

#[test]

2918

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

2919

1

	MockNet::reset();

2920

1

2921

1

	// Relay asset

2922

1

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

2923

1

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

2924

1

2925

1

	let relay_asset_metadata = parachain::AssetMetadata {

2926

1

		name: b"RelayToken".to_vec(),

2927

1

		symbol: b"Relay".to_vec(),

2928

1

		decimals: 12,

2929

1

};

2930

1

2931

1

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

2932

1

2933

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2934

1

		polkadot_parachain::primitives::Sibling,

2935

1

		statemint_like::AccountId,

2936

1

	>::convert_location(&dest_para)

2937

1

	.unwrap();

2938

1

2939

1

	ParaA::execute_with(|| {

2940

1

		assert_ok!(AssetManager::register_foreign_asset(

2941

1

			parachain::RuntimeOrigin::root(),

2942

1

			relay_location.clone(),

2943

1

			relay_asset_metadata,

2944

1

			1u128,

2945

1

			true

2946

1

));

2947

1

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

2948

1

});

2949

1

2950

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2951

1

		network: None,

2952

1

		key: PARAALICE,

2953

1

2954

1

	.into();

2955

1

2956

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2957

1

		network: None,

2958

1

		id: RELAYALICE.into(),

2959

1

2960

1

	.into();

2961

1

2962

1

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

2963

1

	Relay::execute_with(|| {

2964

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2965

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2966

1

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

2967

1

			Box::new(

2968

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

2969

1

					.clone()

2970

1

					.into()

2971

1

),

2972

1

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

2973

1

0,

2974

1

			WeightLimit::Unlimited

2975

1

));

2976

1

});

2977

1

2978

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2979

1

	Statemint::execute_with(|| {

2980

1

		// Check Alice received 200 tokens on AssetHub

2981

1

		assert_eq!(

2982

1

			StatemintBalances::free_balance(RELAYALICE),

2983

1

			INITIAL_BALANCE + 200

2984

1

);

2985

2986

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2987

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2988

1

			sov,

2989

1

			110000000000000

2990

1

));

2991

2992

		// Now send those tokens to ParaA

2993

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2994

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2995

1

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

2996

1

			Box::new(

2997

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

2998

1

					.clone()

2999

1

					.into()

3000

1

),

3001

1

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

3002

1

0,

3003

1

			WeightLimit::Unlimited

3004

1

));

3005

1

});

3006

1

3007

1

	ParaA::execute_with(|| {

3008

1

		// Alice should have received the DOTs

3009

1

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

3010

1

});

3011

1

3012

1

	let dest = Location::new(

3013

1

1,

3014

1

3015

1

			Parachain(1000),

3016

1

			AccountId32 {

3017

1

				network: None,

3018

1

				id: RELAYBOB.into(),

3019

1

},

3020

1

],

3021

1

);

3022

1

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

3023

1

3024

1

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

3025

1

	ParaA::execute_with(|| {

3026

1

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

3027

1

		assert_ok!(PolkadotXcm::transfer_assets(

3028

1

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

3029

1

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

3030

1

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

3031

1

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

3032

1

0,

3033

1

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

3034

1

));

3035

3036

1

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

3037

1

});

3038

1

3039

1

	Statemint::execute_with(|| {

3040

1

		// Check that Bob received the tokens back in AssetHub

3041

1

		assert_eq!(

3042

1

			StatemintBalances::free_balance(RELAYBOB),

3043

1

			INITIAL_BALANCE + 100

3044

1

);

3045

1

});

3046

1

3047

1

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

3048

1

	Statemint::execute_with(|| {

3049

1

		// Now send those tokens to ParaA

3050

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3051

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3052

1

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

3053

1

			Box::new(

3054

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3055

1

					.clone()

3056

1

					.into()

3057

1

),

3058

1

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

3059

1

0,

3060

1

			WeightLimit::Unlimited

3061

1

));

3062

3063

		// 100 DOTs were deducted from Bob's account

3064

1

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

3065

1

});

3066

1

3067

1

	ParaA::execute_with(|| {

3068

1

		// Alice should have received 100 DOTs

3069

1

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

3070

1

});

3071

1

3072

3073

#[test]

3074

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3075

1

	MockNet::reset();

3076

1

3077

1

	// Relay asset

3078

1

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

3079

1

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

3080

1

3081

1

	let relay_asset_metadata = parachain::AssetMetadata {

3082

1

		name: b"RelayToken".to_vec(),

3083

1

		symbol: b"Relay".to_vec(),

3084

1

		decimals: 12,

3085

1

};

3086

1

3087

1

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

3088

1

3089

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3090

1

		polkadot_parachain::primitives::Sibling,

3091

1

		statemint_like::AccountId,

3092

1

	>::convert_location(&dest_para)

3093

1

	.unwrap();

3094

1

3095

1

	ParaA::execute_with(|| {

3096

1

		assert_ok!(AssetManager::register_foreign_asset(

3097

1

			parachain::RuntimeOrigin::root(),

3098

1

			relay_location.clone(),

3099

1

			relay_asset_metadata,

3100

1

			1u128,

3101

1

			true

3102

1

));

3103

1

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

3104

1

});

3105

1

3106

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3107

1

		network: None,

3108

1

		key: PARAALICE,

3109

1

3110

1

	.into();

3111

1

3112

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3113

1

		network: None,

3114

1

		id: RELAYALICE.into(),

3115

1

3116

1

	.into();

3117

1

3118

1

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

3119

1

	Relay::execute_with(|| {

3120

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3121

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3122

1

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

3123

1

			Box::new(

3124

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3125

1

					.clone()

3126

1

					.into()

3127

1

),

3128

1

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

3129

1

0,

3130

1

			WeightLimit::Unlimited

3131

1

));

3132

1

});

3133

1

3134

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3135

1

	Statemint::execute_with(|| {

3136

1

		// Check Alice received 200 tokens on AssetHub

3137

1

		assert_eq!(

3138

1

			StatemintBalances::free_balance(RELAYALICE),

3139

1

			INITIAL_BALANCE + 200

3140

1

);

3141

3142

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3143

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3144

1

			sov,

3145

1

			110000000000000

3146

1

));

3147

3148

		// Now send those tokens to ParaA

3149

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3150

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3151

1

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

3152

1

			Box::new(

3153

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3154

1

					.clone()

3155

1

					.into()

3156

1

),

3157

1

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

3158

1

0,

3159

1

			WeightLimit::Unlimited

3160

1

));

3161

1

});

3162

1

3163

1

	ParaA::execute_with(|| {

3164

1

		// Alice should have received the DOTs

3165

1

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

3166

1

});

3167

1

3168

1

	let dest = Location::new(

3169

1

1,

3170

1

3171

1

			Parachain(1000),

3172

1

			AccountId32 {

3173

1

				network: None,

3174

1

				id: RELAYBOB.into(),

3175

1

},

3176

1

],

3177

1

);

3178

1

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

3179

1

3180

1

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

3181

1

	ParaA::execute_with(|| {

3182

1

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

3183

1

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

3184

1

		assert_ok!(PolkadotXcm::transfer_assets(

3185

1

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

3186

1

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

3187

1

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

3188

1

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

3189

1

0,

3190

1

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

3191

1

));

3192

3193

1

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

3194

1

});

3195

1

3196

1

	Statemint::execute_with(|| {

3197

1

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

3198

1

		assert_eq!(

3199

1

			StatemintBalances::free_balance(RELAYBOB),

3200

1

			INITIAL_BALANCE + 110

3201

1

);

3202

1

});

3203

1

3204

1

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

3205

1

	Statemint::execute_with(|| {

3206

1

		// Now send those tokens to ParaA

3207

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3208

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3209

1

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

3210

1

			Box::new(

3211

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3212

1

					.clone()

3213

1

					.into()

3214

1

),

3215

1

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

3216

1

0,

3217

1

			WeightLimit::Unlimited

3218

1

));

3219

3220

		// 100 DOTs were deducted from Bob's account

3221

1

		assert_eq!(

3222

1

			StatemintBalances::free_balance(RELAYBOB),

3223

1

			INITIAL_BALANCE + 10

3224

1

);

3225

1

});

3226

1

3227

1

	ParaA::execute_with(|| {

3228

1

		// Alice should have received 100 DOTs

3229

1

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

3230

1

});

3231

1

3232

3233

#[test]

3234

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3235

1

	MockNet::reset();

3236

1

3237

1

	// Relay asset

3238

1

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

3239

1

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

3240

1

3241

1

	let relay_asset_metadata = parachain::AssetMetadata {

3242

1

		name: b"RelayToken".to_vec(),

3243

1

		symbol: b"Relay".to_vec(),

3244

1

		decimals: 12,

3245

1

};

3246

1

3247

1

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

3248

1

3249

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3250

1

		polkadot_parachain::primitives::Sibling,

3251

1

		statemint_like::AccountId,

3252

1

	>::convert_location(&dest_para)

3253

1

	.unwrap();

3254

1

3255

1

	ParaA::execute_with(|| {

3256

1

		assert_ok!(AssetManager::register_foreign_asset(

3257

1

			parachain::RuntimeOrigin::root(),

3258

1

			relay_location.clone(),

3259

1

			relay_asset_metadata,

3260

1

			1u128,

3261

1

			true

3262

1

));

3263

1

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

3264

1

});

3265

1

3266

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3267

1

		network: None,

3268

1

		key: PARAALICE,

3269

1

3270

1

	.into();

3271

1

3272

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3273

1

		network: None,

3274

1

		id: RELAYALICE.into(),

3275

1

3276

1

	.into();

3277

1

3278

1

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

3279

1

	Relay::execute_with(|| {

3280

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3281

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3282

1

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

3283

1

			Box::new(

3284

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3285

1

					.clone()

3286

1

					.into()

3287

1

),

3288

1

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

3289

1

0,

3290

1

			WeightLimit::Unlimited

3291

1

));

3292

1

});

3293

1

3294

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3295

1

	Statemint::execute_with(|| {

3296

1

		// Check Alice received 200 tokens on AssetHub

3297

1

		assert_eq!(

3298

1

			StatemintBalances::free_balance(RELAYALICE),

3299

1

			INITIAL_BALANCE + 200

3300

1

);

3301

3302

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3303

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3304

1

			sov,

3305

1

			110000000000000

3306

1

));

3307

3308

		// Now send those tokens to ParaA

3309

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3310

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3311

1

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

3312

1

			Box::new(

3313

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3314

1

					.clone()

3315

1

					.into()

3316

1

),

3317

1

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

3318

1

0,

3319

1

			WeightLimit::Unlimited

3320

1

));

3321

1

});

3322

1

3323

1

	ParaA::execute_with(|| {

3324

1

		// Alice should have received the DOTs

3325

1

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

3326

1

});

3327

1

3328

1

	let dest = Location::new(

3329

1

1,

3330

1

3331

1

			Parachain(1000),

3332

1

			AccountId32 {

3333

1

				network: None,

3334

1

				id: RELAYBOB.into(),

3335

1

},

3336

1

],

3337

1

);

3338

1

3339

1

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

3340

1

	let asset = Asset {

3341

1

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

3342

1

		fun: Fungibility::Fungible(100),

3343

1

};

3344

1

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

3345

1

	ParaA::execute_with(|| {

3346

1

		assert_ok!(PolkadotXcm::transfer_assets(

3347

1

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

3348

1

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

3349

1

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

3350

1

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

3351

1

0,

3352

1

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

3353

1

));

3354

3355

1

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

3356

1

});

3357

1

3358

1

	Statemint::execute_with(|| {

3359

1

		// Check that Bob received the tokens back in AssetHub

3360

1

		assert_eq!(

3361

1

			StatemintBalances::free_balance(RELAYBOB),

3362

1

			INITIAL_BALANCE + 100

3363

1

);

3364

1

});

3365

1

3366

1

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

3367

1

	Statemint::execute_with(|| {

3368

1

		// Now send those tokens to ParaA

3369

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3370

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3371

1

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

3372

1

			Box::new(

3373

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3374

1

					.clone()

3375

1

					.into()

3376

1

),

3377

1

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

3378

1

0,

3379

1

			WeightLimit::Unlimited

3380

1

));

3381

3382

		// 100 DOTs were deducted from Bob's account

3383

1

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

3384

1

});

3385

1

3386

1

	ParaA::execute_with(|| {

3387

1

		// Alice should have received 100 DOTs

3388

1

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

3389

1

});

3390

1

3391

3392

#[test]

3393

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3394

1

	MockNet::reset();

3395

1

3396

1

	// Relay asset

3397

1

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

3398

1

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

3399

1

3400

1

	let relay_asset_metadata = parachain::AssetMetadata {

3401

1

		name: b"RelayToken".to_vec(),

3402

1

		symbol: b"Relay".to_vec(),

3403

1

		decimals: 12,

3404

1

};

3405

1

3406

1

	// Statemint asset

3407

1

	let statemint_asset = Location::new(

3408

1

1,

3409

1

3410

1

			Parachain(1000u32),

3411

1

			PalletInstance(5u8),

3412

1

			GeneralIndex(10u128),

3413

1

],

3414

1

);

3415

1

	let statemint_location_asset = parachain::AssetType::Xcm(

3416

1

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

3417

1

);

3418

1

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

3419

1

3420

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3421

1

		name: b"USDC".to_vec(),

3422

1

		symbol: b"USDC".to_vec(),

3423

1

		decimals: 12,

3424

1

};

3425

1

3426

1

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

3427

1

3428

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3429

1

		polkadot_parachain::primitives::Sibling,

3430

1

		statemint_like::AccountId,

3431

1

	>::convert_location(&dest_para)

3432

1

	.unwrap();

3433

1

3434

1

	ParaA::execute_with(|| {

3435

1

		assert_ok!(AssetManager::register_foreign_asset(

3436

1

			parachain::RuntimeOrigin::root(),

3437

1

			relay_location.clone(),

3438

1

			relay_asset_metadata,

3439

1

			1u128,

3440

1

			true

3441

1

));

3442

1

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

3443

1

3444

1

		assert_ok!(AssetManager::register_foreign_asset(

3445

1

			parachain::RuntimeOrigin::root(),

3446

1

			statemint_location_asset.clone(),

3447

1

			asset_metadata_statemint_asset,

3448

1

			1u128,

3449

1

			true

3450

1

));

3451

1

		XcmWeightTrader::set_asset_price(statemint_asset, 0u128);

3452

1

});

3453

1

3454

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3455

1

		network: None,

3456

1

		key: PARAALICE,

3457

1

3458

1

	.into();

3459

1

3460

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3461

1

		network: None,

3462

1

		id: RELAYALICE.into(),

3463

1

3464

1

	.into();

3465

1

3466

1

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

3467

1

	Relay::execute_with(|| {

3468

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3469

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3470

1

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

3471

1

			Box::new(

3472

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3473

1

					.clone()

3474

1

					.into()

3475

1

),

3476

1

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

3477

1

0,

3478

1

			WeightLimit::Unlimited

3479

1

));

3480

1

});

3481

1

3482

1

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

3483

1

	Statemint::execute_with(|| {

3484

1

		// Check Alice received 200 tokens on AssetHub

3485

1

		assert_eq!(

3486

1

			StatemintBalances::free_balance(RELAYALICE),

3487

1

			INITIAL_BALANCE + 200

3488

1

);

3489

3490

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3491

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3492

1

			sov,

3493

1

			110000000000000

3494

1

));

3495

3496

1

		statemint_like::PrefixChanger::set_prefix(

3497

1

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

3498

1

);

3499

1

3500

1

		assert_ok!(StatemintAssets::create(

3501

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3502

1

10,

3503

1

			RELAYALICE,

3504

1

3505

1

));

3506

3507

1

		assert_ok!(StatemintAssets::mint(

3508

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3509

1

10,

3510

1

			RELAYALICE,

3511

1

			300000000000000

3512

1

));

3513

3514

		// Now send relay tokens to ParaA

3515

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3516

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3517

1

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

3518

1

			Box::new(

3519

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3520

1

					.clone()

3521

1

					.into()

3522

1

),

3523

1

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

3524

1

0,

3525

1

			WeightLimit::Unlimited

3526

1

));

3527

3528

		// Send USDC

3529

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3530

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3531

1

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

3532

1

			Box::new(

3533

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3534

1

					.clone()

3535

1

					.into()

3536

1

),

3537

1

			Box::new(

3538

1

3539

1

3540

1

						xcm::latest::prelude::PalletInstance(

3541

1

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

3542

1

),

3543

1

						GeneralIndex(10),

3544

1

],

3545

1

3546

1

3547

1

					.into()

3548

1

),

3549

1

0,

3550

1

			WeightLimit::Unlimited

3551

1

));

3552

1

});

3553

1

3554

1

	ParaA::execute_with(|| {

3555

1

		// Alice should have received the DOTs

3556

1

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

3557

3558

		// Alice has received 125 USDC

3559

1

		assert_eq!(

3560

1

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

3561

1

3562

1

);

3563

1

});

3564

1

3565

1

	let dest = Location::new(

3566

1

1,

3567

1

3568

1

			Parachain(1000),

3569

1

			AccountId32 {

3570

1

				network: None,

3571

1

				id: RELAYBOB.into(),

3572

1

},

3573

1

],

3574

1

);

3575

1

3576

1

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

3577

1

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

3578

1

	ParaA::execute_with(|| {

3579

1

		let asset = currency_to_asset(

3580

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3581

1

			100,

3582

1

);

3583

1

		let asset_fee =

3584

1

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

3585

1

		assert_ok!(PolkadotXcm::transfer_assets(

3586

1

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

3587

1

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

3588

1

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

3589

1

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

3590

1

0,

3591

1

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

3592

1

));

3593

3594

1

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

3595

1

});

3596

1

3597

1

	Statemint::execute_with(|| {

3598

1

		// Check that Bob received relay tokens back in AssetHub

3599

1

		assert_eq!(

3600

1

			StatemintBalances::free_balance(RELAYBOB),

3601

1

			INITIAL_BALANCE + 100

3602

1

);

3603

3604

		// Check that BOB received 100 USDC on AssetHub

3605

1

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

3606

1

});

3607

1

3608

1

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

3609

1

	Statemint::execute_with(|| {

3610

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3611

1

3612

1

		// Now send those tokens to ParaA

3613

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3614

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3615

1

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

3616

1

			Box::new(

3617

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3618

1

					.clone()

3619

1

					.into()

3620

1

),

3621

1

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

3622

1

0,

3623

1

			WeightLimit::Unlimited

3624

1

));

3625

3626

		// 100 DOTs were deducted from Bob's account

3627

1

		assert_eq!(

3628

1

			StatemintBalances::free_balance(RELAYBOB),

3629

1

			bob_previous_balance - 100

3630

1

);

3631

1

});

3632

1

3633

1

	ParaA::execute_with(|| {

3634

1

		// Alice should have received 100 DOTs

3635

1

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

3636

1

});

3637

1

3638

3639

#[test]

3640

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3641

1

	MockNet::reset();

3642

1

3643

1

	// Relay asset

3644

1

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

3645

1

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

3646

1

3647

1

	let relay_asset_metadata = parachain::AssetMetadata {

3648

1

		name: b"RelayToken".to_vec(),

3649

1

		symbol: b"Relay".to_vec(),

3650

1

		decimals: 12,

3651

1

};

3652

1

3653

1

	// Statemint asset

3654

1

	let statemint_asset = Location::new(

3655

1

1,

3656

1

3657

1

			Parachain(1000u32),

3658

1

			PalletInstance(5u8),

3659

1

			GeneralIndex(10u128),

3660

1

],

3661

1

);

3662

1

	let statemint_location_asset = parachain::AssetType::Xcm(

3663

1

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

3664

1

);

3665

1

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

3666

1

3667

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3668

1

		name: b"USDC".to_vec(),

3669

1

		symbol: b"USDC".to_vec(),

3670

1

		decimals: 12,

3671

1

};

3672

1

3673

1

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

3674

1

3675

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3676

1

		polkadot_parachain::primitives::Sibling,

3677

1

		statemint_like::AccountId,

3678

1

	>::convert_location(&dest_para)

3679

1

	.unwrap();

3680

1

3681

1

	ParaA::execute_with(|| {

3682

1

		assert_ok!(AssetManager::register_foreign_asset(

3683

1

			parachain::RuntimeOrigin::root(),

3684

1

			relay_location.clone(),

3685

1

			relay_asset_metadata,

3686

1

			1u128,

3687

1

			true

3688

1

));

3689

1

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

3690

1

3691

1

		assert_ok!(AssetManager::register_foreign_asset(

3692

1

			parachain::RuntimeOrigin::root(),

3693

1

			statemint_location_asset.clone(),

3694

1

			asset_metadata_statemint_asset,

3695

1

			1u128,

3696

1

			true

3697

1

));

3698

1

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

3699

1

});

3700

1

3701

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3702

1

		network: None,

3703

1

		key: PARAALICE,

3704

1

3705

1

	.into();

3706

1

3707

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3708

1

		network: None,

3709

1

		id: RELAYALICE.into(),

3710

1

3711

1

	.into();

3712

1

3713

1

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

3714

1

	Relay::execute_with(|| {

3715

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3716

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3717

1

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

3718

1

			Box::new(

3719

1

				VersionedLocation::V4(statemint_beneficiary_absolute)

3720

1

					.clone()

3721

1

					.into()

3722

1

),

3723

1

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

3724

1

0,

3725

1

			WeightLimit::Unlimited

3726

1

));

3727

1

});

3728

1

3729

1

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

3730

1

	Statemint::execute_with(|| {

3731

1

		// Check Alice received 200 tokens on AssetHub

3732

1

		assert_eq!(

3733

1

			StatemintBalances::free_balance(RELAYALICE),

3734

1

			INITIAL_BALANCE + 200

3735

1

);

3736

3737

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3738

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3739

1

			sov,

3740

1

			110000000000000

3741

1

));

3742

3743

1

		statemint_like::PrefixChanger::set_prefix(

3744

1

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

3745

1

);

3746

1

3747

1

		assert_ok!(StatemintAssets::create(

3748

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3749

1

10,

3750

1

			RELAYALICE,

3751

1

3752

1

));

3753

3754

1

		assert_ok!(StatemintAssets::mint(

3755

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3756

1

10,

3757

1

			RELAYALICE,

3758

1

			300000000000000

3759

1

));

3760

3761

		// Now send relay tokens to ParaA

3762

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3763

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3764

1

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

3765

1

			Box::new(

3766

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3767

1

					.clone()

3768

1

					.into()

3769

1

),

3770

1

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

3771

1

0,

3772

1

			WeightLimit::Unlimited

3773

1

));

3774

3775

		// Send USDC

3776

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3777

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3778

1

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

3779

1

			Box::new(

3780

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3781

1

					.clone()

3782

1

					.into()

3783

1

),

3784

1

			Box::new(

3785

1

3786

1

3787

1

						xcm::latest::prelude::PalletInstance(

3788

1

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

3789

1

),

3790

1

						GeneralIndex(10),

3791

1

],

3792

1

3793

1

3794

1

					.into()

3795

1

),

3796

1

0,

3797

1

			WeightLimit::Unlimited

3798

1

));

3799

1

});

3800

1

3801

1

	ParaA::execute_with(|| {

3802

1

		// Alice should have received the DOTs

3803

1

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

3804

3805

		// Alice has received 125 USDC

3806

1

		assert_eq!(

3807

1

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

3808

1

3809

1

);

3810

1

});

3811

1

3812

1

	let dest = Location::new(

3813

1

1,

3814

1

3815

1

			Parachain(1000),

3816

1

			AccountId32 {

3817

1

				network: None,

3818

1

				id: RELAYBOB.into(),

3819

1

},

3820

1

],

3821

1

);

3822

1

3823

1

	let statemint_asset_to_send = Asset {

3824

1

		id: AssetId(statemint_asset),

3825

1

		fun: Fungibility::Fungible(100),

3826

1

};

3827

1

3828

1

	let relay_asset_to_send = Asset {

3829

1

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

3830

1

		fun: Fungibility::Fungible(100),

3831

1

};

3832

1

3833

1

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

3834

1

	let assets_to_send: XcmAssets =

3835

1

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

3836

1

3837

1

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

3838

1

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

3839

1

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

3840

3841

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

3842

1

	ParaA::execute_with(|| {

3843

1

		assert_ok!(PolkadotXcm::transfer_assets(

3844

1

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

3845

1

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

3846

1

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

3847

1

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

3848

1

0,

3849

1

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

3850

1

));

3851

3852

1

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

3853

1

});

3854

1

3855

1

	Statemint::execute_with(|| {

3856

1

		// Check that Bob received relay tokens back in AssetHub

3857

1

		assert_eq!(

3858

1

			StatemintBalances::free_balance(RELAYBOB),

3859

1

			INITIAL_BALANCE + 100

3860

1

);

3861

3862

		// Check that BOB received 100 USDC on AssetHub

3863

1

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

3864

1

});

3865

1

3866

1

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

3867

1

	Statemint::execute_with(|| {

3868

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3869

1

3870

1

		// Now send those tokens to ParaA

3871

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3872

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3873

1

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

3874

1

			Box::new(

3875

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3876

1

					.clone()

3877

1

					.into()

3878

1

),

3879

1

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

3880

1

0,

3881

1

			WeightLimit::Unlimited

3882

1

));

3883

3884

		// 100 DOTs were deducted from Bob's account

3885

1

		assert_eq!(

3886

1

			StatemintBalances::free_balance(RELAYBOB),

3887

1

			bob_previous_balance - 100

3888

1

);

3889

1

});

3890

1

3891

1

	ParaA::execute_with(|| {

3892

1

		// Alice should have received 100 DOTs

3893

1

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

3894

1

});

3895

1

3896

3897

#[test]

3898

1

fn transact_through_signed_multilocation() {

3899

1

	MockNet::reset();

3900

1

	let mut ancestry = Location::parent();

3901

1

3902

1

	ParaA::execute_with(|| {

3903

1

		// Root can set transact info

3904

1

		assert_ok!(XcmTransactor::set_transact_info(

3905

1

			parachain::RuntimeOrigin::root(),

3906

1

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

3907

1

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

3908

1

			3000.into(),

3909

1

			20000000000.into(),

3910

1

			// 4 instructions in transact through signed

3911

1

			Some(4000.into())

3912

1

));

3913

		// Root can set transact info

3914

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3915

1

			parachain::RuntimeOrigin::root(),

3916

1

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

3917

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3918

1

));

3919

1

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

3920

1

});

3921

1

3922

1

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

3923

1

	let signed_origin: Junctions = [AccountKey20 {

3924

1

		network: None,

3925

1

		key: PARAALICE,

3926

1

}]

3927

1

	.into();

3928

1

3929

1

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

3930

1

	descend_origin_multilocation

3931

1

		.append_with(signed_origin)

3932

1

		.unwrap();

3933

1

3934

1

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

3935

1

	descend_origin_multilocation

3936

1

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

3937

1

		.unwrap();

3938

1

3939

1

	let derived = xcm_builder::Account32Hash::<

3940

1

		relay_chain::KusamaNetwork,

3941

1

		relay_chain::AccountId,

3942

1

	>::convert_location(&descend_origin_multilocation)

3943

1

	.unwrap();

3944

1

3945

1

	Relay::execute_with(|| {

3946

1

		// free execution, full amount received

3947

1

		assert_ok!(RelayBalances::transfer_allow_death(

3948

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3949

1

			derived.clone(),

3950

1

			4000004100u128,

3951

1

));

3952

		// derived account has all funds

3953

1

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

3954

		// sovereign account has 0 funds

3955

1

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

3956

1

});

3957

1

3958

1

	// Encode the call. Balances transact to para_a_account

3959

1

	// First index

3960

1

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

3961

1

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

3962

1

		relay_chain::Balances,

3963

1

>()

3964

1

	.unwrap() as u8;

3965

1

3966

1

	encoded.push(index);

3967

1

3968

1

	// Then call bytes

3969

1

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

3970

1

		// 100 to sovereign

3971

1

		dest: para_a_account(),

3972

1

		value: 100u32.into(),

3973

1

3974

1

	.encode();

3975

1

	encoded.append(&mut call_bytes);

3976

1

3977

1

	ParaA::execute_with(|| {

3978

1

		assert_ok!(XcmTransactor::transact_through_signed(

3979

1

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

3980

1

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

3981

1

			CurrencyPayment {

3982

1

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

3983

1

					Location::parent()

3984

1

				))),

3985

1

				fee_amount: None

3986

1

},

3987

1

			encoded,

3988

1

			// 4000000000 for transfer + 4000 for XCM

3989

1

			TransactWeights {

3990

1

				transact_required_weight_at_most: 4000000000.into(),

3991

1

				overall_weight: None

3992

1

},

3993

1

			false

3994

1

));

3995

1

});

3996

1

3997

1

	Relay::execute_with(|| {

3998

1

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

3999

4000

1

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

4001

1

});

4002

1

4003

4004

#[test]

4005

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4006

1

	MockNet::reset();

4007

1

	let mut ancestry = Location::parent();

4008

1

4009

1

	ParaA::execute_with(|| {

4010

1

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

4011

1

});

4012

1

4013

1

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

4014

1

	let signed_origin: Junctions = [AccountKey20 {

4015

1

		network: None,

4016

1

		key: PARAALICE,

4017

1

}]

4018

1

	.into();

4019

1

4020

1

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

4021

1

	descend_origin_multilocation

4022

1

		.append_with(signed_origin)

4023

1

		.unwrap();

4024

1

4025

1

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

4026

1

	descend_origin_multilocation

4027

1

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

4028

1

		.unwrap();

4029

1

4030

1

	let derived = xcm_builder::Account32Hash::<

4031

1

		relay_chain::KusamaNetwork,

4032

1

		relay_chain::AccountId,

4033

1

	>::convert_location(&descend_origin_multilocation)

4034

1

	.unwrap();

4035

1

4036

1

	Relay::execute_with(|| {

4037

1

		// free execution, full amount received

4038

1

		assert_ok!(RelayBalances::transfer_allow_death(

4039

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4040

1

			derived.clone(),

4041

1

			4000004100u128,

4042

1

));

4043

		// derived account has all funds

4044

1

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

4045

		// sovereign account has 0 funds

4046

1

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

4047

1

});

4048

1

4049

1

	// Encode the call. Balances transact to para_a_account

4050

1

	// First index

4051

1

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

4052

1

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

4053

1

		relay_chain::Balances,

4054

1

>()

4055

1

	.unwrap() as u8;

4056

1

4057

1

	encoded.push(index);

4058

1

4059

1

	// Then call bytes

4060

1

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

4061

1

		// 100 to sovereign

4062

1

		dest: para_a_account(),

4063

1

		value: 100u32.into(),

4064

1

4065

1

	.encode();

4066

1

	encoded.append(&mut call_bytes);

4067

1

4068

1

	let total_weight = 4000004000u64;

4069

1

	ParaA::execute_with(|| {

4070

1

		assert_ok!(XcmTransactor::transact_through_signed(

4071

1

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

4072

1

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

4073

1

			CurrencyPayment {

4074

1

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

4075

1

					Location::parent()

4076

1

				))),

4077

1

				fee_amount: Some(total_weight as u128)

4078

1

},

4079

1

			encoded,

4080

1

			// 4000000000 for transfer + 4000 for XCM

4081

1

			TransactWeights {

4082

1

				transact_required_weight_at_most: 4000000000.into(),

4083

1

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

4084

1

},

4085

1

			false

4086

1

));

4087

1

});

4088

1

4089

1

	Relay::execute_with(|| {

4090

1

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

4091

4092

1

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

4093

1

});

4094

1

4095

4096

#[test]

4097

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4098

1

	MockNet::reset();

4099

1

	let mut ancestry = Location::parent();

4100

1

4101

1

	ParaA::execute_with(|| {

4102

1

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

4103

1

});

4104

1

4105

1

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

4106

1

	let signed_origin: Junctions = [AccountKey20 {

4107

1

		network: None,

4108

1

		key: PARAALICE,

4109

1

}]

4110

1

	.into();

4111

1

4112

1

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

4113

1

	descend_origin_multilocation

4114

1

		.append_with(signed_origin)

4115

1

		.unwrap();

4116

1

4117

1

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

4118

1

	descend_origin_multilocation

4119

1

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

4120

1

		.unwrap();

4121

1

4122

1

	let derived = xcm_builder::Account32Hash::<

4123

1

		relay_chain::KusamaNetwork,

4124

1

		relay_chain::AccountId,

4125

1

	>::convert_location(&descend_origin_multilocation)

4126

1

	.unwrap();

4127

1

4128

1

	Relay::execute_with(|| {

4129

1

		// free execution, full amount received

4130

1

		assert_ok!(RelayBalances::transfer_allow_death(

4131

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4132

1

			derived.clone(),

4133

1

			4000009100u128,

4134

1

));

4135

		// derived account has all funds

4136

1

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

4137

		// sovereign account has 0 funds

4138

1

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

4139

1

});

4140

1

4141

1

	// Encode the call. Balances transact to para_a_account

4142

1

	// First index

4143

1

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

4144

1

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

4145

1

		relay_chain::Balances,

4146

1

>()

4147

1

	.unwrap() as u8;

4148

1

4149

1

	encoded.push(index);

4150

1

4151

1

	// Then call bytes

4152

1

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

4153

1

		// 100 to sovereign

4154

1

		dest: para_a_account(),

4155

1

		value: 100u32.into(),

4156

1

4157

1

	.encode();

4158

1

	encoded.append(&mut call_bytes);

4159

1

4160

1

	let total_weight = 4000009000u64;

4161

1

	ParaA::execute_with(|| {

4162

1

		assert_ok!(XcmTransactor::transact_through_signed(

4163

1

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

4164

1

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

4165

1

			CurrencyPayment {

4166

1

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

4167

1

					Location::parent()

4168

1

				))),

4169

1

				fee_amount: Some(total_weight as u128)

4170

1

},

4171

1

			encoded,

4172

1

			// 4000000000 for transfer + 9000 for XCM

4173

1

			TransactWeights {

4174

1

				transact_required_weight_at_most: 4000000000.into(),

4175

1

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

4176

1

},

4177

1

			true

4178

1

));

4179

1

});

4180

1

4181

1

	Relay::execute_with(|| {

4182

1

		// 100 transferred

4183

1

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

4184

4185

		// 4000005186 refunded

4186

1

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

4187

1

});

4188

1

4189

4190

#[test]

4191

1

fn transact_through_signed_multilocation_para_to_para() {

4192

1

	MockNet::reset();

4193

1

	let mut ancestry = Location::parent();

4194

1

4195

1

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

4196

1

4197

1

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

4198

1

4199

1

	ParaA::execute_with(|| {

4200

1

		// Root can set transact info

4201

1

		assert_ok!(XcmTransactor::set_transact_info(

4202

1

			parachain::RuntimeOrigin::root(),

4203

1

			// ParaB

4204

1

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

4205

1

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

4206

1

			3.into(),

4207

1

			20000000000.into(),

4208

1

			// 4 instructions in transact through signed

4209

1

			Some(4.into())

4210

1

));

4211

		// Root can set transact info

4212

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4213

1

			parachain::RuntimeOrigin::root(),

4214

1

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

4215

1

			parachain::ParaTokensPerSecond::get(),

4216

1

));

4217

1

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

4218

1

});

4219

1

4220

1

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

4221

1

	let signed_origin: Junctions = [AccountKey20 {

4222

1

		network: None,

4223

1

		key: PARAALICE,

4224

1

}]

4225

1

	.into();

4226

1

4227

1

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

4228

1

	descend_origin_multilocation

4229

1

		.append_with(signed_origin)

4230

1

		.unwrap();

4231

1

4232

1

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

4233

1

	descend_origin_multilocation

4234

1

		.reanchor(&para_b_location, &ancestry.interior)

4235

1

		.unwrap();

4236

1

4237

1

	let derived = xcm_builder::HashedDescription::<

4238

1

		parachain::AccountId,

4239

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4240

1

	>::convert_location(&descend_origin_multilocation)

4241

1

	.unwrap();

4242

1

4243

1

	ParaB::execute_with(|| {

4244

1

		// free execution, full amount received

4245

1

		assert_ok!(ParaBalances::transfer_allow_death(

4246

1

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

4247

1

			derived.clone(),

4248

1

			4000000104u128,

4249

1

));

4250

		// derived account has all funds

4251

1

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

4252

		// sovereign account has 0 funds

4253

1

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

4254

1

});

4255

1

4256

1

	// Encode the call. Balances transact to para_a_account

4257

1

	// First index

4258

1

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

4259

1

	let index =

4260

1

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

4261

1

			.unwrap() as u8;

4262

1

4263

1

	encoded.push(index);

4264

1

4265

1

	// Then call bytes

4266

1

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

4267

1

		// 100 to sovereign

4268

1

		dest: para_a_account_20(),

4269

1

		value: 100u32.into(),

4270

1

4271

1

	.encode();

4272

1

	encoded.append(&mut call_bytes);

4273

1

4274

1

	ParaA::execute_with(|| {

4275

1

		assert_ok!(XcmTransactor::transact_through_signed(

4276

1

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

4277

1

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

4278

1

			CurrencyPayment {

4279

1

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

4280

1

					para_b_balances

4281

1

				))),

4282

1

				fee_amount: None

4283

1

},

4284

1

			encoded,

4285

1

			// 4000000000 for transfer + 4000 for XCM

4286

1

			// 1-1 to fee

4287

1

			TransactWeights {

4288

1

				transact_required_weight_at_most: 4000000000.into(),

4289

1

				overall_weight: None

4290

1

},

4291

1

			false

4292

1

));

4293

1

});

4294

1

4295

1

	ParaB::execute_with(|| {

4296

1

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

4297

4298

1

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

4299

1

});

4300

1

4301

4302

#[test]

4303

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4304

1

	MockNet::reset();

4305

1

	let mut ancestry = Location::parent();

4306

1

4307

1

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

4308

1

4309

1

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

4310

1

4311

1

	ParaA::execute_with(|| {

4312

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4313

1

			parachain::RuntimeOrigin::root(),

4314

1

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

4315

1

			parachain::ParaTokensPerSecond::get(),

4316

1

));

4317

1

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

4318

1

});

4319

1

4320

1

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

4321

1

	let signed_origin: Junctions = [AccountKey20 {

4322

1

		network: None,

4323

1

		key: PARAALICE,

4324

1

}]

4325

1

	.into();

4326

1

4327

1

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

4328

1

	descend_origin_multilocation

4329

1

		.append_with(signed_origin)

4330

1

		.unwrap();

4331

1

4332

1

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

4333

1

	descend_origin_multilocation

4334

1

		.reanchor(&para_b_location, &ancestry.interior)

4335

1

		.unwrap();

4336

1

4337

1

	let derived = xcm_builder::HashedDescription::<

4338

1

		parachain::AccountId,

4339

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4340

1

	>::convert_location(&descend_origin_multilocation)

4341

1

	.unwrap();

4342

1

4343

1

	ParaB::execute_with(|| {

4344

1

		// free execution, full amount received

4345

1

		assert_ok!(ParaBalances::transfer_allow_death(

4346

1

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

4347

1

			derived.clone(),

4348

1

			4000009100u128,

4349

1

));

4350

		// derived account has all funds

4351

1

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

4352

		// sovereign account has 0 funds

4353

1

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

4354

1

});

4355

1

4356

1

	// Encode the call. Balances transact to para_a_account

4357

1

	// First index

4358

1

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

4359

1

	let index =

4360

1

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

4361

1

			.unwrap() as u8;

4362

1

4363

1

	encoded.push(index);

4364

1

4365

1

	// Then call bytes

4366

1

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

4367

1

		// 100 to sovereign

4368

1

		dest: para_a_account_20(),

4369

1

		value: 100u32.into(),

4370

1

4371

1

	.encode();

4372

1

	encoded.append(&mut call_bytes);

4373

1

4374

1

	let overall_weight = 4000009000u64;

4375

1

	ParaA::execute_with(|| {

4376

1

		assert_ok!(XcmTransactor::transact_through_signed(

4377

1

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

4378

1

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

4379

1

			CurrencyPayment {

4380

1

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

4381

1

					para_b_balances

4382

1

				))),

4383

1

				fee_amount: Some(overall_weight as u128)

4384

1

},

4385

1

			encoded,

4386

1

			// 4000000000 for transfer + 9000 for XCM

4387

1

			TransactWeights {

4388

1

				transact_required_weight_at_most: 4000000000.into(),

4389

1

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

4390

1

},

4391

1

			true

4392

1

));

4393

1

});

4394

1

4395

1

	ParaB::execute_with(|| {

4396

1

		// Check the derived account was refunded

4397

1

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

4398

4399

		// Check the transfer was executed

4400

1

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

4401

1

});

4402

1

4403

4404

#[test]

4405

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4406

1

	MockNet::reset();

4407

1

	let mut ancestry = Location::parent();

4408

1

4409

1

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

4410

1

4411

1

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

4412

1

4413

1

	ParaA::execute_with(|| {

4414

1

		// Root can set transact info

4415

1

		assert_ok!(XcmTransactor::set_transact_info(

4416

1

			parachain::RuntimeOrigin::root(),

4417

1

			// ParaB

4418

1

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

4419

1

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

4420

1

			3.into(),

4421

1

			20000000000.into(),

4422

1

			// 4 instructions in transact through signed

4423

1

			Some(4.into())

4424

1

));

4425

		// Root can set transact info

4426

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4427

1

			parachain::RuntimeOrigin::root(),

4428

1

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

4429

1

			parachain::ParaTokensPerSecond::get(),

4430

1

));

4431

1

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

4432

1

});

4433

1

4434

1

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

4435

1

	let signed_origin: Junctions = [AccountKey20 {

4436

1

		network: None,

4437

1

		key: PARAALICE,

4438

1

}]

4439

1

	.into();

4440

1

4441

1

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

4442

1

	descend_origin_multilocation

4443

1

		.append_with(signed_origin)

4444

1

		.unwrap();

4445

1

4446

1

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

4447

1

	descend_origin_multilocation

4448

1

		.reanchor(&para_b_location, &ancestry.interior)

4449

1

		.unwrap();

4450

1

4451

1

	let derived = xcm_builder::HashedDescription::<

4452

1

		parachain::AccountId,

4453

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4454

1

	>::convert_location(&descend_origin_multilocation)

4455

1

	.unwrap();

4456

1

4457

1

	let mut parachain_b_alice_balances_before = 0;

4458

1

	ParaB::execute_with(|| {

4459

1

		assert_ok!(ParaBalances::transfer_allow_death(

4460

1

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

4461

1

			derived.clone(),

4462

1

			4000000104u128,

4463

1

));

4464

		// derived account has all funds

4465

1

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

4466

		// sovereign account has 0 funds

4467

1

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

4468

4469

1

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

4470

1

});

4471

1

4472

1

	// Encode the call. Balances transact to para_a_account

4473

1

	// First index

4474

1

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

4475

1

	let index =

4476

1

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

4477

1

			.unwrap() as u8;

4478

1

4479

1

	encoded.push(index);

4480

1

4481

1

	use sp_core::U256;

4482

1

	// Let's do a EVM transfer

4483

1

	let eth_tx =

4484

1

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

4485

1

			gas_limit: U256::from(21000),

4486

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4487

1

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

4488

1

			value: U256::from(100),

4489

1

			input: BoundedVec::<

4490

1

u8,

4491

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4492

1

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

4493

1

			access_list: None,

4494

1

});

4495

1

4496

1

	// Then call bytes

4497

1

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

4498

1

		xcm_transaction: eth_tx,

4499

1

4500

1

	.encode();

4501

1

	encoded.append(&mut call_bytes);

4502

1

4503

1

	ParaA::execute_with(|| {

4504

1

		assert_ok!(XcmTransactor::transact_through_signed(

4505

1

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

4506

1

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

4507

1

			CurrencyPayment {

4508

1

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

4509

1

					para_b_balances

4510

1

				))),

4511

1

				fee_amount: None

4512

1

},

4513

1

			encoded,

4514

1

			// 4000000000 for transfer + 4000 for XCM

4515

1

			// 1-1 to fee

4516

1

			TransactWeights {

4517

1

				transact_required_weight_at_most: 4000000000.into(),

4518

1

				overall_weight: None

4519

1

},

4520

1

			false

4521

1

));

4522

1

});

4523

1

4524

1

	ParaB::execute_with(|| {

4525

1

		// Make sure the EVM transfer went through

4526

1

		assert!(

4527

1

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

4528

1

				== parachain_b_alice_balances_before + 100

4529

1

);

4530

1

});

4531

1

4532

4533

#[test]

4534

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4535

1

	MockNet::reset();

4536

1

	let mut ancestry = Location::parent();

4537

1

4538

1

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

4539

1

4540

1

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

4541

1

4542

1

	ParaA::execute_with(|| {

4543

1

		// Root can set transact info

4544

1

		assert_ok!(XcmTransactor::set_transact_info(

4545

1

			parachain::RuntimeOrigin::root(),

4546

1

			// ParaB

4547

1

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

4548

1

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

4549

1

			3.into(),

4550

1

			20000000000.into(),

4551

1

			// 4 instructions in transact through signed

4552

1

			Some(4.into())

4553

1

));

4554

		// Root can set transact info

4555

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4556

1

			parachain::RuntimeOrigin::root(),

4557

1

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

4558

1

			parachain::ParaTokensPerSecond::get(),

4559

1

));

4560

1

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

4561

1

});

4562

1

4563

1

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

4564

1

	let signed_origin: Junctions = [AccountKey20 {

4565

1

		network: None,

4566

1

		key: PARAALICE,

4567

1

}]

4568

1

	.into();

4569

1

4570

1

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

4571

1

	descend_origin_multilocation

4572

1

		.append_with(signed_origin)

4573

1

		.unwrap();

4574

1

4575

1

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

4576

1

	descend_origin_multilocation

4577

1

		.reanchor(&para_b_location, &ancestry.interior)

4578

1

		.unwrap();

4579

1

4580

1

	let derived = xcm_builder::HashedDescription::<

4581

1

		parachain::AccountId,

4582

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4583

1

	>::convert_location(&descend_origin_multilocation)

4584

1

	.unwrap();

4585

1

4586

1

	let mut parachain_b_alice_balances_before = 0;

4587

1

	ParaB::execute_with(|| {

4588

1

		assert_ok!(ParaBalances::transfer_allow_death(

4589

1

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

4590

1

			derived.clone(),

4591

1

			4000000104u128,

4592

1

));

4593

		// derived account has all funds

4594

1

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

4595

		// sovereign account has 0 funds

4596

1

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

4597

4598

1

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

4599

1

});

4600

1

4601

1

	// Encode the call. Balances transact to para_a_account

4602

1

	// First index

4603

1

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

4604

1

	let index =

4605

1

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

4606

1

			.unwrap() as u8;

4607

1

4608

1

	encoded.push(index);

4609

1

4610

1

	use sp_core::U256;

4611

1

	// Let's do a EVM transfer

4612

1

	let eth_tx =

4613

1

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

4614

1

			gas_limit: U256::from(21000),

4615

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4616

1

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

4617

1

			value: U256::from(100),

4618

1

			input: BoundedVec::<

4619

1

u8,

4620

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4621

1

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

4622

1

			access_list: None,

4623

1

});

4624

1

4625

1

	// Then call bytes

4626

1

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

4627

1

		transact_as: PARAALICE.into(),

4628

1

		xcm_transaction: eth_tx,

4629

1

4630

1

	.encode();

4631

1

	encoded.append(&mut call_bytes);

4632

1

4633

1

	ParaA::execute_with(|| {

4634

1

		assert_ok!(XcmTransactor::transact_through_signed(

4635

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4636

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4637

1

			CurrencyPayment {

4638

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4639

1

					para_b_balances

4640

1

				))),

4641

1

				fee_amount: None

4642

1

},

4643

1

			encoded,

4644

1

			TransactWeights {

4645

1

				transact_required_weight_at_most: 4000000000.into(),

4646

1

				overall_weight: None

4647

1

},

4648

1

			false

4649

1

));

4650

1

});

4651

1

4652

1

	ParaB::execute_with(|| {

4653

1

		// Make sure the EVM transfer wasn't executed

4654

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4655

1

});

4656

1

4657

4658

#[test]

4659

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4660

1

	MockNet::reset();

4661

1

	let mut ancestry = Location::parent();

4662

1

4663

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4664

1

4665

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4666

1

4667

1

	ParaA::execute_with(|| {

4668

1

		// Root can set transact info

4669

1

		assert_ok!(XcmTransactor::set_transact_info(

4670

1

			parachain::RuntimeOrigin::root(),

4671

1

			// ParaB

4672

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4673

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4674

1

			3.into(),

4675

1

			20000000000.into(),

4676

1

			// 4 instructions in transact through signed

4677

1

			Some(4.into())

4678

1

));

4679

		// Root can set transact info

4680

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4681

1

			parachain::RuntimeOrigin::root(),

4682

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4683

1

			parachain::ParaTokensPerSecond::get(),

4684

1

));

4685

1

		ancestry = parachain::UniversalLocation::get().into();

4686

1

});

4687

1

4688

1

	// Let's construct the Junction that we will append with DescendOrigin

4689

1

	let signed_origin: Junctions = [AccountKey20 {

4690

1

		network: None,

4691

1

		key: PARAALICE,

4692

1

}]

4693

1

	.into();

4694

1

4695

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4696

1

	descend_origin_multilocation

4697

1

		.append_with(signed_origin)

4698

1

		.unwrap();

4699

1

4700

1

	// To convert it to what the paraB will see instead of us

4701

1

	descend_origin_multilocation

4702

1

		.reanchor(&para_b_location, &ancestry.interior)

4703

1

		.unwrap();

4704

1

4705

1

	let derived = xcm_builder::HashedDescription::<

4706

1

		parachain::AccountId,

4707

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4708

1

	>::convert_location(&descend_origin_multilocation)

4709

1

	.unwrap();

4710

1

4711

1

	let transfer_recipient = evm_account();

4712

1

	let mut transfer_recipient_balance_before = 0;

4713

1

	ParaB::execute_with(|| {

4714

1

		assert_ok!(ParaBalances::transfer_allow_death(

4715

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4716

1

			derived.clone(),

4717

1

			4000000104u128,

4718

1

));

4719

		// derived account has all funds

4720

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4721

		// sovereign account has 0 funds

4722

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4723

4724

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

4725

1

4726

1

		// Add proxy ALICE  -> derived

4727

1

		let _ = parachain::Proxy::add_proxy_delegate(

4728

1

			&PARAALICE.into(),

4729

1

			derived,

4730

1

			parachain::ProxyType::Any,

4731

1

0,

4732

1

);

4733

1

});

4734

1

4735

1

	// Encode the call. Balances transact to para_a_account

4736

1

	// First index

4737

1

	let mut encoded: Vec<u8> = Vec::new();

4738

1

	let index =

4739

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4740

1

			.unwrap() as u8;

4741

1

4742

1

	encoded.push(index);

4743

1

4744

1

	use sp_core::U256;

4745

1

	// Let's do a EVM transfer

4746

1

	let eth_tx =

4747

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4748

1

			gas_limit: U256::from(21000),

4749

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

4750

1

			value: U256::from(100),

4751

1

			input: BoundedVec::<

4752

1

u8,

4753

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4754

1

			>::try_from(vec![]).unwrap(),

4755

1

			access_list: None,

4756

1

});

4757

1

4758

1

	// Then call bytes

4759

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4760

1

		transact_as: PARAALICE.into(),

4761

1

		xcm_transaction: eth_tx,

4762

1

4763

1

	.encode();

4764

1

	encoded.append(&mut call_bytes);

4765

1

4766

1

	ParaA::execute_with(|| {

4767

1

		assert_ok!(XcmTransactor::transact_through_signed(

4768

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4769

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4770

1

			CurrencyPayment {

4771

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4772

1

					para_b_balances

4773

1

				))),

4774

1

				fee_amount: None

4775

1

},

4776

1

			encoded,

4777

1

			TransactWeights {

4778

1

				transact_required_weight_at_most: 4000000000.into(),

4779

1

				overall_weight: None

4780

1

},

4781

1

			false

4782

1

));

4783

1

});

4784

1

4785

1

	ParaB::execute_with(|| {

4786

1

		// Make sure the EVM transfer was executed

4787

1

		assert!(

4788

1

			ParaBalances::free_balance(&transfer_recipient.into())

4789

1

				== transfer_recipient_balance_before + 100

4790

1

);

4791

1

});

4792

1

4793

4794

#[test]

4795

1

fn hrmp_init_accept_through_root() {

4796

1

	MockNet::reset();

4797

1

4798

1

	Relay::execute_with(|| {

4799

1

		assert_ok!(RelayBalances::transfer_allow_death(

4800

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4801

1

			para_a_account(),

4802

1

			1000u128

4803

1

));

4804

1

		assert_ok!(RelayBalances::transfer_allow_death(

4805

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4806

1

			para_b_account(),

4807

1

			1000u128

4808

1

));

4809

1

});

4810

1

4811

1

	ParaA::execute_with(|| {

4812

1

		let total_fee = 1_000u128;

4813

1

		let total_weight: u64 = 1_000_000_000;

4814

1

		let tx_weight: u64 = 500_000_000;

4815

1

		// Root can send hrmp init channel

4816

1

		assert_ok!(XcmTransactor::hrmp_manage(

4817

1

			parachain::RuntimeOrigin::root(),

4818

1

			HrmpOperation::InitOpen(HrmpInitParams {

4819

1

				para_id: 2u32.into(),

4820

1

				proposed_max_capacity: 1,

4821

1

				proposed_max_message_size: 1

4822

1

}),

4823

1

			CurrencyPayment {

4824

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4825

1

					Location::parent()

4826

1

				))),

4827

1

				fee_amount: Some(total_fee)

4828

1

},

4829

1

			TransactWeights {

4830

1

				transact_required_weight_at_most: tx_weight.into(),

4831

1

				overall_weight: Some(Limited(total_weight.into()))

4832

1

4833

1

));

4834

1

});

4835

1

	Relay::execute_with(|| {

4836

1

		let expected_event: relay_chain::RuntimeEvent =

4837

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4838

1

				sender: 1u32.into(),

4839

1

				recipient: 2u32.into(),

4840

1

				proposed_max_capacity: 1u32,

4841

1

				proposed_max_message_size: 1u32,

4842

1

4843

1

			.into();

4844

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4845

1

});

4846

1

	ParaB::execute_with(|| {

4847

1

		let total_fee = 1_000u128;

4848

1

		let total_weight: u64 = 1_000_000_000;

4849

1

		let tx_weight: u64 = 500_000_000;

4850

1

		// Root can send hrmp accept channel

4851

1

		assert_ok!(XcmTransactor::hrmp_manage(

4852

1

			parachain::RuntimeOrigin::root(),

4853

1

			HrmpOperation::Accept {

4854

1

				para_id: 1u32.into()

4855

1

},

4856

1

			CurrencyPayment {

4857

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4858

1

					Location::parent()

4859

1

				))),

4860

1

				fee_amount: Some(total_fee)

4861

1

},

4862

1

			TransactWeights {

4863

1

				transact_required_weight_at_most: tx_weight.into(),

4864

1

				overall_weight: Some(Limited(total_weight.into()))

4865

1

4866

1

));

4867

1

});

4868

1

4869

1

	Relay::execute_with(|| {

4870

1

		let expected_event: relay_chain::RuntimeEvent =

4871

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4872

1

				sender: 1u32.into(),

4873

1

				recipient: 2u32.into(),

4874

1

4875

1

			.into();

4876

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4877

1

});

4878

1

4879

4880

#[test]

4881

1

fn hrmp_close_works() {

4882

1

	MockNet::reset();

4883

1

4884

1

	Relay::execute_with(|| {

4885

1

		assert_ok!(RelayBalances::transfer_allow_death(

4886

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4887

1

			para_a_account(),

4888

1

			1000u128

4889

1

));

4890

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4891

1

			relay_chain::RuntimeOrigin::root(),

4892

1

			1u32.into(),

4893

1

			2u32.into(),

4894

1

			1u32,

4895

1

			1u32

4896

1

));

4897

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4898

1

			relay_chain::RuntimeOrigin::root(),

4899

1

			1u32

4900

1

));

4901

1

});

4902

1

4903

1

	ParaA::execute_with(|| {

4904

1

		let total_fee = 1_000u128;

4905

1

		let total_weight: u64 = 1_000_000_000;

4906

1

		let tx_weight: u64 = 500_000_000;

4907

1

		assert_ok!(XcmTransactor::hrmp_manage(

4908

1

			parachain::RuntimeOrigin::root(),

4909

1

			HrmpOperation::Close(HrmpChannelId {

4910

1

				sender: 1u32.into(),

4911

1

				recipient: 2u32.into()

4912

1

}),

4913

1

			CurrencyPayment {

4914

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4915

1

					Location::parent()

4916

1

				))),

4917

1

				fee_amount: Some(total_fee)

4918

1

},

4919

1

			TransactWeights {

4920

1

				transact_required_weight_at_most: tx_weight.into(),

4921

1

				overall_weight: Some(Limited(total_weight.into()))

4922

1

4923

1

));

4924

1

});

4925

1

	Relay::execute_with(|| {

4926

1

		let expected_event: relay_chain::RuntimeEvent =

4927

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4928

1

				by_parachain: 1u32.into(),

4929

1

				channel_id: HrmpChannelId {

4930

1

					sender: 1u32.into(),

4931

1

					recipient: 2u32.into(),

4932

1

},

4933

1

4934

1

			.into();

4935

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4936

1

});

4937

1

4938

4939

use parity_scale_codec::{Decode, Encode};

4940

use sp_io::hashing::blake2_256;

4941

4942

// Helper to derive accountIds

4943

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4944

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4945

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4946

7