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

//! Moonriver Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{PalletInfo, PalletInfoAccess},

23

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

24

	BoundedVec,

25

};

26

use sp_core::ConstU32;

27

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

28

use xcm::{

29

	latest::prelude::{

30

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

31

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

32

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

33

		WeightLimit, WithdrawAsset, Xcm,

34

},

35

	IntoVersion, VersionedAssets, VersionedLocation, WrapVersion,

36

};

37

use xcm_executor::traits::ConvertLocation;

38

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

39

use xcm_mock::relay_chain;

40

use xcm_mock::*;

41

use xcm_simulator::TestExt;

42

mod common;

43

use cumulus_primitives_core::relay_chain::HrmpChannelId;

44

use pallet_xcm_transactor::{

45

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

46

};

47

use xcm_primitives::{

48

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

49

};

50

51

28

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

52

28

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

53

28

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

54

28

		.into_version(4)

55

28

		.map_err(|_| ())?

56

	else {

57

		return Err(());

58

};

59

	use frame_support::weights::WeightToFee as _;

60

28

	let native_amount_per_second: u128 =

61

28

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

62

28

			&Weight::from_parts(

63

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

64

28

0,

65

28

),

66

28

67

28

		.try_into()

68

28

		.map_err(|_| ())?;

69

28

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

70

28

	let relative_price: u128 = if units_per_second > 0u128 {

71

10

		native_amount_per_second

72

10

			.saturating_mul(precision_factor)

73

10

			.saturating_div(units_per_second)

74

	} else {

75

18

		0u128

76

};

77

28

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

78

28

		location_v4,

79

28

		(true, relative_price),

80

28

);

81

28

	Ok(())

82

28

83

84

25

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

85

25

	Asset {

86

25

		id: AssetId(

87

25

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

88

25

				currency_id,

89

25

90

25

			.unwrap(),

91

25

),

92

25

		fun: Fungibility::Fungible(amount),

93

25

94

25

95

96

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

97

#[test]

98

1

fn receive_relay_asset_from_relay() {

99

1

	MockNet::reset();

100

1

101

1

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

102

1

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

103

1

	let asset_metadata = parachain::AssetMetadata {

104

1

		name: b"RelayToken".to_vec(),

105

1

		symbol: b"Relay".to_vec(),

106

1

		decimals: 12,

107

1

};

108

1

	// Register relay asset in parachain A

109

1

	ParaA::execute_with(|| {

110

1

		assert_ok!(AssetManager::register_foreign_asset(

111

1

			parachain::RuntimeOrigin::root(),

112

1

			source_location.clone(),

113

1

			asset_metadata,

114

1

			1u128,

115

1

			true

116

1

));

117

1

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

118

1

});

119

1

120

1

	// Actually send relay asset to parachain

121

1

	let dest: Location = AccountKey20 {

122

1

		network: None,

123

1

		key: PARAALICE,

124

1

125

1

	.into();

126

1

	Relay::execute_with(|| {

127

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

128

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

129

1

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

130

1

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

131

1

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

132

1

0,

133

1

			WeightLimit::Unlimited

134

1

));

135

1

});

136

1

137

1

	// Verify that parachain received the asset

138

1

	ParaA::execute_with(|| {

139

1

		// free execution, full amount received

140

1

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

141

1

});

142

1

143

144

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

145

#[test]

146

1

fn send_relay_asset_to_relay() {

147

1

	MockNet::reset();

148

1

149

1

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

150

1

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

151

1

152

1

	let asset_metadata = parachain::AssetMetadata {

153

1

		name: b"RelayToken".to_vec(),

154

1

		symbol: b"Relay".to_vec(),

155

1

		decimals: 12,

156

1

};

157

1

158

1

	// Register relay asset in paraA

159

1

	ParaA::execute_with(|| {

160

1

		assert_ok!(AssetManager::register_foreign_asset(

161

1

			parachain::RuntimeOrigin::root(),

162

1

			source_location.clone(),

163

1

			asset_metadata,

164

1

			1u128,

165

1

			true

166

1

));

167

		// free execution

168

1

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

169

1

});

170

1

171

1

	let dest: Location = Junction::AccountKey20 {

172

1

		network: None,

173

1

		key: PARAALICE,

174

1

175

1

	.into();

176

1

177

1

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

178

1

	Relay::execute_with(|| {

179

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

180

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

181

1

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

182

1

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

183

1

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

184

1

0,

185

1

			WeightLimit::Unlimited

186

1

));

187

1

});

188

1

189

1

	ParaA::execute_with(|| {

190

1

		// Free execution, full amount received

191

1

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

192

1

});

193

1

194

1

	// Lets gather the balance before sending back money

195

1

	let mut balance_before_sending = 0;

196

1

	Relay::execute_with(|| {

197

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

198

1

});

199

1

200

1

	// We now send back some money to the relay

201

1

	let dest = Location {

202

1

		parents: 1,

203

1

		interior: [AccountId32 {

204

1

			network: None,

205

1

			id: RELAYALICE.into(),

206

1

}]

207

1

		.into(),

208

1

};

209

1

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

210

1

211

1

	ParaA::execute_with(|| {

212

1

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

213

1

		assert_ok!(PolkadotXcm::transfer_assets(

214

1

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

215

1

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

216

1

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

217

1

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

218

1

0,

219

1

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

220

1

));

221

1

});

222

1

223

1

	// The balances in paraAlice should have been substracted

224

1

	ParaA::execute_with(|| {

225

1

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

226

1

});

227

1

228

1

	// Balances in the relay should have been received

229

1

	Relay::execute_with(|| {

230

1

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

231

1

});

232

1

233

234

#[test]

235

1

fn send_relay_asset_to_para_b() {

236

1

	MockNet::reset();

237

1

238

1

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

239

1

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

240

1

241

1

	let asset_metadata = parachain::AssetMetadata {

242

1

		name: b"RelayToken".to_vec(),

243

1

		symbol: b"Relay".to_vec(),

244

1

		decimals: 12,

245

1

};

246

1

247

1

	// Register asset in paraA. Free execution

248

1

	ParaA::execute_with(|| {

249

1

		assert_ok!(AssetManager::register_foreign_asset(

250

1

			parachain::RuntimeOrigin::root(),

251

1

			source_location.clone(),

252

1

			asset_metadata.clone(),

253

1

			1u128,

254

1

			true

255

1

));

256

1

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

257

1

});

258

1

259

1

	// Register asset in paraB. Free execution

260

1

	ParaB::execute_with(|| {

261

1

		assert_ok!(AssetManager::register_foreign_asset(

262

1

			parachain::RuntimeOrigin::root(),

263

1

			source_location.clone(),

264

1

			asset_metadata,

265

1

			1u128,

266

1

			true

267

1

));

268

1

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

269

1

});

270

1

271

1

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

272

1

	let dest: Location = Junction::AccountKey20 {

273

1

		network: None,

274

1

		key: PARAALICE,

275

1

276

1

	.into();

277

1

	Relay::execute_with(|| {

278

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

279

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

280

1

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

281

1

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

282

1

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

283

1

0,

284

1

			WeightLimit::Unlimited

285

1

));

286

1

});

287

1

288

1

	ParaA::execute_with(|| {

289

1

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

290

1

});

291

1

292

1

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

293

1

	let dest = Location {

294

1

		parents: 1,

295

1

		interior: [

296

1

			Parachain(2),

297

1

			AccountKey20 {

298

1

				network: None,

299

1

				key: PARAALICE.into(),

300

1

},

301

1

302

1

		.into(),

303

1

};

304

1

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

305

1

306

1

	ParaA::execute_with(|| {

307

1

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

308

1

		assert_ok!(PolkadotXcm::transfer_assets(

309

1

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

310

1

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

311

1

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

312

1

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

313

1

0,

314

1

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

315

1

));

316

1

});

317

1

318

1

	// Para A balances should have been substracted

319

1

	ParaA::execute_with(|| {

320

1

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

321

1

});

322

1

323

1

	// Para B balances should have been credited

324

1

	ParaB::execute_with(|| {

325

1

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

326

1

});

327

1

328

329

#[test]

330

1

fn send_para_a_asset_to_para_b() {

331

1

	MockNet::reset();

332

1

333

1

	// This represents the asset in paraA

334

1

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

335

1

	let source_location = parachain::AssetType::Xcm(

336

1

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

337

1

);

338

1

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

339

1

340

1

	let asset_metadata = parachain::AssetMetadata {

341

1

		name: b"ParaAToken".to_vec(),

342

1

		symbol: b"ParaA".to_vec(),

343

1

		decimals: 18,

344

1

};

345

1

346

1

	// Register asset in paraB. Free execution

347

1

	ParaB::execute_with(|| {

348

1

		assert_ok!(AssetManager::register_foreign_asset(

349

1

			parachain::RuntimeOrigin::root(),

350

1

			source_location.clone(),

351

1

			asset_metadata,

352

1

			1u128,

353

1

			true

354

1

));

355

1

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

356

1

});

357

1

358

1

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

359

1

	let dest = Location {

360

1

		parents: 1,

361

1

		interior: [

362

1

			Parachain(2),

363

1

			AccountKey20 {

364

1

				network: None,

365

1

				key: PARAALICE.into(),

366

1

},

367

1

368

1

		.into(),

369

1

};

370

1

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

371

1

372

1

	ParaA::execute_with(|| {

373

1

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

374

1

		assert_ok!(PolkadotXcm::transfer_assets(

375

1

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

376

1

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

377

1

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

378

1

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

379

1

0,

380

1

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

381

1

));

382

1

});

383

1

384

1

	// Native token is substracted in paraA

385

1

	ParaA::execute_with(|| {

386

1

		// free execution, full amount received

387

1

		assert_eq!(

388

1

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

389

1

			INITIAL_BALANCE - 100

390

1

);

391

1

});

392

1

393

1

	// Asset is minted in paraB

394

1

	ParaB::execute_with(|| {

395

1

		// free execution, full amount received

396

1

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

397

1

});

398

1

399

400

#[test]

401

1

fn send_para_a_asset_from_para_b_to_para_c() {

402

1

	MockNet::reset();

403

1

404

1

	// Represents para A asset

405

1

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

406

1

	let source_location = parachain::AssetType::Xcm(

407

1

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

408

1

);

409

1

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

410

1

411

1

	let asset_metadata = parachain::AssetMetadata {

412

1

		name: b"ParaAToken".to_vec(),

413

1

		symbol: b"ParaA".to_vec(),

414

1

		decimals: 18,

415

1

};

416

1

417

1

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

418

1

	ParaB::execute_with(|| {

419

1

		assert_ok!(AssetManager::register_foreign_asset(

420

1

			parachain::RuntimeOrigin::root(),

421

1

			source_location.clone(),

422

1

			asset_metadata.clone(),

423

1

			1u128,

424

1

			true

425

1

));

426

1

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

427

1

});

428

1

429

1

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

430

1

	ParaC::execute_with(|| {

431

1

		assert_ok!(AssetManager::register_foreign_asset(

432

1

			parachain::RuntimeOrigin::root(),

433

1

			source_location.clone(),

434

1

			asset_metadata,

435

1

			1u128,

436

1

			true

437

1

));

438

1

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

439

1

});

440

1

441

1

	// Send para A asset to para B

442

1

	let dest = Location {

443

1

		parents: 1,

444

1

		interior: [

445

1

			Parachain(2),

446

1

			AccountKey20 {

447

1

				network: None,

448

1

				key: PARAALICE.into(),

449

1

},

450

1

451

1

		.into(),

452

1

};

453

1

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

454

1

455

1

	ParaA::execute_with(|| {

456

1

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

457

1

		assert_ok!(PolkadotXcm::transfer_assets(

458

1

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

459

1

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

460

1

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

461

1

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

462

1

0,

463

1

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

464

1

));

465

1

});

466

1

467

1

	// Para A balances have been substracted

468

1

	ParaA::execute_with(|| {

469

1

		assert_eq!(

470

1

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

471

1

			INITIAL_BALANCE - 100

472

1

);

473

1

});

474

1

475

1

	// Para B balances have been credited

476

1

	ParaB::execute_with(|| {

477

1

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

478

1

});

479

1

480

1

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

481

1

	let dest = Location {

482

1

		parents: 1,

483

1

		interior: [

484

1

			Parachain(3),

485

1

			AccountKey20 {

486

1

				network: None,

487

1

				key: PARAALICE.into(),

488

1

},

489

1

490

1

		.into(),

491

1

};

492

1

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

493

1

494

1

	ParaB::execute_with(|| {

495

1

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

496

1

		assert_ok!(PolkadotXcm::transfer_assets(

497

1

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

498

1

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

499

1

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

500

1

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

501

1

0,

502

1

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

503

1

));

504

1

});

505

1

506

1

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

507

1

	ParaC::execute_with(|| {

508

1

		// free execution, full amount received

509

1

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

510

1

});

511

1

512

513

#[test]

514

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

515

1

	MockNet::reset();

516

1

517

1

	// Para A asset

518

1

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

519

1

	let source_location = parachain::AssetType::Xcm(

520

1

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

521

1

);

522

1

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

523

1

524

1

	let asset_metadata = parachain::AssetMetadata {

525

1

		name: b"ParaAToken".to_vec(),

526

1

		symbol: b"ParaA".to_vec(),

527

1

		decimals: 18,

528

1

};

529

1

530

1

	// Register para A asset in para B

531

1

	ParaB::execute_with(|| {

532

1

		assert_ok!(AssetManager::register_foreign_asset(

533

1

			parachain::RuntimeOrigin::root(),

534

1

			source_location.clone(),

535

1

			asset_metadata,

536

1

			1u128,

537

1

			true

538

1

));

539

1

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

540

1

});

541

1

542

1

	// Send para A asset to para B

543

1

	let dest = Location {

544

1

		parents: 1,

545

1

		interior: [

546

1

			Parachain(2),

547

1

			AccountKey20 {

548

1

				network: None,

549

1

				key: PARAALICE.into(),

550

1

},

551

1

552

1

		.into(),

553

1

};

554

1

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

555

1

556

1

	ParaA::execute_with(|| {

557

1

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

558

1

		assert_ok!(PolkadotXcm::transfer_assets(

559

1

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

560

1

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

561

1

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

562

1

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

563

1

0,

564

1

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

565

1

));

566

1

});

567

1

568

1

	// Balances have been substracted

569

1

	ParaA::execute_with(|| {

570

1

		assert_eq!(

571

1

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

572

1

			INITIAL_BALANCE - 100

573

1

);

574

1

});

575

1

576

1

	// Para B balances have been credited

577

1

	ParaB::execute_with(|| {

578

1

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

579

1

});

580

1

581

1

	// Send back para A asset to para A

582

1

	let dest = Location {

583

1

		parents: 1,

584

1

		interior: [

585

1

			Parachain(1),

586

1

			AccountKey20 {

587

1

				network: None,

588

1

				key: PARAALICE.into(),

589

1

},

590

1

591

1

		.into(),

592

1

};

593

1

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

594

1

595

1

	ParaB::execute_with(|| {

596

1

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

597

1

		assert_ok!(PolkadotXcm::transfer_assets(

598

1

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

599

1

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

600

1

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

601

1

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

602

1

0,

603

1

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

604

1

));

605

1

});

606

1

607

1

	// Para A asset has been credited

608

1

	ParaA::execute_with(|| {

609

1

		// Weight used is 4

610

1

		assert_eq!(

611

1

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

612

1

			INITIAL_BALANCE - 4

613

1

);

614

1

});

615

1

616

617

#[test]

618

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

619

1

	MockNet::reset();

620

1

621

1

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

622

1

	let source_location = parachain::AssetType::Xcm(

623

1

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

624

1

);

625

1

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

626

1

627

1

	let asset_metadata = parachain::AssetMetadata {

628

1

		name: b"ParaAToken".to_vec(),

629

1

		symbol: b"ParaA".to_vec(),

630

1

		decimals: 18,

631

1

};

632

1

633

1

	ParaB::execute_with(|| {

634

1

		assert_ok!(AssetManager::register_foreign_asset(

635

1

			parachain::RuntimeOrigin::root(),

636

1

			source_location.clone(),

637

1

			asset_metadata,

638

1

			1u128,

639

1

			true

640

1

));

641

1

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

642

1

});

643

1

644

1

	let dest = Location {

645

1

		parents: 1,

646

1

		interior: [

647

1

			Parachain(2),

648

1

			AccountKey20 {

649

1

				network: None,

650

1

				key: PARAALICE.into(),

651

1

},

652

1

653

1

		.into(),

654

1

};

655

1

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

656

1

657

1

	ParaA::execute_with(|| {

658

1

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

659

1

		assert_ok!(PolkadotXcm::transfer_assets(

660

1

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

661

1

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

662

1

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

663

1

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

664

1

0,

665

1

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

666

1

));

667

1

});

668

1

669

1

	ParaA::execute_with(|| {

670

1

		// Free execution, full amount received

671

1

		assert_eq!(

672

1

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

673

1

			INITIAL_BALANCE - 100

674

1

);

675

1

});

676

1

677

1

	ParaB::execute_with(|| {

678

1

		// Free execution, full amount received

679

1

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

680

1

});

681

1

682

1

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

683

1

	// Message through polkadotXCM pallet

684

1

685

1

	let dest = Location {

686

1

		parents: 1,

687

1

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

688

1

};

689

1

690

1

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

691

1

692

1

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

693

1

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

694

1

		ClearOrigin,

695

1

		BuyExecution {

696

1

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

697

1

			weight_limit: Limited(80.into()),

698

1

},

699

1

		DepositAsset {

700

1

			assets: All.into(),

701

1

			beneficiary: Location::new(

702

1

0,

703

1

				[AccountKey20 {

704

1

					network: None,

705

1

					key: PARAALICE,

706

1

}],

707

1

),

708

1

},

709

1

	]));

710

1

	ParaB::execute_with(|| {

711

1

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

712

1

		// and deposit asset

713

1

		assert_ok!(ParachainPalletXcm::send(

714

1

			parachain::RuntimeOrigin::root(),

715

1

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

716

1

			Box::new(message),

717

1

));

718

1

});

719

1

720

1

	ParaB::execute_with(|| {

721

1

		// free execution, full amount received

722

1

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

723

1

});

724

1

725

1

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

726

1

	// Message through polkadotXCM pallet

727

1

728

1

	let dest = Location {

729

1

		parents: 1,

730

1

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

731

1

};

732

1

733

1

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

734

1

735

1

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

736

1

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

737

1

		ClearOrigin,

738

1

		BuyExecution {

739

1

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

740

1

			weight_limit: Limited(80.into()),

741

1

},

742

1

		DepositAsset {

743

1

			assets: All.into(),

744

1

			beneficiary: Location::new(

745

1

0,

746

1

				[AccountKey20 {

747

1

					network: None,

748

1

					key: PARAALICE,

749

1

}],

750

1

),

751

1

},

752

1

	]));

753

1

	ParaB::execute_with(|| {

754

1

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

755

1

		// and deposit asset

756

1

		assert_ok!(ParachainPalletXcm::send(

757

1

			parachain::RuntimeOrigin::root(),

758

1

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

759

1

			Box::new(message),

760

1

));

761

1

});

762

1

763

1

	ParaA::execute_with(|| {

764

1

		// Weight used is 4

765

1

		assert_eq!(

766

1

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

767

1

			INITIAL_BALANCE - 4

768

1

);

769

1

});

770

1

771

772

#[test]

773

1

fn receive_relay_asset_with_trader() {

774

1

	MockNet::reset();

775

1

776

1

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

777

1

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

778

1

779

1

	let asset_metadata = parachain::AssetMetadata {

780

1

		name: b"RelayToken".to_vec(),

781

1

		symbol: b"Relay".to_vec(),

782

1

		decimals: 12,

783

1

};

784

1

785

1

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

786

1

	// we know later we will divide by 1e12

787

1

	// Lets put 1e6 as units per second

788

1

	ParaA::execute_with(|| {

789

1

		assert_ok!(AssetManager::register_foreign_asset(

790

1

			parachain::RuntimeOrigin::root(),

791

1

			source_location.clone(),

792

1

			asset_metadata,

793

1

			1u128,

794

1

			true

795

1

));

796

1

		assert_ok!(add_supported_asset(

797

1

			source_location.clone(),

798

1

			2500000000000u128

799

1

));

800

1

});

801

1

802

1

	let dest: Location = Junction::AccountKey20 {

803

1

		network: None,

804

1

		key: PARAALICE,

805

1

806

1

	.into();

807

1

	// We are sending 100 tokens from relay.

808

1

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

809

1

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

810

1

	// Units per second should be 2_500_000_000_000_000

811

1

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

812

1

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

813

1

	Relay::execute_with(|| {

814

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

815

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

816

1

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

817

1

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

818

1

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

819

1

0,

820

1

			WeightLimit::Unlimited

821

1

));

822

1

});

823

1

824

1

	ParaA::execute_with(|| {

825

1

		// non-free execution, not full amount received

826

1

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

827

		// Fee should have been received by treasury

828

1

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

829

1

});

830

1

831

832

#[test]

833

1

fn send_para_a_asset_to_para_b_with_trader() {

834

1

	MockNet::reset();

835

1

836

1

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

837

1

	let source_location = parachain::AssetType::Xcm(

838

1

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

839

1

);

840

1

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

841

1

842

1

	let asset_metadata = parachain::AssetMetadata {

843

1

		name: b"ParaAToken".to_vec(),

844

1

		symbol: b"ParaA".to_vec(),

845

1

		decimals: 18,

846

1

};

847

1

848

1

	ParaB::execute_with(|| {

849

1

		assert_ok!(AssetManager::register_foreign_asset(

850

1

			parachain::RuntimeOrigin::root(),

851

1

			source_location.clone(),

852

1

			asset_metadata,

853

1

			1u128,

854

1

			true

855

1

));

856

1

		assert_ok!(add_supported_asset(

857

1

			source_location.clone(),

858

1

			2500000000000u128

859

1

));

860

1

});

861

1

862

1

	let dest = Location {

863

1

		parents: 1,

864

1

		interior: [

865

1

			Parachain(2),

866

1

			AccountKey20 {

867

1

				network: None,

868

1

				key: PARAALICE.into(),

869

1

},

870

1

871

1

		.into(),

872

1

};

873

1

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

874

1

875

1

	// In destination chain, we only need 4 weight

876

1

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

877

1

	ParaA::execute_with(|| {

878

1

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

879

1

		assert_ok!(PolkadotXcm::transfer_assets(

880

1

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

881

1

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

882

1

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

883

1

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

884

1

0,

885

1

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

886

1

));

887

1

});

888

1

	ParaA::execute_with(|| {

889

1

		// free execution, full amount received

890

1

		assert_eq!(

891

1

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

892

1

			INITIAL_BALANCE - 100

893

1

);

894

1

});

895

1

896

1

	// We are sending 100 tokens from para A.

897

1

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

898

1

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

899

1

	// Units per second should be 2_500_000_000_000_000

900

1

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

901

1

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

902

1

	// will be 4

903

1

	ParaB::execute_with(|| {

904

1

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

905

		// Fee should have been received by treasury

906

1

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

907

1

});

908

1

909

910

#[test]

911

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

912

1

	MockNet::reset();

913

1

914

1

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

915

1

	let source_location = parachain::AssetType::Xcm(

916

1

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

917

1

);

918

1

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

919

1

920

1

	let asset_metadata = parachain::AssetMetadata {

921

1

		name: b"ParaAToken".to_vec(),

922

1

		symbol: b"ParaA".to_vec(),

923

1

		decimals: 18,

924

1

};

925

1

926

1

	ParaB::execute_with(|| {

927

1

		assert_ok!(AssetManager::register_foreign_asset(

928

1

			parachain::RuntimeOrigin::root(),

929

1

			source_location.clone(),

930

1

			asset_metadata,

931

1

			1u128,

932

1

			true

933

1

));

934

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

935

1

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

936

1

});

937

1

938

1

	let dest = Location {

939

1

		parents: 1,

940

1

		interior: [

941

1

			Parachain(2),

942

1

			AccountKey20 {

943

1

				network: None,

944

1

				key: PARAALICE.into(),

945

1

},

946

1

947

1

		.into(),

948

1

};

949

1

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

950

1

951

1

	// we use transfer_with_fee

952

1

	ParaA::execute_with(|| {

953

1

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

954

1

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

955

1

		assert_ok!(PolkadotXcm::transfer_assets(

956

1

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

957

1

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

958

1

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

959

1

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

960

1

0,

961

1

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

962

1

));

963

1

});

964

1

	ParaA::execute_with(|| {

965

1

		// 100 tokens transferred plus 1 taken from fees

966

1

		assert_eq!(

967

1

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

968

1

			INITIAL_BALANCE - 100 - 1

969

1

);

970

1

});

971

1

972

1

	ParaB::execute_with(|| {

973

1

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

974

1

		// what it is specified

975

1

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

976

1

});

977

1

978

979

#[test]

980

1

fn error_when_not_paying_enough() {

981

1

	MockNet::reset();

982

1

983

1

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

984

1

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

985

1

986

1

	let asset_metadata = parachain::AssetMetadata {

987

1

		name: b"RelayToken".to_vec(),

988

1

		symbol: b"Relay".to_vec(),

989

1

		decimals: 12,

990

1

};

991

1

992

1

	let dest: Location = Junction::AccountKey20 {

993

1

		network: None,

994

1

		key: PARAALICE,

995

1

996

1

	.into();

997

1

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

998

1

	// we know later we will divide by 1e12

999

1

	// Lets put 1e6 as units per second

1000

1

	ParaA::execute_with(|| {

1001

1

		assert_ok!(AssetManager::register_foreign_asset(

1002

1

			parachain::RuntimeOrigin::root(),

1003

1

			source_location.clone(),

1004

1

			asset_metadata,

1005

1

			1u128,

1006

1

			true

1007

1

));

1008

1

		assert_ok!(add_supported_asset(

1009

1

			source_location.clone(),

1010

1

			2500000000000u128

1011

1

));

1012

1

});

1013

1

1014

1

	// We are sending 100 tokens from relay.

1015

1

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

1016

1

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

1017

1

	Relay::execute_with(|| {

1018

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1019

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1020

1

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

1021

1

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

1022

1

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

1023

1

0,

1024

1

			WeightLimit::Unlimited

1025

1

));

1026

1

});

1027

1

1028

1

	ParaA::execute_with(|| {

1029

1

		// amount not received as it is not paying enough

1030

1

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

1031

1

});

1032

1

1033

1034

#[test]

1035

1

fn transact_through_derivative_multilocation() {

1036

1

	MockNet::reset();

1037

1

1038

1

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

1039

1

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

1040

1

1041

1

	let asset_metadata = parachain::AssetMetadata {

1042

1

		name: b"RelayToken".to_vec(),

1043

1

		symbol: b"Relay".to_vec(),

1044

1

		decimals: 12,

1045

1

};

1046

1

1047

1

	ParaA::execute_with(|| {

1048

1

		assert_ok!(AssetManager::register_foreign_asset(

1049

1

			parachain::RuntimeOrigin::root(),

1050

1

			source_location.clone(),

1051

1

			asset_metadata,

1052

1

			1u128,

1053

1

			true

1054

1

));

1055

1

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

1056

1057

		// Root can set transact info

1058

1

		assert_ok!(XcmTransactor::set_transact_info(

1059

1

			parachain::RuntimeOrigin::root(),

1060

1

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

1061

1

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

1062

1

			3000.into(),

1063

1

			20000000000.into(),

1064

1

			None

1065

1

));

1066

		// Root can set transact info

1067

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1068

1

			parachain::RuntimeOrigin::root(),

1069

1

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

1070

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1071

1

));

1072

1

});

1073

1

1074

1

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

1075

1

1076

1

	let dest: Location = AccountKey20 {

1077

1

		network: None,

1078

1

		key: PARAALICE,

1079

1

1080

1

	.into();

1081

1

	Relay::execute_with(|| {

1082

1

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

1083

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1084

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1085

1

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

1086

1

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

1087

1

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

1088

1

0,

1089

1

			WeightLimit::Unlimited

1090

1

));

1091

1

});

1092

1

1093

1

	ParaA::execute_with(|| {

1094

1

		// free execution, full amount received

1095

1

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

1096

1

});

1097

1

1098

1

	// Register address

1099

1

	ParaA::execute_with(|| {

1100

1

		assert_ok!(XcmTransactor::register(

1101

1

			parachain::RuntimeOrigin::root(),

1102

1

			PARAALICE.into(),

1103

1

0,

1104

1

));

1105

1

});

1106

1

1107

1

	// Send to registered address

1108

1

1109

1

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

1110

1

	let dest = Location {

1111

1

		parents: 1,

1112

1

		interior: [AccountId32 {

1113

1

			network: None,

1114

1

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

1115

1

}]

1116

1

		.into(),

1117

1

};

1118

1

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

1119

1

1120

1

	ParaA::execute_with(|| {

1121

1

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

1122

1

		// free execution, full amount received

1123

1

		assert_ok!(PolkadotXcm::transfer_assets(

1124

1

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

1125

1

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

1126

1

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

1127

1

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

1128

1

0,

1129

1

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

1130

1

));

1131

1

});

1132

1

1133

1

	ParaA::execute_with(|| {

1134

1

		// free execution, full amount received

1135

1

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

1136

1

});

1137

1

1138

1

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

1139

1

	// again

1140

1

	Relay::execute_with(|| {

1141

1

		// free execution,x	 full amount received

1142

1

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

1143

1

});

1144

1

1145

1

	// Encode the call. Balances transact to para_a_account

1146

1

	// First index

1147

1

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

1148

1

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

1149

1

		relay_chain::Balances,

1150

1

>()

1151

1

	.unwrap() as u8;

1152

1

1153

1

	encoded.push(index);

1154

1

1155

1

	// Then call bytes

1156

1

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

1157

1

		dest: para_a_account(),

1158

1

		value: 100u32.into(),

1159

1

1160

1

	.encode();

1161

1

	encoded.append(&mut call_bytes);

1162

1

1163

1

	ParaA::execute_with(|| {

1164

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1165

1

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

1166

1

			parachain::MockTransactors::Relay,

1167

1

0,

1168

1

			CurrencyPayment {

1169

1

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

1170

1

					Location::parent()

1171

1

				))),

1172

1

				fee_amount: None

1173

1

},

1174

1

			encoded,

1175

1

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

1176

1

			TransactWeights {

1177

1

				transact_required_weight_at_most: 4000000000.into(),

1178

1

				overall_weight: None

1179

1

},

1180

1

			false

1181

1

));

1182

1

});

