Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonbase Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{ConstU32, PalletInfo, PalletInfoAccess},

23

	weights::constants::WEIGHT_REF_TIME_PER_SECOND,

24

	weights::Weight,

25

	BoundedVec,

26

};

27

use moonbase_runtime::xcm_config::AssetType;

28

use pallet_xcm_transactor::{

29

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

30

};

31

use sp_runtime::traits::Convert;

32

use sp_std::boxed::Box;

33

use xcm::{

34

	latest::prelude::{

35

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

36

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

37

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

38

		WeightLimit, WithdrawAsset, Xcm,

39

},

40

	VersionedAssets,

41

};

42

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

43

use xcm_executor::traits::ConvertLocation;

44

use xcm_mock::*;

45

use xcm_primitives::{

46

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

47

};

48

use xcm_simulator::TestExt;

49

mod common;

50

use cumulus_primitives_core::relay_chain::HrmpChannelId;

51

use parachain::PolkadotXcm;

52

53

28

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

54

28

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

55

28

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

56

28

		.into_version(xcm::latest::VERSION)

57

28

		.map_err(|_| ())?

58

	else {

59

		return Err(());

60

};

61

	use frame_support::weights::WeightToFee as _;

62

28

	let native_amount_per_second: u128 =

63

28

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

64

28

			&Weight::from_parts(

65

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

66

28

0,

67

28

),

68

28

69

28

		.try_into()

70

28

		.map_err(|_| ())?;

71

28

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

72

28

	let relative_price: u128 = if units_per_second > 0u128 {

73

10

		native_amount_per_second

74

10

			.saturating_mul(precision_factor)

75

10

			.saturating_div(units_per_second)

76

	} else {

77

18

		0u128

78

};

79

28

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

80

28

		location_v5,

81

28

		(true, relative_price),

82

28

);

83

28

	Ok(())

84

28

85

86

25

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

87

25

	Asset {

88

25

		id: AssetId(

89

25

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

90

25

				currency_id,

91

25

92

25

			.unwrap(),

93

25

),

94

25

		fun: Fungibility::Fungible(amount),

95

25

96

25

97

98

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

99

#[test]

100

1

fn receive_relay_asset_from_relay() {

101

1

	MockNet::reset();

102

1

103

1

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

104

1

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

105

1

	let asset_metadata = parachain::AssetMetadata {

106

1

		name: b"RelayToken".to_vec(),

107

1

		symbol: b"Relay".to_vec(),

108

1

		decimals: 12,

109

1

};

110

1

	// register relay asset in parachain A

111

1

	ParaA::execute_with(|| {

112

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

113

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

114

1

			.try_into()

115

1

			.expect("v3 to latest location conversion failed");

116

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

117

1

			source_id,

118

1

			source_location_latest,

119

1

			asset_metadata.decimals,

120

1

			asset_metadata.symbol.try_into().expect("too long"),

121

1

			asset_metadata.name.try_into().expect("too long"),

122

1

));

123

1

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

124

1

});

125

1

126

1

	// Actually send relay asset to parachain

127

1

	let dest: Location = AccountKey20 {

128

1

		network: None,

129

1

		key: PARAALICE,

130

1

131

1

	.into();

132

1

	Relay::execute_with(|| {

133

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

134

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

135

1

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

136

1

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

137

1

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

138

1

0,

139

1

			WeightLimit::Unlimited

140

1

));

141

1

});

142

1

143

1

	// Verify that parachain received the asset

144

1

	ParaA::execute_with(|| {

145

1

		// free execution, full amount received

146

1

		assert_eq!(

147

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

148

1

			Ok(U256::from(123))

149

1

);

150

1

});

151

1

152

153

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

154

#[test]

155

1

fn send_relay_asset_to_relay() {

156

1

	MockNet::reset();

157

1

158

1

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

159

1

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

160

1

161

1

	let asset_metadata = parachain::AssetMetadata {

162

1

		name: b"RelayToken".to_vec(),

163

1

		symbol: b"Relay".to_vec(),

164

1

		decimals: 12,

165

1

};

166

1

167

1

	// Register relay asset in paraA

168

1

	ParaA::execute_with(|| {

169

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

170

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

171

1

			.try_into()

172

1

			.expect("v3 to latest location conversion failed");

173

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

174

1

			source_id,

175

1

			source_location_latest,

176

1

			asset_metadata.decimals,

177

1

			asset_metadata.symbol.try_into().expect("too long"),

178

1

			asset_metadata.name.try_into().expect("too long"),

179

1

));

180

		// Free execution

181

1

		assert_ok!(add_supported_asset(source_location, 0));

182

1

});

183

1

184

1

	let dest: Location = Junction::AccountKey20 {

185

1

		network: None,

186

1

		key: PARAALICE,

187

1

188

1

	.into();

189

1

190

1

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

191

1

	Relay::execute_with(|| {

192

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

193

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

194

1

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

195

1

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

196

1

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

197

1

0,

198

1

			WeightLimit::Unlimited

199

1

));

200

1

});

201

1

202

1

	ParaA::execute_with(|| {

203

1

		// Free execution, full amount received

204

1

		assert_eq!(

205

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

206

1

			Ok(U256::from(123))

207

1

);

208

1

});

209

1

210

1

	// Lets gather the balance before sending back money

211

1

	let mut balance_before_sending = 0;

212

1

	Relay::execute_with(|| {

213

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

214

1

});

215

1

216

1

	// We now send back some money to the relay

217

1

	let dest = Location {

218

1

		parents: 1,

219

1

		interior: [AccountId32 {

220

1

			network: None,

221

1

			id: RELAYALICE.into(),

222

1

}]

223

1

		.into(),

224

1

};

225

1

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

226

1

227

1

	ParaA::execute_with(|| {

228

1

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

229

1

		// free execution, full amount received

230

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

231

1

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

232

1

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

233

1

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

234

1

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

235

1

0,

236

1

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

237

1

));

238

1

});

239

1

240

1

	// The balances in paraAlice should have been substracted

241

1

	ParaA::execute_with(|| {

242

1

		assert_eq!(

243

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

244

1

			Ok(U256::from(0))

245

1

);

246

1

});

247

1

248

1

	// Balances in the relay should have been received

249

1

	Relay::execute_with(|| {

250

1

		// Free execution,x	 full amount received

251

1

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

252

1

});

253

1

254

255

#[test]

256

1

fn send_relay_asset_to_para_b() {

257

1

	MockNet::reset();

258

1

259

1

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

260

1

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

261

1

262

1

	let asset_metadata = parachain::AssetMetadata {

263

1

		name: b"RelayToken".to_vec(),

264

1

		symbol: b"Relay".to_vec(),

265

1

		decimals: 12,

266

1

};

267

1

268

1

	// Register asset in paraA. Free execution

269

1

	ParaA::execute_with(|| {

270

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

271

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

272

1

			.try_into()

273

1

			.expect("v3 to latest location conversion failed");

274

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

275

1

			source_id,

276

1

			source_location_latest,

277

1

			asset_metadata.decimals,

278

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

279

1

			asset_metadata.name.clone().try_into().expect("too long"),

280

1

));

281

1

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

282

1

});

283

1

284

1

	// Register asset in paraB. Free execution

285

1

	ParaB::execute_with(|| {

286

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

287

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

288

1

			.try_into()

289

1

			.expect("v3 to latest location conversion failed");

290

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

291

1

			source_id,

292

1

			source_location_latest,

293

1

			asset_metadata.decimals,

294

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

295

1

			asset_metadata.name.clone().try_into().expect("too long"),

296

1

));

297

1

		assert_ok!(add_supported_asset(source_location, 0));

298

1

});

299

1

300

1

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

301

1

	let dest: Location = Junction::AccountKey20 {

302

1

		network: None,

303

1

		key: PARAALICE,

304

1

305

1

	.into();

306

1

	Relay::execute_with(|| {

307

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

308

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

309

1

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

310

1

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

311

1

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

312

1

0,

313

1

			WeightLimit::Unlimited

314

1

));

315

1

});

316

1

317

1

	ParaA::execute_with(|| {

318

1

		// Free execution, full amount received

319

1

		assert_eq!(

320

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

321

1

			Ok(U256::from(123))

322

1

);

323

1

});

324

1

325

1

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

326

1

	let dest = Location {

327

1

		parents: 1,

328

1

		interior: [

329

1

			Parachain(2),

330

1

			AccountKey20 {

331

1

				network: None,

332

1

				key: PARAALICE.into(),

333

1

},

334

1

335

1

		.into(),

336

1

};

337

1

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

338

1

339

1

	ParaA::execute_with(|| {

340

1

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

341

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

342

1

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

343

1

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

344

1

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

345

1

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

346

1

0,

347

1

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

348

1

));

349

1

});

350

1

351

1

	// Para A balances should have been subtracted

352

1

	ParaA::execute_with(|| {

353

1

		assert_eq!(

354

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

355

1

			Ok(U256::from(23))

356

1

);

357

1

});

358

1

359

1

	// Para B balances should have been credited

360

1

	ParaB::execute_with(|| {

361

1

		assert_eq!(

362

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

363

1

			Ok(U256::from(100))

364

1

);

365

1

});

366

1

367

368

#[test]

369

1

fn send_para_a_asset_to_para_b() {

370

1

	MockNet::reset();

371

1

372

1

	// this represents the asset in paraA

373

1

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

374

1

	let source_location: AssetType = para_a_balances

375

1

		.try_into()

376

1

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

377

1

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

378

1

379

1

	let asset_metadata = parachain::AssetMetadata {

380

1

		name: b"ParaAToken".to_vec(),

381

1

		symbol: b"ParaA".to_vec(),

382

1

		decimals: 18,

383

1

};

384

1

385

1

	// Register asset in paraB. Free execution

386

1

	ParaB::execute_with(|| {

387

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

388

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

389

1

			.try_into()

390

1

			.expect("v3 to latest location conversion failed");

391

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

392

1

			source_id,

393

1

			source_location_latest,

394

1

			asset_metadata.decimals,

395

1

			asset_metadata.symbol.try_into().expect("too long"),

396

1

			asset_metadata.name.try_into().expect("too long"),

397

1

));

398

1

		assert_ok!(add_supported_asset(source_location, 0));

399

1

});

400

1

401

1

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

402

1

	let dest = Location {

403

1

		parents: 1,

404

1

		interior: [

405

1

			Parachain(2),

406

1

			AccountKey20 {

407

1

				network: None,

408

1

				key: PARAALICE.into(),

409

1

},

410

1

411

1

		.into(),

412

1

};

413

1

414

1

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

415

1

416

1

	ParaA::execute_with(|| {

417

1

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

418

1

		// Free execution, full amount received

419

1

		assert_ok!(PolkadotXcm::transfer_assets(

420

1

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

421

1

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

422

1

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

423

1

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

424

1

0,

425

1

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

426

1

));

427

1

});

428

1

429

1

	// Native token is substracted in paraA

430

1

	ParaA::execute_with(|| {

431

1

		assert_eq!(

432

1

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

433

1

			INITIAL_BALANCE - 100

434

1

);

435

1

});

436

1

437

1

	// Asset is minted in paraB

438

1

	ParaB::execute_with(|| {

439

1

		assert_eq!(

440

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

441

1

			Ok(U256::from(100))

442

1

);

443

1

});

444

1

445

446

#[test]

447

1

fn send_para_a_asset_from_para_b_to_para_c() {

448

1

	MockNet::reset();

449

1

450

1

	// Represents para A asset

451

1

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

452

1

	let source_location: AssetType = para_a_balances

453

1

		.try_into()

454

1

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

455

1

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

456

1

457

1

	let asset_metadata = parachain::AssetMetadata {

458

1

		name: b"ParaAToken".to_vec(),

459

1

		symbol: b"ParaA".to_vec(),

460

1

		decimals: 18,

461

1

};

462

1

463

1

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

464

1

	ParaB::execute_with(|| {

465

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

466

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

467

1

			.try_into()

468

1

			.expect("v3 to latest location conversion failed");

469

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

470

1

			source_id,

471

1

			source_location_latest,

472

1

			asset_metadata.decimals,

473

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

474

1

			asset_metadata.name.clone().try_into().expect("too long"),

475

1

));

476

1

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

477

1

});

478

1

479

1

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

480

1

	ParaC::execute_with(|| {

481

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

482

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

483

1

			.try_into()

484

1

			.expect("v3 to latest location conversion failed");

485

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

486

1

			source_id,

487

1

			source_location_latest,

488

1

			asset_metadata.decimals,

489

1

			asset_metadata.symbol.clone().try_into().expect("too long"),

490

1

			asset_metadata.name.clone().try_into().expect("too long"),

491

1

));

492

1

		assert_ok!(add_supported_asset(source_location, 0));

493

1

});

494

1

495

1

	// Send para A asset to para B

496

1

	let dest = Location {

497

1

		parents: 1,

498

1

		interior: [

499

1

			Parachain(2),

500

1

			AccountKey20 {

501

1

				network: None,

502

1

				key: PARAALICE.into(),

503

1

},

504

1

505

1

		.into(),

506

1

};

507

1

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

508

1

509

1

	ParaA::execute_with(|| {

510

1

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

511

1

		// free execution, full amount received

512

1

		assert_ok!(PolkadotXcm::transfer_assets(

513

1

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

514

1

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

515

1

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

516

1

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

517

1

0,

518

1

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

519

1

));

520

1

});

521

1

522

1

	// Para A balances have been substracted

523

1

	ParaA::execute_with(|| {

524

1

		assert_eq!(

525

1

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

526

1

			INITIAL_BALANCE - 100

527

1

);

528

1

});

529

1

530

1

	// Para B balances have been credited

531

1

	ParaB::execute_with(|| {

532

1

		assert_eq!(

533

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

534

1

			Ok(U256::from(100))

535

1

);

536

1

});

537

1

538

1

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

539

1

	let dest = Location {

540

1

		parents: 1,

541

1

		interior: [

542

1

			Parachain(3),

543

1

			AccountKey20 {

544

1

				network: None,

545

1

				key: PARAALICE.into(),

546

1

},

547

1

548

1

		.into(),

549

1

};

550

1

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

551

1

552

1

	ParaB::execute_with(|| {

553

1

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

554

1

		assert_ok!(PolkadotXcm::transfer_assets(

555

1

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

556

1

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

557

1

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

558

1

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

559

1

0,

560

1

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

561

1

));

562

1

});

563

1

564

1

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

565

1

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

566

1

	ParaC::execute_with(|| {

567

1

		assert_eq!(

568

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

569

1

			Ok(U256::from(95))

570

1

);

571

1

});

572

1

573

574

#[test]

575

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

576

1

	MockNet::reset();

577

1

578

1

	// Para A asset

579

1

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

580

1

	let source_location: AssetType = para_a_balances

581

1

		.try_into()

582

1

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

583

1

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

584

1

585

1

	let asset_metadata = parachain::AssetMetadata {

586

1

		name: b"ParaAToken".to_vec(),

587

1

		symbol: b"ParaA".to_vec(),

588

1

		decimals: 18,

589

1

};

590

1

591

1

	// Register para A asset in para B

592

1

	ParaB::execute_with(|| {

593

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

594

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

595

1

			.try_into()

596

1

			.expect("v3 to latest location conversion failed");

597

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

598

1

			source_id,

599

1

			source_location_latest,

600

1

			asset_metadata.decimals,

601

1

			asset_metadata.symbol.try_into().expect("too long"),

602

1

			asset_metadata.name.try_into().expect("too long"),

603

1

));

604

1

		assert_ok!(add_supported_asset(source_location, 0));

605

1

});

606

1

607

1

	// Send para A asset to para B

608

1

	let dest = Location {

609

1

		parents: 1,

610

1

		interior: [

611

1

			Parachain(2),

612

1

			AccountKey20 {

613

1

				network: None,

614

1

				key: PARAALICE.into(),

615

1

},

616

1

617

1

		.into(),

618

1

};

619

1

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

620

1

621

1

	ParaA::execute_with(|| {

622

1

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

623

1

		assert_ok!(PolkadotXcm::transfer_assets(

624

1

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

625

1

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

626

1

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

627

1

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

628

1

0,

629

1

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

630

1

));

631

1

});

632

1

633

1

	// Balances have been subtracted

634

1

	ParaA::execute_with(|| {

635

1

		assert_eq!(

636

1

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

637

1

			INITIAL_BALANCE - 100

638

1

);

639

1

});

640

1

641

1

	// Para B balances have been credited

642

1

	ParaB::execute_with(|| {

643

1

		assert_eq!(

644

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

645

1

			Ok(U256::from(100))

646

1

);

647

1

});

648

1

649

1

	// Send back para A asset to para A

650

1

	let dest = Location {

651

1

		parents: 1,

652

1

		interior: [

653

1

			Parachain(1),

654

1

			AccountKey20 {

655

1

				network: None,

656

1

				key: PARAALICE.into(),

657

1

},

658

1

659

1

		.into(),

660

1

};

661

1

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

662

1

663

1

	ParaB::execute_with(|| {

664

1

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

665

1

		assert_ok!(PolkadotXcm::transfer_assets(

666

1

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

667

1

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

668

1

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

669

1

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

670

1

0,

671

1

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

672

1

));

673

1

});

674

1

675

1

	ParaA::execute_with(|| {

676

1

		// Weight used is 4

677

1

		assert_eq!(

678

1

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

679

1

			INITIAL_BALANCE - 4

680

1

);

681

1

});

682

1

683

684

#[test]

685

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

686

1

	MockNet::reset();

687

1

688

1

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

689

1

	let source_location: AssetType = para_a_balances

690

1

		.try_into()

691

1

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

692

1

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

693

1

694

1

	let asset_metadata = parachain::AssetMetadata {

695

1

		name: b"ParaAToken".to_vec(),

696

1

		symbol: b"ParaA".to_vec(),

697

1

		decimals: 18,

698

1

};

699

1

700

1

	ParaB::execute_with(|| {

701

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

702

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

703

1

			.try_into()

704

1

			.expect("v3 to latest location conversion failed");

705

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

706

1

			source_id,

707

1

			source_location_latest,

708

1

			asset_metadata.decimals,

709

1

			asset_metadata.symbol.try_into().expect("too long"),

710

1

			asset_metadata.name.try_into().expect("too long"),

711

1

));

712

1

		assert_ok!(add_supported_asset(source_location, 0));

713

1

});