1183

1

1184

1

	Relay::execute_with(|| {

1185

1

		// free execution,x	 full amount received

1186

1

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

1187

1188

1

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

1189

1

});

1190

1

1191

1192

#[test]

1193

1

fn transact_through_derivative_with_custom_fee_weight() {

1194

1

	MockNet::reset();

1195

1

1196

1

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

1197

1

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

1198

1

1199

1

	let asset_metadata = parachain::AssetMetadata {

1200

1

		name: b"RelayToken".to_vec(),

1201

1

		symbol: b"Relay".to_vec(),

1202

1

		decimals: 12,

1203

1

};

1204

1

1205

1

	ParaA::execute_with(|| {

1206

1

		assert_ok!(AssetManager::register_foreign_asset(

1207

1

			parachain::RuntimeOrigin::root(),

1208

1

			source_location.clone(),

1209

1

			asset_metadata,

1210

1

			1u128,

1211

1

			true

1212

1

));

1213

1

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

1214

1

});

1215

1

1216

1

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

1217

1

1218

1

	let dest: Location = AccountKey20 {

1219

1

		network: None,

1220

1

		key: PARAALICE,

1221

1

1222

1

	.into();

1223

1

	Relay::execute_with(|| {

1224

1

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

1225

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1226

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1227

1

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

1228

1

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

1229

1

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

1230

1

0,

1231

1

			WeightLimit::Unlimited

1232

1

));

1233

1

});

1234

1

1235

1

	ParaA::execute_with(|| {

1236

1

		// free execution, full amount received

1237

1

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

1238

1

});

1239

1

1240

1

	// Register address

1241

1

	ParaA::execute_with(|| {

1242

1

		assert_ok!(XcmTransactor::register(

1243

1

			parachain::RuntimeOrigin::root(),

1244

1

			PARAALICE.into(),

1245

1

0,

1246

1

));

1247

1

});

1248

1

1249

1

	// Send to registered address

1250

1

1251

1

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

1252

1

	let dest = Location {

1253

1

		parents: 1,

1254

1

		interior: [AccountId32 {

1255

1

			network: None,

1256

1

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

1257

1

}]

1258

1

		.into(),

1259

1

};

1260

1

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

1261

1

1262

1

	ParaA::execute_with(|| {

1263

1

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

1264

1

		// free execution, full amount received

1265

1

		assert_ok!(PolkadotXcm::transfer_assets(

1266

1

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

1267

1

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

1268

1

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

1269

1

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

1270

1

0,

1271

1

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

1272

1

));

1273

1

});

1274

1

1275

1

	ParaA::execute_with(|| {

1276

1

		// free execution, full amount received

1277

1

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

1278

1

});

1279

1

1280

1

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

1281

1

	// again

1282

1

	Relay::execute_with(|| {

1283

1

		// free execution,x	 full amount received

1284

1

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

1285

1

});

1286

1

1287

1

	// Encode the call. Balances transact to para_a_account

1288

1

	// First index

1289

1

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

1290

1

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

1291

1

		relay_chain::Balances,

1292

1

>()

1293

1

	.unwrap() as u8;

1294

1

1295

1

	encoded.push(index);

1296

1

1297

1

	// Then call bytes

1298

1

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

1299

1

		dest: para_a_account(),

1300

1

		value: 100u32.into(),

1301

1

1302

1

	.encode();

1303

1

	encoded.append(&mut call_bytes);

1304

1

1305

1

	let overall_weight = 4000003000u64;

1306

1

	ParaA::execute_with(|| {

1307

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1308

1

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

1309

1

			parachain::MockTransactors::Relay,

1310

1

0,

1311

1

			CurrencyPayment {

1312

1

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

1313

1

					Location::parent()

1314

1

				))),

1315

1

				// 1-1 fee weight mapping

1316

1

				fee_amount: Some(overall_weight as u128)

1317

1

},

1318

1

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

1319

1

			encoded,

1320

1

			TransactWeights {

1321

1

				transact_required_weight_at_most: 4000000000.into(),

1322

1

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

1323

1

},

1324

1

			false

1325

1

));

1326

1

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

1327

1

			.iter()

1328

12

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

1329

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

1330

..

1331

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

1332

12

				_ => None,

1333

12

});

1334

1

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

1335