714

1

715

1

	let dest = Location {

716

1

		parents: 1,

717

1

		interior: [

718

1

			Parachain(2),

719

1

			AccountKey20 {

720

1

				network: None,

721

1

				key: PARAALICE.into(),

722

1

},

723

1

724

1

		.into(),

725

1

};

726

1

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

727

1

728

1

	ParaA::execute_with(|| {

729

1

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

730

1

		assert_ok!(PolkadotXcm::transfer_assets(

731

1

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

732

1

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

733

1

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

734

1

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

735

1

0,

736

1

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

737

1

));

738

1

});

739

1

740

1

	// Para A asset has been credited

741

1

	ParaA::execute_with(|| {

742

1

		assert_eq!(

743

1

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

744

1

			INITIAL_BALANCE - 100

745

1

);

746

1

});

747

1

748

1

	ParaB::execute_with(|| {

749

1

		// free execution, full amount received

750

1

		assert_eq!(

751

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

752

1

			Ok(U256::from(100))

753

1

);

754

1

});

755

1

756

1

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

757

1

	// Message through polkadotXCM pallet

758

1

759

1

	let dest = Location {

760

1

		parents: 1,

761

1

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

762

1

};

763

1

764

1

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

765

1

766

1

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

767

1

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

768

1

		ClearOrigin,

769

1

		BuyExecution {

770

1

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

771

1

			weight_limit: Limited(80.into()),

772

1

},

773

1

		DepositAsset {

774

1

			assets: All.into(),

775

1

			beneficiary: Location::new(

776

1

0,

777

1

				[AccountKey20 {

778

1

					network: None,

779

1

					key: PARAALICE,

780

1

}],

781

1

),

782

1

},

783

1

	]));

784

1

	ParaB::execute_with(|| {

785

1

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

786

1

		// and deposit asset

787

1

		assert_ok!(ParachainPalletXcm::send(

788

1

			parachain::RuntimeOrigin::root(),

789

1

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

790

1

			Box::new(message),

791

1

));

792

1

});

793

1

794

1

	ParaA::execute_with(|| {

795

1

		// Weight used is 4

796

1

		assert_eq!(

797

1

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

798

1

			INITIAL_BALANCE - 4

799

1

);

800

1

});

801

1

802

803

#[test]

804

1

fn receive_relay_asset_with_trader() {

805

1

	MockNet::reset();

806

1

807

1

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

808

1

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

809

1

810

1

	let asset_metadata = parachain::AssetMetadata {

811

1

		name: b"RelayToken".to_vec(),

812

1

		symbol: b"Relay".to_vec(),

813

1

		decimals: 12,

814

1

};

815

1

816

1

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

817

1

	// we know later we will divide by 1e12

818

1

	// Lets put 1e6 as units per second

819

1

	ParaA::execute_with(|| {

820

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

821

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

822

1

			.try_into()

823

1

			.expect("v3 to latest location conversion failed");

824

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

825

1

			source_id,

826

1

			source_location_latest,

827

1

			asset_metadata.decimals,

828

1

			asset_metadata.symbol.try_into().expect("too long"),

829

1

			asset_metadata.name.try_into().expect("too long"),

830

1

));

831

1

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

832

1

});

833

1

834

1

	let dest: Location = Junction::AccountKey20 {

835

1

		network: None,

836

1

		key: PARAALICE,

837

1

838

1

	.into();

839

1

	// We are sending 100 tokens from relay.

840

1

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

841

1

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

842

1

	// Units per second should be 2_500_000_000_000_000

843

1

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

844

1

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

845

1

	Relay::execute_with(|| {

846

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

847

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

848

1

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

849

1

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

850

1

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

851

1

0,

852

1

			WeightLimit::Unlimited

853

1

));

854

1

});

855

1

856

1

	ParaA::execute_with(|| {

857

1

		// non-free execution, not full amount received

858

1

		assert_eq!(

859

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

860

1

			Ok(U256::from(90))

861

1

);

862

		// Fee should have been received by treasury

863

1

		assert_eq!(

864

1

			EvmForeignAssets::balance(source_id, Treasury::account_id()),

865

1

			Ok(U256::from(10))

866

1

);

867

1

});

868

1

869

870

#[test]

871

1

fn send_para_a_asset_to_para_b_with_trader() {

872

1

	MockNet::reset();

873

1

874

1

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

875

1

	let source_location: AssetType = para_a_balances

876

1

		.try_into()

877

1

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

878

1

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

879

1

880

1

	let asset_metadata = parachain::AssetMetadata {

881

1

		name: b"ParaAToken".to_vec(),

882

1

		symbol: b"ParaA".to_vec(),

883

1

		decimals: 18,

884

1

};

885

1

886

1

	ParaB::execute_with(|| {

887

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

888

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

889

1

			.try_into()

890

1

			.expect("v3 to latest location conversion failed");

891

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

892

1

			source_id,

893

1

			source_location_latest,

894

1

			asset_metadata.decimals,

895

1

			asset_metadata.symbol.try_into().expect("too long"),

896

1

			asset_metadata.name.try_into().expect("too long"),

897

1

));

898

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

899

1

});

900

1

901

1

	let dest = Location {

902

1

		parents: 1,

903

1

		interior: [

904

1

			Parachain(2),

905

1

			AccountKey20 {

906

1

				network: None,

907

1

				key: PARAALICE.into(),

908

1

},

909

1

910

1

		.into(),

911

1

};

912

1

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

913

1

914

1

	// In destination chain, we only need 4 weight

915

1

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

916

1

	ParaA::execute_with(|| {

917

1

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

918

1

		assert_ok!(PolkadotXcm::transfer_assets(

919

1

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

920

1

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

921

1

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

922

1

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

923

1

0,

924

1

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

925

1

));

926

1

});

927

1

	ParaA::execute_with(|| {

928

1

		// free execution, full amount received

929

1

		assert_eq!(

930

1

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

931

1

			INITIAL_BALANCE - 100

932

1

);

933

1

});

934

1

935

1

	// We are sending 100 tokens from para A.

936

1

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

937

1

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

938

1

	// Units per second should be 2_500_000_000_000_000

939

1

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

940

1

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

941

1

	// will be 4

942

1

	ParaB::execute_with(|| {

943

1

		assert_eq!(

944

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

945

1

			Ok(U256::from(90))

946

1

);

947

		// Fee should have been received by treasury

948

1

		assert_eq!(

949

1

			EvmForeignAssets::balance(source_id, Treasury::account_id()),

950

1

			Ok(U256::from(10))

951

1

);

952

1

});

953

1

954

955

#[test]

956

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

957

1

	MockNet::reset();

958

1

959

1

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

960

1

	let source_location: AssetType = para_a_balances

961

1

		.try_into()

962

1

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

963

1

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

964

1

965

1

	let asset_metadata = parachain::AssetMetadata {

966

1

		name: b"ParaAToken".to_vec(),

967

1

		symbol: b"ParaA".to_vec(),

968

1

		decimals: 18,

969

1

};

970

1

971

1

	ParaB::execute_with(|| {

972

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

973

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

974

1

			.try_into()

975

1

			.expect("v3 to latest location conversion failed");

976

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

977

1

			source_id,

978

1

			source_location_latest,

979

1

			asset_metadata.decimals,

980

1

			asset_metadata.symbol.try_into().expect("too long"),

981

1

			asset_metadata.name.try_into().expect("too long"),

982

1

));

983

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

984

1

		assert_ok!(add_supported_asset(source_location, 12500000));

985

1

});

986

1

987

1

	let dest = Location {

988

1

		parents: 1,

989

1

		interior: [

990

1

			Parachain(2),

991

1

			AccountKey20 {

992

1

				network: None,

993

1

				key: PARAALICE.into(),

994

1

},

995

1

996

1

		.into(),

997

1

};

998

1

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

999

1

	// we use transfer_with_fee

1000

1

	ParaA::execute_with(|| {

1001

1

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

1002

1

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

1003

1

		assert_ok!(PolkadotXcm::transfer_assets(

1004

1

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

1005

1

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

1006

1

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

1007

1

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

1008

1

0,

1009

1

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

1010

1

));

1011

1

});

1012

1

	ParaA::execute_with(|| {

1013

1

		// 100 tokens transferred plus 1 taken from fees

1014

1

		assert_eq!(

1015

1

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

1016

1

			INITIAL_BALANCE - 100 - 1

1017

1

);

1018

1

});

1019

1

1020

1

	ParaB::execute_with(|| {

1021

1

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

1022

1

		// what it is specified

1023

1

		assert_eq!(

1024

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1025

1

			Ok(U256::from(101))

1026

1

);

1027

1

});

1028

1

1029

1030

#[test]

1031

1

fn error_when_not_paying_enough() {

1032

1

	MockNet::reset();

1033

1

1034

1

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

1035

1

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

1036

1

1037

1

	let asset_metadata = parachain::AssetMetadata {

1038

1

		name: b"RelayToken".to_vec(),

1039

1

		symbol: b"Relay".to_vec(),

1040

1

		decimals: 12,

1041

1

};

1042

1

1043

1

	let dest: Location = Junction::AccountKey20 {

1044

1

		network: None,

1045

1

		key: PARAALICE,

1046

1

1047

1

	.into();

1048

1

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

1049

1

	// we know later we will divide by 1e12

1050

1

	// Lets put 1e6 as units per second

1051

1

	ParaA::execute_with(|| {

1052

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1053

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1054

1

			.try_into()

1055

1

			.expect("v3 to latest location conversion failed");

1056

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1057

1

			source_id,

1058

1

			source_location_latest,

1059

1

			asset_metadata.decimals,

1060

1

			asset_metadata.symbol.try_into().expect("too long"),

1061

1

			asset_metadata.name.try_into().expect("too long"),

1062

1

));

1063

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

1064

1

});

1065

1

1066

1

	ParaA::execute_with(|| {

1067

1

		// amount not received as it is not paying enough

1068

1

		assert_eq!(

1069

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1070

1

			Ok(U256::from(0))

1071

1

);

1072

1

});

1073

1

1074

1

	// We are sending 100 tokens from relay.

1075

1

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

1076

1

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

1077

1

	Relay::execute_with(|| {

1078

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1079

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1080

1

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

1081

1

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

1082

1

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

1083

1

0,

1084

1

			WeightLimit::Unlimited

1085

1

));

1086

1

});

1087

1

1088

1

	ParaA::execute_with(|| {

1089

1

		// amount not received as it is not paying enough

1090

1

		assert_eq!(

1091

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1092

1

			Ok(U256::from(0))

1093

1

);

1094

1

});

1095

1

1096

1097

#[test]

1098

1

fn transact_through_derivative_multilocation() {

1099

1

	MockNet::reset();

1100

1

1101

1

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

1102

1

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

1103

1

1104

1

	let asset_metadata = parachain::AssetMetadata {

1105

1

		name: b"RelayToken".to_vec(),

1106

1

		symbol: b"Relay".to_vec(),

1107

1

		decimals: 12,

1108

1

};

1109

1

1110

1

	ParaA::execute_with(|| {

1111

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1112

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1113

1

			.try_into()

1114

1

			.expect("v3 to latest location conversion failed");

1115

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1116

1

			source_id,

1117

1

			source_location_latest,

1118

1

			asset_metadata.decimals,

1119

1

			asset_metadata.symbol.try_into().expect("too long"),

1120

1

			asset_metadata.name.try_into().expect("too long"),

1121

1

));

1122

1

		assert_ok!(add_supported_asset(source_location, 1));

1123

1124

		// Root can set transact info

1125

1

		assert_ok!(XcmTransactor::set_transact_info(

1126

1

			parachain::RuntimeOrigin::root(),

1127

1

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

1128

1

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

1129

1

			3000.into(),

1130

1

			20000000000.into(),

1131

1

			None

1132

1

));

1133

		// Root can set transact info

1134

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1135

1

			parachain::RuntimeOrigin::root(),

1136

1

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

1137

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1138

1

));

1139

1

});

1140

1

1141

1

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

1142

1

1143

1

	let dest: Location = AccountKey20 {

1144

1

		network: None,

1145

1

		key: PARAALICE,

1146

1

1147

1

	.into();

1148

1

	Relay::execute_with(|| {

1149

1

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

1150

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1151

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1152

1

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

1153

1

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

1154

1

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

1155

1

0,

1156

1

			WeightLimit::Unlimited

1157

1

));

1158

1

});

1159

1

1160

1

	ParaA::execute_with(|| {

1161

1

		// free execution, full amount received

1162

1

		assert_eq!(

1163

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1164

1

			Ok(U256::from(4000003100u128))

1165

1

);

1166

1

});

1167

1

1168

1

	// Register address

1169

1

	ParaA::execute_with(|| {

1170

1

		assert_ok!(XcmTransactor::register(

1171

1

			parachain::RuntimeOrigin::root(),

1172

1

			PARAALICE.into(),

1173

1

0,

1174

1

));

1175

1

});

1176

1

1177

1

	// Send to registered address

1178

1

1179

1

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

1180

1

	let dest = Location {

1181

1

		parents: 1,

1182

1

		interior: [AccountId32 {

1183

1

			network: None,

1184

1

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

1185

1

}]

1186

1

		.into(),

1187

1

};

1188

1

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

1189

1

1190

1

	ParaA::execute_with(|| {

1191

1

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

1192

1

		// free execution, full amount received

1193

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1194

1

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

1195

1

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

1196

1

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

1197

1

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

1198

1

0,

1199

1

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

1200

1

));

1201

1

});

1202

1

1203

1

	ParaA::execute_with(|| {

1204

1

		// free execution, full amount received

1205

1

		assert_eq!(

1206

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1207

1

			Ok(U256::from(4000003000u128))

1208

1

);

1209

1

});

1210

1

1211

1

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

1212

1

	// again

1213

1

	Relay::execute_with(|| {

1214

1

		// free execution,x	 full amount received

1215

1

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

1216

1

});

1217

1

1218

1

	// Encode the call. Balances transact to para_a_account

1219

1

	// First index

1220

1

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

1221

1

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

1222

1

		relay_chain::Balances,

1223

1

>()

1224

1

	.unwrap() as u8;

1225

1

1226

1

	encoded.push(index);

1227

1

1228

1

	// Then call bytes

1229

1

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

1230

1

		dest: para_a_account(),

1231

1

		value: 100u32.into(),

1232

1

1233

1

	.encode();

1234

1

	encoded.append(&mut call_bytes);

1235

1

1236

1

	ParaA::execute_with(|| {

1237

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1238

1

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

1239

1

			parachain::MockTransactors::Relay,

1240

1

0,

1241

1

			CurrencyPayment {

1242

1

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

1243

1

					Location::parent()

1244

1

				))),

1245

1

				fee_amount: None

1246

1

},

1247

1

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

1248

1

			encoded,

1249

1

			TransactWeights {

1250

1

				transact_required_weight_at_most: 4000000000.into(),

1251

1

				overall_weight: None

1252

1

},

1253

1

			false

1254

1

));

1255

1

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

1256

1

			.iter()

1257

20

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

1258

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

1259

..

1260

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

1261

20

				_ => None,

1262

20

});

1263

1

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

1264

1

		assert!(event_found.is_none());

1265

1

});

1266

1

1267

1

	Relay::execute_with(|| {

1268

1

		// free execution,x	 full amount received

1269

1

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

1270

1271

1

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

1272

1

});

1273

1

1274

1275

#[test]

1276

1

fn transact_through_derivative_with_custom_fee_weight() {

1277

1

	MockNet::reset();

1278

1

1279

1

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

1280

1

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

1281

1

1282

1

	let asset_metadata = parachain::AssetMetadata {

1283

1

		name: b"RelayToken".to_vec(),

1284

1

		symbol: b"Relay".to_vec(),

1285

1

		decimals: 12,

1286

1

};

1287

1

1288

1

	ParaA::execute_with(|| {

1289

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1290

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1291

1

			.try_into()

1292

1

			.expect("v3 to latest location conversion failed");

1293

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1294

1

			source_id,

1295

1

			source_location_latest,

1296

1

			asset_metadata.decimals,

1297

1

			asset_metadata.symbol.try_into().expect("too long"),

1298

1

			asset_metadata.name.try_into().expect("too long"),

1299

1

));

1300

1

		assert_ok!(add_supported_asset(source_location, 1));

1301

1

});

1302

1

1303

1

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

1304

1

1305

1

	let dest: Location = AccountKey20 {

1306

1

		network: None,

1307

1

		key: PARAALICE,

1308

1

1309

1

	.into();

1310

1

	Relay::execute_with(|| {

1311

1

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

1312

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1313

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1314

1

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

1315

1

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

1316

1

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

1317

1

0,

1318

1

			WeightLimit::Unlimited

1319

1

));

1320

1

});

1321

1

1322

1

	ParaA::execute_with(|| {

1323

1

		// free execution, full amount received

1324

1

		assert_eq!(

1325

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1326

1

			Ok(U256::from(4000003100u128))

1327

1

);

1328

1

});

1329

1

1330

1

	// Register address

1331

1

	ParaA::execute_with(|| {

1332

1

		assert_ok!(XcmTransactor::register(

1333

1

			parachain::RuntimeOrigin::root(),

1334

1

			PARAALICE.into(),

1335

1

0,

1336

1

));

1337

1

});

1338

1

1339

1

	// Send to registered address

1340

1

1341

1

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

1342

1

	let dest = Location {

1343

1

		parents: 1,

1344

1

		interior: [AccountId32 {

1345

1

			network: None,

1346

1

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

1347

1

}]

1348

1

		.into(),

1349

1

};

1350

1

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

1351

1

1352

1

	ParaA::execute_with(|| {

1353

1

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

1354

1

		// free execution, full amount received

1355

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1356

1

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

1357

1

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

1358

1

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

1359

1

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

1360

1

0,

1361

1

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

1362

1

));

1363

1

});

1364

1

1365

1

	ParaA::execute_with(|| {

1366

1

		// free execution, full amount received

1367

1

		assert_eq!(

1368

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1369

1

			Ok(U256::from(4000003000u128))

1370

1

);

1371

1

});

1372

1

1373

1

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

1374

1

	// again

1375

1

	Relay::execute_with(|| {

1376

1

		// free execution,x	 full amount received

1377

1

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

1378

1

});

1379

1

1380

1

	// Encode the call. Balances transact to para_a_account

1381

1

	// First index

1382

1

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

1383

1

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

1384

1

		relay_chain::Balances,

1385

1

>()

1386

1

	.unwrap() as u8;

1387

1

1388

1

	encoded.push(index);

1389

1

1390

1

	// Then call bytes

1391

1

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

1392

1

		dest: para_a_account(),

1393

1

		value: 100u32.into(),

1394

1

1395

1

	.encode();

1396

1

	encoded.append(&mut call_bytes);

1397

1

1398

1

	let overall_weight = 4000003000u64;

1399

1

	ParaA::execute_with(|| {

1400

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1401

1

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

1402

1

			parachain::MockTransactors::Relay,

1403

1

0,

1404

1

			CurrencyPayment {

1405

1

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

1406

1

					Location::parent()

1407

1

				))),

1408

1

				// 1-1 fee weight mapping

1409

1

				fee_amount: Some(overall_weight as u128)

1410

1

},

1411

1

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

1412

1

			encoded,

1413

1

			TransactWeights {

1414

1

				transact_required_weight_at_most: 4000000000.into(),

1415

1

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

1416

1

},

1417

1

			false

1418

1

));

1419

1

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

1420

1

			.iter()

1421

18

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

1422

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

1423

..

1424

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

1425

18

				_ => None,

1426

18

});

1427

1

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

1428

1

		assert!(event_found.is_none());

1429

1

});

1430

1

1431

1

	Relay::execute_with(|| {

1432

1

		// free execution,x	 full amount received

1433

1

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

1434

1435

1

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

1436

1

});

1437

1

1438

1439

#[test]

1440

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1441

1

	MockNet::reset();

1442

1

1443

1

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

1444

1

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

1445

1

1446

1

	let asset_metadata = parachain::AssetMetadata {

1447

1

		name: b"RelayToken".to_vec(),

1448

1

		symbol: b"Relay".to_vec(),

1449

1

		decimals: 12,

1450

1

};

1451

1

1452

1

	ParaA::execute_with(|| {

1453

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1454

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1455

1

			.try_into()

1456

1

			.expect("v3 to latest location conversion failed");

1457

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1458

1

			source_id,

1459

1

			source_location_latest,

1460

1

			asset_metadata.decimals,

1461

1

			asset_metadata.symbol.try_into().expect("too long"),

1462

1

			asset_metadata.name.try_into().expect("too long"),

1463

1

));

1464

1

		assert_ok!(add_supported_asset(source_location, 1));

1465

1

});

1466

1

1467

1

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

1468

1

1469

1

	let dest: Location = AccountKey20 {

1470

1

		network: None,

1471

1

		key: PARAALICE,

1472

1

1473

1

	.into();

1474

1

	Relay::execute_with(|| {

1475

1

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

1476

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1477

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1478

1

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

1479

1

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

1480

1

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

1481

1

0,

1482

1

			WeightLimit::Unlimited

1483

1

));

1484

1

});

1485

1

1486

1

	ParaA::execute_with(|| {

1487

1

		// free execution, full amount received

1488

1

		assert_eq!(

1489

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1490

1

			Ok(U256::from(4000009100u128))

1491

1

);

1492

1

});

1493

1

1494

1

	// Register address

1495

1

	ParaA::execute_with(|| {

1496

1

		assert_ok!(XcmTransactor::register(

1497

1

			parachain::RuntimeOrigin::root(),

1498

1

			PARAALICE.into(),

1499

1

0,

1500

1

));

1501

1

});

1502

1

1503

1

	// Send to registered address

1504

1

1505

1

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

1506

1

	let dest = Location {

1507

1

		parents: 1,

1508

1

		interior: [AccountId32 {

1509

1

			network: None,

1510

1

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

1511

1

}]

1512

1

		.into(),

1513

1

};

1514

1

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

1515

1

1516

1

	ParaA::execute_with(|| {

1517

1

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

1518

1

		// free execution, full amount received

1519

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1520

1

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

1521

1

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

1522

1

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

1523

1

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

1524

1

0,

1525

1

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

1526

1

));

1527

1

});

1528

1

1529

1

	ParaA::execute_with(|| {

1530

1

		// free execution, full amount received

1531

1

		assert_eq!(

1532

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1533

1

			Ok(U256::from(4000009000u128))

1534

1

);

1535

1

});

1536

1

1537

1

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

1538

1

	// again

1539

1

	Relay::execute_with(|| {

1540

1

		// free execution,x	 full amount received

1541

1

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

1542

1

});

1543

1

1544

1

	// Encode the call. Balances transact to para_a_account

1545

1

	// First index

1546

1

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

1547

1

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

1548

1

		relay_chain::Balances,

1549

1

>()

1550

1

	.unwrap() as u8;

1551

1

1552

1

	encoded.push(index);

1553

1

1554

1

	// Then call bytes

1555

1

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

1556

1

		dest: para_a_account(),

1557

1

		value: 100u32.into(),

1558

1

1559

1

	.encode();

1560

1

	encoded.append(&mut call_bytes);

1561

1

1562

1

	let overall_weight = 4000009000u64;

1563

1

	ParaA::execute_with(|| {

1564

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1565

1

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

1566

1

			parachain::MockTransactors::Relay,

1567

1

0,

1568

1

			CurrencyPayment {

1569

1

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

1570

1

					Location::parent()

1571

1

				))),

1572

1

				// 1-1 fee weight mapping

1573

1

				fee_amount: Some(overall_weight as u128)

1574

1

},

1575

1

			encoded,

1576

1

			TransactWeights {

1577

1

				transact_required_weight_at_most: 4000000000.into(),

1578

1

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

1579

1

},

1580

1

			true

1581

1

));

1582

1

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

1583

1

			.iter()

1584

18

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

1585

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

1586

..

1587

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

1588

18

				_ => None,

1589

18

});

1590

1

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

1591

1

		assert!(event_found.is_none());

1592

1

});

1593

1

1594

1

	Relay::execute_with(|| {

1595

1

		// free execution, full amount received

1596

1

		// 4000009000 refunded + 100 transferred = 4000009100

1597

1

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

1598

1

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

1599

1

});

1600

1

1601

1602

#[test]

1603

1

fn transact_through_sovereign() {

1604

1

	MockNet::reset();

1605

1

1606

1

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

1607

1

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

1608

1

1609

1

	let asset_metadata = parachain::AssetMetadata {

1610

1

		name: b"RelayToken".to_vec(),

1611

1

		symbol: b"Relay".to_vec(),

1612

1

		decimals: 12,

1613

1

};

1614

1

1615

1

	ParaA::execute_with(|| {

1616

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

1617

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1618

1

			.try_into()

1619

1

			.expect("v3 to latest location conversion failed");

1620

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1621

1

			source_id,

1622

1

			source_location_latest,

1623

1

			asset_metadata.decimals,

1624

1

			asset_metadata.symbol.try_into().expect("too long"),

1625

1

			asset_metadata.name.try_into().expect("too long"),

1626

1

));

1627

1

		assert_ok!(add_supported_asset(source_location, 1));

1628

1629

		// Root can set transact info

1630

1

		assert_ok!(XcmTransactor::set_transact_info(

1631

1

			parachain::RuntimeOrigin::root(),

1632

1

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

1633

1

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

1634

1

			3000.into(),

1635

1

			20000000000.into(),

1636

1

			None

1637

1

));

1638

		// Root can set transact info

1639

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1640

1

			parachain::RuntimeOrigin::root(),

1641

1

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

1642

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1643

1

));

1644

1

});

1645

1

1646

1

	let dest: Location = AccountKey20 {

1647

1

		network: None,

1648

1

		key: PARAALICE,

1649

1

1650

1

	.into();

1651

1

	Relay::execute_with(|| {

1652

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1653

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1654

1

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

1655

1

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

1656

1

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

1657

1

0,

1658

1

			WeightLimit::Unlimited

1659

1

));

1660

1

});

1661

1

1662

1

	ParaA::execute_with(|| {

1663

1

		// free execution, full amount received

1664

1

		assert_eq!(

1665

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1666

1

			Ok(U256::from(4000003100u128))

1667

1

);

1668

1

});

1669

1

1670

1

	// Register address

1671

1

	ParaA::execute_with(|| {

1672

1

		assert_ok!(XcmTransactor::register(

1673

1

			parachain::RuntimeOrigin::root(),

1674

1

			PARAALICE.into(),

1675

1

0,

1676

1

));

1677

1

});

1678

1

1679

1

	// Send to registered address

1680

1

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

1681

1

	let dest = Location {

1682

1

		parents: 1,

1683

1

		interior: [AccountId32 {

1684

1

			network: None,

1685

1

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

1686

1

}]

1687

1

		.into(),

1688

1

};

1689

1

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

1690

1

1691

1

	ParaA::execute_with(|| {

1692

1

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

1693

1

		// free execution, full amount received

1694

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1695

1

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

1696

1

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

1697

1

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

1698

1

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

1699

1

0,

1700

1

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

1701

1

));

1702

1

});

1703

1

1704

1

	ParaA::execute_with(|| {

1705

1

		// free execution, full amount received

1706

1

		assert_eq!(

1707

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1708

1

			Ok(U256::from(4000003000u128))

1709

1

);

1710

1

});

1711

1

1712

1

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

1713

1

	// again

1714

1

	Relay::execute_with(|| {

1715

1

		// free execution,x	 full amount received

1716

1

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

1717

1

1718

1

});

1719

1

1720

1

	// We send the xcm transact operation to parent

1721

1

	let dest = Location {

1722

1

		parents: 1,

1723

1

		interior: [].into(),

1724

1

};

1725

1

1726

1

	// Encode the call. Balances transact to para_a_account

1727

1

	// First index

1728

1

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

1729

1

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

1730

1

		relay_chain::Balances,

1731

1

>()

1732

1

	.unwrap() as u8;

1733

1

1734

1

	encoded.push(index);

1735

1

1736

1

	// Then call bytes

1737

1

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

1738

1

		dest: para_a_account(),

1739

1

		value: 100u32.into(),

1740

1

1741

1

	.encode();

1742

1

	encoded.append(&mut call_bytes);

1743

1

1744

1

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

1745

1

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

1746

1

);

1747

1

1748

1

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

1749

1

	ParaA::execute_with(|| {

1750

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1751

1

			parachain::RuntimeOrigin::root(),

1752

1

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

1753

1

			Some(PARAALICE.into()),

1754

1

			CurrencyPayment {

1755

1

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

1756

1

					Location::parent()

1757

1

				))),

1758

1

				fee_amount: None

1759

1

},

1760

1

			utility_bytes,

1761

1

			OriginKind::SovereignAccount,

1762

1

			TransactWeights {

1763

1

				transact_required_weight_at_most: 4000000000.into(),

1764

1

				overall_weight: None

1765

1

},

1766

1

			false

1767

1

));

1768

1

});

1769

1

1770

1

	Relay::execute_with(|| {

1771

1

		// free execution,x	 full amount received

1772

1

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

1773

1774

1

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

1775

1

});

1776

1

1777

1778

#[test]

1779

1

fn transact_through_sovereign_fee_payer_none() {

1780

1

	MockNet::reset();

1781

1

1782

1

	ParaA::execute_with(|| {

1783

1

		// Root can set transact info

1784

1

		assert_ok!(XcmTransactor::set_transact_info(

1785

1

			parachain::RuntimeOrigin::root(),

1786

1

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

1787

1

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

1788

1

			3000.into(),

1789

1

			20000000000.into(),

1790

1

			None

1791

1

));

1792

		// Root can set transact info

1793

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1794

1

			parachain::RuntimeOrigin::root(),

1795

1

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

1796

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1797

1

));

1798

1

});

1799

1

1800

1

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

1801

1

1802

1

	Relay::execute_with(|| {

1803

1

		// Transfer 100 tokens to derivative_address on the relay

1804

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1805

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1806

1

			derivative_address.clone(),

1807

1

			100u128

1808

1

));

1809

1810

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

1811

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1812

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1813

1

			para_a_account(),

1814

1

			4000003000u128

1815

1

));

1816

1

});

1817

1

1818

1

	// Check balances before the transact call

1819

1

	Relay::execute_with(|| {

1820

1

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

1821

1

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

1822

1

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

1823

1

});

1824

1

1825

1

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

1826

1

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

1827

1

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

1828

1

		relay_chain::Balances,

1829

1

>()

1830

1

	.unwrap() as u8;

1831

1

1832

1

	encoded.push(index);

1833

1

1834

1

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

1835

1

		dest: RELAYBOB,

1836

1

		value: 100u32.into(),

1837

1

1838

1

	.encode();

1839

1

	encoded.append(&mut call_bytes);

1840

1

1841

1

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

1842

1

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

1843

1

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

1844

1

);

1845

1

1846

1

	// We send the xcm transact operation to parent

1847

1

	let dest = Location {

1848

1

		parents: 1,

1849

1

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

1850

1

};

1851

1

1852

1

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

1853

1

	ParaA::execute_with(|| {

1854

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1855

1

			parachain::RuntimeOrigin::root(),

1856

1

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

1857

1

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

1858

1

			None,

1859

1

			CurrencyPayment {

1860

1

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

1861

1

					Location::parent()

1862

1

				))),

1863

1

				fee_amount: None

1864

1

},

1865

1

			utility_bytes,

1866

1

			OriginKind::SovereignAccount,

1867

1

			TransactWeights {

1868

1

				transact_required_weight_at_most: 4000000000.into(),

1869

1

				overall_weight: None

1870

1

},

1871

1

			false

1872

1

));

1873

1

});

1874

1

1875

1

	// Check balances after the transact call are correct

1876

1

	Relay::execute_with(|| {

1877

1

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

1878

1

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

1879

1

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

1880

1

});

1881

1

1882

1883

#[test]

1884

1

fn transact_through_sovereign_with_custom_fee_weight() {

1885

1

	MockNet::reset();

1886

1

1887

1

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

1888

1

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

1889

1

1890

1

	let asset_metadata = parachain::AssetMetadata {

1891

1

		name: b"RelayToken".to_vec(),

1892

1

		symbol: b"Relay".to_vec(),

1893

1

		decimals: 12,

1894

1

};

1895

1

1896

1

	ParaA::execute_with(|| {

1897

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location;

1898

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

1899

1

			.try_into()

1900

1

			.expect("v3 to latest location conversion failed");

1901

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1902

1

			source_id,

1903

1

			source_location_latest,

1904

1

			asset_metadata.decimals,

1905

1

			asset_metadata.symbol.try_into().expect("too long"),

1906

1

			asset_metadata.name.try_into().expect("too long"),

1907

1

));

1908

1

		assert_ok!(add_supported_asset(source_location, 1));

1909

1

});

1910

1

1911

1

	let dest: Location = AccountKey20 {

1912

1

		network: None,

1913

1

		key: PARAALICE,

1914

1

1915

1

	.into();

1916

1

	Relay::execute_with(|| {

1917

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1918

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1919

1

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

1920

1

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

1921

1

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

1922

1

0,

1923

1

			WeightLimit::Unlimited

1924

1

));

1925

1

});

1926

1

1927

1

	ParaA::execute_with(|| {

1928

1

		// free execution, full amount received

1929

1

		assert_eq!(

1930

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1931

1

			Ok(U256::from(4000003100u128))

1932

1

);

1933

1

});

1934

1

1935

1

	// Register address

1936

1

	ParaA::execute_with(|| {

1937

1

		assert_ok!(XcmTransactor::register(

1938

1

			parachain::RuntimeOrigin::root(),

1939

1

			PARAALICE.into(),

1940

1

0,

1941

1

));

1942

1

});

1943

1

1944

1

	// Send to registered address

1945

1

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

1946

1

	let dest = Location {

1947

1

		parents: 1,

1948

1

		interior: [AccountId32 {

1949

1

			network: None,

1950

1

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

1951

1

}]

1952

1

		.into(),

1953

1

};

1954

1

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

1955

1

1956

1

	ParaA::execute_with(|| {

1957

1

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

1958

1

		// free execution, full amount received

1959

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1960

1

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

1961

1

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

1962

1

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

1963

1

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

1964

1

0,

1965

1

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

1966

1

));

1967

1

});

1968

1

1969

1

	ParaA::execute_with(|| {

1970

1

		// free execution, full amount received

1971

1

		assert_eq!(

1972

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

1973

1

			Ok(U256::from(4000003000u128))

1974

1

);

1975

1

});

1976

1

1977

1

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

1978

1

	// again

1979

1

	Relay::execute_with(|| {

1980

1

		// free execution,x	 full amount received

1981

1

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

1982

1

1983

1

});

1984

1

1985

1

	// We send the xcm transact operation to parent

1986

1

	let dest = Location {

1987

1

		parents: 1,

1988

1

		interior: [].into(),

1989

1

};

1990

1

1991

1

	// Encode the call. Balances transact to para_a_account

1992

1

	// First index

1993

1

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

1994

1

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

1995

1

		relay_chain::Balances,

1996

1

>()

1997

1

	.unwrap() as u8;

1998

1

1999

1

	encoded.push(index);

2000

1

2001

1

	// Then call bytes

2002

1

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

2003

1

		dest: para_a_account(),

2004

1

		value: 100u32.into(),

2005

1

2006

1

	.encode();

2007

1

	encoded.append(&mut call_bytes);

2008

1

2009

1

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

2010

1

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

2011

1

);

2012

1

2013

1

	let total_weight = 4000003000u64;

2014

1

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

2015

1

	ParaA::execute_with(|| {

2016

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2017

1

			parachain::RuntimeOrigin::root(),

2018

1

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

2019

1

			Some(PARAALICE.into()),

2020

1

			CurrencyPayment {

2021

1

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

2022

1

					Location::parent()

2023

1

				))),

2024

1

				// 1-1 fee-weight mapping

2025

1

				fee_amount: Some(total_weight as u128)

2026

1

},

2027

1

			utility_bytes,

2028

1

			OriginKind::SovereignAccount,

2029

1

			TransactWeights {

2030

1

				transact_required_weight_at_most: 4000000000.into(),

2031

1

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

2032

1

},

2033

1

			false