1

		assert!(event_found.is_none());

1336

1

});

1337

1

1338

1

	Relay::execute_with(|| {

1339

1

		// free execution,x	 full amount received

1340

1

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

1341

1342

1

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

1343

1

});

1344

1

1345

1346

#[test]

1347

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1348

1

	MockNet::reset();

1349

1

1350

1

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

1351

1

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

1352

1

1353

1

	let asset_metadata = parachain::AssetMetadata {

1354

1

		name: b"RelayToken".to_vec(),

1355

1

		symbol: b"Relay".to_vec(),

1356

1

		decimals: 12,

1357

1

};

1358

1

1359

1

	ParaA::execute_with(|| {

1360

1

		assert_ok!(AssetManager::register_foreign_asset(

1361

1

			parachain::RuntimeOrigin::root(),

1362

1

			source_location.clone(),

1363

1

			asset_metadata,

1364

1

			1u128,

1365

1

			true

1366

1

));

1367

1

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

1368

1

});

1369

1

1370

1

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

1371

1

1372

1

	let dest: Location = AccountKey20 {

1373

1

		network: None,

1374

1

		key: PARAALICE,

1375

1

1376

1

	.into();

1377

1

	Relay::execute_with(|| {

1378

1

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

1379

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1380

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1381

1

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

1382

1

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

1383

1

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

1384

1

0,

1385

1

			WeightLimit::Unlimited

1386

1

));

1387

1

});

1388

1

1389

1

	ParaA::execute_with(|| {

1390

1

		// free execution, full amount received

1391

1

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

1392

1

});

1393

1

1394

1

	// Register address

1395

1

	ParaA::execute_with(|| {

1396

1

		assert_ok!(XcmTransactor::register(

1397

1

			parachain::RuntimeOrigin::root(),

1398

1

			PARAALICE.into(),

1399

1

0,

1400

1

));

1401

1

});

1402

1

1403

1

	// Send to registered address

1404

1

1405

1

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

1406

1

	let dest = Location {

1407

1

		parents: 1,

1408

1

		interior: [AccountId32 {

1409

1

			network: None,

1410

1

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

1411

1

}]

1412

1

		.into(),

1413

1

};

1414

1

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

1415

1

1416

1

	ParaA::execute_with(|| {

1417

1

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

1418

1

		// free execution, full amount received

1419

1

		assert_ok!(PolkadotXcm::transfer_assets(

1420

1

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

1421

1

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

1422

1

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

1423

1

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

1424

1

0,

1425

1

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

1426

1

));

1427

1

});

1428

1

1429

1

	ParaA::execute_with(|| {

1430

1

		// free execution, full amount received

1431

1

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

1432

1

});

1433

1

1434

1

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

1435

1

	// again

1436

1

	Relay::execute_with(|| {

1437

1

		// free execution,x	 full amount received

1438

1

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

1439

1

});

1440

1

1441

1

	// Encode the call. Balances transact to para_a_account

1442

1

	// First index

1443

1

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

1444

1

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

1445

1

		relay_chain::Balances,

1446

1

>()

1447

1

	.unwrap() as u8;

1448

1

1449

1

	encoded.push(index);

1450

1

1451

1

	// Then call bytes

1452

1

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

1453

1

		dest: para_a_account(),

1454

1

		value: 100u32.into(),

1455

1

1456

1

	.encode();

1457

1

	encoded.append(&mut call_bytes);

1458

1

1459

1

	let overall_weight = 4000009000u64;

1460

1

	ParaA::execute_with(|| {

1461

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1462

1

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

1463

1

			parachain::MockTransactors::Relay,

1464

1

0,

1465

1

			CurrencyPayment {

1466

1

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

1467

1

					Location::parent()

1468

1

				))),

1469

1

				// 1-1 fee weight mapping

1470

1

				fee_amount: Some(overall_weight as u128)

1471

1

},

1472

1

			encoded,

1473

1

			TransactWeights {

1474

1

				transact_required_weight_at_most: 4000000000.into(),

1475

1

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

1476

1

},

1477

1

			true

1478

1

));

1479

1

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

1480

1

			.iter()

1481

12

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

1482

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

1483

..

1484

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

1485

12

				_ => None,

1486

12

});

1487

1

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

1488

1

		assert!(event_found.is_none());

1489

1

});

1490

1

1491

1

	Relay::execute_with(|| {

1492

1

		// free execution,x	 full amount received

1493

1

		// 4000005186 refunded + 100 transferred = 4000005286

1494

1

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

1495

1

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

1496

1

});

1497

1

1498

1499

#[test]

1500

1

fn transact_through_sovereign() {

1501

1

	MockNet::reset();

1502

1

1503

1

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

1504

1

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

1505

1

1506

1

	let asset_metadata = parachain::AssetMetadata {

1507

1

		name: b"RelayToken".to_vec(),

1508

1

		symbol: b"Relay".to_vec(),

1509

1

		decimals: 12,

1510

1

};

1511

1

1512

1

	ParaA::execute_with(|| {

1513

1

		assert_ok!(AssetManager::register_foreign_asset(

1514

1

			parachain::RuntimeOrigin::root(),

1515

1

			source_location.clone(),

1516

1

			asset_metadata,

1517

1

			1u128,

1518

1

			true

1519

1

));

1520

1

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

1521

1522

		// Root can set transact info

1523

1

		assert_ok!(XcmTransactor::set_transact_info(

1524

1

			parachain::RuntimeOrigin::root(),

1525

1

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

1526

1

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

1527

1

			3000.into(),

1528

1

			20000000000.into(),

1529

1

			None

1530

1

));

1531

		// Root can set transact info

1532

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1533

1

			parachain::RuntimeOrigin::root(),

1534

1

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

1535

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1536

1

));

1537

1

});

1538

1

1539

1

	let dest: Location = AccountKey20 {

1540

1

		network: None,

1541

1

		key: PARAALICE,

1542

1

1543

1

	.into();

1544

1

	Relay::execute_with(|| {

1545

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1546

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1547

1

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

1548

1

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

1549

1

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

1550

1

0,

1551

1

			WeightLimit::Unlimited

1552

1

));

1553

1

});

1554

1

1555

1

	ParaA::execute_with(|| {

1556

1

		// free execution, full amount received

1557

1

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

1558

1

});

1559

1

1560

1

	// Register address

1561

1

	ParaA::execute_with(|| {

1562

1

		assert_ok!(XcmTransactor::register(

1563

1

			parachain::RuntimeOrigin::root(),

1564

1

			PARAALICE.into(),

1565

1

0,

1566

1

));

1567

1

});

1568

1

1569

1

	// Send to registered address

1570

1

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

1571

1

	let dest = Location {

1572

1

		parents: 1,

1573

1

		interior: [AccountId32 {

1574

1

			network: None,

1575

1

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

1576

1

}]

1577

1

		.into(),

1578

1

};

1579

1

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

1580

1

1581

1

	ParaA::execute_with(|| {

1582

1

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

1583

1

		// free execution, full amount received

1584

1

		assert_ok!(PolkadotXcm::transfer_assets(

1585

1

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

1586

1

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

1587

1

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

1588

1

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

1589

1

0,

1590

1

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

1591

1

));

1592

1

});

1593

1

1594

1

	ParaA::execute_with(|| {

1595

1

		// free execution, full amount received

1596

1

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

1597

1

});

1598

1

1599

1

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

1600

1

	// again

1601

1

	Relay::execute_with(|| {

1602

1

		// free execution,x	 full amount received

1603

1

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

1604

1

1605

1

});

1606

1

1607

1

	// We send the xcm transact operation to parent

1608

1

	let dest = Location {

1609

1

		parents: 1,

1610

1

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

1611

1

};

1612

1

1613

1

	// Encode the call. Balances transact to para_a_account

1614

1

	// First index

1615

1

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

1616

1

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

1617

1

		relay_chain::Balances,

1618

1

>()

1619

1

	.unwrap() as u8;

1620

1

1621

1

	encoded.push(index);

1622

1

1623

1

	// Then call bytes

1624

1

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

1625

1

		dest: para_a_account(),

1626

1

		value: 100u32.into(),

1627

1

1628

1

	.encode();

1629

1

	encoded.append(&mut call_bytes);

1630

1

1631

1

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

1632

1

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

1633

1

);

1634

1

1635

1

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

1636

1

	ParaA::execute_with(|| {

1637

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1638

1

			parachain::RuntimeOrigin::root(),

1639

1

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

1640

1

			Some(PARAALICE.into()),

1641

1

			CurrencyPayment {

1642

1

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

1643

1

					Location::parent()

1644

1

				))),

1645

1

				fee_amount: None

1646

1

},

1647

1

			utility_bytes,

1648

1

			OriginKind::SovereignAccount,

1649

1

			TransactWeights {

1650

1

				transact_required_weight_at_most: 4000000000.into(),

1651

1

				overall_weight: None

1652

1

},

1653

1

			false

1654

1

));

1655

1

});

1656

1

1657

1

	Relay::execute_with(|| {

1658

1

		// free execution,x	 full amount received

1659

1

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

1660

1661

1

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

1662

1

});

1663

1

1664

1665

#[test]

1666

1

fn transact_through_sovereign_fee_payer_none() {

1667

1

	MockNet::reset();

1668

1

1669

1

	ParaA::execute_with(|| {

1670

1

		// Root can set transact info

1671

1

		assert_ok!(XcmTransactor::set_transact_info(

1672

1

			parachain::RuntimeOrigin::root(),

1673

1

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

1674

1

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

1675

1

			3000.into(),

1676

1

			20000000000.into(),

1677

1

			None

1678

1

));

1679

		// Root can set transact info

1680

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1681

1

			parachain::RuntimeOrigin::root(),

1682

1

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

1683

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1684

1

));

1685

1

});

1686

1

1687

1

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

1688

1

1689

1

	Relay::execute_with(|| {

1690

1

		// Transfer 100 tokens to derivative_address on the relay

1691

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1692

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1693

1

			derivative_address.clone(),

1694

1

			100u128

1695

1

));

1696

1697

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

1698

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1699

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1700

1

			para_a_account(),

1701

1

			4000003000u128

1702

1

));

1703

1

});

1704

1

1705

1

	// Check balances before the transact call

1706

1

	Relay::execute_with(|| {

1707

1

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

1708

1

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

1709

1

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

1710

1

});

1711

1

1712

1

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

1713

1

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

1714

1

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

1715

1

		relay_chain::Balances,

1716

1

>()

1717

1

	.unwrap() as u8;

1718

1

1719

1

	encoded.push(index);

1720

1

1721

1

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

1722

1

		dest: RELAYBOB,

1723

1

		value: 100u32.into(),

1724

1

1725

1

	.encode();

1726

1

	encoded.append(&mut call_bytes);

1727

1

1728

1

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

1729

1

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

1730

1

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

1731

1

);

1732

1

1733

1

	// We send the xcm transact operation to parent

1734

1

	let dest = Location {

1735

1

		parents: 1,

1736

1

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

1737

1

};

1738

1

1739

1

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

1740

1

	ParaA::execute_with(|| {

1741

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1742

1

			parachain::RuntimeOrigin::root(),

1743

1

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

1744

1

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

1745

1

			None,

1746

1

			CurrencyPayment {

1747

1

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

1748

1

					Location::parent()

1749

1

				))),

1750

1

				fee_amount: None

1751

1

},

1752

1

			utility_bytes,

1753

1

			OriginKind::SovereignAccount,

1754

1

			TransactWeights {

1755

1

				transact_required_weight_at_most: 4000000000.into(),

1756

1

				overall_weight: None

1757

1

},

1758

1

			false

1759

1

));

1760

1

});

1761

1

1762

1

	// Check balances after the transact call are correct

1763

1

	Relay::execute_with(|| {

1764

1

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

1765

1

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

1766

1

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

1767

1

});

1768

1

1769

1770

#[test]

1771

1

fn transact_through_sovereign_with_custom_fee_weight() {

1772

1

	MockNet::reset();

1773

1

1774

1

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

1775

1

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

1776

1

1777

1

	let asset_metadata = parachain::AssetMetadata {

1778

1

		name: b"RelayToken".to_vec(),

1779

1

		symbol: b"Relay".to_vec(),

1780

1

		decimals: 12,

1781

1

};

1782

1

1783

1

	ParaA::execute_with(|| {

1784

1

		assert_ok!(AssetManager::register_foreign_asset(

1785

1

			parachain::RuntimeOrigin::root(),

1786

1

			source_location.clone(),

1787

1

			asset_metadata,

1788

1

			1u128,

1789

1

			true

1790

1

));

1791

1

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

1792

1

});

1793

1

1794

1

	let dest: Location = AccountKey20 {

1795

1

		network: None,

1796

1

		key: PARAALICE,

1797

1

1798

1

	.into();

1799

1

	Relay::execute_with(|| {

1800

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1801

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1802

1

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

1803

1

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

1804

1

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

1805

1

0,

1806

1

			WeightLimit::Unlimited

1807

1

));

1808

1

});

1809

1

1810

1

	ParaA::execute_with(|| {

1811

1

		// free execution, full amount received

1812

1

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

1813

1

});

1814

1

1815

1

	// Register address

1816

1

	ParaA::execute_with(|| {

1817

1

		assert_ok!(XcmTransactor::register(

1818

1

			parachain::RuntimeOrigin::root(),

1819

1

			PARAALICE.into(),

1820

1

0,

1821

1

));

1822

1

});

1823

1

1824

1

	// Send to registered address

1825

1

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

1826

1

	let dest = Location {

1827

1

		parents: 1,

1828

1

		interior: [AccountId32 {

1829

1

			network: None,

1830

1

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

1831

1

}]

1832

1

		.into(),

1833

1

};

1834

1

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

1835

1

1836

1

	ParaA::execute_with(|| {

1837

1

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

1838

1

		// free execution, full amount received

1839

1

		assert_ok!(PolkadotXcm::transfer_assets(

1840

1

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

1841

1

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

1842

1

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

1843

1

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

1844

1

0,

1845

1

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

1846

1

));

1847

1

});

1848

1

1849

1

	ParaA::execute_with(|| {

1850

1

		// free execution, full amount received

1851

1

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

1852

1

});

1853

1

1854

1

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

1855

1

	// again

1856

1

	Relay::execute_with(|| {

1857

1

		// free execution,x	 full amount received

1858

1

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

1859

1

1860

1

});

1861

1

1862

1

	// We send the xcm transact operation to parent

1863

1

	let dest = Location {

1864

1

		parents: 1,

1865

1

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

1866

1

};

1867

1

1868

1

	// Encode the call. Balances transact to para_a_account

1869

1

	// First index

1870

1

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

1871

1

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

1872

1

		relay_chain::Balances,

1873

1

>()

1874

1

	.unwrap() as u8;

1875

1

1876

1

	encoded.push(index);

1877

1

1878

1

	// Then call bytes

1879

1

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

1880

1

		dest: para_a_account(),

1881

1

		value: 100u32.into(),

1882

1

1883

1

	.encode();

1884

1

	encoded.append(&mut call_bytes);

1885

1

1886

1

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

1887

1

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

1888

1

);

1889

1

1890

1

	let total_weight = 4000003000u64;

1891

1

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

1892

1

	ParaA::execute_with(|| {

1893

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1894

1

			parachain::RuntimeOrigin::root(),

1895

1

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

1896

1

			Some(PARAALICE.into()),

1897

1

			CurrencyPayment {

1898

1

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

1899

1

					Location::parent()

1900

1

				))),

1901

1

				// 1-1 fee-weight mapping

1902

1

				fee_amount: Some(total_weight as u128)

1903

1

},

1904

1

			utility_bytes,

1905

1

			OriginKind::SovereignAccount,

1906

1

			TransactWeights {

1907

1

				transact_required_weight_at_most: 4000000000.into(),

1908

1

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

1909

1

},

1910

1

			false

1911

1

));

1912

1

});

1913

1

1914

1

	Relay::execute_with(|| {

1915

1

		// free execution,x	 full amount received

1916

1

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

1917

1918

1

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

1919

1

});

1920

1

1921

1922

#[test]

1923

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1924

1

	MockNet::reset();

1925

1

1926

1

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

1927

1

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

1928

1

1929

1

	let asset_metadata = parachain::AssetMetadata {

1930

1

		name: b"RelayToken".to_vec(),

1931

1

		symbol: b"Relay".to_vec(),

1932

1

		decimals: 12,

1933

1

};

1934

1

1935

1

	ParaA::execute_with(|| {

1936

1

		assert_ok!(AssetManager::register_foreign_asset(

1937

1

			parachain::RuntimeOrigin::root(),

1938

1

			source_location.clone(),

1939

1

			asset_metadata,

1940

1

			1u128,

1941

1

			true

1942

1

));

1943

1

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

1944

1

});

1945

1

1946

1

	let dest: Location = AccountKey20 {

1947

1

		network: None,

1948

1

		key: PARAALICE,

1949

1

1950

1

	.into();

1951

1

	Relay::execute_with(|| {

1952

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1953

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1954

1

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

1955

1

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

1956

1

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

1957

1

0,

1958

1

			WeightLimit::Unlimited

1959

1

));

1960

1

});

1961

1

1962

1

	ParaA::execute_with(|| {

1963

1

		// free execution, full amount received

1964

1

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

1965

1

});

1966

1

1967

1

	// Register address

1968

1

	ParaA::execute_with(|| {

1969

1

		assert_ok!(XcmTransactor::register(

1970

1

			parachain::RuntimeOrigin::root(),

1971

1

			PARAALICE.into(),

1972

1

0,

1973

1

));

1974

1

});

1975

1

1976

1

	// Send to registered address

1977

1

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

1978

1

	let dest = Location {

1979

1

		parents: 1,

1980

1

		interior: [AccountId32 {

1981

1

			network: None,

1982

1

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

1983

1

}]

1984

1

		.into(),

1985

1

};

1986

1

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

1987

1

1988

1

	ParaA::execute_with(|| {

1989

1

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

1990

1

		// free execution, full amount received

1991

1

		assert_ok!(PolkadotXcm::transfer_assets(

1992

1

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

1993

1

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

1994

1

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

1995

1

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

1996

1

0,

1997

1

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

1998

1

));

1999

1

});

2000

1

2001

1

	ParaA::execute_with(|| {

2002

1

		// free execution, full amount received

2003

1

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

2004

1

});

2005

1

2006

1

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

2007

1

	// again

2008

1

	Relay::execute_with(|| {

2009

1

		// free execution,x	 full amount received

2010

1

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

2011

1

2012

1

});

2013

1

2014

1

	// We send the xcm transact operation to parent

2015

1

	let dest = Location {

2016

1

		parents: 1,

2017

1

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

2018

1

};

2019

1

2020

1

	// Encode the call. Balances transact to para_a_account

2021

1

	// First index

2022

1

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

2023

1

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

2024

1

		relay_chain::Balances,

2025

1

>()

2026

1

	.unwrap() as u8;

2027

1

2028

1

	encoded.push(index);

2029

1

2030

1

	// Then call bytes

2031

1

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

2032

1

		dest: para_a_account(),

2033

1

		value: 100u32.into(),

2034

1

2035

1

	.encode();

2036

1

	encoded.append(&mut call_bytes);

2037

1

2038

1

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

2039

1

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

2040

1

);

2041

1

2042

1

	let total_weight = 4000009000u64;

2043

1

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

2044

1

	ParaA::execute_with(|| {

2045

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2046

1

			parachain::RuntimeOrigin::root(),

2047

1

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

2048

1

			Some(PARAALICE.into()),

2049

1

			CurrencyPayment {

2050

1

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

2051

1

					Location::parent()

2052

1

				))),

2053

1

				// 1-1 fee-weight mapping

2054

1

				fee_amount: Some(total_weight as u128)

2055

1

},

2056

1

			utility_bytes,

2057

1

			OriginKind::SovereignAccount,

2058

1

			TransactWeights {

2059

1

				transact_required_weight_at_most: 4000000000.into(),

2060

1

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

2061

1

},

2062

1

			true

2063

1

));

2064

1

});

2065

1

2066

1

	Relay::execute_with(|| {

2067

1

		// free execution,x	 full amount received

2068

1

		// 4000005186 refunded + 100 transferred = 4000005286

2069

1

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

2070

2071

1

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

2072

1

});

2073

1

2074

2075

#[test]

2076

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2077

1

	MockNet::reset();

2078

1

2079

1

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

2080

1

	let asset_metadata = parachain::AssetMetadata {

2081

1

		name: b"RelayToken".to_vec(),

2082

1

		symbol: b"Relay".to_vec(),

2083

1

		decimals: 12,

2084

1

};

2085

1

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

2086

1

	ParaA::execute_with(|| {

2087

1

		parachain::XcmVersioner::set_version(1);

2088

1

		assert_ok!(AssetManager::register_foreign_asset(

2089

1

			parachain::RuntimeOrigin::root(),

2090

1

			source_location.clone(),

2091

1

			asset_metadata,

2092

1

			1u128,

2093

1

			true

2094

1

));

2095

1

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

2096

1

});

2097

1

2098

1

	let response = Response::Version(2);

2099

1

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

2100

1

2101

1

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

2102

1

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

2103

1

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

2104

1

		query_id: 0,

2105

1

		response,

2106

1

		max_weight: Weight::zero(),

2107

1

		querier: Some(querier),

2108

1

	}]);

2109

1

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

2110

1

	// it directly here

2111

1

	// Actually send relay asset to parachain

2112

1

	let dest: Location = AccountKey20 {

2113

1

		network: None,

2114

1

		key: PARAALICE,

2115

1

2116

1

	.into();

2117

1

2118

1

	Relay::execute_with(|| {

2119

1

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

2120

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2121

1

			relay_chain::RuntimeOrigin::root(),

2122

1

			Some(2)

2123

1

));

2124

2125

		// Wrap version, which sets VersionedStorage

2126

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

2127

		// this is not necessary in prod

2128

1

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

2129

1

			&Parachain(1).into(),

2130

1

			mock_message

2131

1

));

2132

2133

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

2134

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2135

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2136

1

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

2137

1

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

2138

1

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

2139

1

0,

2140

1

			WeightLimit::Unlimited

2141

1

));

2142

2143

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

2144

1

		relay_chain::relay_roll_to(2);

2145

1

2146

1

		// queries should have been updated

2147

1

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

2148

1

});

2149

1

2150

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2151

1

		pallet_xcm::Event::SupportedVersionChanged {

2152

1

			location: Location {

2153

1

				parents: 0,

2154

1

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

2155

1

},

2156

1

			version: 1,

2157

1

2158

1

		.into();

2159

1

2160

1

	Relay::execute_with(|| {

2161

1

		// Assert that the events vector contains the version change

2162

1

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

2163

1

});

2164

1

2165

1

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

2166

1

	// of the new version change

2167

1

	ParaA::execute_with(|| {

2168

1

		// Set version

2169

1

		parachain::XcmVersioner::set_version(2);

2170

1

		// Do runtime upgrade

2171

1

		parachain::on_runtime_upgrade();

2172

1

		// Initialize block, to call on_initialize and notify targets

2173

1

		parachain::para_roll_to(2);

2174

1

		// Expect the event in the parachain

2175

10

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

2176

2

e,

2177

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

2178

				result: 2,

2179

..

2180

})

2181

10

		)));

2182

1

});

2183

1

2184

1

	// This event should have been seen in the relay

2185

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2186

1

		pallet_xcm::Event::SupportedVersionChanged {

2187

1

			location: Location {

2188

1

				parents: 0,

2189

1

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

2190

1

},

2191

1

			version: 2,

2192

1

2193

1

		.into();

2194

1

2195

1

	Relay::execute_with(|| {

2196

1

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

2197

1

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

2198

1

});

2199

1

2200

2201

#[test]

2202

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2203

1

	MockNet::reset();

2204

1

2205

1

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

2206

1

	let source_location = parachain::AssetType::Xcm(

2207

1

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

2208

1

);

2209

1

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

2210

1

2211

1

	let asset_metadata = parachain::AssetMetadata {

2212

1

		name: b"ParaAToken".to_vec(),

2213

1

		symbol: b"ParaA".to_vec(),

2214

1

		decimals: 18,

2215

1

};

2216

1

	let response = Response::Version(2);

2217

1

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

2218

1

		.into();

2219

1

2220

1

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

2221

1

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

2222

1

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

2223

1

		query_id: 0,

2224

1

		response,

2225

1

		max_weight: Weight::zero(),

2226

1

		querier: Some(querier),

2227

1

	}]);

2228

1

2229

1

	ParaA::execute_with(|| {

2230

1

		// advertised version

2231

1

		parachain::XcmVersioner::set_version(2);

2232

1

});

2233

1

2234

1

	ParaB::execute_with(|| {

2235

1

		// Let's try with v0

2236

1

		parachain::XcmVersioner::set_version(0);

2237

1

2238

1

		assert_ok!(AssetManager::register_foreign_asset(

2239

1

			parachain::RuntimeOrigin::root(),

2240

1

			source_location.clone(),

2241

1

			asset_metadata,

2242

1

			1u128,

2243

1

			true

2244

1

));

2245

1

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

2246

1

});

2247

1

2248

1

	ParaA::execute_with(|| {

2249

1

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

2250

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2251

1

			parachain::RuntimeOrigin::root(),

2252

1

			Some(2)

2253

1

));

2254

		// Wrap version, which sets VersionedStorage

2255

1

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

2256

1

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

2257

1

			mock_message

2258

1

));

2259

2260

1

		parachain::para_roll_to(2);

2261

1

2262

1

		// queries should have been updated

2263

1

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

2264

1

});

2265

1

2266

1

	let expected_supported_version: parachain::RuntimeEvent =

2267

1

		pallet_xcm::Event::SupportedVersionChanged {

2268

1

			location: Location {

2269

1

				parents: 1,

2270

1

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

2271

1

},

2272

1

			version: 0,

2273

1

2274

1

		.into();

2275

1

2276

1

	ParaA::execute_with(|| {

2277

1

		// Assert that the events vector contains the version change

2278

1

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

2279

1

});

2280

1

2281

1

	// Let's ensure talking in v0 works

2282

1

	let dest = Location {

2283

1

		parents: 1,

2284

1

		interior: [

2285

1

			Parachain(2),

2286

1

			AccountKey20 {

2287

1

				network: None,

2288

1

				key: PARAALICE.into(),

2289

1

},

2290

1

2291

1

		.into(),

2292

1

};

2293

1

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

2294

1

	ParaA::execute_with(|| {

2295

1

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

2296

1

		// free execution, full amount received

2297

1

		assert_ok!(PolkadotXcm::transfer_assets(

2298

1

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

2299

1

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

2300

1

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

2301

1

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

2302

1

0,

2303

1

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

2304

1

));

2305

		// free execution, full amount received

2306

1

		assert_eq!(

2307

1

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

2308

1

			INITIAL_BALANCE - 100

2309

1

);

2310

1

});

2311

1

2312

1

	ParaB::execute_with(|| {

2313

1

		// free execution, full amount received

2314

1

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

2315

1

});

2316

1

2317

1

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

2318

1

	// of the new version change

2319

1

	ParaB::execute_with(|| {

2320

1

		// Set version

2321

1

		parachain::XcmVersioner::set_version(2);

2322

1

		// Do runtime upgrade

2323

1

		parachain::on_runtime_upgrade();

2324

1

		// Initialize block, to call on_initialize and notify targets

2325

1

		parachain::para_roll_to(2);

2326

1

		// Expect the event in the parachain

2327

10

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

2328

2

e,

2329

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

2330

				result: 2,

2331

..

2332

})

2333

10

		)));

2334

1

});

2335

1

2336

1

	// This event should have been seen in para A

2337

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2338

1

		pallet_xcm::Event::SupportedVersionChanged {

2339

1

			location: Location {

2340

1

				parents: 1,

2341

1

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

2342

1

},

2343

1

			version: 2,

2344

1

2345

1

		.into();

2346

1

2347

1

	// Para A should have received the version change

2348

1

	ParaA::execute_with(|| {

2349

1

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

2350

1

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

2351

1

});

2352

1

2353

2354

#[test]

2355

1

fn receive_asset_with_no_sufficients_not_possible_if_non_existent_account() {

2356

1

	MockNet::reset();

2357

1

2358

1

	let fresh_account = [2u8; 20];

2359

1

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

2360

1

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

2361

1

	let asset_metadata = parachain::AssetMetadata {

2362

1

		name: b"RelayToken".to_vec(),

2363

1

		symbol: b"Relay".to_vec(),

2364

1

		decimals: 12,

2365

1

};

2366

1

	// register relay asset in parachain A

2367

1

	ParaA::execute_with(|| {

2368

1

		assert_ok!(AssetManager::register_foreign_asset(

2369

1

			parachain::RuntimeOrigin::root(),

2370

1

			source_location.clone(),

2371

1

			asset_metadata,

2372

1

			1u128,

2373

1

			false

2374

1

));

2375

1

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

2376

1

});

2377

1

2378

1

	// Actually send relay asset to parachain

2379

1

	let dest: Location = AccountKey20 {

2380

1

		network: None,

2381

1

		key: fresh_account,

2382

1

2383

1

	.into();

2384

1

	Relay::execute_with(|| {

2385

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2386

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2387

1

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

2388

1

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

2389

1

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

2390

1

0,

2391

1

			WeightLimit::Unlimited

2392

1

));

2393

1

});

2394

1

2395

1

	// parachain should not have received assets

2396

1

	ParaA::execute_with(|| {

2397

1

		// free execution, full amount received

2398

1

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

2399

1

});

2400

1

2401

1

	// Send native token to fresh_account

2402

1

	ParaA::execute_with(|| {

2403

1

		assert_ok!(ParaBalances::transfer_allow_death(

2404

1

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

2405

1

			fresh_account.into(),

2406

1

2407

1

));

2408

1

});

2409

1

2410

1

	// Re-send tokens

2411

1

	Relay::execute_with(|| {

2412

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2413

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2414

1

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

2415

1

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

2416

1

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

2417

1

0,

2418

1

			WeightLimit::Unlimited

2419

1

));

2420

1

});

2421

1

2422

1

	// parachain should have received assets

2423

1

	ParaA::execute_with(|| {

2424

1

		// free execution, full amount received

2425

1

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

2426

1

});

2427

1

2428

2429

#[test]

2430

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2431

1

	MockNet::reset();

2432

1

2433

1

	let fresh_account = [2u8; 20];

2434

1

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

2435

1

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

2436

1

	let asset_metadata = parachain::AssetMetadata {

2437

1

		name: b"RelayToken".to_vec(),

2438

1

		symbol: b"Relay".to_vec(),

2439

1

		decimals: 12,

2440

1

};

2441

1

	// register relay asset in parachain A

2442

1

	ParaA::execute_with(|| {

2443

1

		assert_ok!(AssetManager::register_foreign_asset(

2444

1

			parachain::RuntimeOrigin::root(),

2445

1

			source_location.clone(),

2446

1

			asset_metadata,

2447

1

			1u128,

2448

1

			true

2449

1

));

2450

1

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

2451

1

});

2452

1

2453

1

	// Actually send relay asset to parachain

2454

1

	let dest: Location = AccountKey20 {

2455

1

		network: None,

2456

1

		key: fresh_account,

2457

1

2458

1

	.into();

2459

1

	Relay::execute_with(|| {

2460

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2461

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2462

1

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

2463

1

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

2464

1

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

2465

1

0,

2466

1

			WeightLimit::Unlimited

2467

1

));

2468

1

});

2469

1

2470

1

	// parachain should have received assets

2471

1

	ParaA::execute_with(|| {

2472

1

		// free execution, full amount received

2473

1

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

2474

1

});

2475

1

2476

2477

#[test]

2478

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2479

1

	MockNet::reset();

2480

1

2481

1

	let mut sufficient_account = [0u8; 20];

2482

1

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

2483

1

2484

1

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

2485

1

2486

1

	// Evm account is self sufficient

2487

1

	ParaA::execute_with(|| {

2488

1

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

2489

1

});

2490

1

2491

1

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

2492

1

	let asset_metadata = parachain::AssetMetadata {

2493

1

		name: b"RelayToken".to_vec(),

2494

1

		symbol: b"Relay".to_vec(),

2495

1

		decimals: 12,

2496

1

};

2497

1

	// register relay asset in parachain A

2498

1

	ParaA::execute_with(|| {

2499

1

		assert_ok!(AssetManager::register_foreign_asset(

2500

1

			parachain::RuntimeOrigin::root(),

2501

1

			source_location.clone(),

2502

1

			asset_metadata,

2503

1

			1u128,

2504

1

			true

2505

1

));

2506

1

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

2507

1

});

2508

1

2509

1

	// Actually send relay asset to parachain

2510

1

	let dest: Location = AccountKey20 {

2511

1

		network: None,

2512

1

		key: sufficient_account,

2513

1

2514

1

	.into();

2515

1

	Relay::execute_with(|| {

2516

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2517

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2518

1

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

2519

1

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

2520

1

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

2521

1

0,

2522

1

			WeightLimit::Unlimited

2523

1

));

2524

1

});

2525

1

2526

1

	// Evm account sufficient ref count increased by 1.

2527

1

	ParaA::execute_with(|| {

2528

1

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

2529

1

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

2530

1

		// will be implemented in a future release

2531

1

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

2532

1

});

2533

1

2534

1

	ParaA::execute_with(|| {

2535

1

		// Remove the account from the evm context.

2536

1

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

2537

1

		// Evm account sufficient ref count decreased by 1.

2538

1

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

2539

1

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

2540

1

		// will be implemented in a future release

2541

1

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

2542

1

});

2543

1

2544

2545

#[test]

2546

1

fn empty_account_should_not_be_reset() {

2547

1

	MockNet::reset();

2548

1

2549

1

	// Test account has nonce 1 on genesis.

2550

1

	let mut sufficient_account = [0u8; 20];

2551

1

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

2552

1

2553

1

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

2554

1

2555

1

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

2556

1

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

2557

1

	let asset_metadata = parachain::AssetMetadata {

2558

1

		name: b"RelayToken".to_vec(),

2559

1

		symbol: b"Relay".to_vec(),

2560

1

		decimals: 12,

2561

1

};

2562

1

	// register relay asset in parachain A

2563

1

	ParaA::execute_with(|| {

2564

1

		assert_ok!(AssetManager::register_foreign_asset(

2565

1

			parachain::RuntimeOrigin::root(),

2566

1

			source_location.clone(),

2567

1

			asset_metadata,

2568

1

			1u128,

2569

1

			false

2570

1

));

2571

1

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

2572

1

});

2573

1

2574

1

	// Send native token to evm_account

2575

1

	ParaA::execute_with(|| {

2576

1

		assert_ok!(ParaBalances::transfer_allow_death(

2577

1

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

2578

1

			evm_account_id,

2579

1

2580

1

));

2581

1

});

2582

1

2583

1

	// Actually send relay asset to parachain

2584

1

	let dest: Location = AccountKey20 {

2585

1

		network: None,

2586

1

		key: sufficient_account,

2587

1

2588

1

	.into();

2589

1

	Relay::execute_with(|| {

2590

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2591

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2592

1

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

2593

1

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

2594

1

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

2595

1

0,

2596

1

			WeightLimit::Unlimited

2597

1

));

2598

1

});