2034

1

));

2035

1

});

2036

1

2037

1

	Relay::execute_with(|| {

2038

1

		// free execution,x	 full amount received

2039

1

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

2040

2041

1

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

2042

1

});

2043

1

2044

2045

#[test]

2046

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2047

1

	MockNet::reset();

2048

1

2049

1

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

2050

1

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

2051

1

2052

1

	let asset_metadata = parachain::AssetMetadata {

2053

1

		name: b"RelayToken".to_vec(),

2054

1

		symbol: b"Relay".to_vec(),

2055

1

		decimals: 12,

2056

1

};

2057

1

2058

1

	ParaA::execute_with(|| {

2059

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2060

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2061

1

			.try_into()

2062

1

			.expect("v3 to latest location conversion failed");

2063

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2064

1

			source_id,

2065

1

			source_location_latest,

2066

1

			asset_metadata.decimals,

2067

1

			asset_metadata.symbol.try_into().expect("too long"),

2068

1

			asset_metadata.name.try_into().expect("too long"),

2069

1

));

2070

1

		assert_ok!(add_supported_asset(source_location, 1));

2071

1

});

2072

1

2073

1

	let dest: Location = AccountKey20 {

2074

1

		network: None,

2075

1

		key: PARAALICE,

2076

1

2077

1

	.into();

2078

1

	Relay::execute_with(|| {

2079

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2080

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2081

1

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

2082

1

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

2083

1

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

2084

1

0,

2085

1

			WeightLimit::Unlimited

2086

1

));

2087

1

});

2088

1

2089

1

	ParaA::execute_with(|| {

2090

1

		// free execution, full amount received

2091

1

		assert_eq!(

2092

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2093

1

			Ok(U256::from(4000009100u128))

2094

1

);

2095

1

});

2096

1

2097

1

	// Register address

2098

1

	ParaA::execute_with(|| {

2099

1

		assert_ok!(XcmTransactor::register(

2100

1

			parachain::RuntimeOrigin::root(),

2101

1

			PARAALICE.into(),

2102

1

0,

2103

1

));

2104

1

});

2105

1

2106

1

	// Send to registered address

2107

1

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

2108

1

	let dest = Location {

2109

1

		parents: 1,

2110

1

		interior: [AccountId32 {

2111

1

			network: None,

2112

1

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

2113

1

}]

2114

1

		.into(),

2115

1

};

2116

1

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

2117

1

2118

1

	ParaA::execute_with(|| {

2119

1

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

2120

1

		// free execution, full amount received

2121

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

2122

1

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

2123

1

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

2124

1

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

2125

1

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

2126

1

0,

2127

1

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

2128

1

));

2129

1

});

2130

1

2131

1

	ParaA::execute_with(|| {

2132

1

		// free execution, full amount received

2133

1

		assert_eq!(

2134

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2135

1

			Ok(U256::from(4000009000u128))

2136

1

);

2137

1

});

2138

1

2139

1

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

2140

1

	// again

2141

1

	Relay::execute_with(|| {

2142

1

		// free execution,x	 full amount received

2143

1

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

2144

1

2145

1

});

2146

1

2147

1

	// We send the xcm transact operation to parent

2148

1

	let dest = Location {

2149

1

		parents: 1,

2150

1

		interior: [].into(),

2151

1

};

2152

1

2153

1

	// Encode the call. Balances transact to para_a_account

2154

1

	// First index

2155

1

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

2156

1

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

2157

1

		relay_chain::Balances,

2158

1

>()

2159

1

	.unwrap() as u8;

2160

1

2161

1

	encoded.push(index);

2162

1

2163

1

	// Then call bytes

2164

1

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

2165

1

		dest: para_a_account(),

2166

1

		value: 100u32.into(),

2167

1

2168

1

	.encode();

2169

1

	encoded.append(&mut call_bytes);

2170

1

2171

1

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

2172

1

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

2173

1

);

2174

1

2175

1

	let total_weight = 4000009000u64;

2176

1

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

2177

1

	ParaA::execute_with(|| {

2178

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2179

1

			parachain::RuntimeOrigin::root(),

2180

1

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

2181

1

			Some(PARAALICE.into()),

2182

1

			CurrencyPayment {

2183

1

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

2184

1

					Location::parent()

2185

1

				))),

2186

1

				// 1-1 fee-weight mapping

2187

1

				fee_amount: Some(total_weight as u128)

2188

1

},

2189

1

			utility_bytes,

2190

1

			OriginKind::SovereignAccount,

2191

1

			TransactWeights {

2192

1

				transact_required_weight_at_most: 4000000000.into(),

2193

1

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

2194

1

},

2195

1

			true

2196

1

));

2197

1

});

2198

1

2199

1

	Relay::execute_with(|| {

2200

1

		// free execution, full amount received

2201

1

		// 4000009000 refunded + 100 transferred = 4000009100

2202

1

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

2203

2204

1

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

2205

1

});

2206

1

2207

2208

#[test]

2209

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2210

1

	MockNet::reset();

2211

1

2212

1

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

2213

1

	let asset_metadata = parachain::AssetMetadata {

2214

1

		name: b"RelayToken".to_vec(),

2215

1

		symbol: b"Relay".to_vec(),

2216

1

		decimals: 12,

2217

1

};

2218

1

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

2219

1

	ParaA::execute_with(|| {

2220

1

		parachain::XcmVersioner::set_version(1);

2221

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2222

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2223

1

			.try_into()

2224

1

			.expect("v3 to latest location conversion failed");

2225

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2226

1

3,

2227

1

			source_location_latest,

2228

1

			asset_metadata.decimals,

2229

1

			asset_metadata.symbol.try_into().expect("too long"),

2230

1

			asset_metadata.name.try_into().expect("too long"),

2231

1

));

2232

1

		assert_ok!(add_supported_asset(source_location, 0));

2233

1

});

2234

1

2235

1

	let response = Response::Version(2);

2236

1

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

2237

1

2238

1

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

2239

1

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

2240

1

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

2241

1

		query_id: 0,

2242

1

		response,

2243

1

		max_weight: Weight::zero(),

2244

1

		querier: Some(querier),

2245

1

	}]);

2246

1

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

2247

1

	// it directly here

2248

1

	// Actually send relay asset to parachain

2249

1

	let dest: Location = AccountKey20 {

2250

1

		network: None,

2251

1

		key: PARAALICE,

2252

1

2253

1

	.into();

2254

1

2255

1

	Relay::execute_with(|| {

2256

1

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

2257

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2258

1

			relay_chain::RuntimeOrigin::root(),

2259

1

			Some(3)

2260

1

));

2261

2262

		// Wrap version, which sets VersionedStorage

2263

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

2264

		// this is not necessary in prod

2265

1

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

2266

1

			&Parachain(1).into(),

2267

1

			mock_message

2268

1

));

2269

2270

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

2271

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2272

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2273

1

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

2274

1

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

2275

1

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

2276

1

0,

2277

1

			WeightLimit::Unlimited

2278

1

));

2279

2280

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

2281

1

		relay_chain::relay_roll_to(2);

2282

1

2283

1

		// queries should have been updated

2284

1

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

2285

1

});

2286

1

2287

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2288

1

		pallet_xcm::Event::SupportedVersionChanged {

2289

1

			location: Location {

2290

1

				parents: 0,

2291

1

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

2292

1

},

2293

1

			version: 1,

2294

1

2295

1

		.into();

2296

1

2297

1

	Relay::execute_with(|| {

2298

1

		// Assert that the events vector contains the version change

2299

1

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

2300

1

});

2301

1

2302

1

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

2303

1

	// of the new version change

2304

1

	ParaA::execute_with(|| {

2305

1

		// Set version

2306

1

		parachain::XcmVersioner::set_version(2);

2307

1

		// Do runtime upgrade

2308

1

		parachain::on_runtime_upgrade();

2309

1

		// Initialize block, to call on_initialize and notify targets

2310

1

		parachain::para_roll_to(2);

2311

1

		// Expect the event in the parachain

2312

1

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

2313

2

e,

2314

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

2315

				result: 2,

2316

..

2317

})

2318

1

		)));

2319

1

});

2320

1

2321

1

	// This event should have been seen in the relay

2322

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2323

1

		pallet_xcm::Event::SupportedVersionChanged {

2324

1

			location: Location {

2325

1

				parents: 0,

2326

1

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

2327

1

},

2328

1

			version: 2,

2329

1

2330

1

		.into();

2331

1

2332

1

	Relay::execute_with(|| {

2333

1

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

2334

1

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

2335

1

});

2336

1

2337

2338

#[test]

2339

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2340

1

	MockNet::reset();

2341

1

2342

1

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

2343

1

	let source_location: AssetType = para_a_balances

2344

1

		.try_into()

2345

1

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

2346

1

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

2347

1

2348

1

	let asset_metadata = parachain::AssetMetadata {

2349

1

		name: b"ParaAToken".to_vec(),

2350

1

		symbol: b"ParaA".to_vec(),

2351

1

		decimals: 18,

2352

1

};

2353

1

	let response = Response::Version(2);

2354

1

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

2355

1

2356

1

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

2357

1

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

2358

1

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

2359

1

		query_id: 0,

2360

1

		response,

2361

1

		max_weight: Weight::zero(),

2362

1

		querier: Some(querier),

2363

1

	}]);

2364

1

2365

1

	ParaA::execute_with(|| {

2366

1

		// advertised version

2367

1

		parachain::XcmVersioner::set_version(2);

2368

1

});

2369

1

2370

1

	ParaB::execute_with(|| {

2371

1

		// Let's try with v0

2372

1

		parachain::XcmVersioner::set_version(0);

2373

1

2374

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2375

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2376

1

			.try_into()

2377

1

			.expect("v3 to latest location conversion failed");

2378

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2379

1

			source_id,

2380

1

			source_location_latest,

2381

1

			asset_metadata.decimals,

2382

1

			asset_metadata.symbol.try_into().expect("too long"),

2383

1

			asset_metadata.name.try_into().expect("too long"),

2384

1

));

2385

1

		assert_ok!(add_supported_asset(source_location, 0));

2386

1

});

2387

1

2388

1

	ParaA::execute_with(|| {

2389

1

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

2390

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2391

1

			parachain::RuntimeOrigin::root(),

2392

1

			Some(3)

2393

1

));

2394

		// Wrap version, which sets VersionedStorage

2395

1

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

2396

1

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

2397

1

			mock_message

2398

1

));

2399

2400

1

		parachain::para_roll_to(2);

2401

1

2402

1

		// queries should have been updated

2403

1

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

2404

1

});

2405

1

2406

1

	let expected_supported_version: parachain::RuntimeEvent =

2407

1

		pallet_xcm::Event::SupportedVersionChanged {

2408

1

			location: Location {

2409

1

				parents: 1,

2410

1

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

2411

1

},

2412

1

			version: 0,

2413

1

2414

1

		.into();

2415

1

2416

1

	ParaA::execute_with(|| {

2417

1

		// Assert that the events vector contains the version change

2418

1

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

2419

1

});

2420

1

2421

1

	// Let's ensure talking in v0 works

2422

1

	let dest = Location {

2423

1

		parents: 1,

2424

1

		interior: [

2425

1

			Parachain(2),

2426

1

			AccountKey20 {

2427

1

				network: None,

2428

1

				key: PARAALICE.into(),

2429

1

},

2430

1

2431

1

		.into(),

2432

1

2433

1

	.into();

2434

1

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

2435

1

	ParaA::execute_with(|| {

2436

1

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

2437

1

		// free execution, full amount received

2438

1

		assert_ok!(PolkadotXcm::transfer_assets(

2439

1

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

2440

1

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

2441

1

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

2442

1

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

2443

1

0,

2444

1

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

2445

1

));

2446

		// free execution, full amount received

2447

1

		assert_eq!(

2448

1

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

2449

1

			INITIAL_BALANCE - 100

2450

1

);

2451

1

});

2452

1

2453

1

	ParaB::execute_with(|| {

2454

1

		// free execution, full amount received

2455

1

		assert_eq!(

2456

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2457

1

			Ok(U256::from(100))

2458

1

);

2459

1

});

2460

1

2461

1

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

2462

1

	// of the new version change

2463

1

	ParaB::execute_with(|| {

2464

1

		// Set version

2465

1

		parachain::XcmVersioner::set_version(2);

2466

1

		// Do runtime upgrade

2467

1

		parachain::on_runtime_upgrade();

2468

1

		// Initialize block, to call on_initialize and notify targets

2469

1

		parachain::para_roll_to(2);

2470

1

		// Expect the event in the parachain

2471

1

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

2472

2

e,

2473

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

2474

				result: 2,

2475

..

2476

})

2477

1

		)));

2478

1

});

2479

1

2480

1

	// This event should have been seen in para A

2481

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2482

1

		pallet_xcm::Event::SupportedVersionChanged {

2483

1

			location: Location {

2484

1

				parents: 1,

2485

1

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

2486

1

},

2487

1

			version: 2,

2488

1

2489

1

		.into();

2490

1

2491

1

	// Para A should have received the version change

2492

1

	ParaA::execute_with(|| {

2493

1

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

2494

1

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

2495

1

});

2496

1

2497

2498

#[test]

2499

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2500

1

	MockNet::reset();

2501

1

2502

1

	let fresh_account = PARABOB;

2503

1

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

2504

1

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

2505

1

	let asset_metadata = parachain::AssetMetadata {

2506

1

		name: b"RelayToken".to_vec(),

2507

1

		symbol: b"Relay".to_vec(),

2508

1

		decimals: 12,

2509

1

};

2510

1

	// register relay asset in parachain A

2511

1

	ParaA::execute_with(|| {

2512

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2513

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2514

1

			.try_into()

2515

1

			.expect("v3 to latest location conversion failed");

2516

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2517

1

			source_id,

2518

1

			source_location_latest,

2519

1

			asset_metadata.decimals,

2520

1

			asset_metadata.symbol.try_into().expect("too long"),

2521

1

			asset_metadata.name.try_into().expect("too long"),

2522

1

));

2523

1

		assert_ok!(add_supported_asset(source_location, 0));

2524

1

});

2525

1

2526

1

	// Actually send relay asset to parachain

2527

1

	let dest: Location = AccountKey20 {

2528

1

		network: None,

2529

1

		key: fresh_account,

2530

1

2531

1

	.into();

2532

1

	Relay::execute_with(|| {

2533

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2534

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2535

1

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

2536

1

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

2537

1

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

2538

1

0,

2539

1

			WeightLimit::Unlimited

2540

1

));

2541

1

});

2542

1

2543

1

	// parachain should not have received assets

2544

1

	ParaA::execute_with(|| {

2545

1

		// free execution, full amount received

2546

1

		assert_eq!(

2547

1

			EvmForeignAssets::balance(source_id, fresh_account.into()),

2548

1

			Ok(U256::from(123))

2549

1

);

2550

1

});

2551

1

2552

2553

#[test]

2554

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2555

1

	MockNet::reset();

2556

1

2557

1

	let fresh_account = [2u8; 20];

2558

1

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

2559

1

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

2560

1

	let asset_metadata = parachain::AssetMetadata {

2561

1

		name: b"RelayToken".to_vec(),

2562

1

		symbol: b"Relay".to_vec(),

2563

1

		decimals: 12,

2564

1

};

2565

1

	// register relay asset in parachain A

2566

1

	ParaA::execute_with(|| {

2567

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2568

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2569

1

			.try_into()

2570

1

			.expect("v3 to latest location conversion failed");

2571

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2572

1

			source_id,

2573

1

			source_location_latest,

2574

1

			asset_metadata.decimals,

2575

1

			asset_metadata.symbol.try_into().expect("too long"),

2576

1

			asset_metadata.name.try_into().expect("too long"),

2577

1

));

2578

1

		assert_ok!(add_supported_asset(source_location, 0));

2579

1

});

2580

1

2581

1

	// Actually send relay asset to parachain

2582

1

	let dest: Location = AccountKey20 {

2583

1

		network: None,

2584

1

		key: fresh_account,

2585

1

2586

1

	.into();

2587

1

	Relay::execute_with(|| {

2588

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2589

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2590

1

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

2591

1

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

2592

1

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

2593

1

0,

2594

1

			WeightLimit::Unlimited

2595

1

));

2596

1

});

2597

1

2598

1

	// parachain should have received assets

2599

1

	ParaA::execute_with(|| {

2600

1

		// free execution, full amount received

2601

1

		assert_eq!(

2602

1

			EvmForeignAssets::balance(source_id, fresh_account.into()),

2603

1

			Ok(U256::from(123))

2604

1

);

2605

1

});

2606

1

2607

2608

#[test]

2609

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2610

1

	MockNet::reset();

2611

1

2612

1

	let mut sufficient_account = [0u8; 20];

2613

1

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

2614

1

2615

1

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

2616

1

2617

1

	// Evm account is self sufficient

2618

1

	ParaA::execute_with(|| {

2619

1

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

2620

1

});

2621

1

2622

1

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

2623

1

	let asset_metadata = parachain::AssetMetadata {

2624

1

		name: b"RelayToken".to_vec(),

2625

1

		symbol: b"Relay".to_vec(),

2626

1

		decimals: 12,

2627

1

};

2628

1

	// register relay asset in parachain A

2629

1

	ParaA::execute_with(|| {

2630

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2631

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2632

1

			.try_into()

2633

1

			.expect("v3 to latest location conversion failed");

2634

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2635

1

1,

2636

1

			source_location_latest,

2637

1

			asset_metadata.decimals,

2638

1

			asset_metadata.symbol.try_into().expect("too long"),

2639

1

			asset_metadata.name.try_into().expect("too long"),

2640

1

));

2641

1

		assert_ok!(add_supported_asset(source_location, 0));

2642

1

});

2643

1

2644

1

	// Actually send relay asset to parachain

2645

1

	let dest: Location = AccountKey20 {

2646

1

		network: None,

2647

1

		key: sufficient_account,

2648

1

2649

1

	.into();

2650

1

	Relay::execute_with(|| {

2651

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2652

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2653

1

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

2654

1

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

2655

1

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

2656

1

0,

2657

1

			WeightLimit::Unlimited

2658

1

));

2659

1

});

2660

1

2661

1

	// Evm account sufficient ref count increased by 1.

2662

1

	ParaA::execute_with(|| {

2663

1

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

2664

1

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

2665

1

		// remove contract data

2666

1

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

2667

1

});

2668

1

2669

1

	ParaA::execute_with(|| {

2670

1

		// Remove the account from the evm context.

2671

1

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

2672

1

		// Evm account sufficient ref count decreased by 1.

2673

1

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

2674

1

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

2675

1

		// remove contract data

2676

1

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

2677

1

});

2678

1

2679

2680

#[test]

2681

1

fn empty_account_should_not_be_reset() {

2682

1

	MockNet::reset();

2683

1

2684

1

	// Test account has nonce 1 when used for the first time.

2685

1

	let sufficient_account = PARABOB;

2686

1

2687

1

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

2688

1

2689

1

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

2690

1

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

2691

1

	let asset_metadata = parachain::AssetMetadata {

2692

1

		name: b"RelayToken".to_vec(),

2693

1

		symbol: b"Relay".to_vec(),

2694

1

		decimals: 12,

2695

1

};

2696

1

	// register relay asset in parachain A

2697

1

	ParaA::execute_with(|| {

2698

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2699

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2700

1

			.try_into()

2701

1

			.expect("v3 to latest location conversion failed");

2702

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2703

1

			source_id,

2704

1

			source_location_latest,

2705

1

			asset_metadata.decimals,

2706

1

			asset_metadata.symbol.try_into().expect("too long"),

2707

1

			asset_metadata.name.try_into().expect("too long"),

2708

1

));

2709

1

		assert_ok!(add_supported_asset(source_location, 0));

2710

1

});

2711

1

2712

1

	// Send native token to evm_account

2713

1

	ParaA::execute_with(|| {

2714

1

		assert_ok!(ParaBalances::transfer_allow_death(

2715

1

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

2716

1

			evm_account_id,

2717

1

2718

1

));

2719

1

});

2720

1

2721

1

	// Actually send relay asset to parachain

2722

1

	let dest: Location = AccountKey20 {

2723

1

		network: None,

2724

1

		key: sufficient_account,

2725

1

2726

1

	.into();

2727

1

	Relay::execute_with(|| {

2728

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2729

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2730

1

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

2731

1

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

2732

1

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

2733

1

0,

2734

1

			WeightLimit::Unlimited

2735

1

));

2736

1

});

2737

1

2738

1

	ParaA::execute_with(|| {

2739

1

		// Empty the assets from the account.

2740

1

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

2741

1

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

2742

1

		assert_ok!(parachain::EvmForeignAssets::transfer(

2743

1

			source_id,

2744

1

			evm_account_id,

2745

1

			PARAALICE.into(),

2746

1

			U256::from(123)

2747

1

));

2748

		// Verify account asset balance is Zero.

2749

1

		assert_eq!(

2750

1

			parachain::EvmForeignAssets::balance(source_id, evm_account_id.into()),

2751

1

			Ok(U256::from(0))

2752

1

);

2753

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

2754

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

2755

1

		assert_ok!(ParaBalances::force_set_balance(

2756

1

			parachain::RuntimeOrigin::root(),

2757

1

			evm_account_id,

2758

1

0,

2759

1

));

2760

		// Verify account native balance is Zero.

2761

1

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

2762

		// Remove the account from the evm context.

2763

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

2764

1

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

2765

1

		// Verify reference count.

2766

1

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

2767

1

		assert_eq!(account.sufficients, 0);

2768

1

		assert_eq!(account.consumers, 0);

2769

1

		assert_eq!(account.providers, 1);

2770

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

2771

1

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

2772

1

});

2773

1

2774

2775

#[test]

2776

1

fn test_statemint_like() {

2777

1

	MockNet::reset();

2778

1

2779

1

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

2780

1

2781

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2782

1

		polkadot_parachain::primitives::Sibling,

2783

1

		statemint_like::AccountId,

2784

1

	>::convert_location(&dest_para)

2785

1

	.unwrap();

2786

1

2787

1

	let statemint_asset_a_balances = Location::new(

2788

1

1,

2789

1

2790

1

			Parachain(1000),

2791

1

			PalletInstance(5),

2792

1

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

2793

1

],

2794

1

);

2795

1

	let source_location: AssetType = statemint_asset_a_balances

2796

1

		.try_into()

2797

1

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

2798

1

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

2799

1

2800

1

	let asset_metadata = parachain::AssetMetadata {

2801

1

		name: b"StatemintToken".to_vec(),

2802

1

		symbol: b"StatemintToken".to_vec(),

2803

1

		decimals: 12,

2804

1

};

2805

1

2806

1

	ParaA::execute_with(|| {

2807

1

		let parachain::AssetType::Xcm(source_location_v3) = source_location.clone();

2808

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

2809

1

			.try_into()

2810

1

			.expect("v3 to latest location conversion failed");

2811

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2812

1

			source_id,

2813

1

			source_location_latest,

2814

1

			asset_metadata.decimals,

2815

1

			asset_metadata.symbol.try_into().expect("too long"),

2816

1

			asset_metadata.name.try_into().expect("too long"),

2817

1

));

2818

1

		assert_ok!(add_supported_asset(source_location, 0));

2819

1

});

2820

1

2821

1

	Statemint::execute_with(|| {

2822

1

		// Set new prefix

2823

1

		statemint_like::PrefixChanger::set_prefix(

2824

1

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

2825

1

);

2826

1

		assert_ok!(StatemintAssets::create(

2827

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2828

1

0,

2829

1

			RELAYALICE,

2830

1

2831

1

));

2832

2833

1

		assert_ok!(StatemintAssets::mint(

2834

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2835

1

0,

2836

1

			RELAYALICE,

2837

1

			300000000000000

2838

1

));

2839

2840

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

2841

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2842

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2843

1

			sov,

2844

1

			100000000000000

2845

1

));

2846

2847

		// Actually send relay asset to parachain

2848

1

		let dest: Location = AccountKey20 {

2849

1

			network: None,

2850

1

			key: PARAALICE,

2851

1

2852

1

		.into();

2853

1

2854

1

		// Send asset with previous prefix

2855

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2856

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2857

1

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

2858

1

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

2859

1

			Box::new(

2860

1

2861

1

2862

1

						xcm::latest::prelude::PalletInstance(

2863

1

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

2864

1

),

2865

1

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

2866

1

],

2867

1

2868

1

2869

1

					.into()

2870

1

),

2871

1

0,

2872

1

			WeightLimit::Unlimited

2873

1

));

2874

1

});

2875

1

2876

1

	ParaA::execute_with(|| {

2877

1

		assert_eq!(

2878

1

			EvmForeignAssets::balance(source_id, PARAALICE.into()),

2879

1

			Ok(U256::from(123))

2880

1

);

2881

1

});

2882

1

2883

2884

#[test]

2885

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2886

1

	MockNet::reset();

2887

1

2888

1

	// Relay asset

2889

1

	let relay_location = Location::parent();

2890

1

	let relay_location_v3 =

2891

1

		match xcm::VersionedLocation::V5(relay_location.clone()).into_version(xcm::v3::VERSION) {

2892

1

			Ok(xcm::VersionedLocation::V3(loc)) => loc.into(),

2893

			_ => panic!("Failed to convert relay location to v3"),

2894

};

2895

1

	let relay_asset_type = parachain::AssetType::Xcm(relay_location_v3);

2896

1

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

2897

1

2898

1

	let relay_asset_metadata = parachain::AssetMetadata {

2899

1

		name: b"RelayToken".to_vec(),

2900

1

		symbol: b"Relay".to_vec(),

2901

1

		decimals: 12,

2902

1

};

2903

1

2904

1

	// Statemint asset

2905

1

	let statemint_asset = Location::new(

2906

1

1,

2907

1

2908

1

			Parachain(1000u32),

2909

1

			PalletInstance(5u8),

2910

1

			GeneralIndex(10u128),

2911

1

],

2912

1

);

2913

1

	let statemint_location_asset: AssetType = statemint_asset

2914

1

		.clone()

2915

1

		.try_into()

2916

1

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

2917

1

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

2918

1

2919

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2920

1

		name: b"USDC".to_vec(),

2921

1

		symbol: b"USDC".to_vec(),

2922

1

		decimals: 12,

2923

1

};

2924

1

2925

1

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

2926

1

2927

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2928

1

		polkadot_parachain::primitives::Sibling,

2929

1

		statemint_like::AccountId,

2930

1

	>::convert_location(&dest_para)

2931

1

	.unwrap();

2932

1

2933

1

	ParaA::execute_with(|| {

2934

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2935

1

			source_relay_id,

2936

1

			relay_location.clone(),

2937

1

			relay_asset_metadata.decimals,

2938

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

2939

1

			relay_asset_metadata.name.try_into().expect("too long"),

2940

1

));

2941

1

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

2942

2943

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2944

1

			source_statemint_asset_id,

2945

1

			statemint_asset.clone(),

2946

1

			asset_metadata_statemint_asset.decimals,

2947

1

			asset_metadata_statemint_asset

2948

1

				.symbol

2949

1

				.try_into()

2950

1

				.expect("too long"),

2951

1

			asset_metadata_statemint_asset

2952

1

				.name

2953

1

				.try_into()

2954

1

				.expect("too long"),

2955

1

));

2956

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0));

2957

1

});

2958

1

2959

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2960

1

		network: None,

2961

1

		key: PARAALICE,

2962

1

2963

1

	.into();

2964

1

2965

1

	// Send relay chain asset to Alice in Parachain A

2966

1

	Relay::execute_with(|| {

2967

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2968

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2969

1

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

2970

1

			Box::new(

2971

1

				VersionedLocation::from(parachain_beneficiary_from_relay)

2972

1

					.clone()

2973

1

					.into()

2974

1

),

2975

1

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

2976

1

0,

2977

1

			WeightLimit::Unlimited

2978

1

));

2979

1

});

2980

1

2981

1

	Statemint::execute_with(|| {

2982

1

		// Set new prefix

2983

1

		statemint_like::PrefixChanger::set_prefix(

2984

1

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

2985

1

);

2986

1

2987

1

		assert_ok!(StatemintAssets::create(

2988

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2989

1

10,

2990

1

			RELAYALICE,

2991

1

2992

1

));

2993

2994

1

		assert_ok!(StatemintAssets::mint(

2995

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2996

1

10,

2997

1

			RELAYALICE,

2998

1

			300000000000000

2999

1

));

3000

3001

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

3002

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

3003

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3004

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3005

1

			sov,

3006

1

			100000000000000

3007

1

));

3008

3009

		// Send statemint USDC asset to Alice in Parachain A

3010

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

3011

1

			network: None,

3012

1

			key: PARAALICE,

3013

1

3014

1

		.into();

3015

1

3016

1

		// Send with new prefix

3017

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3018

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3019

1

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

3020

1

			Box::new(

3021

1

				VersionedLocation::from(parachain_beneficiary_from_statemint)

3022

1

					.clone()

3023

1

					.into()

3024

1

),

3025

1

			Box::new(

3026

1

3027

1

3028

1

						xcm::latest::prelude::PalletInstance(

3029

1

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

3030

1

),

3031

1

						GeneralIndex(10),

3032

1

],

3033

1

3034

1

3035

1

					.into()

3036

1

),

3037

1

0,

3038

1

			WeightLimit::Unlimited

3039

1

));

3040

1

});

3041

1

3042

1

	let statemint_beneficiary = Location {

3043

1

		parents: 1,

3044

1

		interior: [

3045

1

			Parachain(1000),

3046

1

			AccountId32 {

3047

1

				network: None,

3048

1

				id: RELAYBOB.into(),

3049

1

},

3050

1

3051

1

		.into(),

3052

1

};

3053

1

3054

1

	ParaA::execute_with(|| {

3055

1

		// Alice has received 125 USDC

3056

1

		assert_eq!(

3057

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

3058

1

			Ok(U256::from(125))

3059

1

);

3060

3061

		// Alice has received 200 Relay assets

3062

1

		assert_eq!(

3063

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3064

1

			Ok(U256::from(200))

3065

1

);

3066

1

});

3067

1

3068

1

	Statemint::execute_with(|| {

3069

1

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

3070

1

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

3071

1

});

3072

1

3073

1

	let (chain_part, beneficiary) =

3074

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

3075

1

3076

1

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

3077

1

	ParaA::execute_with(|| {

3078

1

		let asset = currency_to_asset(

3079

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3080

1

			100,

3081

1

);

3082

1

		let asset_fee =

3083

1

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

3084

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3085

1

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

3086

1

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

3087

1

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

3088

1

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

3089

1

0,

3090

1

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

3091

1

));

3092

1

});

3093

1

3094

1

	ParaA::execute_with(|| {

3095

1

		// Alice has 100 USDC less

3096

1

		assert_eq!(

3097

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

3098

1

			Ok(U256::from(25))

3099

1

);

3100

3101

		// Alice has 100 relay asset less

3102

1

		assert_eq!(

3103

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3104

1

			Ok(U256::from(100))

3105

1

);

3106

1

});

3107

1

3108

1

	Statemint::execute_with(|| {

3109

1

		// Check that BOB received 100 USDC on statemint

3110

1

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

3111

1

});

3112

1

3113

3114

#[test]

3115

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3116

1

	MockNet::reset();

3117

1

3118

1

	// Relay asset

3119

1

	let relay_location_v3 = xcm::v3::Location::parent();

3120

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3121

1

	let relay_location_v5 = Location::parent();

3122

1

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

3123

1

3124

1

	let relay_asset_metadata = parachain::AssetMetadata {

3125

1

		name: b"RelayToken".to_vec(),

3126

1

		symbol: b"Relay".to_vec(),

3127

1

		decimals: 12,

3128

1

};

3129

1

3130

1

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

3131

1

3132

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3133

1

		polkadot_parachain::primitives::Sibling,

3134

1

		statemint_like::AccountId,

3135

1

	>::convert_location(&dest_para)

3136

1

	.unwrap();

3137

1

3138

1

	ParaA::execute_with(|| {

3139

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3140

1

			source_relay_id,

3141

1

			relay_location_v5.clone(),

3142

1

			relay_asset_metadata.decimals,

3143

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3144

1

			relay_asset_metadata.name.try_into().expect("too long"),

3145

1

));

3146

1

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

3147

1

});

3148

1

3149

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3150

1

		network: None,

3151

1

		key: PARAALICE,

3152

1

3153

1

	.into();

3154

1

3155

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3156

1

		network: None,

3157

1

		id: RELAYALICE.into(),

3158

1

3159

1

	.into();

3160

1

3161

1

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

3162

1

	Relay::execute_with(|| {

3163

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3164

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3165

1

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

3166

1

			Box::new(

3167

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3168

1

					.clone()

3169

1

					.into()

3170

1

),

3171

1

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

3172

1

0,

3173

1

			WeightLimit::Unlimited

3174

1

));

3175

1

});

3176

1

3177

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3178

1

	Statemint::execute_with(|| {

3179

1

		// Check Alice received 200 tokens on AssetHub

3180

1

		assert_eq!(

3181

1

			StatemintBalances::free_balance(RELAYALICE),

3182

1

			INITIAL_BALANCE + 200

3183

1

);

3184

3185

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3186

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3187

1

			sov,

3188

1

			110000000000000

3189

1

));

3190

3191

		// Now send those tokens to ParaA

3192

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3193

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3194

1

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

3195

1

			Box::new(

3196

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3197

1

					.clone()

3198

1

					.into()

3199

1

),

3200

1

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

3201

1

0,

3202

1

			WeightLimit::Unlimited

3203

1

));

3204

1

});

3205

1

3206

1

	ParaA::execute_with(|| {

3207

1

		// Alice should have received the DOTs

3208

1

		assert_eq!(

3209

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3210

1

			Ok(U256::from(200))

3211

1

);

3212

1

});

3213

1

3214

1

	let dest = Location::new(

3215

1

1,

3216

1

3217

1

			Parachain(1000),

3218

1

			AccountId32 {

3219

1

				network: None,

3220

1

				id: RELAYBOB.into(),

3221

1

},

3222

1

],

3223

1

);

3224

1

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

3225

1

3226

1

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

3227

1

	ParaA::execute_with(|| {

3228

1

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

3229

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3230

1

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

3231

1

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

3232

1

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

3233

1

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

3234

1

0,

3235

1

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

3236

1

));

3237

3238

1

		assert_eq!(

3239

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3240

1

			Ok(U256::from(100))

3241

1

);

3242

1

});

3243

1

3244

1

	Statemint::execute_with(|| {

3245

1

		// Check that Bob received the tokens back in AssetHub

3246

1

		assert_eq!(

3247

1

			StatemintBalances::free_balance(RELAYBOB),

3248

1

			INITIAL_BALANCE + 100

3249

1

);

3250

1

});

3251

1

3252

1

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

3253

1

	Statemint::execute_with(|| {

3254

1

		// Now send those tokens to ParaA

3255

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3256

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3257

1

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

3258

1

			Box::new(

3259

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3260

1

					.clone()

3261

1

					.into()

3262

1

),

3263

1

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

3264

1

0,

3265

1

			WeightLimit::Unlimited

3266

1

));

3267

3268

		// 100 DOTs were deducted from Bob's account

3269

1

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

3270

1

});

3271

1

3272

1

	ParaA::execute_with(|| {

3273

1

		// Alice should have received 100 DOTs

3274

1

		assert_eq!(

3275

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3276

1

			Ok(U256::from(200))

3277

1

);

3278

1

});

3279

1

3280

3281

#[test]

3282

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3283

1

	MockNet::reset();

3284

1

3285

1

	// Relay asset

3286

1

	let relay_location_v3 = xcm::v3::Location::parent();

3287

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3288

1

	let relay_location_v5 = Location::parent();

3289

1

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

3290

1

3291

1

	let relay_asset_metadata = parachain::AssetMetadata {

3292

1

		name: b"RelayToken".to_vec(),

3293

1

		symbol: b"Relay".to_vec(),

3294

1

		decimals: 12,

3295

1

};

3296

1

3297

1

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

3298

1

3299

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3300

1

		polkadot_parachain::primitives::Sibling,

3301

1

		statemint_like::AccountId,

3302

1

	>::convert_location(&dest_para)

3303

1

	.unwrap();

3304

1

3305