2599

1

2600

1

	ParaA::execute_with(|| {

2601

1

		// Empty the assets from the account.

2602

1

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

2603

1

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

2604

1

		assert_ok!(parachain::Assets::transfer(

2605

1

			parachain::RuntimeOrigin::signed(evm_account_id),

2606

1

			source_id,

2607

1

			PARAALICE.into(),

2608

1

2609

1

));

2610

		// Verify account asset balance is Zero.

2611

1

		assert_eq!(

2612

1

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

2613

1

2614

1

);

2615

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

2616

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

2617

1

		assert_ok!(ParaBalances::force_set_balance(

2618

1

			parachain::RuntimeOrigin::root(),

2619

1

			evm_account_id,

2620

1

0,

2621

1

));

2622

		// Verify account native balance is Zero.

2623

1

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

2624

		// Remove the account from the evm context.

2625

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

2626

1

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

2627

1

		// Verify reference count.

2628

1

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

2629

1

		assert_eq!(account.sufficients, 0);

2630

1

		assert_eq!(account.consumers, 0);

2631

1

		assert_eq!(account.providers, 1);

2632

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

2633

1

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

2634

1

});

2635

1

2636

2637

#[test]

2638

1

fn test_statemine_like() {

2639

1

	MockNet::reset();

2640

1

2641

1

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

2642

1

2643

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2644

1

		polkadot_parachain::primitives::Sibling,

2645

1

		statemine_like::AccountId,

2646

1

	>::convert_location(&dest_para)

2647

1

	.unwrap();

2648

1

2649

1

	let statemine_asset_a_balances = Location::new(

2650

1

1,

2651

1

2652

1

			Parachain(1000),

2653

1

			PalletInstance(5),

2654

1

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

2655

1

],

2656

1

);

2657

1

	let source_location = parachain::AssetType::Xcm(

2658

1

		xcm_builder::WithLatestLocationConverter::convert(&statemine_asset_a_balances)

2659

1

			.expect("convert to v3"),

2660

1

);

2661

1

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

2662

1

2663

1

	let asset_metadata = parachain::AssetMetadata {

2664

1

		name: b"StatemineToken".to_vec(),

2665

1

		symbol: b"StatemineToken".to_vec(),

2666

1

		decimals: 12,

2667

1

};

2668

1

2669

1

	ParaA::execute_with(|| {

2670

1

		assert_ok!(AssetManager::register_foreign_asset(

2671

1

			parachain::RuntimeOrigin::root(),

2672

1

			source_location.clone(),

2673

1

			asset_metadata.clone(),

2674

1

			1u128,

2675

1

			true

2676

1

));

2677

1

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

2678

1

});

2679

1

2680

1

	Statemine::execute_with(|| {

2681

1

		// Set new prefix

2682

1

		statemine_like::PrefixChanger::set_prefix(

2683

1

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

2684

1

);

2685

1

		assert_ok!(StatemineAssets::create(

2686

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2687

1

0,

2688

1

			RELAYALICE,

2689

1

2690

1

));

2691

2692

1

		assert_ok!(StatemineAssets::mint(

2693

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2694

1

0,

2695

1

			RELAYALICE,

2696

1

			300000000000000

2697

1

));

2698

2699

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

2700

1

		assert_ok!(StatemineBalances::transfer_allow_death(

2701

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2702

1

			sov,

2703

1

			100000000000000

2704

1

));

2705

2706

		// Actually send relay asset to parachain

2707

1

		let dest: Location = AccountKey20 {

2708

1

			network: None,

2709

1

			key: PARAALICE,

2710

1

2711

1

		.into();

2712

1

2713

1

		// Send with new prefix

2714

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

2715

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2716

1

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

2717

1

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

2718

1

			Box::new(

2719

1

2720

1

2721

1

						xcm::latest::prelude::PalletInstance(

2722

1

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

2723

1

),

2724

1

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

2725

1

],

2726

1

2727

1

2728

1

					.into()

2729

1

),

2730

1

0,

2731

1

			WeightLimit::Unlimited

2732

1

));

2733

1

});

2734

1

2735

1

	ParaA::execute_with(|| {

2736

1

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

2737

1

});

2738

1

2739

2740

#[test]

2741

1

fn send_statemine_asset_from_para_a_to_statemine_with_relay_fee() {

2742

1

	MockNet::reset();

2743

1

2744

1

	// Relay asset

2745

1

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

2746

1

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

2747

1

2748

1

	let relay_asset_metadata = parachain::AssetMetadata {

2749

1

		name: b"RelayToken".to_vec(),

2750

1

		symbol: b"Relay".to_vec(),

2751

1

		decimals: 12,

2752

1

};

2753

1

2754

1

	// Statemine asset

2755

1

	let statemine_asset = Location::new(

2756

1

1,

2757

1

2758

1

			Parachain(1000u32),

2759

1

			PalletInstance(5u8),

2760

1

			GeneralIndex(10u128),

2761

1

],

2762

1

);

2763

1

	let statemine_location_asset = parachain::AssetType::Xcm(

2764

1

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

2765

1

);

2766

1

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

2767

1

2768

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

2769

1

		name: b"USDC".to_vec(),

2770

1

		symbol: b"USDC".to_vec(),

2771

1

		decimals: 12,

2772

1

};

2773

1

2774

1

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

2775

1

2776

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2777

1

		polkadot_parachain::primitives::Sibling,

2778

1

		statemine_like::AccountId,

2779

1

	>::convert_location(&dest_para)

2780

1

	.unwrap();

2781

1

2782

1

	ParaA::execute_with(|| {

2783

1

		assert_ok!(AssetManager::register_foreign_asset(

2784

1

			parachain::RuntimeOrigin::root(),

2785

1

			relay_location.clone(),

2786

1

			relay_asset_metadata,

2787

1

			1u128,

2788

1

			true

2789

1

));

2790

1

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

2791

2792

1

		assert_ok!(AssetManager::register_foreign_asset(

2793

1

			parachain::RuntimeOrigin::root(),

2794

1

			statemine_location_asset.clone(),

2795

1

			asset_metadata_statemine_asset,

2796

1

			1u128,

2797

1

			true

2798

1

));

2799

1

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

2800

1

});

2801

1

2802

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2803

1

		network: None,

2804

1

		key: PARAALICE,

2805

1

2806

1

	.into();

2807

1

2808

1

	// Send relay chain asset to Alice in Parachain A

2809

1

	Relay::execute_with(|| {

2810

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2811

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2812

1

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

2813

1

			Box::new(

2814

1

				VersionedLocation::V4(parachain_beneficiary_from_relay)

2815

1

					.clone()

2816

1

					.into()

2817

1

),

2818

1

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

2819

1

0,

2820

1

			WeightLimit::Unlimited

2821

1

));

2822

1

});

2823

1

2824

1

	Statemine::execute_with(|| {

2825

1

		// Set new prefix

2826

1

		statemine_like::PrefixChanger::set_prefix(

2827

1

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

2828

1

);

2829

1

2830

1

		assert_ok!(StatemineAssets::create(

2831

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2832

1

10,

2833

1

			RELAYALICE,

2834

1

2835

1

));

2836

2837

1

		assert_ok!(StatemineAssets::mint(

2838

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2839

1

10,

2840

1

			RELAYALICE,

2841

1

			300000000000000

2842

1

));

2843

2844

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

2845

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

2846

1

		assert_ok!(StatemineBalances::transfer_allow_death(

2847

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2848

1

			sov,

2849

1

			100000000000000

2850

1

));

2851

2852

		// Send statemine USDC asset to Alice in Parachain A

2853

1

		let parachain_beneficiary_from_statemine: Location = AccountKey20 {

2854

1

			network: None,

2855

1

			key: PARAALICE,

2856

1

2857

1

		.into();

2858

1

2859

1

		// Send with new prefix

2860

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

2861

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2862

1

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

2863

1

			Box::new(

2864

1

				VersionedLocation::V4(parachain_beneficiary_from_statemine)

2865

1

					.clone()

2866

1

					.into()

2867

1

),

2868

1

			Box::new(

2869

1

2870

1

2871

1

						xcm::latest::prelude::PalletInstance(

2872

1

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

2873

1

),

2874

1

						GeneralIndex(10),

2875

1

],

2876

1

2877

1

2878

1

					.into()

2879

1

),

2880

1

0,

2881

1

			WeightLimit::Unlimited

2882

1

));

2883

1

});

2884

1

2885

1

	let statemine_beneficiary = Location {

2886

1

		parents: 1,

2887

1

		interior: [

2888

1

			Parachain(1000),

2889

1

			AccountId32 {

2890

1

				network: None,

2891

1

				id: RELAYBOB.into(),

2892

1

},

2893

1

2894

1

		.into(),

2895

1

};

2896

1

2897

1

	ParaA::execute_with(|| {

2898

1

		// Alice has received 125 USDC

2899

1

		assert_eq!(

2900

1

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

2901

1

2902

1

);

2903

2904

		// Alice has received 200 Relay assets

2905

1

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

2906

1

});

2907

1

2908

1

	Statemine::execute_with(|| {

2909

1

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

2910

1

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

2911

1

});

2912

1

	let (chain_part, beneficiary) =

2913

1

		split_location_into_chain_part_and_beneficiary(statemine_beneficiary).unwrap();

2914

1

2915

1

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

2916

1

	ParaA::execute_with(|| {

2917

1

		let asset_1 = currency_to_asset(

2918

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

2919

1

			100,

2920

1

);

2921

1

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

2922

1

		let assets_to_send = vec![asset_1, asset_2];

2923

1

		assert_ok!(PolkadotXcm::transfer_assets(

2924

1

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

2925

1

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

2926

1

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

2927

1

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

2928

1

1,

2929

1

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

2930

1

));

2931

1

});

2932

1

2933

1

	ParaA::execute_with(|| {

2934

1

		// Alice has 100 USDC less

2935

1

		assert_eq!(

2936

1

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

2937

1

2938

1

);

2939

2940

		// Alice has 100 relay asset less

2941

1

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

2942

1

});

2943

1

2944

1

	Statemine::execute_with(|| {

2945

1

		// Check that BOB received 100 USDC on statemine

2946

1

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

2947

1

});

2948

1

2949

2950

#[test]

2951

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer() {

2952

1

	MockNet::reset();

2953

1

2954

1

	// Relay asset

2955

1

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

2956

1

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

2957

1

2958

1

	let relay_asset_metadata = parachain::AssetMetadata {

2959

1

		name: b"RelayToken".to_vec(),

2960

1

		symbol: b"Relay".to_vec(),

2961

1

		decimals: 12,

2962

1

};

2963

1

2964

1

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

2965

1

2966

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2967

1

		polkadot_parachain::primitives::Sibling,

2968

1

		statemine_like::AccountId,

2969

1

	>::convert_location(&dest_para)

2970

1

	.unwrap();

2971

1

2972

1

	ParaA::execute_with(|| {

2973

1

		assert_ok!(AssetManager::register_foreign_asset(

2974

1

			parachain::RuntimeOrigin::root(),

2975

1

			relay_location.clone(),

2976

1

			relay_asset_metadata,

2977

1

			1u128,

2978

1

			true

2979

1

));

2980

1

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

2981

1

});

2982

1

2983

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2984

1

		network: None,

2985

1

		key: PARAALICE,

2986

1

2987

1

	.into();

2988

1

2989

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

2990

1

		network: None,

2991

1

		id: RELAYALICE.into(),

2992

1

2993

1

	.into();

2994

1

2995

1

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

2996

1

	Relay::execute_with(|| {

2997

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2998

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2999

1

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

3000

1

			Box::new(

3001

1

				VersionedLocation::V4(statemine_beneficiary_absolute)

3002

1

					.clone()

3003

1

					.into()

3004

1

),

3005

1

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

3006

1

0,

3007

1

			WeightLimit::Unlimited

3008

1

));

3009

1

});

3010

1

3011

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3012

1

	Statemine::execute_with(|| {

3013

1

		// Check Alice received 200 tokens on AssetHub

3014

1

		assert_eq!(

3015

1

			StatemineBalances::free_balance(RELAYALICE),

3016

1

			INITIAL_BALANCE + 200

3017

1

);

3018

3019

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3020

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3021

1

			sov,

3022

1

			110000000000000

3023

1

));

3024

3025

		// Now send those tokens to ParaA

3026

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3027

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3028

1

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

3029

1

			Box::new(

3030

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3031

1

					.clone()

3032

1

					.into()

3033

1

),

3034

1

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

3035

1

0,

3036

1

			WeightLimit::Unlimited

3037

1

));

3038

1

});

3039

1

3040

1

	ParaA::execute_with(|| {

3041

1

		// Alice should have received the DOTs

3042

1

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

3043

1

});

3044

1

3045

1

	let dest = Location::new(

3046

1

1,

3047

1

3048

1

			Parachain(1000),

3049

1

			AccountId32 {

3050

1

				network: None,

3051

1

				id: RELAYBOB.into(),

3052

1

},

3053

1

],

3054

1

);

3055

1

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

3056

1

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

3057

1

	ParaA::execute_with(|| {

3058

1

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

3059

1

		assert_ok!(PolkadotXcm::transfer_assets(

3060

1

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

3061

1

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

3062

1

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

3063

1

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

3064

1

0,

3065

1

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

3066

1

));

3067

3068

1

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

3069

1

});

3070

1

3071

1

	Statemine::execute_with(|| {

3072

1

		// Check that Bob received the tokens back in AssetHub

3073

1

		assert_eq!(

3074

1

			StatemineBalances::free_balance(RELAYBOB),

3075

1

			INITIAL_BALANCE + 100

3076

1

);

3077

1

});

3078

1

3079

1

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

3080

1

	Statemine::execute_with(|| {

3081

1

		// Now send those tokens to ParaA

3082

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3083

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3084

1

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

3085

1

			Box::new(

3086

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3087

1

					.clone()

3088

1

					.into()

3089

1

),

3090

1

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

3091

1

0,

3092

1

			WeightLimit::Unlimited

3093

1

));

3094

3095

		// 100 DOTs were deducted from Bob's account

3096

1

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

3097

1

});

3098

1

3099

1

	ParaA::execute_with(|| {

3100

1

		// Alice should have received 100 DOTs

3101

1

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

3102

1

});

3103

1

3104

3105

#[test]

3106

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_with_fee() {

3107

1

	MockNet::reset();

3108

1

3109

1

	// Relay asset

3110

1

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

3111

1

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

3112

1

3113

1

	let relay_asset_metadata = parachain::AssetMetadata {

3114

1

		name: b"RelayToken".to_vec(),

3115

1

		symbol: b"Relay".to_vec(),

3116

1

		decimals: 12,

3117

1

};

3118

1

3119

1

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

3120

1

3121

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3122

1

		polkadot_parachain::primitives::Sibling,

3123

1

		statemine_like::AccountId,

3124

1

	>::convert_location(&dest_para)

3125

1

	.unwrap();

3126

1

3127

1

	ParaA::execute_with(|| {

3128

1

		assert_ok!(AssetManager::register_foreign_asset(

3129

1

			parachain::RuntimeOrigin::root(),

3130

1

			relay_location.clone(),

3131

1

			relay_asset_metadata,

3132

1

			1u128,

3133

1

			true

3134

1

));

3135

1

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

3136

1

});

3137

1

3138

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3139

1

		network: None,

3140

1

		key: PARAALICE,

3141

1

3142

1

	.into();

3143

1

3144

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3145

1

		network: None,

3146

1

		id: RELAYALICE.into(),

3147

1

3148

1

	.into();

3149

1

3150

1

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

3151

1

	Relay::execute_with(|| {

3152

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3153

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3154

1

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

3155

1

			Box::new(

3156

1

				VersionedLocation::V4(statemine_beneficiary_absolute)

3157

1

					.clone()

3158

1

					.into()

3159

1

),

3160

1

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

3161

1

0,

3162

1

			WeightLimit::Unlimited

3163

1

));

3164

1

});

3165

1

3166

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3167

1

	Statemine::execute_with(|| {

3168

1

		// Check Alice received 200 tokens on AssetHub

3169

1

		assert_eq!(

3170

1

			StatemineBalances::free_balance(RELAYALICE),

3171

1

			INITIAL_BALANCE + 200

3172

1

);

3173

3174

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3175

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3176

1

			sov,

3177

1

			110000000000000

3178

1

));

3179

3180

		// Now send those tokens to ParaA

3181

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3182

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3183

1

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

3184

1

			Box::new(

3185

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3186

1

					.clone()

3187

1

					.into()

3188

1

),

3189

1

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

3190

1

0,

3191

1

			WeightLimit::Unlimited

3192

1

));

3193

1

});

3194

1

3195

1

	ParaA::execute_with(|| {

3196

1

		// Alice should have received the DOTs

3197

1

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

3198

1

});

3199

1

3200

1

	let dest = Location::new(

3201

1

1,

3202

1

3203

1

			Parachain(1000),

3204

1

			AccountId32 {

3205

1

				network: None,

3206

1

				id: RELAYBOB.into(),

3207

1

},

3208

1

],

3209

1

);

3210

1

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

3211

1

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

3212

1

	ParaA::execute_with(|| {

3213

1

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

3214

1

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

3215

1

		assert_ok!(PolkadotXcm::transfer_assets(

3216

1

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

3217

1

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

3218

1

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

3219

1

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

3220

1

0,

3221

1

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

3222

1

));

3223

3224

1

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

3225

1

});

3226

1

3227

1

	Statemine::execute_with(|| {

3228

1

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

3229

1

		assert_eq!(

3230

1

			StatemineBalances::free_balance(RELAYBOB),

3231

1

			INITIAL_BALANCE + 110

3232

1

);

3233

1

});

3234

1

3235

1

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

3236

1

	Statemine::execute_with(|| {

3237

1

		// Now send those tokens to ParaA

3238

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3239

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3240

1

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

3241

1

			Box::new(

3242

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3243

1

					.clone()

3244

1

					.into()

3245

1

),

3246

1

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

3247

1

0,

3248

1

			WeightLimit::Unlimited

3249

1

));

3250

3251

		// 100 DOTs were deducted from Bob's account

3252

1

		assert_eq!(

3253

1

			StatemineBalances::free_balance(RELAYBOB),

3254

1

			INITIAL_BALANCE + 10

3255

1

);

3256

1

});

3257

1

3258

1

	ParaA::execute_with(|| {

3259

1

		// Alice should have received 100 DOTs

3260

1

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

3261

1

});

3262

1

3263

3264

#[test]

3265

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiasset() {

3266

1

	MockNet::reset();

3267

1

3268

1

	// Relay asset

3269

1

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

3270

1

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

3271

1

3272

1

	let relay_asset_metadata = parachain::AssetMetadata {

3273

1

		name: b"RelayToken".to_vec(),

3274

1

		symbol: b"Relay".to_vec(),

3275

1

		decimals: 12,

3276

1

};

3277

1

3278

1

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

3279

1

3280

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3281

1

		polkadot_parachain::primitives::Sibling,

3282

1

		statemine_like::AccountId,

3283

1

	>::convert_location(&dest_para)

3284

1

	.unwrap();

3285

1

3286

1

	ParaA::execute_with(|| {

3287

1

		assert_ok!(AssetManager::register_foreign_asset(

3288

1

			parachain::RuntimeOrigin::root(),

3289

1

			relay_location.clone(),

3290

1

			relay_asset_metadata,

3291

1

			1u128,

3292

1

			true

3293

1

));

3294

1

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

3295

1

});

3296

1

3297

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3298

1

		network: None,

3299

1

		key: PARAALICE,

3300

1

3301

1

	.into();

3302

1

3303

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3304

1

		network: None,

3305

1

		id: RELAYALICE.into(),

3306

1

3307

1

	.into();

3308

1

3309

1

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

3310

1

	Relay::execute_with(|| {

3311

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3312

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3313

1

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

3314

1

			Box::new(

3315

1

				VersionedLocation::V4(statemine_beneficiary_absolute)

3316

1

					.clone()

3317

1

					.into()

3318

1

),

3319

1

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

3320

1

0,

3321

1

			WeightLimit::Unlimited

3322

1

));

3323

1

});

3324

1

3325

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3326

1

	Statemine::execute_with(|| {

3327

1

		// Check Alice received 200 tokens on AssetHub

3328

1

		assert_eq!(

3329

1

			StatemineBalances::free_balance(RELAYALICE),

3330

1

			INITIAL_BALANCE + 200

3331

1

);

3332

3333

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3334

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3335

1

			sov,

3336

1

			110000000000000

3337

1

));

3338

3339

		// Now send those tokens to ParaA

3340

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3341

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3342

1

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

3343

1

			Box::new(

3344

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3345

1

					.clone()

3346

1

					.into()

3347

1

),

3348

1

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

3349

1

0,

3350

1

			WeightLimit::Unlimited

3351

1

));

3352

1

});

3353

1

3354

1

	ParaA::execute_with(|| {

3355

1

		// Alice should have received the DOTs

3356

1

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

3357

1

});

3358

1

3359

1

	let dest = Location::new(

3360

1

1,

3361

1

3362

1

			Parachain(1000),

3363

1

			AccountId32 {

3364

1

				network: None,

3365

1

				id: RELAYBOB.into(),

3366

1

},

3367

1

],

3368

1

);

3369

1

3370

1

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

3371

1

3372

1

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

3373

1

	ParaA::execute_with(|| {

3374

1

		assert_ok!(PolkadotXcm::transfer_assets(

3375

1

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

3376

1

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

3377

1

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

3378

1

			Box::new(VersionedAssets::V4(

3379

1

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

3380

1

)),

3381

1

0,

3382

1

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

3383

1

));

3384

3385

1

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

3386

1

});

3387

1

3388

1

	Statemine::execute_with(|| {

3389

1

		// Check that Bob received the tokens back in AssetHub

3390

1

		assert_eq!(

3391

1

			StatemineBalances::free_balance(RELAYBOB),

3392

1

			INITIAL_BALANCE + 100

3393

1

);

3394

1

});

3395

1

3396

1

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

3397

1

	Statemine::execute_with(|| {

3398

1

		// Now send those tokens to ParaA

3399

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3400

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3401

1

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

3402

1

			Box::new(

3403

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3404

1

					.clone()

3405

1

					.into()

3406

1

),

3407

1

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

3408

1

0,

3409

1

			WeightLimit::Unlimited

3410

1

));

3411

3412

		// 100 DOTs were deducted from Bob's account

3413

1

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

3414

1

});

3415

1

3416

1

	ParaA::execute_with(|| {

3417

1

		// Alice should have received 100 DOTs

3418

1

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

3419

1

});

3420

1

3421

3422

#[test]

3423

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multicurrencies() {

3424

1

	MockNet::reset();

3425

1

3426

1

	// Relay asset

3427

1

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

3428

1

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

3429

1

3430

1

	let relay_asset_metadata = parachain::AssetMetadata {

3431

1

		name: b"RelayToken".to_vec(),

3432

1

		symbol: b"Relay".to_vec(),

3433

1

		decimals: 12,

3434

1

};

3435

1

3436

1

	// Statemine asset

3437

1

	let statemine_asset = Location::new(

3438

1

1,

3439

1

3440

1

			Parachain(1000u32),

3441

1

			PalletInstance(5u8),

3442

1

			GeneralIndex(10u128),

3443

1

],

3444

1

);

3445

1

	let statemine_location_asset = parachain::AssetType::Xcm(

3446

1

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

3447

1

);

3448

1

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

3449

1

3450

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3451

1

		name: b"USDC".to_vec(),

3452

1

		symbol: b"USDC".to_vec(),

3453

1

		decimals: 12,

3454

1

};

3455

1

3456

1

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

3457

1

3458

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3459

1

		polkadot_parachain::primitives::Sibling,

3460

1

		statemine_like::AccountId,

3461

1

	>::convert_location(&dest_para)

3462

1

	.unwrap();

3463

1

3464

1

	ParaA::execute_with(|| {

3465

1

		assert_ok!(AssetManager::register_foreign_asset(

3466

1

			parachain::RuntimeOrigin::root(),

3467

1

			relay_location.clone(),

3468

1

			relay_asset_metadata,

3469

1

			1u128,

3470

1

			true

3471

1

));

3472

1

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

3473

1

3474

1

		assert_ok!(AssetManager::register_foreign_asset(

3475

1

			parachain::RuntimeOrigin::root(),

3476

1

			statemine_location_asset.clone(),

3477

1

			asset_metadata_statemine_asset,

3478

1

			1u128,

3479

1

			true

3480

1

));

3481

1

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

3482

1

});

3483

1

3484

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3485

1

		network: None,

3486

1

		key: PARAALICE,

3487

1

3488

1

	.into();

3489

1

3490

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3491

1

		network: None,

3492

1

		id: RELAYALICE.into(),

3493

1

3494

1

	.into();

3495

1

3496

1

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

3497

1

	Relay::execute_with(|| {

3498

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3499

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3500

1

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

3501

1

			Box::new(

3502

1

				VersionedLocation::V4(statemine_beneficiary_absolute)

3503

1

					.clone()

3504

1

					.into()

3505

1

),

3506

1

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

3507

1

0,

3508

1

			WeightLimit::Unlimited

3509

1

));

3510

1

});

3511

1

3512

1

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

3513

1

	Statemine::execute_with(|| {

3514

1

		// Check Alice received 200 tokens on AssetHub

3515

1

		assert_eq!(

3516

1

			StatemineBalances::free_balance(RELAYALICE),

3517

1

			INITIAL_BALANCE + 200

3518

1

);

3519

3520

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3521

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3522

1

			sov,

3523

1

			110000000000000

3524

1

));

3525

3526

1

		statemine_like::PrefixChanger::set_prefix(

3527

1

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

3528

1

);

3529

1

3530

1

		assert_ok!(StatemineAssets::create(

3531

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3532

1

10,

3533

1

			RELAYALICE,

3534

1

3535

1

));

3536

3537

1

		assert_ok!(StatemineAssets::mint(

3538

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3539

1

10,

3540

1

			RELAYALICE,

3541

1

			300000000000000

3542

1

));

3543

3544

		// Now send relay tokens to ParaA

3545

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3546

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3547

1

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

3548

1

			Box::new(

3549

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3550

1

					.clone()

3551

1

					.into()

3552

1

),

3553

1

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

3554

1

0,

3555

1

			WeightLimit::Unlimited

3556

1

));

3557

3558

		// Send USDC

3559

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3560

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3561

1

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

3562

1

			Box::new(

3563

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3564

1

					.clone()

3565

1

					.into()

3566

1

),

3567

1

			Box::new(

3568

1

3569

1

3570

1

						xcm::latest::prelude::PalletInstance(

3571

1

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

3572

1

),

3573

1

						GeneralIndex(10),

3574

1

],

3575

1

3576

1

3577

1

					.into()

3578

1

),

3579

1

0,

3580

1

			WeightLimit::Unlimited

3581

1

));

3582

1

});

3583

1

3584

1

	ParaA::execute_with(|| {

3585

1

		// Alice should have received the DOTs

3586

1

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

3587

3588

		// Alice has received 125 USDC

3589

1

		assert_eq!(

3590

1

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

3591

1

3592

1

);

3593

1

});

3594

1

3595

1

	let dest = Location::new(

3596

1

1,

3597

1

3598

1

			Parachain(1000),

3599

1

			AccountId32 {

3600

1

				network: None,

3601

1

				id: RELAYBOB.into(),

3602

1

},

3603

1

],

3604

1

);

3605

1

3606

1

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

3607

1

3608

1

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

3609

1

	ParaA::execute_with(|| {

3610

1

		let asset_1 = currency_to_asset(

3611

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3612

1

			100,

3613

1

);

3614

1

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

3615

1

		assert_ok!(PolkadotXcm::transfer_assets(

3616

1

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

3617

1

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

3618

1

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

3619

1

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

3620

1

1,

3621

1

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

3622

1

));

3623

3624

1

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

3625

1

});

3626

1

3627

1

	Statemine::execute_with(|| {

3628

1

		// Check that Bob received relay tokens back in AssetHub

3629

1

		// (100 - MinXcmFee)

3630

1

		assert_eq!(

3631

1

			StatemineBalances::free_balance(RELAYBOB),

3632

1

			INITIAL_BALANCE + 100

3633

1

);

3634

3635

		// Check that BOB received 100 USDC on AssetHub

3636

1

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

3637

1

});

3638

1

3639

1

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

3640

1

	Statemine::execute_with(|| {

3641

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

3642

1

3643

1

		// Now send those tokens to ParaA

3644

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3645

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3646

1

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

3647

1

			Box::new(

3648

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3649

1

					.clone()

3650

1

					.into()

3651

1

),

3652

1

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

3653

1

0,

3654

1

			WeightLimit::Unlimited

3655

1

));

3656

3657

		// 100 DOTs were deducted from Bob's account

3658

1

		assert_eq!(

3659

1

			StatemineBalances::free_balance(RELAYBOB),

3660

1

			bob_previous_balance - 100

3661

1

);

3662

1

});

3663

1

3664

1

	ParaA::execute_with(|| {

3665

1

		// Alice should have received 100 DOTs

3666

1

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

3667

1

});

3668

1

3669

3670

#[test]

3671

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiassets() {

3672

1

	MockNet::reset();

3673

1

3674

1

	// Relay asset

3675

1

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

3676

1

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

3677

1

3678

1

	let relay_asset_metadata = parachain::AssetMetadata {

3679

1

		name: b"RelayToken".to_vec(),

3680

1

		symbol: b"Relay".to_vec(),

3681

1

		decimals: 12,

3682

1

};

3683

1

3684

1

	// Statemine asset

3685

1

	let statemine_asset = Location::new(

3686

1

1,

3687

1

3688

1

			Parachain(1000u32),

3689

1

			PalletInstance(5u8),

3690

1

			GeneralIndex(10u128),

3691

1

],

3692

1

);

3693

1

	let statemine_location_asset = parachain::AssetType::Xcm(

3694

1

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

3695

1

);

3696

1

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

3697

1

3698

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3699

1

		name: b"USDC".to_vec(),

3700

1

		symbol: b"USDC".to_vec(),

3701

1

		decimals: 12,

3702

1

};

3703

1

3704

1

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

3705

1

3706

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3707

1

		polkadot_parachain::primitives::Sibling,

3708

1

		statemine_like::AccountId,

3709

1

	>::convert_location(&dest_para)

3710

1

	.unwrap();

3711

1

3712

1

	ParaA::execute_with(|| {

3713

1

		assert_ok!(AssetManager::register_foreign_asset(

3714

1

			parachain::RuntimeOrigin::root(),

3715

1

			relay_location.clone(),

3716

1

			relay_asset_metadata,

3717

1

			1u128,

3718

1

			true

3719

1

));

3720

1

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

3721

1

3722

1

		assert_ok!(AssetManager::register_foreign_asset(

3723

1

			parachain::RuntimeOrigin::root(),

3724

1

			statemine_location_asset.clone(),

3725

1

			asset_metadata_statemine_asset,

3726

1

			1u128,

3727

1

			true

3728

1

));

3729

1

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

3730

1

});

3731

1

3732

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3733

1

		network: None,

3734

1

		key: PARAALICE,

3735

1

3736

1

	.into();

3737

1

3738

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3739

1

		network: None,

3740

1

		id: RELAYALICE.into(),

3741

1

3742

1

	.into();

3743

1

3744

1

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

3745

1

	Relay::execute_with(|| {

3746

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3747

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3748

1

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

3749

1

			Box::new(

3750

1

				VersionedLocation::V4(statemine_beneficiary_absolute)

3751

1

					.clone()

3752

1

					.into()

3753

1

),

3754

1

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

3755

1

0,

3756

1

			WeightLimit::Unlimited

3757

1

));

3758

1

});

3759

1

3760

1

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

3761

1

	Statemine::execute_with(|| {

3762

1

		// Check Alice received 200 tokens on AssetHub

3763

1

		assert_eq!(

3764

1

			StatemineBalances::free_balance(RELAYALICE),

3765

1

			INITIAL_BALANCE + 200

3766

1

);

3767

3768

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3769

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3770

1

			sov,

3771

1

			110000000000000

3772

1

));

3773

3774

1

		statemine_like::PrefixChanger::set_prefix(

3775

1

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

3776

1

);

3777

1

3778

1

		assert_ok!(StatemineAssets::create(

3779

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3780

1

10,

3781

1

			RELAYALICE,

3782

1

3783

1

));

3784

3785

1

		assert_ok!(StatemineAssets::mint(

3786

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3787

1

10,

3788

1

			RELAYALICE,

3789

1

			300000000000000

3790

1

));

3791

3792

		// Now send relay tokens to ParaA

3793

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3794

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3795

1

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

3796

1

			Box::new(

3797

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3798

1

					.clone()

3799

1

					.into()

3800

1

),

3801

1

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

3802

1

0,

3803

1

			WeightLimit::Unlimited

3804

1

));

3805

3806

		// Send USDC

3807

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3808

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3809

1

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

3810

1

			Box::new(

3811

1

				VersionedLocation::V4(parachain_beneficiary_absolute.clone())

3812

1

					.clone()

3813

1

					.into()

3814

1

),

3815

1

			Box::new(

3816

1

3817

1

3818

1

						xcm::latest::prelude::PalletInstance(

3819

1

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

3820

1

),

3821

1

						GeneralIndex(10),

3822

1

],

3823

1

3824

1

3825

1

					.into()

3826

1

),

3827

1

0,

3828

1

			WeightLimit::Unlimited

3829

1

));

3830

1

});

3831

1

3832

1

	ParaA::execute_with(|| {

3833

1

		// Alice should have received the DOTs

3834

1

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

3835

3836

		// Alice has received 125 USDC

3837

1

		assert_eq!(

3838

1

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

3839

1

3840

1

);

3841

1

});

3842

1

3843

1

	let dest = Location::new(

3844

1

1,

3845

1

3846

1

			Parachain(1000),

3847

1

			AccountId32 {

3848

1

				network: None,

3849

1

				id: RELAYBOB.into(),

3850

1

},

3851

1

],

3852

1

);

3853

1

3854