1

	ParaA::execute_with(|| {

3306

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3307

1

			source_relay_id,

3308

1

			relay_location_v5.clone(),

3309

1

			relay_asset_metadata.decimals,

3310

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3311

1

			relay_asset_metadata.name.try_into().expect("too long"),

3312

1

));

3313

1

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

3314

1

});

3315

1

3316

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3317

1

		network: None,

3318

1

		key: PARAALICE,

3319

1

3320

1

	.into();

3321

1

3322

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3323

1

		network: None,

3324

1

		id: RELAYALICE.into(),

3325

1

3326

1

	.into();

3327

1

3328

1

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

3329

1

	Relay::execute_with(|| {

3330

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3331

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3332

1

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

3333

1

			Box::new(

3334

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3335

1

					.clone()

3336

1

					.into()

3337

1

),

3338

1

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

3339

1

0,

3340

1

			WeightLimit::Unlimited

3341

1

));

3342

1

});

3343

1

3344

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3345

1

	Statemint::execute_with(|| {

3346

1

		// Check Alice received 200 tokens on AssetHub

3347

1

		assert_eq!(

3348

1

			StatemintBalances::free_balance(RELAYALICE),

3349

1

			INITIAL_BALANCE + 200

3350

1

);

3351

3352

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3353

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3354

1

			sov,

3355

1

			110000000000000

3356

1

));

3357

3358

		// Now send those tokens to ParaA

3359

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3360

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3361

1

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

3362

1

			Box::new(

3363

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3364

1

					.clone()

3365

1

					.into()

3366

1

),

3367

1

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

3368

1

0,

3369

1

			WeightLimit::Unlimited

3370

1

));

3371

1

});

3372

1

3373

1

	ParaA::execute_with(|| {

3374

1

		// Alice should have received the DOTs

3375

1

		assert_eq!(

3376

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3377

1

			Ok(U256::from(200))

3378

1

);

3379

1

});

3380

1

3381

1

	let dest = Location::new(

3382

1

1,

3383

1

3384

1

			Parachain(1000),

3385

1

			AccountId32 {

3386

1

				network: None,

3387

1

				id: RELAYBOB.into(),

3388

1

},

3389

1

],

3390

1

);

3391

1

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

3392

1

3393

1

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

3394

1

	ParaA::execute_with(|| {

3395

1

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

3396

1

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

3397

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3398

1

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

3399

1

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

3400

1

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

3401

1

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

3402

1

0,

3403

1

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

3404

1

));

3405

3406

1

		assert_eq!(

3407

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3408

1

			Ok(U256::from(90))

3409

1

);

3410

1

});

3411

1

3412

1

	Statemint::execute_with(|| {

3413

1

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

3414

1

		assert_eq!(

3415

1

			StatemintBalances::free_balance(RELAYBOB),

3416

1

			INITIAL_BALANCE + 110

3417

1

);

3418

1

});

3419

1

3420

1

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

3421

1

	Statemint::execute_with(|| {

3422

1

		// Now send those tokens to ParaA

3423

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3424

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3425

1

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

3426

1

			Box::new(

3427

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3428

1

					.clone()

3429

1

					.into()

3430

1

),

3431

1

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

3432

1

0,

3433

1

			WeightLimit::Unlimited

3434

1

));

3435

3436

		// 100 DOTs were deducted from Bob's account

3437

1

		assert_eq!(

3438

1

			StatemintBalances::free_balance(RELAYBOB),

3439

1

			INITIAL_BALANCE + 10

3440

1

);

3441

1

});

3442

1

3443

1

	ParaA::execute_with(|| {

3444

1

		// Alice should have received 100 DOTs

3445

1

		assert_eq!(

3446

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3447

1

			Ok(U256::from(190))

3448

1

);

3449

1

});

3450

1

3451

3452

#[test]

3453

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3454

1

	MockNet::reset();

3455

1

3456

1

	// Relay asset

3457

1

	let relay_location_v3 = xcm::v3::Location::parent();

3458

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3459

1

	let relay_location_v5 = Location::parent();

3460

1

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

3461

1

3462

1

	let relay_asset_metadata = parachain::AssetMetadata {

3463

1

		name: b"RelayToken".to_vec(),

3464

1

		symbol: b"Relay".to_vec(),

3465

1

		decimals: 12,

3466

1

};

3467

1

3468

1

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

3469

1

3470

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3471

1

		polkadot_parachain::primitives::Sibling,

3472

1

		statemint_like::AccountId,

3473

1

	>::convert_location(&dest_para)

3474

1

	.unwrap();

3475

1

3476

1

	ParaA::execute_with(|| {

3477

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3478

1

			source_relay_id,

3479

1

			relay_location_v5.clone(),

3480

1

			relay_asset_metadata.decimals,

3481

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3482

1

			relay_asset_metadata.name.try_into().expect("too long"),

3483

1

));

3484

1

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

3485

1

});

3486

1

3487

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3488

1

		network: None,

3489

1

		key: PARAALICE,

3490

1

3491

1

	.into();

3492

1

3493

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3494

1

		network: None,

3495

1

		id: RELAYALICE.into(),

3496

1

3497

1

	.into();

3498

1

3499

1

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

3500

1

	Relay::execute_with(|| {

3501

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3502

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3503

1

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

3504

1

			Box::new(

3505

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3506

1

					.clone()

3507

1

					.into()

3508

1

),

3509

1

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

3510

1

0,

3511

1

			WeightLimit::Unlimited

3512

1

));

3513

1

});

3514

1

3515

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3516

1

	Statemint::execute_with(|| {

3517

1

		// Check Alice received 200 tokens on AssetHub

3518

1

		assert_eq!(

3519

1

			StatemintBalances::free_balance(RELAYALICE),

3520

1

			INITIAL_BALANCE + 200

3521

1

);

3522

3523

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3524

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3525

1

			sov,

3526

1

			110000000000000

3527

1

));

3528

3529

		// Now send those tokens to ParaA

3530

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3531

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3532

1

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

3533

1

			Box::new(

3534

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3535

1

					.clone()

3536

1

					.into()

3537

1

),

3538

1

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

3539

1

0,

3540

1

			WeightLimit::Unlimited

3541

1

));

3542

1

});

3543

1

3544

1

	ParaA::execute_with(|| {

3545

1

		// Alice should have received the DOTs

3546

1

		assert_eq!(

3547

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3548

1

			Ok(U256::from(200))

3549

1

);

3550

1

});

3551

1

3552

1

	let dest = Location::new(

3553

1

1,

3554

1

3555

1

			Parachain(1000),

3556

1

			AccountId32 {

3557

1

				network: None,

3558

1

				id: RELAYBOB.into(),

3559

1

},

3560

1

],

3561

1

);

3562

1

3563

1

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

3564

1

	let asset = Asset {

3565

1

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

3566

1

		fun: Fungibility::Fungible(100),

3567

1

};

3568

1

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

3569

1

	ParaA::execute_with(|| {

3570

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3571

1

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

3572

1

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

3573

1

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

3574

1

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

3575

1

0,

3576

1

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

3577

1

));

3578

3579

1

		assert_eq!(

3580

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3581

1

			Ok(U256::from(100))

3582

1

);

3583

1

});

3584

1

3585

1

	Statemint::execute_with(|| {

3586

1

		// Check that Bob received the tokens back in AssetHub

3587

1

		assert_eq!(

3588

1

			StatemintBalances::free_balance(RELAYBOB),

3589

1

			INITIAL_BALANCE + 100

3590

1

);

3591

1

});

3592

1

3593

1

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

3594

1

	Statemint::execute_with(|| {

3595

1

		// Now send those tokens to ParaA

3596

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3597

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3598

1

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

3599

1

			Box::new(

3600

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3601

1

					.clone()

3602

1

					.into()

3603

1

),

3604

1

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

3605

1

0,

3606

1

			WeightLimit::Unlimited

3607

1

));

3608

3609

		// 100 DOTs were deducted from Bob's account

3610

1

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

3611

1

});

3612

1

3613

1

	ParaA::execute_with(|| {

3614

1

		// Alice should have received 100 DOTs

3615

1

		assert_eq!(

3616

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3617

1

			Ok(U256::from(200))

3618

1

);

3619

1

});

3620

1

3621

3622

#[test]

3623

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3624

1

	MockNet::reset();

3625

1

3626

1

	// Relay asset

3627

1

	let relay_location_v3 = xcm::v3::Location::parent();

3628

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3629

1

	let relay_location_v5 = Location::parent();

3630

1

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

3631

1

3632

1

	let relay_asset_metadata = parachain::AssetMetadata {

3633

1

		name: b"RelayToken".to_vec(),

3634

1

		symbol: b"Relay".to_vec(),

3635

1

		decimals: 12,

3636

1

};

3637

1

3638

1

	// Statemint asset

3639

1

	let statemint_asset = Location::new(

3640

1

1,

3641

1

3642

1

			Parachain(1000u32),

3643

1

			PalletInstance(5u8),

3644

1

			GeneralIndex(10u128),

3645

1

],

3646

1

);

3647

1

	let statemint_location_asset: AssetType = statemint_asset

3648

1

		.clone()

3649

1

		.try_into()

3650

1

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

3651

1

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

3652

1

3653

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3654

1

		name: b"USDC".to_vec(),

3655

1

		symbol: b"USDC".to_vec(),

3656

1

		decimals: 12,

3657

1

};

3658

1

3659

1

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

3660

1

3661

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3662

1

		polkadot_parachain::primitives::Sibling,

3663

1

		statemint_like::AccountId,

3664

1

	>::convert_location(&dest_para)

3665

1

	.unwrap();

3666

1

3667

1

	ParaA::execute_with(|| {

3668

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3669

1

			source_relay_id,

3670

1

			relay_location_v5.clone(),

3671

1

			relay_asset_metadata.decimals,

3672

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3673

1

			relay_asset_metadata.name.try_into().expect("too long"),

3674

1

));

3675

1

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

3676

1

3677

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3678

1

			source_statemint_asset_id,

3679

1

			statemint_asset.clone(),

3680

1

			asset_metadata_statemint_asset.decimals,

3681

1

			asset_metadata_statemint_asset

3682

1

				.symbol

3683

1

				.try_into()

3684

1

				.expect("too long"),

3685

1

			asset_metadata_statemint_asset

3686

1

				.name

3687

1

				.try_into()

3688

1

				.expect("too long"),

3689

1

));

3690

1

		XcmWeightTrader::set_asset_price(statemint_asset, 0u128);

3691

1

});

3692

1

3693

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3694

1

		network: None,

3695

1

		key: PARAALICE,

3696

1

3697

1

	.into();

3698

1

3699

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3700

1

		network: None,

3701

1

		id: RELAYALICE.into(),

3702

1

3703

1

	.into();

3704

1

3705

1

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

3706

1

	Relay::execute_with(|| {

3707

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3708

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3709

1

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

3710

1

			Box::new(

3711

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3712

1

					.clone()

3713

1

					.into()

3714

1

),

3715

1

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

3716

1

0,

3717

1

			WeightLimit::Unlimited

3718

1

));

3719

1

});

3720

1

3721

1

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

3722

1

	Statemint::execute_with(|| {

3723

1

		// Check Alice received 200 tokens on AssetHub

3724

1

		assert_eq!(

3725

1

			StatemintBalances::free_balance(RELAYALICE),

3726

1

			INITIAL_BALANCE + 200

3727

1

);

3728

3729

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3730

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3731

1

			sov,

3732

1

			110000000000000

3733

1

));

3734

3735

1

		statemint_like::PrefixChanger::set_prefix(

3736

1

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

3737

1

);

3738

1

3739

1

		assert_ok!(StatemintAssets::create(

3740

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3741

1

10,

3742

1

			RELAYALICE,

3743

1

3744

1

));

3745

3746

1

		assert_ok!(StatemintAssets::mint(

3747

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3748

1

10,

3749

1

			RELAYALICE,

3750

1

			300000000000000

3751

1

));

3752

3753

		// Now send relay tokens to ParaA

3754

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3755

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3756

1

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

3757

1

			Box::new(

3758

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3759

1

					.clone()

3760

1

					.into()

3761

1

),

3762

1

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

3763

1

0,

3764

1

			WeightLimit::Unlimited

3765

1

));

3766

3767

		// Send USDC

3768

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3769

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3770

1

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

3771

1

			Box::new(

3772

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3773

1

					.clone()

3774

1

					.into()

3775

1

),

3776

1

			Box::new(

3777

1

3778

1

3779

1

						xcm::latest::prelude::PalletInstance(

3780

1

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

3781

1

),

3782

1

						GeneralIndex(10),

3783

1

],

3784

1

3785

1

3786

1

					.into()

3787

1

),

3788

1

0,

3789

1

			WeightLimit::Unlimited

3790

1

));

3791

1

});

3792

1

3793

1

	ParaA::execute_with(|| {

3794

1

		// Alice should have received the DOTs

3795

1

		assert_eq!(

3796

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3797

1

			Ok(U256::from(200))

3798

1

);

3799

3800

		// Alice has received 125 USDC

3801

1

		assert_eq!(

3802

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

3803

1

			Ok(U256::from(125))

3804

1

);

3805

1

});

3806

1

3807

1

	let dest = Location::new(

3808

1

1,

3809

1

3810

1

			Parachain(1000),

3811

1

			AccountId32 {

3812

1

				network: None,

3813

1

				id: RELAYBOB.into(),

3814

1

},

3815

1

],

3816

1

);

3817

1

3818

1

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

3819

1

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

3820

1

	ParaA::execute_with(|| {

3821

1

		let asset = currency_to_asset(

3822

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3823

1

			100,

3824

1

);

3825

1

		let asset_fee =

3826

1

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

3827

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3828

1

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

3829

1

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

3830

1

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

3831

1

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

3832

1

0,

3833

1

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

3834

1

));

3835

3836

1

		assert_eq!(

3837

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3838

1

			Ok(U256::from(100))

3839

1

);

3840

1

});

3841

1

3842

1

	Statemint::execute_with(|| {

3843

1

		// Check that Bob received relay tokens back in AssetHub

3844

1

		assert_eq!(

3845

1

			StatemintBalances::free_balance(RELAYBOB),

3846

1

			INITIAL_BALANCE + 100

3847

1

);

3848

3849

		// Check that BOB received 100 USDC on AssetHub

3850

1

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

3851

1

});

3852

1

3853

1

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

3854

1

	Statemint::execute_with(|| {

3855

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3856

1

3857

1

		// Now send those tokens to ParaA

3858

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3859

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3860

1

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

3861

1

			Box::new(

3862

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3863

1

					.clone()

3864

1

					.into()

3865

1

),

3866

1

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

3867

1

0,

3868

1

			WeightLimit::Unlimited

3869

1

));

3870

3871

		// 100 DOTs were deducted from Bob's account

3872

1

		assert_eq!(

3873

1

			StatemintBalances::free_balance(RELAYBOB),

3874

1

			bob_previous_balance - 100

3875

1

);

3876

1

});

3877

1

3878

1

	ParaA::execute_with(|| {

3879

1

		// Alice should have received 100 DOTs

3880

1

		assert_eq!(

3881

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3882

1

			Ok(U256::from(200))

3883

1

);

3884

1

});

3885

1

3886

3887

#[test]

3888

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3889

1

	MockNet::reset();

3890

1

3891

1

	// Relay asset

3892

1

	let relay_location_v3 = xcm::v3::Location::parent();

3893

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3894

1

	let relay_location_v5 = Location::parent();

3895

1

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

3896

1

3897

1

	let relay_asset_metadata = parachain::AssetMetadata {

3898

1

		name: b"RelayToken".to_vec(),

3899

1

		symbol: b"Relay".to_vec(),

3900

1

		decimals: 12,

3901

1

};

3902

1

3903

1

	// Statemint asset

3904

1

	let statemint_asset = Location::new(

3905

1

1,

3906

1

3907

1

			Parachain(1000u32),

3908

1

			PalletInstance(5u8),

3909

1

			GeneralIndex(10u128),

3910

1

],

3911

1

);

3912

1

	let statemint_location_asset: AssetType = statemint_asset

3913

1

		.clone()

3914

1

		.try_into()

3915

1

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

3916

1

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

3917

1

3918

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3919

1

		name: b"USDC".to_vec(),

3920

1

		symbol: b"USDC".to_vec(),

3921

1

		decimals: 12,

3922

1

};

3923

1

3924

1

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

3925

1

3926

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3927

1

		polkadot_parachain::primitives::Sibling,

3928

1

		statemint_like::AccountId,

3929

1

	>::convert_location(&dest_para)

3930

1

	.unwrap();

3931

1

3932

1

	ParaA::execute_with(|| {

3933

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3934

1

			source_relay_id,

3935

1

			relay_location_v5.clone(),

3936

1

			relay_asset_metadata.decimals,

3937

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3938

1

			relay_asset_metadata.name.try_into().expect("too long"),

3939

1

));

3940

1

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

3941

1

3942

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3943

1

			source_statemint_asset_id,

3944

1

			statemint_asset.clone(),

3945

1

			asset_metadata_statemint_asset.decimals,

3946

1

			asset_metadata_statemint_asset

3947

1

				.symbol

3948

1

				.try_into()

3949

1

				.expect("too long"),

3950

1

			asset_metadata_statemint_asset

3951

1

				.name

3952

1

				.try_into()

3953

1

				.expect("too long"),

3954

1

));

3955

1

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

3956

1

});

3957

1

3958

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3959

1

		network: None,

3960

1

		key: PARAALICE,

3961

1

3962

1

	.into();

3963

1

3964

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3965

1

		network: None,

3966

1

		id: RELAYALICE.into(),

3967

1

3968

1

	.into();

3969

1

3970

1

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

3971

1

	Relay::execute_with(|| {

3972

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3973

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3974

1

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

3975

1

			Box::new(

3976

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3977

1

					.clone()

3978

1

					.into()

3979

1

),

3980

1

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

3981

1

0,

3982

1

			WeightLimit::Unlimited

3983

1

));

3984

1

});

3985

1

3986

1

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

3987

1

	Statemint::execute_with(|| {

3988

1

		// Check Alice received 200 tokens on AssetHub

3989

1

		assert_eq!(

3990

1

			StatemintBalances::free_balance(RELAYALICE),

3991

1

			INITIAL_BALANCE + 200

3992

1

);

3993

3994

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3995

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3996

1

			sov,

3997

1

			110000000000000

3998

1

));