1

	let statemine_asset_to_send = Asset {

3855

1

		id: AssetId(statemine_asset),

3856

1

		fun: Fungibility::Fungible(100),

3857

1

};

3858

1

3859

1

	let relay_asset_to_send = Asset {

3860

1

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

3861

1

		fun: Fungibility::Fungible(100),

3862

1

};

3863

1

3864

1

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

3865

1

	let assets_to_send: XcmAssets =

3866

1

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

3867

1

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

3868

1

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

3869

1

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

3870

3871

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

3872

1

	ParaA::execute_with(|| {

3873

1

		assert_ok!(PolkadotXcm::transfer_assets(

3874

1

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

3875

1

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

3876

1

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

3877

1

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

3878

1

0,

3879

1

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

3880

1

));

3881

3882

1

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

3883

1

});

3884

1

3885

1

	Statemine::execute_with(|| {

3886

1

		// Check that Bob received relay tokens back in AssetHub

3887

1

		// (100 - MinXcmFee)

3888

1

		assert_eq!(

3889

1

			StatemineBalances::free_balance(RELAYBOB),

3890

1

			INITIAL_BALANCE + 100

3891

1

);

3892

3893

		// Check that BOB received 100 USDC on AssetHub

3894

1

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

3895

1

});

3896

1

3897

1

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

3898

1

	Statemine::execute_with(|| {

3899

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

3900

1

3901

1

		// Now send those tokens to ParaA

3902

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3903

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3904

1

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

3905

1

			Box::new(

3906

1

				VersionedLocation::V4(parachain_beneficiary_absolute)

3907

1

					.clone()

3908

1

					.into()

3909

1

),

3910

1

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

3911

1

0,

3912

1

			WeightLimit::Unlimited

3913

1

));

3914

3915

		// 100 DOTs were deducted from Bob's account

3916

1

		assert_eq!(

3917

1

			StatemineBalances::free_balance(RELAYBOB),

3918

1

			bob_previous_balance - 100

3919

1

);

3920

1

});

3921

1

3922

1

	ParaA::execute_with(|| {

3923

1

		// Alice should have received 100 DOTs

3924

1

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

3925

1

});

3926

1

3927

3928

#[test]

3929

1

fn transact_through_signed_multilocation() {

3930

1

	MockNet::reset();

3931

1

	let mut ancestry = Location::parent();

3932

1

3933

1

	ParaA::execute_with(|| {

3934

1

		// Root can set transact info

3935

1

		assert_ok!(XcmTransactor::set_transact_info(

3936

1

			parachain::RuntimeOrigin::root(),

3937

1

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

3938

1

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

3939

1

			3000.into(),

3940

1

			20000000000.into(),

3941

1

			// 4 instructions in transact through signed

3942

1

			Some(4000.into())

3943

1

));

3944

		// Root can set transact info

3945

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3946

1

			parachain::RuntimeOrigin::root(),

3947

1

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

3948

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3949

1

));

3950

1

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

3951

1

});

3952

1

3953

1

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

3954

1

	let signed_origin: Junctions = [AccountKey20 {

3955

1

		network: None,

3956

1

		key: PARAALICE,

3957

1

}]

3958

1

	.into();

3959

1

3960

1

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

3961

1

	descend_origin_multilocation

3962

1

		.append_with(signed_origin)

3963

1

		.unwrap();

3964

1

3965

1

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

3966

1

	descend_origin_multilocation

3967

1

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

3968

1

		.unwrap();

3969

1

3970

1

	let derived = xcm_builder::Account32Hash::<

3971

1

		relay_chain::KusamaNetwork,

3972

1

		relay_chain::AccountId,

3973

1

	>::convert_location(&descend_origin_multilocation)

3974

1

	.unwrap();

3975

1

3976

1

	Relay::execute_with(|| {

3977

1

		// free execution, full amount received

3978

1

		assert_ok!(RelayBalances::transfer_allow_death(

3979

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3980

1

			derived.clone(),

3981

1

			4000004100u128,

3982

1

));

3983

		// derived account has all funds

3984

1

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

3985

		// sovereign account has 0 funds

3986

1

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

3987

1

});

3988

1

3989

1

	// Encode the call. Balances transact to para_a_account

3990

1

	// First index

3991

1

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

3992

1

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

3993

1

		relay_chain::Balances,

3994

1

>()

3995

1

	.unwrap() as u8;

3996

1

3997

1

	encoded.push(index);

3998

1

3999

1

	// Then call bytes

4000

1

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

4001

1

		// 100 to sovereign

4002

1

		dest: para_a_account(),

4003

1

		value: 100u32.into(),

4004

1

4005

1

	.encode();

4006

1

	encoded.append(&mut call_bytes);

4007

1

4008

1

	ParaA::execute_with(|| {

4009

1

		assert_ok!(XcmTransactor::transact_through_signed(

4010

1

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

4011

1

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

4012

1

			CurrencyPayment {

4013

1

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

4014

1

					Location::parent()

4015

1

				))),

4016

1

				fee_amount: None

4017

1

},

4018

1

			encoded,

4019

1

			// 4000000000 for transfer + 4000 for XCM

4020

1

			// 1-1 to fee

4021

1

			TransactWeights {

4022

1

				transact_required_weight_at_most: 4000000000.into(),

4023

1

				overall_weight: None

4024

1

},

4025

1

			false

4026

1

));

4027

1

});

4028

1

4029

1

	Relay::execute_with(|| {

4030

1

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

4031

4032

1

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

4033

1

});

4034

1

4035

4036

#[test]

4037

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4038

1

	MockNet::reset();

4039

1

	let mut ancestry = Location::parent();

4040

1

4041

1

	ParaA::execute_with(|| {

4042

1

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

4043

1

});

4044

1

4045

1

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

4046

1

	let signed_origin: Junctions = [AccountKey20 {

4047

1

		network: None,

4048

1

		key: PARAALICE,

4049

1

}]

4050

1

	.into();

4051

1

4052

1

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

4053

1

	descend_origin_multilocation

4054

1

		.append_with(signed_origin)

4055

1

		.unwrap();

4056

1

4057

1

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

4058

1

	descend_origin_multilocation

4059

1

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

4060

1

		.unwrap();

4061

1

4062

1

	let derived = xcm_builder::Account32Hash::<

4063

1

		relay_chain::KusamaNetwork,

4064

1

		relay_chain::AccountId,

4065

1

	>::convert_location(&descend_origin_multilocation)

4066

1

	.unwrap();

4067

1

4068

1

	Relay::execute_with(|| {

4069

1

		// free execution, full amount received

4070

1

		assert_ok!(RelayBalances::transfer_allow_death(

4071

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4072

1

			derived.clone(),

4073

1

			4000004100u128,

4074

1

));

4075

		// derived account has all funds

4076

1

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

4077

		// sovereign account has 0 funds

4078

1

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

4079

1

});

4080

1

4081

1

	// Encode the call. Balances transact to para_a_account

4082

1

	// First index

4083

1

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

4084

1

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

4085

1

		relay_chain::Balances,

4086

1

>()

4087

1

	.unwrap() as u8;

4088

1

4089

1

	encoded.push(index);

4090

1

4091

1

	// Then call bytes

4092

1

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

4093

1

		// 100 to sovereign

4094

1

		dest: para_a_account(),

4095

1

		value: 100u32.into(),

4096

1

4097

1

	.encode();

4098

1

	encoded.append(&mut call_bytes);

4099

1

4100

1

	let total_weight = 4000004000u64;

4101

1

	ParaA::execute_with(|| {

4102

1

		assert_ok!(XcmTransactor::transact_through_signed(

4103

1

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

4104

1

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

4105

1

			CurrencyPayment {

4106

1

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

4107

1

					Location::parent()

4108

1

				))),

4109

1

				fee_amount: Some(total_weight as u128)

4110

1

},

4111

1

			encoded,

4112

1

			// 4000000000 for transfer + 4000 for XCM

4113

1

			TransactWeights {

4114

1

				transact_required_weight_at_most: 4000000000.into(),

4115

1

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

4116

1

},

4117

1

			false

4118

1

));

4119

1

});

4120

1

4121

1

	Relay::execute_with(|| {

4122

1

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

4123

4124

1

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

4125

1

});

4126

1

4127

4128

#[test]

4129

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4130

1

	MockNet::reset();

4131

1

	let mut ancestry = Location::parent();

4132

1

4133

1

	ParaA::execute_with(|| {

4134

1

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

4135

1

});

4136

1

4137

1

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

4138

1

	let signed_origin: Junctions = [AccountKey20 {

4139

1

		network: None,

4140

1

		key: PARAALICE,

4141

1

}]

4142

1

	.into();

4143

1

4144

1

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

4145

1

	descend_origin_multilocation

4146

1

		.append_with(signed_origin)

4147

1

		.unwrap();

4148

1

4149

1

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

4150

1

	descend_origin_multilocation

4151

1

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

4152

1

		.unwrap();

4153

1

4154

1

	let derived = xcm_builder::Account32Hash::<

4155

1

		relay_chain::KusamaNetwork,

4156

1

		relay_chain::AccountId,

4157

1

	>::convert_location(&descend_origin_multilocation)

4158

1

	.unwrap();

4159

1

4160

1

	Relay::execute_with(|| {

4161

1

		// free execution, full amount received

4162

1

		assert_ok!(RelayBalances::transfer_allow_death(

4163

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4164

1

			derived.clone(),

4165

1

			4000009100u128,

4166

1

));

4167

		// derived account has all funds

4168

1

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

4169

		// sovereign account has 0 funds

4170

1

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

4171

1

});

4172

1

4173

1

	// Encode the call. Balances transact to para_a_account

4174

1

	// First index

4175

1

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

4176

1

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

4177

1

		relay_chain::Balances,

4178

1

>()

4179

1

	.unwrap() as u8;

4180

1

4181

1

	encoded.push(index);

4182

1

4183

1

	// Then call bytes

4184

1

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

4185

1

		// 100 to sovereign

4186

1

		dest: para_a_account(),

4187

1

		value: 100u32.into(),

4188

1

4189

1

	.encode();

4190

1

	encoded.append(&mut call_bytes);

4191

1

4192

1

	let total_weight = 4000009000u64;

4193

1

	ParaA::execute_with(|| {

4194

1

		assert_ok!(XcmTransactor::transact_through_signed(

4195

1

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

4196

1

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

4197

1

			CurrencyPayment {

4198

1

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

4199

1

					Location::parent()

4200

1

				))),

4201

1

				fee_amount: Some(total_weight as u128)

4202

1

},

4203

1

			encoded,

4204

1

			// 4000000000 for transfer + 9000 for XCM

4205

1

			TransactWeights {

4206

1

				transact_required_weight_at_most: 4000000000.into(),

4207

1

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

4208

1

},

4209

1

			true

4210

1

));

4211

1

});

4212

1

4213

1

	Relay::execute_with(|| {

4214

1

		// 100 transferred

4215

1

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

4216

4217

		// 4000005186 refunded

4218

1

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

4219

1

});

4220

1

4221

4222

#[test]

4223

1

fn transact_through_signed_multilocation_para_to_para() {

4224

1

	MockNet::reset();

4225

1

	let mut ancestry = Location::parent();

4226

1

4227

1

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

4228

1

4229

1

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

4230

1

4231

1

	ParaA::execute_with(|| {

4232

1

		// Root can set transact info

4233

1

		assert_ok!(XcmTransactor::set_transact_info(

4234

1

			parachain::RuntimeOrigin::root(),

4235

1

			// ParaB

4236

1

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

4237

1

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

4238

1

			3.into(),

4239

1

			20000000000.into(),

4240

1

			// 4 instructions in transact through signed

4241

1

			Some(4.into())

4242

1

));

4243

		// Root can set transact info

4244

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4245

1

			parachain::RuntimeOrigin::root(),

4246

1

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

4247

1

			parachain::ParaTokensPerSecond::get(),

4248

1

));

4249

1

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

4250

1

});

4251

1

4252

1

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

4253

1

	let signed_origin: Junctions = [AccountKey20 {

4254

1

		network: None,

4255

1

		key: PARAALICE,

4256

1

}]

4257

1

	.into();

4258

1

4259

1

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

4260

1

	descend_origin_location.append_with(signed_origin).unwrap();

4261

1

4262

1

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

4263

1

	descend_origin_location

4264

1

		.reanchor(&para_b_location, &ancestry.interior)

4265

1

		.unwrap();

4266

1

4267

1

	let derived = xcm_builder::HashedDescription::<

4268

1

		parachain::AccountId,

4269

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4270

1

	>::convert_location(&descend_origin_location)

4271

1

	.unwrap();

4272

1

4273

1

	ParaB::execute_with(|| {

4274

1

		// free execution, full amount received

4275

1

		assert_ok!(ParaBalances::transfer_allow_death(

4276

1

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

4277

1

			derived.clone(),

4278

1

			4000000104u128,

4279

1

));

4280

		// derived account has all funds

4281

1

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

4282

		// sovereign account has 0 funds

4283

1

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

4284

1

});

4285

1

4286

1

	// Encode the call. Balances transact to para_a_account

4287

1

	// First index

4288

1

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

4289

1

	let index =

4290

1

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

4291

1

			.unwrap() as u8;

4292

1

4293

1

	encoded.push(index);

4294

1

4295

1

	// Then call bytes

4296

1

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

4297

1

		// 100 to sovereign

4298

1

		dest: para_a_account_20(),

4299

1

		value: 100u32.into(),

4300

1

4301

1

	.encode();

4302

1

	encoded.append(&mut call_bytes);

4303

1

4304

1

	ParaA::execute_with(|| {

4305

1

		assert_ok!(XcmTransactor::transact_through_signed(

4306

1

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

4307

1

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

4308

1

			CurrencyPayment {

4309

1

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

4310

1

					para_b_balances

4311

1

				))),

4312

1

				fee_amount: None

4313

1

},

4314

1

			encoded,

4315

1

			// 4000000000 for transfer + 4000 for XCM

4316

1

			// 1-1 to fee

4317

1

			TransactWeights {

4318

1

				transact_required_weight_at_most: 4000000000.into(),

4319

1

				overall_weight: None

4320

1

},

4321

1

			false

4322

1

));

4323

1

});

4324

1

4325

1

	ParaB::execute_with(|| {

4326

1

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

4327

4328

1

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

4329

1

});

4330

1

4331

4332

#[test]

4333

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4334

1

	MockNet::reset();

4335

1

	let mut ancestry = Location::parent();

4336

1

4337

1

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

4338

1

4339

1

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

4340

1

4341

1

	ParaA::execute_with(|| {

4342

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4343

1

			parachain::RuntimeOrigin::root(),

4344

1

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

4345

1

			parachain::ParaTokensPerSecond::get(),

4346

1

));

4347

1

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

4348

1

});

4349

1

4350

1

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

4351

1

	let signed_origin: Junctions = [AccountKey20 {

4352

1

		network: None,

4353

1

		key: PARAALICE,

4354

1

}]

4355

1

	.into();

4356

1

4357

1

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

4358

1

	descend_origin_location.append_with(signed_origin).unwrap();

4359

1

4360

1

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

4361

1

	descend_origin_location

4362

1

		.reanchor(&para_b_location, &ancestry.interior)

4363

1

		.unwrap();

4364

1

4365

1

	let derived = xcm_builder::HashedDescription::<

4366

1

		parachain::AccountId,

4367

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4368

1

	>::convert_location(&descend_origin_location)

4369

1

	.unwrap();

4370

1

4371

1

	ParaB::execute_with(|| {

4372

1

		// free execution, full amount received

4373

1

		assert_ok!(ParaBalances::transfer_allow_death(

4374

1

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

4375

1

			derived.clone(),

4376

1

			4000009100u128,

4377

1

));

4378

		// derived account has all funds

4379

1

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

4380

		// sovereign account has 0 funds

4381

1

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

4382

1

});

4383

1

4384

1

	// Encode the call. Balances transact to para_a_account

4385

1

	// First index

4386

1

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

4387

1

	let index =

4388

1

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

4389

1

			.unwrap() as u8;

4390

1

4391

1

	encoded.push(index);

4392

1

4393

1

	// Then call bytes

4394

1

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

4395

1

		// 100 to sovereign

4396

1

		dest: para_a_account_20(),

4397

1

		value: 100u32.into(),

4398

1

4399

1

	.encode();

4400

1

	encoded.append(&mut call_bytes);

4401

1

4402

1

	let overall_weight = 4000009000u64;

4403

1

	ParaA::execute_with(|| {

4404

1

		assert_ok!(XcmTransactor::transact_through_signed(

4405

1

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

4406

1

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

4407

1

			CurrencyPayment {

4408

1

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

4409

1

					para_b_balances

4410

1

				))),

4411

1

				fee_amount: Some(overall_weight as u128)

4412

1

},

4413

1

			encoded,

4414

1

			// 4000000000 for transfer + 9000 for XCM

4415

1

			TransactWeights {

4416

1

				transact_required_weight_at_most: 4000000000.into(),

4417

1

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

4418

1

},

4419

1

			true

4420

1

));

4421

1

});

4422

1

4423

1

	ParaB::execute_with(|| {

4424

1

		// Check the derived account was refunded

4425

1

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

4426

4427

		// Check the transfer was executed

4428

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4429

1

});

4430

1

4431

4432

#[test]

4433

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4434

1

	MockNet::reset();

4435

1

	let mut ancestry = Location::parent();

4436

1

4437

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4438

1

4439

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4440

1

4441