3999

4000

1

		statemint_like::PrefixChanger::set_prefix(

4001

1

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

4002

1

);

4003

1

4004

1

		assert_ok!(StatemintAssets::create(

4005

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4006

1

10,

4007

1

			RELAYALICE,

4008

1

4009

1

));

4010

4011

1

		assert_ok!(StatemintAssets::mint(

4012

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4013

1

10,

4014

1

			RELAYALICE,

4015

1

			300000000000000

4016

1

));

4017

4018

		// Now send relay tokens to ParaA

4019

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

4020

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4021

1

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

4022

1

			Box::new(

4023

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

4024

1

					.clone()

4025

1

					.into()

4026

1

),

4027

1

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

4028

1

0,

4029

1

			WeightLimit::Unlimited

4030

1

));

4031

4032

		// Send USDC

4033

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

4034

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4035

1

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

4036

1

			Box::new(

4037

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

4038

1

					.clone()

4039

1

					.into()

4040

1

),

4041

1

			Box::new(

4042

1

4043

1

4044

1

						xcm::latest::prelude::PalletInstance(

4045

1

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

4046

1

),

4047

1

						GeneralIndex(10),

4048

1

],

4049

1

4050

1

4051

1

					.into()

4052

1

),

4053

1

0,

4054

1

			WeightLimit::Unlimited

4055

1

));

4056

1

});

4057

1

4058

1

	ParaA::execute_with(|| {

4059

1

		// Alice should have received the DOTs

4060

1

		assert_eq!(

4061

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4062

1

			Ok(U256::from(200))

4063

1

);

4064

4065

		// Alice has received 125 USDC

4066

1

		assert_eq!(

4067

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4068

1

			Ok(U256::from(125))

4069

1

);

4070

1

});

4071

1

4072

1

	let dest = Location::new(

4073

1

1,

4074

1

4075

1

			Parachain(1000),

4076

1

			AccountId32 {

4077

1

				network: None,

4078

1

				id: RELAYBOB.into(),

4079

1

},

4080

1

],

4081

1

);

4082

1

4083

1

	let statemint_asset_to_send = Asset {

4084

1

		id: AssetId(statemint_asset),

4085

1

		fun: Fungibility::Fungible(100),

4086

1

};

4087

1

4088

1

	let relay_asset_to_send = Asset {

4089

1

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

4090

1

		fun: Fungibility::Fungible(100),

4091

1

};

4092

1

4093

1

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

4094

1

	let assets_to_send: XcmAssets =

4095

1

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

4096

1

4097

1

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

4098

1

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

4099

1

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

4100

4101

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

4102

1

	ParaA::execute_with(|| {

4103

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

4104

1

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

4105

1

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

4106

1

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

4107

1

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

4108

1

0,

4109

1

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

4110

1

));

4111

4112

1

		assert_eq!(

4113

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4114

1

			Ok(U256::from(100))

4115

1

);

4116

1

});

4117

1

4118

1

	Statemint::execute_with(|| {

4119

1

		// Check that Bob received relay tokens back in AssetHub

4120

1

		assert_eq!(

4121

1

			StatemintBalances::free_balance(RELAYBOB),

4122

1

			INITIAL_BALANCE + 100

4123

1

);

4124

4125

		// Check that BOB received 100 USDC on AssetHub

4126

1

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

4127

1

});

4128

1

4129

1

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

4130

1

	Statemint::execute_with(|| {

4131

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4132

1

4133

1

		// Now send those tokens to ParaA

4134

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

4135

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

4136

1

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

4137

1

			Box::new(

4138

1

				VersionedLocation::from(parachain_beneficiary_absolute)

4139

1

					.clone()

4140

1

					.into()

4141

1

),

4142

1

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

4143

1

0,

4144

1

			WeightLimit::Unlimited

4145

1

));

4146

4147

		// 100 DOTs were deducted from Bob's account

4148

1

		assert_eq!(

4149

1

			StatemintBalances::free_balance(RELAYBOB),

4150

1

			bob_previous_balance - 100

4151

1

);

4152

1

});

4153

1

4154

1

	ParaA::execute_with(|| {

4155

1

		// Alice should have received 100 DOTs

4156

1

		assert_eq!(

4157

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4158

1

			Ok(U256::from(200))

4159

1

);

4160

1

});

4161

1

4162

4163

#[test]

4164

1

fn transact_through_signed_multilocation() {

4165

1

	MockNet::reset();

4166

1

	let mut ancestry = Location::parent();

4167

1

4168

1

	ParaA::execute_with(|| {

4169

1

		// Root can set transact info

4170

1

		assert_ok!(XcmTransactor::set_transact_info(

4171

1

			parachain::RuntimeOrigin::root(),

4172

1

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

4173

1

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

4174

1

			3000.into(),

4175

1

			20000000000.into(),

4176

1

			// 4 instructions in transact through signed

4177

1

			Some(4000.into())

4178

1

));

4179

		// Root can set transact info

4180

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4181

1

			parachain::RuntimeOrigin::root(),

4182

1

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

4183

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

4184

1

));

4185

1

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

4186

1

});

4187

1

4188

1

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

4189

1

	let signed_origin: Junctions = [AccountKey20 {

4190

1

		network: None,

4191

1

		key: PARAALICE,

4192

1

}]

4193

1

	.into();

4194

1

4195

1

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

4196

1

	descend_origin_multilocation

4197

1

		.append_with(signed_origin)

4198

1

		.unwrap();

4199

1

4200

1

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

4201

1

	descend_origin_multilocation

4202

1

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

4203

1

		.unwrap();

4204

1

4205

1

	let derived = xcm_builder::Account32Hash::<

4206

1

		relay_chain::KusamaNetwork,

4207

1

		relay_chain::AccountId,

4208

1

	>::convert_location(&descend_origin_multilocation)

4209

1

	.unwrap();

4210

1

4211

1

	Relay::execute_with(|| {

4212

1

		// free execution, full amount received

4213

1

		assert_ok!(RelayBalances::transfer_allow_death(

4214

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4215

1

			derived.clone(),

4216

1

			4000004100u128,

4217

1

));

4218

		// derived account has all funds

4219

1

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

4220

		// sovereign account has 0 funds

4221

1

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

4222

1

});

4223

1

4224

1

	// Encode the call. Balances transact to para_a_account

4225

1

	// First index

4226

1

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

4227

1

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

4228

1

		relay_chain::Balances,

4229

1

>()

4230

1

	.unwrap() as u8;

4231

1

4232

1

	encoded.push(index);

4233

1

4234

1

	// Then call bytes

4235

1

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

4236

1

		// 100 to sovereign

4237

1

		dest: para_a_account(),

4238

1

		value: 100u32.into(),

4239

1

4240

1

	.encode();

4241

1

	encoded.append(&mut call_bytes);

4242

1

4243

1

	ParaA::execute_with(|| {

4244

1

		assert_ok!(XcmTransactor::transact_through_signed(

4245

1

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

4246

1

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

4247

1

			CurrencyPayment {

4248

1

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

4249

1

					Location::parent()

4250

1

				))),

4251

1

				fee_amount: None

4252

1

},

4253

1

			encoded,

4254

1

			// 4000000000 for transfer + 4000 for XCM

4255

1

			TransactWeights {

4256

1

				transact_required_weight_at_most: 4000000000.into(),

4257

1

				overall_weight: None

4258

1

},

4259

1

			false

4260

1

));

4261

1

});

4262

1

4263

1

	Relay::execute_with(|| {

4264

1

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

4265

4266

1

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

4267

1

});

4268

1

4269

4270

#[test]

4271

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4272

1

	MockNet::reset();

4273

1

	let mut ancestry = Location::parent();

4274

1

4275

1

	ParaA::execute_with(|| {

4276

1

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

4277

1

});

4278

1

4279

1

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

4280

1

	let signed_origin: Junctions = [AccountKey20 {

4281

1

		network: None,

4282

1

		key: PARAALICE,

4283

1

}]

4284

1

	.into();

4285

1

4286

1

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

4287

1

	descend_origin_multilocation

4288

1

		.append_with(signed_origin)

4289

1

		.unwrap();

4290

1

4291

1

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

4292

1

	descend_origin_multilocation

4293

1

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

4294

1

		.unwrap();

4295

1

4296

1

	let derived = xcm_builder::Account32Hash::<

4297

1

		relay_chain::KusamaNetwork,

4298

1

		relay_chain::AccountId,

4299

1

	>::convert_location(&descend_origin_multilocation)

4300

1

	.unwrap();

4301

1

4302

1

	Relay::execute_with(|| {

4303

1

		// free execution, full amount received

4304

1

		assert_ok!(RelayBalances::transfer_allow_death(

4305

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4306

1

			derived.clone(),

4307

1

			4000004100u128,

4308

1

));

4309

		// derived account has all funds

4310

1

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

4311

		// sovereign account has 0 funds

4312

1

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

4313

1

});

4314

1

4315

1

	// Encode the call. Balances transact to para_a_account

4316

1

	// First index

4317

1

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

4318

1

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

4319

1

		relay_chain::Balances,

4320

1

>()

4321

1

	.unwrap() as u8;

4322

1

4323

1

	encoded.push(index);

4324

1

4325

1

	// Then call bytes

4326

1

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

4327

1

		// 100 to sovereign

4328

1

		dest: para_a_account(),

4329

1

		value: 100u32.into(),

4330

1

4331

1

	.encode();

4332

1

	encoded.append(&mut call_bytes);

4333

1

4334

1

	let total_weight = 4000004000u64;

4335

1

	ParaA::execute_with(|| {

4336

1

		assert_ok!(XcmTransactor::transact_through_signed(

4337

1

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

4338

1

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

4339

1

			CurrencyPayment {

4340

1

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

4341

1

					Location::parent()

4342

1

				))),

4343

1

				fee_amount: Some(total_weight as u128)

4344

1

},

4345

1

			encoded,

4346

1

			// 4000000000 for transfer + 4000 for XCM

4347

1

			TransactWeights {

4348

1

				transact_required_weight_at_most: 4000000000.into(),

4349

1

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

4350

1

},

4351

1

			false

4352

1

));

4353

1

});

4354

1

4355

1

	Relay::execute_with(|| {

4356

1

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

4357

4358

1

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

4359

1

});

4360

1

4361

4362

#[test]

4363

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4364

1

	MockNet::reset();

4365

1

	let mut ancestry = Location::parent();

4366

1

4367

1

	ParaA::execute_with(|| {

4368

1

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

4369

1

});

4370

1

4371

1

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

4372

1

	let signed_origin: Junctions = [AccountKey20 {

4373

1

		network: None,

4374

1

		key: PARAALICE,

4375

1

}]

4376

1

	.into();

4377

1

4378

1

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

4379

1

	descend_origin_multilocation

4380

1

		.append_with(signed_origin)

4381

1

		.unwrap();

4382

1

4383

1

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

4384

1

	descend_origin_multilocation

4385

1

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

4386

1

		.unwrap();

4387

1

4388

1

	let derived = xcm_builder::Account32Hash::<

4389

1

		relay_chain::KusamaNetwork,

4390

1

		relay_chain::AccountId,

4391

1

	>::convert_location(&descend_origin_multilocation)

4392

1

	.unwrap();

4393

1

4394

1

	Relay::execute_with(|| {

4395

1

		// free execution, full amount received

4396

1

		assert_ok!(RelayBalances::transfer_allow_death(

4397

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4398

1

			derived.clone(),

4399

1

			4000009100u128,

4400

1

));

4401

		// derived account has all funds

4402

1

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

4403

		// sovereign account has 0 funds

4404

1

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

4405

1

});

4406

1

4407

1

	// Encode the call. Balances transact to para_a_account

4408

1

	// First index

4409

1

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

4410

1

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

4411

1

		relay_chain::Balances,

4412

1

>()

4413

1

	.unwrap() as u8;

4414

1

4415

1

	encoded.push(index);

4416

1

4417

1

	// Then call bytes

4418

1

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

4419

1

		// 100 to sovereign

4420

1

		dest: para_a_account(),

4421

1

		value: 100u32.into(),

4422

1

4423

1

	.encode();

4424

1

	encoded.append(&mut call_bytes);

4425

1

4426

1

	let total_weight = 4000009000u64;

4427

1

	ParaA::execute_with(|| {

4428

1

		assert_ok!(XcmTransactor::transact_through_signed(

4429

1

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

4430

1

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

4431

1

			CurrencyPayment {

4432

1

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

4433

1

					Location::parent()

4434

1

				))),

4435

1

				fee_amount: Some(total_weight as u128)

4436

1

},

4437

1

			encoded,

4438

1

			// 4000000000 for transfer + 9000 for XCM

4439

1

			TransactWeights {

4440

1

				transact_required_weight_at_most: 4000000000.into(),

4441

1

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

4442

1

},

4443

1

			true

4444

1

));

4445

1

});

4446

1

4447

1

	Relay::execute_with(|| {

4448

1

		// 100 transferred

4449

1

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

4450

4451

		// 4000009000 refunded

4452

1

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

4453

1

});

4454

1

4455

4456

#[test]

4457

1

fn transact_through_signed_multilocation_para_to_para() {

4458

1

	frame_support::__private::sp_tracing::init_for_tests();

4459

1

	MockNet::reset();

4460

1

	let mut ancestry = Location::parent();

4461

1

4462

1

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

4463

1

4464

1

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

4465

1

4466

1

	ParaA::execute_with(|| {

4467

1

		// Root can set transact info

4468

1

		assert_ok!(XcmTransactor::set_transact_info(

4469

1

			parachain::RuntimeOrigin::root(),

4470

1

			// ParaB

4471

1

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

4472

1

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

4473

1

			3.into(),

4474

1

			20000000000.into(),

4475

1

			// 4 instructions in transact through signed

4476

1

			Some(4.into())

4477

1

));

4478

		// Root can set transact info

4479

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4480

1

			parachain::RuntimeOrigin::root(),

4481

1

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

4482

1

			parachain::ParaTokensPerSecond::get(),

4483

1

));

4484

1

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

4485

1

});

4486

1

4487

1

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

4488

1

	let signed_origin: Junctions = [AccountKey20 {

4489

1

		network: None,

4490

1

		key: PARAALICE,

4491

1

}]

4492

1

	.into();

4493

1

4494

1

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

4495

1

	descend_origin_multilocation

4496

1

		.append_with(signed_origin)

4497

1

		.unwrap();

4498

1

4499

1

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

4500

1

	descend_origin_multilocation

4501

1

		.reanchor(&para_b_location, &ancestry.interior)

4502

1

		.unwrap();

4503

1

4504

1

	let derived = xcm_builder::HashedDescription::<

4505

1

		parachain::AccountId,

4506

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4507

1

	>::convert_location(&descend_origin_multilocation)

4508

1

	.unwrap();

4509

1

4510

1

	ParaB::execute_with(|| {

4511

1

		// free execution, full amount received

4512

1

		assert_ok!(ParaBalances::transfer_allow_death(

4513

1

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

4514

1

			derived.clone(),

4515

1

			4000000104u128,

4516

1

));

4517

		// derived account has all funds

4518

1

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

4519

		// sovereign account has 0 funds

4520

1

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

4521

1

});

4522

1

4523

1

	// Encode the call. Balances transact to para_a_account

4524

1

	// First index

4525

1

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

4526

1

	let index =

4527

1

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

4528

1

			.unwrap() as u8;

4529

1

4530

1

	encoded.push(index);

4531

1

4532

1

	// Then call bytes

4533

1

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

4534

1

		// 100 to sovereign

4535

1

		dest: para_a_account_20(),

4536

1

		value: 100u32.into(),

4537

1

4538

1

	.encode();

4539

1

	encoded.append(&mut call_bytes);

4540

1

4541

1

	ParaA::execute_with(|| {

4542

1

		assert_ok!(XcmTransactor::transact_through_signed(

4543

1

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

4544

1

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

4545

1

			CurrencyPayment {

4546

1

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

4547

1

					para_b_balances

4548

1

				))),

4549

1

				fee_amount: None

4550

1

},

4551

1

			encoded,

4552

1

			// 4000000000 for transfer + 4000 for XCM

4553

1

			// 1-1 to fee

4554

1

			TransactWeights {

4555

1

				transact_required_weight_at_most: 4000000000.into(),

4556

1

				overall_weight: None

4557

1

},

4558

1

			false

4559

1

));

4560

1

});

4561

1

4562

1

	ParaB::execute_with(|| {

4563

1

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

4564

4565

1

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

4566

1

});

4567

1

4568

4569

#[test]

4570

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4571

1

	MockNet::reset();

4572

1

	let mut ancestry = Location::parent();

4573

1

4574

1

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

4575

1

4576

1

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

4577

1

4578

1

	ParaA::execute_with(|| {

4579

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4580

1

			parachain::RuntimeOrigin::root(),

4581

1

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

4582

1

			parachain::ParaTokensPerSecond::get(),

4583

1

));

4584

1

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

4585

1

});

4586

1

4587

1

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

4588

1

	let signed_origin: Junctions = [AccountKey20 {

4589

1

		network: None,

4590

1

		key: PARAALICE,

4591

1

}]

4592

1

	.into();

4593

1

4594

1

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

4595

1

	descend_origin_multilocation

4596

1

		.append_with(signed_origin)

4597

1

		.unwrap();

4598

1

4599

1

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

4600

1

	descend_origin_multilocation

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_multilocation)

4608

1

	.unwrap();

4609

1

4610

1

	ParaB::execute_with(|| {

4611

1

		// free execution, full amount received

4612

1

		assert_ok!(ParaBalances::transfer_allow_death(

4613

1

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

4614

1

			derived.clone(),

4615

1

			4000009100u128,

4616

1

));

4617

		// derived account has all funds

4618

1

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

4619

		// sovereign account has 0 funds

4620

1

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

4621

1

});

4622

1

4623

1

	// Encode the call. Balances transact to para_a_account

4624

1

	// First index

4625

1

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

4626

1

	let index =

4627

1

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

4628

1

			.unwrap() as u8;

4629

1

4630

1

	encoded.push(index);

4631

1

4632

1

	// Then call bytes