1

	ParaA::execute_with(|| {

4442

1

		// Root can set transact info

4443

1

		assert_ok!(XcmTransactor::set_transact_info(

4444

1

			parachain::RuntimeOrigin::root(),

4445

1

			// ParaB

4446

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4447

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4448

1

			3.into(),

4449

1

			20000000000.into(),

4450

1

			// 4 instructions in transact through signed

4451

1

			Some(4.into())

4452

1

));

4453

		// Root can set transact info

4454

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4455

1

			parachain::RuntimeOrigin::root(),

4456

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4457

1

			parachain::ParaTokensPerSecond::get(),

4458

1

));

4459

1

		ancestry = parachain::UniversalLocation::get().into();

4460

1

});

4461

1

4462

1

	// Let's construct the Junction that we will append with DescendOrigin

4463

1

	let signed_origin: Junctions = [AccountKey20 {

4464

1

		network: None,

4465

1

		key: PARAALICE,

4466

1

}]

4467

1

	.into();

4468

1

4469

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4470

1

	descend_origin_location.append_with(signed_origin).unwrap();

4471

1

4472

1

	// To convert it to what the paraB will see instead of us

4473

1

	descend_origin_location

4474

1

		.reanchor(&para_b_location, &ancestry.interior)

4475

1

		.unwrap();

4476

1

4477

1

	let derived = xcm_builder::HashedDescription::<

4478

1

		parachain::AccountId,

4479

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4480

1

	>::convert_location(&descend_origin_location)

4481

1

	.unwrap();

4482

1

4483

1

	let mut parachain_b_alice_balances_before = 0;

4484

1

	ParaB::execute_with(|| {

4485

1

		assert_ok!(ParaBalances::transfer_allow_death(

4486

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4487

1

			derived.clone(),

4488

1

			4000000104u128,

4489

1

));

4490

		// derived account has all funds

4491

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4492

		// sovereign account has 0 funds

4493

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4494

4495

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4496

1

});

4497

1

4498

1

	// Encode the call. Balances transact to para_a_account

4499

1

	// First index

4500

1

	let mut encoded: Vec<u8> = Vec::new();

4501

1

	let index =

4502

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4503

1

			.unwrap() as u8;

4504

1

4505

1

	encoded.push(index);

4506

1

4507

1

	use sp_core::U256;

4508

1

	// Let's do a EVM transfer

4509

1

	let eth_tx =

4510

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4511

1

			gas_limit: U256::from(21000),

4512

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4513

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4514

1

			value: U256::from(100),

4515

1

			input: BoundedVec::<

4516

1

u8,

4517

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4518

1

			>::try_from(vec![]).unwrap(),

4519

1

			access_list: None,

4520

1

});

4521

1

4522

1

	// Then call bytes

4523

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4524

1

		xcm_transaction: eth_tx,

4525

1

4526

1

	.encode();

4527

1

	encoded.append(&mut call_bytes);

4528

1

4529

1

	ParaA::execute_with(|| {

4530

1

		assert_ok!(XcmTransactor::transact_through_signed(

4531

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4532

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4533

1

			CurrencyPayment {

4534

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4535

1

					para_b_balances

4536

1

				))),

4537

1

				fee_amount: None

4538

1

},

4539

1

			encoded,

4540

1

			// 4000000000 for transfer + 4000 for XCM

4541

1

			// 1-1 to fee

4542

1

			TransactWeights {

4543

1

				transact_required_weight_at_most: 4000000000.into(),

4544

1

				overall_weight: None

4545

1

},

4546

1

			false

4547

1

));

4548

1

});

4549

1

4550

1

	ParaB::execute_with(|| {

4551

1

		// Make sure the EVM transfer went through

4552

1

		assert!(

4553

1

			ParaBalances::free_balance(&PARAALICE.into())

4554

1

				== parachain_b_alice_balances_before + 100

4555

1

);

4556

1

});

4557

1

4558

4559

#[test]

4560

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4561

1

	MockNet::reset();

4562

1

	let mut ancestry = Location::parent();

4563

1

4564

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4565

1

4566

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4567

1

4568

1

	ParaA::execute_with(|| {

4569

1

		// Root can set transact info

4570

1

		assert_ok!(XcmTransactor::set_transact_info(

4571

1

			parachain::RuntimeOrigin::root(),

4572

1

			// ParaB

4573

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4574

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4575

1

			3.into(),

4576

1

			20000000000.into(),

4577

1

			// 4 instructions in transact through signed

4578

1

			Some(4.into())

4579

1

));

4580

		// Root can set transact info

4581

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4582

1

			parachain::RuntimeOrigin::root(),

4583

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4584

1

			parachain::ParaTokensPerSecond::get(),

4585

1

));

4586

1

		ancestry = parachain::UniversalLocation::get().into();

4587

1

});

4588

1

4589

1

	// Let's construct the Junction that we will append with DescendOrigin

4590

1

	let signed_origin: Junctions = [AccountKey20 {

4591

1

		network: None,

4592

1

		key: PARAALICE,

4593

1

}]

4594

1

	.into();

4595

1

4596

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4597

1

	descend_origin_location.append_with(signed_origin).unwrap();

4598

1

4599

1

	// To convert it to what the paraB will see instead of us

4600

1

	descend_origin_location

4601

1

		.reanchor(&para_b_location, &ancestry.interior)

4602

1

		.unwrap();

4603

1

4604

1

	let derived = xcm_builder::HashedDescription::<

4605

1

		parachain::AccountId,

4606

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4607

1

	>::convert_location(&descend_origin_location)

4608

1

	.unwrap();

4609

1

4610

1

	let mut parachain_b_alice_balances_before = 0;

4611

1

	ParaB::execute_with(|| {

4612

1

		assert_ok!(ParaBalances::transfer_allow_death(

4613

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4614

1

			derived.clone(),

4615

1

			4000000104u128,

4616

1

));

4617

		// derived account has all funds

4618

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4619

		// sovereign account has 0 funds

4620

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4621

4622

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4623

1

});

4624

1

4625

1

	// Encode the call. Balances transact to para_a_account

4626

1

	// First index

4627

1

	let mut encoded: Vec<u8> = Vec::new();

4628

1

	let index =

4629

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4630

1

			.unwrap() as u8;

4631

1

4632

1

	encoded.push(index);

4633

1

4634

1

	use sp_core::U256;

4635

1

	// Let's do a EVM transfer

4636

1

	let eth_tx =

4637

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4638

1

			gas_limit: U256::from(21000),

4639

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4640

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4641

1

			value: U256::from(100),

4642

1

			input: BoundedVec::<

4643

1

u8,

4644

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4645

1

			>::try_from(vec![]).unwrap(),

4646

1

			access_list: None,

4647

1

});

4648

1

4649

1

	// Then call bytes

4650

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4651

1

		transact_as: PARAALICE.into(),

4652

1

		xcm_transaction: eth_tx,

4653

1

4654

1

	.encode();

4655

1

	encoded.append(&mut call_bytes);

4656

1

4657

1

	ParaA::execute_with(|| {

4658

1

		assert_ok!(XcmTransactor::transact_through_signed(

4659

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4660

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4661

1

			CurrencyPayment {

4662

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4663

1

					para_b_balances

4664

1

				))),

4665

1

				fee_amount: None

4666

1

},

4667

1

			encoded,

4668

1

			TransactWeights {

4669

1

				transact_required_weight_at_most: 4000000000.into(),

4670

1

				overall_weight: None

4671

1

},

4672

1

			false

4673

1

));

4674

1

});

4675

1

4676

1

	ParaB::execute_with(|| {

4677

1

		// Make sure the EVM transfer wasn't executed

4678

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4679

1

});

4680

1

4681

4682

#[test]

4683

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4684

1

	MockNet::reset();

4685

1

	let mut ancestry = Location::parent();

4686

1

4687

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4688

1

4689

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4690

1

4691

1

	ParaA::execute_with(|| {

4692

1

		// Root can set transact info

4693

1

		assert_ok!(XcmTransactor::set_transact_info(

4694

1

			parachain::RuntimeOrigin::root(),

4695

1

			// ParaB

4696

1

			Box::new(xcm::VersionedLocation::V4(para_b_location.clone())),

4697

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4698

1

			3.into(),

4699

1

			20000000000.into(),

4700

1

			// 4 instructions in transact through signed

4701

1

			Some(4.into())

4702

1

));

4703

		// Root can set transact info

4704

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4705

1

			parachain::RuntimeOrigin::root(),

4706

1

			Box::new(xcm::VersionedLocation::V4(para_b_balances.clone())),

4707

1

			parachain::ParaTokensPerSecond::get(),

4708

1

));

4709

1

		ancestry = parachain::UniversalLocation::get().into();

4710

1

});

4711

1

4712

1

	// Let's construct the Junction that we will append with DescendOrigin

4713

1

	let signed_origin: Junctions = [AccountKey20 {

4714

1

		network: None,

4715

1

		key: PARAALICE,

4716

1

}]

4717

1

	.into();

4718

1

4719

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4720

1

	descend_origin_location.append_with(signed_origin).unwrap();

4721

1

4722

1

	// To convert it to what the paraB will see instead of us

4723

1

	descend_origin_location

4724

1

		.reanchor(&para_b_location, &ancestry.interior)

4725

1

		.unwrap();

4726

1

4727

1

	let derived = xcm_builder::HashedDescription::<

4728

1

		parachain::AccountId,

4729

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4730

1

	>::convert_location(&descend_origin_location)

4731

1

	.unwrap();

4732

1

4733

1

	let transfer_recipient = evm_account();

4734

1

	let mut transfer_recipient_balance_before = 0;

4735

1

	ParaB::execute_with(|| {

4736

1

		assert_ok!(ParaBalances::transfer_allow_death(

4737

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4738

1

			derived.clone(),

4739

1

			4000000104u128,

4740

1

));

4741

		// derived account has all funds

4742

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4743

		// sovereign account has 0 funds

4744

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4745

4746

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

4747

1

4748

1

		// Add proxy ALICE  -> derived

4749

1

		let _ = parachain::Proxy::add_proxy_delegate(

4750

1

			&PARAALICE.into(),

4751

1

			derived,

4752

1

			parachain::ProxyType::Any,

4753

1

0,

4754

1

);

4755

1

});

4756

1

4757

1

	// Encode the call. Balances transact to para_a_account

4758

1

	// First index

4759

1

	let mut encoded: Vec<u8> = Vec::new();

4760

1

	let index =

4761

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4762

1

			.unwrap() as u8;

4763

1

4764

1

	encoded.push(index);

4765

1

4766

1

	use sp_core::U256;

4767

1

	// Let's do a EVM transfer

4768

1

	let eth_tx =

4769

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4770

1

			gas_limit: U256::from(21000),

4771

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

4772

1

			value: U256::from(100),

4773

1

			input: BoundedVec::<

4774

1

u8,

4775

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4776

1

			>::try_from(vec![]).unwrap(),

4777

1

			access_list: None,

4778

1

});

4779

1

4780

1

	// Then call bytes

4781

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4782

1

		transact_as: PARAALICE.into(),

4783

1

		xcm_transaction: eth_tx,

4784

1

4785

1

	.encode();

4786

1

	encoded.append(&mut call_bytes);

4787

1

4788

1

	ParaA::execute_with(|| {

4789

1

		assert_ok!(XcmTransactor::transact_through_signed(

4790

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4791

1

			Box::new(xcm::VersionedLocation::V4(para_b_location)),

4792

1

			CurrencyPayment {

4793

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4794

1

					para_b_balances

4795

1

				))),

4796

1

				fee_amount: None

4797

1

},

4798

1

			encoded,

4799

1

			TransactWeights {

4800

1

				transact_required_weight_at_most: 4000000000.into(),

4801

1

				overall_weight: None

4802

1

},

4803

1

			false

4804

1

));

4805

1

});

4806

1

4807

1

	ParaB::execute_with(|| {

4808

1

		// Make sure the EVM transfer was executed

4809

1

		assert!(

4810

1

			ParaBalances::free_balance(&transfer_recipient.into())

4811

1

				== transfer_recipient_balance_before + 100

4812

1

);

4813

1

});

4814

1

4815

4816

#[test]

4817

1

fn hrmp_init_accept_through_root() {

4818

1

	MockNet::reset();

4819

1

4820

1

	Relay::execute_with(|| {

4821

1

		assert_ok!(RelayBalances::transfer_allow_death(

4822

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4823

1

			para_a_account(),

4824

1

			1000u128

4825

1

));

4826

1

		assert_ok!(RelayBalances::transfer_allow_death(

4827

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4828

1

			para_b_account(),

4829

1

			1000u128

4830

1

));

4831

1

});

4832

1

4833

1

	ParaA::execute_with(|| {

4834

1

		let total_fee = 1_000u128;

4835

1

		let total_weight: u64 = 1_000_000_000;

4836

1

		let tx_weight: u64 = 500_000_000;

4837

1

		// Root can send hrmp init channel

4838

1

		assert_ok!(XcmTransactor::hrmp_manage(

4839

1

			parachain::RuntimeOrigin::root(),

4840

1

			HrmpOperation::InitOpen(HrmpInitParams {

4841

1

				para_id: 2u32.into(),

4842

1

				proposed_max_capacity: 1,

4843

1

				proposed_max_message_size: 1

4844

1

}),

4845

1

			CurrencyPayment {

4846

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4847

1

					Location::parent()

4848

1

				))),

4849

1

				fee_amount: Some(total_fee)

4850

1

},

4851

1

			TransactWeights {

4852

1

				transact_required_weight_at_most: tx_weight.into(),

4853

1

				overall_weight: Some(Limited(total_weight.into()))

4854

1

4855

1

));

4856

1

});

4857

1

	Relay::execute_with(|| {

4858

1

		let expected_event: relay_chain::RuntimeEvent =

4859

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4860

1

				sender: 1u32.into(),

4861

1

				recipient: 2u32.into(),

4862

1

				proposed_max_capacity: 1u32,

4863

1

				proposed_max_message_size: 1u32,

4864

1

4865

1

			.into();

4866

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4867

1

});

4868

1

	ParaB::execute_with(|| {

4869

1

		let total_fee = 1_000u128;

4870

1

		let total_weight: u64 = 1_000_000_000;

4871

1

		let tx_weight: u64 = 500_000_000;

4872

1

		// Root can send hrmp accept channel

4873

1

		assert_ok!(XcmTransactor::hrmp_manage(

4874

1

			parachain::RuntimeOrigin::root(),

4875

1

			HrmpOperation::Accept {

4876

1

				para_id: 1u32.into()

4877

1

},

4878

1

			CurrencyPayment {

4879

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4880

1

					Location::parent()

4881

1

				))),

4882

1

				fee_amount: Some(total_fee)

4883

1

},

4884

1

			TransactWeights {

4885

1

				transact_required_weight_at_most: tx_weight.into(),

4886

1

				overall_weight: Some(Limited(total_weight.into()))

4887

1

4888

1

));

4889

1

});

4890

1

4891

1

	Relay::execute_with(|| {

4892

1

		let expected_event: relay_chain::RuntimeEvent =

4893

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4894

1

				sender: 1u32.into(),

4895

1

				recipient: 2u32.into(),

4896

1

4897

1

			.into();

4898

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4899

1

});

4900

1

4901

4902

#[test]

4903

1

fn hrmp_close_works() {

4904

1

	MockNet::reset();

4905

1

4906

1

	Relay::execute_with(|| {

4907

1

		assert_ok!(RelayBalances::transfer_allow_death(

4908

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4909

1

			para_a_account(),

4910

1

			1000u128

4911

1

));

4912

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4913

1

			relay_chain::RuntimeOrigin::root(),

4914

1

			1u32.into(),

4915

1

			2u32.into(),

4916

1

			1u32,

4917

1

			1u32

4918

1

));

4919

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4920

1

			relay_chain::RuntimeOrigin::root(),

4921

1

			1u32

4922

1

));

4923

1

});

4924

1

4925

1

	ParaA::execute_with(|| {

4926

1

		let total_fee = 1_000u128;

4927

1

		let total_weight: u64 = 1_000_000_000;

4928

1

		let tx_weight: u64 = 500_000_000;

4929

1

		// Root can send hrmp close

4930

1

		assert_ok!(XcmTransactor::hrmp_manage(

4931

1

			parachain::RuntimeOrigin::root(),

4932

1

			HrmpOperation::Close(HrmpChannelId {

4933

1

				sender: 1u32.into(),

4934

1

				recipient: 2u32.into()

4935

1

}),

4936

1

			CurrencyPayment {

4937

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

4938

1

					Location::parent()

4939

1

				))),

4940

1

				fee_amount: Some(total_fee)

4941

1

},

4942

1

			TransactWeights {

4943

1

				transact_required_weight_at_most: tx_weight.into(),

4944

1

				overall_weight: Some(Limited(total_weight.into()))

4945

1

4946

1

));

4947

1

});

4948

1

	Relay::execute_with(|| {

4949

1

		let expected_event: relay_chain::RuntimeEvent =

4950

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4951

1

				by_parachain: 1u32.into(),

4952

1

				channel_id: HrmpChannelId {

4953

1

					sender: 1u32.into(),

4954

1

					recipient: 2u32.into(),

4955

1

},

4956

1

4957

1

			.into();

4958

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4959

1

});

4960

1

4961

4962

use parity_scale_codec::{Decode, Encode};

4963

use sp_io::hashing::blake2_256;

4964

4965

// Helper to derive accountIds

4966

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4967

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4968

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4969

7