4633

1

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

4634

1

		// 100 to sovereign

4635

1

		dest: para_a_account_20(),

4636

1

		value: 100u32.into(),

4637

1

4638

1

	.encode();

4639

1

	encoded.append(&mut call_bytes);

4640

1

4641

1

	let overall_weight = 4000009000u64;

4642

1

	ParaA::execute_with(|| {

4643

1

		assert_ok!(XcmTransactor::transact_through_signed(

4644

1

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

4645

1

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

4646

1

			CurrencyPayment {

4647

1

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

4648

1

					para_b_balances

4649

1

				))),

4650

1

				fee_amount: Some(overall_weight as u128)

4651

1

},

4652

1

			encoded,

4653

1

			// 4000000000 for transfer + 9000 for XCM

4654

1

			TransactWeights {

4655

1

				transact_required_weight_at_most: 4000000000.into(),

4656

1

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

4657

1

},

4658

1

			true

4659

1

));

4660

1

});

4661

1

4662

1

	ParaB::execute_with(|| {

4663

1

		// Check the derived account was refunded

4664

1

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

4665

4666

		// Check the transfer was executed

4667

1

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

4668

1

});

4669

1

4670

4671

#[test]

4672

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4673

1

	MockNet::reset();

4674

1

	let mut ancestry = Location::parent();

4675

1

4676

1

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

4677

1

4678

1

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

4679

1

4680

1

	ParaA::execute_with(|| {

4681

1

		// Root can set transact info

4682

1

		assert_ok!(XcmTransactor::set_transact_info(

4683

1

			parachain::RuntimeOrigin::root(),

4684

1

			// ParaB

4685

1

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

4686

1

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

4687

1

			3.into(),

4688

1

			20000000000.into(),

4689

1

			// 4 instructions in transact through signed

4690

1

			Some(4.into())

4691

1

));

4692

		// Root can set transact info

4693

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4694

1

			parachain::RuntimeOrigin::root(),

4695

1

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

4696

1

			parachain::ParaTokensPerSecond::get(),

4697

1

));

4698

1

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

4699

1

});

4700

1

4701

1

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

4702

1

	let signed_origin: Junctions = [AccountKey20 {

4703

1

		network: None,

4704

1

		key: PARAALICE,

4705

1

}]

4706

1

	.into();

4707

1

4708

1

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

4709

1

	descend_origin_multilocation

4710

1

		.append_with(signed_origin)

4711

1

		.unwrap();

4712

1

4713

1

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

4714

1

	descend_origin_multilocation

4715

1

		.reanchor(&para_b_location, &ancestry.interior)

4716

1

		.unwrap();

4717

1

4718

1

	let derived = xcm_builder::HashedDescription::<

4719

1

		parachain::AccountId,

4720

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4721

1

	>::convert_location(&descend_origin_multilocation)

4722

1

	.unwrap();

4723

1

4724

1

	let mut parachain_b_alice_balances_before = 0;

4725

1

	ParaB::execute_with(|| {

4726

1

		assert_ok!(ParaBalances::transfer_allow_death(

4727

1

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

4728

1

			derived.clone(),

4729

1

			4000000104u128,

4730

1

));

4731

		// derived account has all funds

4732

1

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

4733

		// sovereign account has 0 funds

4734

1

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

4735

4736

1

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

4737

1

});

4738

1

4739

1

	// Encode the call. Balances transact to para_a_account

4740

1

	// First index

4741

1

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

4742

1

	let index =

4743

1

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

4744

1

			.unwrap() as u8;

4745

1

4746

1

	encoded.push(index);

4747

4748

	use sp_core::U256;

4749

	// Let's do a EVM transfer

4750

1

	let eth_tx =

4751

1

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

4752

1

			gas_limit: U256::from(21000),

4753

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4754

1

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

4755

1

			value: U256::from(100),

4756

1

			input: BoundedVec::<

4757

1

u8,

4758

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4759

1

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

4760

1

			access_list: None,

4761

1

});

4762

1

4763

1

	// Then call bytes

4764

1

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

4765

1

		xcm_transaction: eth_tx,

4766

1

4767

1

	.encode();

4768

1

	encoded.append(&mut call_bytes);

4769

1

4770

1

	ParaA::execute_with(|| {

4771

1

		assert_ok!(XcmTransactor::transact_through_signed(

4772

1

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

4773

1

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

4774

1

			CurrencyPayment {

4775

1

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

4776

1

					para_b_balances

4777

1

				))),

4778

1

				fee_amount: None

4779

1

},

4780

1

			encoded,

4781

1

			// 4000000000 for transfer + 4000 for XCM

4782

1

			// 1-1 to fee

4783

1

			TransactWeights {

4784

1

				transact_required_weight_at_most: 4000000000.into(),

4785

1

				overall_weight: None

4786

1

},

4787

1

			false

4788

1

));

4789

1

});

4790

1

4791

1

	ParaB::execute_with(|| {

4792

1

		// Make sure the EVM transfer went through

4793

1

		assert!(

4794

1

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

4795

1

				== parachain_b_alice_balances_before + 100

4796

1

);

4797

1

});

4798

1

4799

4800

#[test]

4801

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4802

1

	MockNet::reset();

4803

1

	let mut ancestry = Location::parent();

4804

1

4805

1

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

4806

1

4807

1

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

4808

1

4809

1

	ParaA::execute_with(|| {

4810

1

		// Root can set transact info

4811

1

		assert_ok!(XcmTransactor::set_transact_info(

4812

1

			parachain::RuntimeOrigin::root(),

4813

1

			// ParaB

4814

1

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

4815

1

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

4816

1

			3.into(),

4817

1

			20000000000.into(),

4818

1

			// 4 instructions in transact through signed

4819

1

			Some(4.into())

4820

1

));

4821

		// Root can set transact info

4822

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4823

1

			parachain::RuntimeOrigin::root(),

4824

1

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

4825

1

			parachain::ParaTokensPerSecond::get(),

4826

1

));

4827

1

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

4828

1

});

4829

1

4830

1

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

4831

1

	let signed_origin: Junctions = [AccountKey20 {

4832

1

		network: None,

4833

1

		key: PARAALICE,

4834

1

}]

4835

1

	.into();

4836

1

4837

1

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

4838

1

	descend_origin_multilocation

4839

1

		.append_with(signed_origin)

4840

1

		.unwrap();

4841

1

4842

1

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

4843

1

	descend_origin_multilocation

4844

1

		.reanchor(&para_b_location, &ancestry.interior)

4845

1

		.unwrap();

4846

1

4847

1

	let derived = xcm_builder::HashedDescription::<

4848

1

		parachain::AccountId,

4849

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4850

1

	>::convert_location(&descend_origin_multilocation)

4851

1

	.unwrap();

4852

1

4853

1

	let mut parachain_b_alice_balances_before = 0;

4854

1

	ParaB::execute_with(|| {

4855

1

		assert_ok!(ParaBalances::transfer_allow_death(

4856

1

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

4857

1

			derived.clone(),

4858

1

			4000000104u128,

4859

1

));

4860

		// derived account has all funds

4861

1

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

4862

		// sovereign account has 0 funds

4863

1

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

4864

4865

1

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

4866

1

});

4867

1

4868

1

	// Encode the call. Balances transact to para_a_account

4869

1

	// First index

4870

1

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

4871

1

	let index =

4872

1

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

4873

1

			.unwrap() as u8;

4874

1

4875

1

	encoded.push(index);

4876

4877

	use sp_core::U256;

4878

	// Let's do a EVM transfer

4879

1

	let eth_tx =

4880

1

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

4881

1

			gas_limit: U256::from(21000),

4882

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4883

1

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

4884

1

			value: U256::from(100),

4885

1

			input: BoundedVec::<

4886

1

u8,

4887

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4888

1

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

4889

1

			access_list: None,

4890

1

});

4891

1

4892

1

	// Then call bytes

4893

1

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

4894

1

		transact_as: PARAALICE.into(),

4895

1

		xcm_transaction: eth_tx,

4896

1

4897

1

	.encode();

4898

1

	encoded.append(&mut call_bytes);

4899

1

4900

1

	ParaA::execute_with(|| {

4901

1

		assert_ok!(XcmTransactor::transact_through_signed(

4902

1

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

4903

1

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

4904

1

			CurrencyPayment {

4905

1

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

4906

1

					para_b_balances

4907

1

				))),

4908

1

				fee_amount: None

4909

1

},

4910

1

			encoded,

4911

1

			TransactWeights {

4912

1

				transact_required_weight_at_most: 4000000000.into(),

4913

1

				overall_weight: None

4914

1

},

4915

1

			false

4916

1

));

4917

1

});

4918

1

4919

1

	ParaB::execute_with(|| {

4920

1

		// Make sure the EVM transfer wasn't executed

4921

1

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

4922

1

});

4923

1

4924

4925

#[test]

4926

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4927

1

	MockNet::reset();

4928

1

	let mut ancestry = Location::parent();

4929

1

4930

1

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

4931

1

4932

1

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

4933

1

4934

1

	ParaA::execute_with(|| {

4935

1

		// Root can set transact info

4936

1

		assert_ok!(XcmTransactor::set_transact_info(

4937

1

			parachain::RuntimeOrigin::root(),

4938

1

			// ParaB

4939

1

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

4940

1

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

4941

1

			3.into(),

4942

1

			20000000000.into(),

4943

1

			// 4 instructions in transact through signed

4944

1

			Some(4.into())

4945

1

));

4946

		// Root can set transact info

4947

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4948

1

			parachain::RuntimeOrigin::root(),

4949

1

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

4950

1

			parachain::ParaTokensPerSecond::get(),

4951

1

));

4952

1

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

4953

1

});

4954

1

4955

1

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

4956

1

	let signed_origin: Junctions = [AccountKey20 {

4957

1

		network: None,

4958

1

		key: PARAALICE,

4959

1

}]

4960

1

	.into();

4961

1

4962

1

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

4963

1

	descend_origin_multilocation

4964

1

		.append_with(signed_origin)

4965

1

		.unwrap();

4966

1

4967

1

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

4968

1

	descend_origin_multilocation

4969

1

		.reanchor(&para_b_location, &ancestry.interior)

4970

1

		.unwrap();

4971

1

4972

1

	let derived = xcm_builder::HashedDescription::<

4973

1

		parachain::AccountId,

4974

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4975

1

	>::convert_location(&descend_origin_multilocation)

4976

1

	.unwrap();

4977

1

4978

1

	let transfer_recipient = evm_account();

4979

1

	let mut transfer_recipient_balance_before = 0;

4980

1

	ParaB::execute_with(|| {

4981

1

		assert_ok!(ParaBalances::transfer_allow_death(

4982

1

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

4983

1

			derived.clone(),

4984

1

			4000000104u128,

4985

1

));

4986

		// derived account has all funds

4987

1

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

4988

		// sovereign account has 0 funds

4989

1

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

4990

4991

1

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

4992

1

4993

1

		// Add proxy ALICE  -> derived

4994

1

		let _ = parachain::Proxy::add_proxy_delegate(

4995

1

			&PARAALICE.into(),

4996

1

			derived,

4997

1

			parachain::ProxyType::Any,

4998

1

0,

4999

1

);

5000

1

});

5001

1

5002

1

	// Encode the call. Balances transact to para_a_account

5003

1

	// First index

5004

1

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

5005

1

	let index =

5006

1

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

5007

1

			.unwrap() as u8;

5008

1

5009

1

	encoded.push(index);

5010

5011

	use sp_core::U256;

5012

	// Let's do a EVM transfer

5013

1

	let eth_tx =

5014

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5015

1

			gas_limit: U256::from(21000),

5016

1

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

5017

1

			value: U256::from(100),

5018

1

			input: BoundedVec::<

5019

1

u8,

5020

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5021

1

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

5022

1

			access_list: None,

5023

1

});

5024

1

5025

1

	// Then call bytes

5026

1

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

5027

1

		transact_as: PARAALICE.into(),

5028

1

		xcm_transaction: eth_tx,

5029

1

5030

1

	.encode();

5031

1

	encoded.append(&mut call_bytes);

5032

1

5033

1

	ParaA::execute_with(|| {

5034

1

		assert_ok!(XcmTransactor::transact_through_signed(

5035

1

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

5036

1

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

5037

1

			CurrencyPayment {

5038

1

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

5039

1

					para_b_balances

5040

1

				))),

5041

1

				fee_amount: None

5042

1

},

5043

1

			encoded,

5044

1

			TransactWeights {

5045

1

				transact_required_weight_at_most: 4000000000.into(),

5046

1

				overall_weight: None

5047

1

},

5048

1

			false

5049

1

));

5050

1

});

5051

1

5052

1

	ParaB::execute_with(|| {

5053

1

		// Make sure the EVM transfer was executed

5054

1

		assert!(

5055

1

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

5056

1

				== transfer_recipient_balance_before + 100

5057

1

);

5058

1

});

5059

1

5060

5061

#[test]

5062

1

fn hrmp_init_accept_through_root() {

5063

1

	MockNet::reset();

5064

1

5065

1

	Relay::execute_with(|| {

5066

1

		assert_ok!(RelayBalances::transfer_allow_death(

5067

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5068

1

			para_a_account(),

5069

1

			1000u128

5070

1

));

5071

1

		assert_ok!(RelayBalances::transfer_allow_death(

5072

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5073

1

			para_b_account(),

5074

1

			1000u128

5075

1

));

5076

1

});

5077

1

5078

1

	ParaA::execute_with(|| {

5079

1

		let total_fee = 1_000u128;

5080

1

		let total_weight: u64 = 1_000_000_000;

5081

1

		let tx_weight: u64 = 500_000_000;

5082

1

		// Root can send hrmp init channel

5083

1

		assert_ok!(XcmTransactor::hrmp_manage(

5084

1

			parachain::RuntimeOrigin::root(),

5085

1

			HrmpOperation::InitOpen(HrmpInitParams {

5086

1

				para_id: 2u32.into(),

5087

1

				proposed_max_capacity: 1,

5088

1

				proposed_max_message_size: 1

5089

1

}),

5090

1

			CurrencyPayment {

5091

1

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

5092

1

					Location::parent()

5093

1

				))),

5094

1

				fee_amount: Some(total_fee)

5095

1

},

5096

1

			TransactWeights {

5097

1

				transact_required_weight_at_most: tx_weight.into(),

5098

1

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

5099

1

5100

1

));

5101

1

});

5102

1

	Relay::execute_with(|| {

5103

1

		let expected_event: relay_chain::RuntimeEvent =

5104

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5105

1

				sender: 1u32.into(),

5106

1

				recipient: 2u32.into(),

5107

1

				proposed_max_capacity: 1u32,

5108

1

				proposed_max_message_size: 1u32,

5109

1

5110

1

			.into();

5111

1

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

5112

1

});

5113

1

	ParaB::execute_with(|| {

5114

1

		let total_fee = 1_000u128;

5115

1

		let total_weight: u64 = 1_000_000_000;

5116

1

		let tx_weight: u64 = 500_000_000;

5117

1

		// Root can send hrmp accept channel

5118

1

		assert_ok!(XcmTransactor::hrmp_manage(

5119

1

			parachain::RuntimeOrigin::root(),

5120

1

			HrmpOperation::Accept {

5121

1

				para_id: 1u32.into()

5122

1

},

5123

1

			CurrencyPayment {

5124

1

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

5125

1

					Location::parent()

5126

1

				))),

5127

1

				fee_amount: Some(total_fee)

5128

1

},

5129

1

			TransactWeights {

5130

1

				transact_required_weight_at_most: tx_weight.into(),

5131

1

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

5132

1

5133

1

));

5134

1

});

5135

1

5136

1

	Relay::execute_with(|| {

5137

1

		let expected_event: relay_chain::RuntimeEvent =

5138

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5139

1

				sender: 1u32.into(),

5140

1

				recipient: 2u32.into(),

5141

1

5142

1

			.into();

5143

1

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

5144

1

});

5145

1

5146

5147

#[test]

5148

1

fn hrmp_close_works() {

5149

1

	MockNet::reset();

5150

1

5151

1

	Relay::execute_with(|| {

5152

1

		assert_ok!(RelayBalances::transfer_allow_death(

5153

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5154

1

			para_a_account(),

5155

1

			1000u128

5156

1

));

5157

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5158

1

			relay_chain::RuntimeOrigin::root(),

5159

1

			1u32.into(),

5160

1

			2u32.into(),

5161

1

			1u32,

5162

1

			1u32

5163

1

));

5164

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5165

1

			relay_chain::RuntimeOrigin::root(),

5166

1

			1u32

5167

1

));

5168

1

});

5169

1

5170

1

	ParaA::execute_with(|| {

5171

1

		let total_fee = 1_000u128;

5172

1

		let total_weight: u64 = 1_000_000_000;

5173

1

		let tx_weight: u64 = 500_000_000;

5174

1

		assert_ok!(XcmTransactor::hrmp_manage(

5175

1

			parachain::RuntimeOrigin::root(),

5176

1

			HrmpOperation::Close(HrmpChannelId {

5177

1

				sender: 1u32.into(),

5178

1

				recipient: 2u32.into()

5179

1

}),

5180

1

			CurrencyPayment {

5181

1

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

5182

1

					Location::parent()

5183

1

				))),

5184

1

				fee_amount: Some(total_fee)

5185

1

},

5186

1

			TransactWeights {

5187

1

				transact_required_weight_at_most: tx_weight.into(),

5188

1

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

5189

1

5190

1

));

5191

1

});

5192

1

	Relay::execute_with(|| {

5193

1

		let expected_event: relay_chain::RuntimeEvent =

5194

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5195

1

				by_parachain: 1u32.into(),

5196

1

				channel_id: HrmpChannelId {

5197

1

					sender: 1u32.into(),

5198

1

					recipient: 2u32.into(),

5199

1

},

5200

1

5201

1

			.into();

5202

1

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

5203

1

});

5204

1

5205

5206

use crate::xcm_mock::parachain::{EvmForeignAssets, Treasury, XcmWeightTrader};

5207

use parity_scale_codec::{Decode, Encode};

5208

use sp_core::U256;

5209

use sp_io::hashing::blake2_256;

5210

5211

// Helper to derive accountIds

5212

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5213

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5214

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5215

7