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

//! Moonbeam Runtime Xcm Tests

18

19

mod xcm_mock;

20

21

use cumulus_primitives_core::relay_chain::HrmpChannelId;

22

use frame_support::{

23

	assert_ok,

24

	traits::{PalletInfo, PalletInfoAccess},

25

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

26

	BoundedVec,

27

};

28

use moonbeam_runtime::xcm_config::AssetType;

29

use pallet_xcm_transactor::{

30

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

31

};

32

use sp_core::ConstU32;

33

use sp_core::U256;

34

use sp_runtime::traits::Convert;

35

use xcm::{

36

	latest::prelude::{

37

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

38

		Fungibility, Fungible, GeneralIndex, Junction, Junctions, Limited, Location, OriginKind,

39

		PalletInstance, Parachain, QueryResponse, Reanchorable, Response, WeightLimit, Wild, Xcm,

40

},

41

	IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm, WrapVersion,

42

};

43

use xcm_executor::traits::{ConvertLocation, TransferType};

44

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

45

use xcm_mock::relay_chain;

46

use xcm_mock::*;

47

use xcm_primitives::{

48

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

49

};

50

use xcm_simulator::TestExt;

51

52

26

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

53

26

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

54

26

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

55

26

		.into_version(xcm::latest::VERSION)

56

26

		.map_err(|_| ())?

57

	else {

58

		return Err(());

59

};

60

	use frame_support::weights::WeightToFee as _;

61

26

	let native_amount_per_second: u128 =

62

26

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

63

26

			&Weight::from_parts(

64

26

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

65

26

0,

66

26

),

67

68

26

		.try_into()

69

26

		.map_err(|_| ())?;

70

26

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

71

26

	let relative_price: u128 = if units_per_second > 0u128 {

72

10

		native_amount_per_second

73

10

			.saturating_mul(precision_factor)

74

10

			.saturating_div(units_per_second)

75

	} else {

76

16

		0u128

77

};

78

26

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

79

26

		location_v5,

80

26

		(true, relative_price),

81

);

82

26

	Ok(())

83

26

84

85

23

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

86

23

	Asset {

87

23

		id: AssetId(

88

23

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

89

23

				currency_id,

90

23

91

23

			.unwrap(),

92

23

),

93

23

		fun: Fungibility::Fungible(amount),

94

23

95

23

96

97

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

98

#[test]

99

1

fn receive_relay_asset_from_relay() {

100

1

	MockNet::reset();

101

102

1

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

103

1

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

104

1

	let asset_metadata = parachain::AssetMetadata {

105

1

		name: b"RelayToken".to_vec(),

106

1

		symbol: b"Relay".to_vec(),

107

1

		decimals: 12,

108

1

};

109

110

	// Register relay asset in paraA

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

));

123

1

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

124

1

});

125

126

	// 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

133

	// First send relay chain asset to Parachain

134

1

	Relay::execute_with(|| {

135

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

136

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

137

1

			assets: Wild(All),

138

1

			beneficiary: dest.clone(),

139

1

		}]);

140

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

141

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

142

1

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

143

1

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

144

1

			Box::new(TransferType::LocalReserve),

145

1

			Box::new(fees_id),

146

1

			Box::new(TransferType::LocalReserve),

147

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

148

1

			WeightLimit::Unlimited

149

));

150

1

});

151

152

	// Verify that parachain received the asset

153

1

	ParaA::execute_with(|| {

154

		// free execution, full amount received

155

1

		assert_eq!(

156

1

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

157

1

			Ok(U256::from(123))

158

);

159

1

});

160

1

161

162

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

163

#[test]

164

1

fn send_relay_asset_to_relay() {

165

1

	MockNet::reset();

166

167

1

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

168

1

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

169

170

1

	let asset_metadata = parachain::AssetMetadata {

171

1

		name: b"RelayToken".to_vec(),

172

1

		symbol: b"Relay".to_vec(),

173

1

		decimals: 12,

174

1

};

175

176

	// Register relay asset in paraA

177

1

	ParaA::execute_with(|| {

178

1

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

179

1

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

180

1

			.try_into()

181

1

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

182

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

183

1

			source_id,

184

1

			source_location_latest,

185

1

			asset_metadata.decimals,

186

1

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

187

1

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

188

));

189

		// Free execution

190

1

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

191

1

});

192

193

1

	let dest: Location = Junction::AccountKey20 {

194

1

		network: None,

195

1

		key: PARAALICE,

196

1

197

1

	.into();

198

199

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

200

1

	Relay::execute_with(|| {

201

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

202

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

203

1

			assets: Wild(All),

204

1

			beneficiary: dest.clone(),

205

1

		}]);

206

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

207

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

208

1

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

209

1

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

210

1

			Box::new(TransferType::LocalReserve),

211

1

			Box::new(fees_id),

212

1

			Box::new(TransferType::LocalReserve),

213

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

214

1

			WeightLimit::Unlimited

215

));

216

1

});

217

218

1

	ParaA::execute_with(|| {

219

		// Free execution, full amount received

220

1

		assert_eq!(

221

1

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

222

1

			Ok(U256::from(123))

223

);

224

1

});

225

226

	// Lets gather the balance before sending back money

227

1

	let mut balance_before_sending = 0;

228

1

	Relay::execute_with(|| {

229

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

230

1

});

231

232

	// We now send back some money to the relay

233

1

	let dest = Location {

234

1

		parents: 1,

235

1

		interior: [AccountId32 {

236

1

			network: None,

237

1

			id: RELAYALICE.into(),

238

1

}]

239

1

		.into(),

240

1

};

241

1

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

242

1

	ParaA::execute_with(|| {

243

1

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

244

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

245

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

246

1

			assets: Wild(All),

247

1

			beneficiary: beneficiary.clone(),

248

1

		}]);

249

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

250

1

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

251

1

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

252

1

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

253

1

			Box::new(TransferType::DestinationReserve),

254

1

			Box::new(fees_id),

255

1

			Box::new(TransferType::DestinationReserve),

256

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

257

1

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

258

));

259

1

});

260

261

	// The balances in paraAlice should have been substracted

262

1

	ParaA::execute_with(|| {

263

1

		assert_eq!(

264

1

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

265

1

			Ok(U256::from(0))

266

);

267

1

});

268

269

	// Balances in the relay should have been received

270

1

	Relay::execute_with(|| {

271

		// free execution,x	 full amount received

272

1

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

273

1

});

274

1

275

276

#[test]

277

1

fn send_relay_asset_to_para_b() {

278

1

	MockNet::reset();

279

280

1

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

281

1

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

282

283

1

	let asset_metadata = parachain::AssetMetadata {

284

1

		name: b"RelayToken".to_vec(),

285

1

		symbol: b"Relay".to_vec(),

286

1

		decimals: 12,

287

1

};

288

289

	// Register asset in paraA. Free execution

290

1

	ParaA::execute_with(|| {

291

1

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

292

1

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

293

1

			.try_into()

294

1

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

295

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

296

1

			source_id,

297

1

			source_location_latest,

298

1

			asset_metadata.decimals,

299

1

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

300

1

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

301

));

302

1

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

303

1

});

304

305

	// Register asset in paraB. Free execution

306

1

	ParaB::execute_with(|| {

307

1

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

308

1

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

309

1

			.try_into()

310

1

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

311

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

312

1

			source_id,

313

1

			source_location_latest,

314

1

			asset_metadata.decimals,

315

1

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

316

1

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

317

));

318

1

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

319

1

});

320

321

1

	let dest: Location = Junction::AccountKey20 {

322

1

		network: None,

323

1

		key: PARAALICE,

324

1

325

1

	.into();

326

1

	Relay::execute_with(|| {

327

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

328

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

329

1

			assets: Wild(All),

330

1

			beneficiary: dest.clone(),

331

1

		}]);

332

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

333

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

334

1

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

335

1

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

336

1

			Box::new(TransferType::LocalReserve),

337

1

			Box::new(fees_id),

338

1

			Box::new(TransferType::LocalReserve),

339

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

340

1

			WeightLimit::Unlimited

341

));

342

1

});

343

344

1

	ParaA::execute_with(|| {

345

		// free execution, full amount received

346

1

		assert_eq!(

347

1

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

348

1

			Ok(U256::from(123))

349

);

350

1

});

351

352

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

353

1

	let dest = Location {

354

1

		parents: 1,

355

1

		interior: [

356

1

			Parachain(2),

357

1

			AccountKey20 {

358

1

				network: None,

359

1

				key: PARAALICE.into(),

360

1

},

361

1

362

1

		.into(),

363

1

};

364

1

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

365

1

	ParaA::execute_with(|| {

366

1

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

367

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

368

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

369

1

			assets: Wild(All),

370

1

			beneficiary: beneficiary.clone(),

371

1

		}]);

372

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

373

1

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

374

1

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

375

1

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

376

1

			Box::new(TransferType::RemoteReserve(Location::parent().into())),

377

1

			Box::new(fees_id),

378

1

			Box::new(TransferType::RemoteReserve(Location::parent().into())),

379

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

380

1

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

381

));

382

1

});

383

384

	// Para A balances should have been substracted

385

1

	ParaA::execute_with(|| {

386

1

		assert_eq!(

387

1

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

388

1

			Ok(U256::from(23))

389

);

390

1

});

391

392

	// Para B balances should have been credited

393

1

	ParaB::execute_with(|| {

394

1

		assert_eq!(

395

1

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

396

1

			Ok(U256::from(100))

397

);

398

1

});

399

1

400

401

#[test]

402

1

fn send_para_a_asset_to_para_b() {

403

1

	MockNet::reset();

404

405

	// This represents the asset in paraA

406

1

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

407

1

	let source_location: AssetType = para_a_balances

408

1

		.try_into()

409

1

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

410

1

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

411

412

1

	let asset_metadata = parachain::AssetMetadata {

413

1

		name: b"ParaAToken".to_vec(),

414

1

		symbol: b"ParaA".to_vec(),

415

1

		decimals: 18,

416

1

};

417

418

	// Register asset in paraB. Free execution

419

1

	ParaB::execute_with(|| {

420

1

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

421

1

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

422

1

			.try_into()

423

1

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

424

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

425

1

			source_id,

426

1

			source_location_latest,

427

1

			asset_metadata.decimals,

428

1

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

429

1

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

430

));

431

1

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

432

1

});

433

434

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

435

1

	let dest = Location {

436

1

		parents: 1,

437

1

		interior: [

438

1

			Parachain(2),

439

1

			AccountKey20 {

440

1

				network: None,

441

1

				key: PARAALICE.into(),

442

1

},

443

1

444

1

		.into(),

445

1

};

446

447

1

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

448

	// Native token is substracted in paraA

449

1

	ParaA::execute_with(|| {

450

1

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

451

		// Free execution, full amount received

452

1

		assert_ok!(PolkadotXcm::transfer_assets(

453

1

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

454

1

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

455

1

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

456

1

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

457

0,

458

1

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

459

));

460

1

});

461

462

1

	ParaA::execute_with(|| {

463

1

		assert_eq!(

464

1

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

465

			INITIAL_BALANCE - 100

466

);

467

1

});

468

469

	// Asset is minted in paraB

470

1

	ParaB::execute_with(|| {

471

		// Free execution, full amount received

472

1

		assert_eq!(

473

1

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

474

1

			Ok(U256::from(100))

475

);

476

1

});

477

1

478

479

#[test]

480

1

fn send_para_a_asset_from_para_b_to_para_c() {

481

1

	MockNet::reset();

482

483

	// Represents para A asset

484

1

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

485

1

	let source_location: AssetType = para_a_balances

486

1

		.try_into()

487

1

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

488

1

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

489

490

1

	let asset_metadata = parachain::AssetMetadata {

491

1

		name: b"ParaAToken".to_vec(),

492

1

		symbol: b"ParaA".to_vec(),

493

1

		decimals: 18,

494

1

};

495

496

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

497

1

	ParaB::execute_with(|| {

498

1

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

499

1

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

500

1

			.try_into()

501

1

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

502

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

503

1

			source_id,

504

1

			source_location_latest,

505

1

			asset_metadata.decimals,

506

1

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

507

1

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

508

));

509

1

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

510

1

});

511

512

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

513

1

	ParaC::execute_with(|| {

514

1

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

515

1

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

516

1

			.try_into()

517

1

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

518

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

519

1

			source_id,

520

1

			source_location_latest,

521

1

			asset_metadata.decimals,

522

1

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

523

1

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

524

));

525

1

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

526

1

});

527

528

1

	let dest = Location {

529

1

		parents: 1,

530

1

		interior: [

531

1

			Parachain(2),

532

1

			AccountKey20 {

533

1

				network: None,

534

1

				key: PARAALICE.into(),

535

1

},

536

1

537

1

		.into(),

538

1

};

539

1

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

540

1

	ParaA::execute_with(|| {

541

1

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

542

1

		assert_ok!(PolkadotXcm::transfer_assets(

543

1

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

544

1

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

545

1

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

546

1

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

547

0,

548

1

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

549

));

550

1

});

551

552

	// Para A balances have been substracted

553

1

	ParaA::execute_with(|| {

554

1

		assert_eq!(

555

1

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

556

			INITIAL_BALANCE - 100

557

);

558

1

});

559

560

	// Para B balances have been credited

561

1

	ParaB::execute_with(|| {

562

1

		assert_eq!(

563

1

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

564

1

			Ok(U256::from(100))

565

);

566

1

});

567

568

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

569

1

	let dest = Location {

570

1

		parents: 1,

571

1

		interior: [

572

1

			Parachain(3),

573

1

			AccountKey20 {

574

1

				network: None,

575

1

				key: PARAALICE.into(),

576

1

},

577

1

578

1

		.into(),

579

1

};

580

1

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

581

1

	ParaB::execute_with(|| {

582

1

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

583

1

		assert_ok!(PolkadotXcm::transfer_assets(

584

1

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

585

1

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

586

1

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

587

1

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

588

0,

589

1

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

590

));

591

1

});

592

593

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

594

1

	ParaC::execute_with(|| {

595

1

		assert_eq!(

596

1

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

597

1

			Ok(U256::from(95))

598

);

599

1

});

600

1

601

602

#[test]

603

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

604

1

	MockNet::reset();

605

606

	// para A asset

607

1

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

608

1

	let source_location: AssetType = para_a_balances

609

1

		.try_into()

610

1

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

611

1

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

612

613

1

	let asset_metadata = parachain::AssetMetadata {

614

1

		name: b"ParaAToken".to_vec(),

615

1

		symbol: b"ParaA".to_vec(),

616

1

		decimals: 18,

617

1

};

618

619

	// Register para A asset in para B

620

1

	ParaB::execute_with(|| {

621

1

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

622

1

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

623

1

			.try_into()

624

1

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

625

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

626

1

			source_id,

627

1

			source_location_latest,

628

1

			asset_metadata.decimals,

629

1

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

630

1

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

631

));

632

1

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

633

1

});

634

635

	// Send para A asset to para B

636

1

	let dest = Location {

637

1

		parents: 1,

638

1

		interior: [

639

1

			Parachain(2),

640

1

			AccountKey20 {

641

1

				network: None,

642

1

				key: PARAALICE.into(),

643

1

},

644

1

645

1

		.into(),

646

1

};

647

1

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

648

1

	ParaA::execute_with(|| {

649

1

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

650

1

		assert_ok!(PolkadotXcm::transfer_assets(

651

1

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

652

1

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

653

1

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

654

1

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

655

0,

656

1

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

657

));

658

1

});

659

660

	// Balances have been substracted

661

1

	ParaA::execute_with(|| {

662

1

		assert_eq!(

663

1

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

664

			INITIAL_BALANCE - 100

665

);

666

1

});

667

668

	// Para B balances have been credited

669

1

	ParaB::execute_with(|| {

670

1

		assert_eq!(

671

1

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

672

1

			Ok(U256::from(100))

673

);

674

1

});

675

676

	// Send back para A asset to para A

677

1

	let dest = Location {

678

1

		parents: 1,

679

1

		interior: [

680

1

			Parachain(1),

681

1

			AccountKey20 {

682

1

				network: None,

683

1

				key: PARAALICE.into(),

684

1

},

685

1

686

1

		.into(),

687

1

};

688

1

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

689

1

	ParaB::execute_with(|| {

690

1

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

691

1

		assert_ok!(PolkadotXcm::transfer_assets(

692

1

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

693

1

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

694

1

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

695

1

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

696

0,

697

1

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

698

));

699

1

});

700

701

1

	ParaA::execute_with(|| {

702

		// Weight used is 4

703

1

		assert_eq!(

704

1

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

705

			INITIAL_BALANCE - 4

706

);

707

1

});

708

1

709

710

#[test]

711

1

fn receive_relay_asset_with_trader() {

712

1

	MockNet::reset();

713

714

1

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

715

1

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

716

717

1

	let asset_metadata = parachain::AssetMetadata {

718

1

		name: b"RelayToken".to_vec(),

719

1

		symbol: b"Relay".to_vec(),

720

1

		decimals: 12,

721

1

};

722

723

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

724

	// we know later we will divide by 1e12

725

	// Lets put 1e6 as units per second

726

1

	ParaA::execute_with(|| {

727

1

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

728

1

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

729

1

			.try_into()

730

1

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

731

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

732

1

			source_id,

733

1

			source_location_latest,

734

1

			asset_metadata.decimals,

735

1

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

736

1

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

737

));

738

1

		assert_ok!(add_supported_asset(

739

1

			source_location.clone(),

740

			2500000000000u128

741

));

742

1

});

743

744

1

	let dest: Location = Junction::AccountKey20 {

745

1

		network: None,

746

1

		key: PARAALICE,

747

1

748

1

	.into();

749

	// We are sending 100 tokens from relay.

750

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

751

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

752

	// Units per second should be 2_500_000_000_000_000

753

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

754

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

755

1

	Relay::execute_with(|| {

756

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

757

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

758

1

			assets: Wild(All),

759

1

			beneficiary: dest.clone(),

760

1

		}]);

761

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

762

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

763

1

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

764

1

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

765

1

			Box::new(TransferType::LocalReserve),

766

1

			Box::new(fees_id),

767

1

			Box::new(TransferType::LocalReserve),

768

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

769

1

			WeightLimit::Unlimited

770

));

771

1

});

772

773

1

	ParaA::execute_with(|| {

774

		// non-free execution, not full amount received

775

1

		assert_eq!(

776

1

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

777

1

			Ok(U256::from(90))

778

);

779

		// Fee should have been received by treasury

780

1

		assert_eq!(

781

1

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

782

1

			Ok(U256::from(10))

783

);

784

1

});

785

1

786

787

#[test]

788

1

fn send_para_a_asset_to_para_b_with_trader() {

789

1

	MockNet::reset();

790

791

1

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

792

1

	let source_location: AssetType = para_a_balances

793

1

		.try_into()

794

1

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

795

1

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

796

797

1

	let asset_metadata = parachain::AssetMetadata {

798

1

		name: b"ParaAToken".to_vec(),

799

1

		symbol: b"ParaA".to_vec(),

800

1

		decimals: 18,

801

1

};

802

803

1

	ParaB::execute_with(|| {

804

1

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

805

1

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

806

1

			.try_into()

807

1

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

808

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

809

1

			source_id,

810

1

			source_location_latest,

811

1

			asset_metadata.decimals,

812

1

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

813

1

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

814

));

815

1

		assert_ok!(add_supported_asset(

816

1

			source_location.clone(),

817

			2500000000000u128

818

));

819

1

});

820

821

1

	let dest = Location {

822

1

		parents: 1,

823

1

		interior: [

824

1

			Parachain(2),

825

1

			AccountKey20 {

826

1

				network: None,

827

1

				key: PARAALICE.into(),

828

1

},

829

1

830

1

		.into(),

831

1

};

832

833

1

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

834

	// In destination chain, we only need 4 weight

835

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

836

1

	ParaA::execute_with(|| {

837

1

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

838

1

		assert_ok!(PolkadotXcm::transfer_assets(

839

1

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

840

1

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

841

1

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

842

1

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

843

0,

844

1

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

845

));

846

1

});

847

1

	ParaA::execute_with(|| {

848

		// free execution, full amount received

849

1

		assert_eq!(

850

1

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

851

			INITIAL_BALANCE - 100

852

);

853

1

});

854

855

	// We are sending 100 tokens from para A.

856

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

857

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

858

	// Units per second should be 2_500_000_000_000_000

859

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

860

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

861

	// will be 4

862

1

	ParaB::execute_with(|| {

863

1

		assert_eq!(

864

1

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

865

1

			Ok(U256::from(90))

866

);

867

		// Fee should have been received by treasury

868

1

		assert_eq!(

869

1

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

870

1

			Ok(U256::from(10))

871

);

872

1

});

873

1

874

875

#[test]

876

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

877

1

	MockNet::reset();

878

879

1

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

880

1

	let source_location: AssetType = para_a_balances

881

1

		.try_into()

882

1

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

883

1

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

884

885

1

	let asset_metadata = parachain::AssetMetadata {

886

1

		name: b"ParaAToken".to_vec(),

887

1

		symbol: b"ParaA".to_vec(),

888

1

		decimals: 18,

889

1

};

890

891

1

	ParaB::execute_with(|| {

892

1

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

893

1

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

894

1

			.try_into()

895

1

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

896

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

897

1

			source_id,

898

1

			source_location_latest,

899

1

			asset_metadata.decimals,

900

1

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

901

1

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

902

));

903

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

904

1

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

905

1

});

906

907

1

	let dest = Location {

908

1

		parents: 1,

909

1

		interior: [

910

1

			Parachain(2),

911

1

			AccountKey20 {

912

1

				network: None,

913

1

				key: PARAALICE.into(),

914

1

},

915

1

916

1

		.into(),

917

1

};

918

1

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

919

	// we use transfer_with_fee

920

1

	ParaA::execute_with(|| {

921

1

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

922

1

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

923

1

		assert_ok!(PolkadotXcm::transfer_assets(

924

1

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

925

1

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

926

1

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

927

1

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

928

0,

929

1

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

930

));

931

1

});

932

1

	ParaA::execute_with(|| {

933

		// 100 tokens transferred plus 1 taken from fees

934

1

		assert_eq!(

935

1

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

936

			INITIAL_BALANCE - 100 - 1

937

);

938

1

});

939

940

1

	ParaB::execute_with(|| {

941

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

942

		// what it is specified

943

1

		assert_eq!(

944

1

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

945

1

			Ok(U256::from(101))

946

);

947

1

});

948

1

949

950

#[test]

951

1

fn error_when_not_paying_enough() {

952

1

	MockNet::reset();

953

954

1

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

955

1

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

956

957

1

	let asset_metadata = parachain::AssetMetadata {

958

1

		name: b"RelayToken".to_vec(),

959

1

		symbol: b"Relay".to_vec(),

960

1

		decimals: 12,

961

1

};

962

963

1

	let dest: Location = Junction::AccountKey20 {

964

1

		network: None,

965

1

		key: PARAALICE,

966

1

967

1

	.into();

968

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

969

	// we know later we will divide by 1e12

970

	// Lets put 1e6 as units per second

971

1

	ParaA::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

));

983

1

		assert_ok!(add_supported_asset(

984

1

			source_location.clone(),

985

			2500000000000u128

986

));

987

1

});

988

989

	// We are sending 100 tokens from relay.

990

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

991

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

992

1

	Relay::execute_with(|| {

993

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

994

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

995

1

			assets: Wild(All),

996

1

			beneficiary: dest.clone(),

997

1

		}]);

998

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

999

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1000

1

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

1001

1

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

1002

1

			Box::new(TransferType::LocalReserve),

1003

1

			Box::new(fees_id),

1004

1

			Box::new(TransferType::LocalReserve),

1005

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1006

1

			WeightLimit::Unlimited

1007

));

1008

1

});

1009

1010

1

	ParaA::execute_with(|| {

1011

		// amount not received as it is not paying enough

1012

1

		assert_eq!(

1013

1

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

1014

1

			Ok(U256::from(0))

1015

);

1016

1

});

1017

1

1018

1019

#[test]

1020

1

fn transact_through_derivative_multilocation() {

1021

1

	MockNet::reset();

1022

1023

1

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

1024

1

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

1025

1026

1

	let asset_metadata = parachain::AssetMetadata {

1027

1

		name: b"RelayToken".to_vec(),

1028

1

		symbol: b"Relay".to_vec(),

1029

1

		decimals: 12,

1030

1

};

1031

1032

1

	ParaA::execute_with(|| {

1033

1

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

1034

1

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

1035

1

			.try_into()

1036

1

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

1037

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1038

1

			source_id,

1039

1

			source_location_latest,

1040

1

			asset_metadata.decimals,

1041

1

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

1042

1

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

1043

));

1044

1

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

1045

1046

		// Root can set transact info

1047

1

		assert_ok!(XcmTransactor::set_transact_info(

1048

1

			parachain::RuntimeOrigin::root(),

1049

1

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

1050

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

1051

1

			3000.into(),

1052

1

			20000000000.into(),

1053

1

			None

1054

));

1055

		// Root can set transact info

1056

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1057

1

			parachain::RuntimeOrigin::root(),

1058

1

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

1059

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1060

));

1061

1

});

1062

1063

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

1064

1065

1

	let dest: Location = AccountKey20 {

1066

1

		network: None,

1067

1

		key: PARAALICE,

1068

1

1069

1

	.into();

1070

1

	Relay::execute_with(|| {

1071

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

1072

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1073

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1074

1

			assets: Wild(All),

1075

1

			beneficiary: dest.clone(),

1076

1

		}]);

1077

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1078

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1079

1

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

1080

1

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

1081

1

			Box::new(TransferType::LocalReserve),

1082

1

			Box::new(fees_id),

1083

1

			Box::new(TransferType::LocalReserve),

1084

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1085

1

			WeightLimit::Unlimited

1086

));

1087

1

});

1088

1089

1

	ParaA::execute_with(|| {

1090

		// free execution, full amount received

1091

1

		assert_eq!(

1092

1

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

1093

1

			Ok(U256::from(4000003100u64))

1094

);

1095

1

});

1096

1097

	// Register address

1098

1

	ParaA::execute_with(|| {

1099

1

		assert_ok!(XcmTransactor::register(

1100

1

			parachain::RuntimeOrigin::root(),

1101

1

			PARAALICE.into(),

1102

0,

1103

));

1104

1

});

1105

1106

	// Send to registered address

1107

1108

1

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

1109

1

	let dest = Location {

1110

1

		parents: 1,

1111

1

		interior: [AccountId32 {

1112

1

			network: None,

1113

1

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

1114

1

}]

1115

1

		.into(),

1116

1

};

1117

1

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

1118

1119

1

	ParaA::execute_with(|| {

1120

1

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

1121

		// free execution, full amount received

1122

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1123

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1124

1

			assets: Wild(All),

1125

1

			beneficiary: beneficiary.clone(),

1126

1

		}]);

1127

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1128

1

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

1129

1

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

1130

1

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

1131

1

			Box::new(TransferType::DestinationReserve),

1132

1

			Box::new(fees_id),

1133

1

			Box::new(TransferType::DestinationReserve),

1134

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1135

1

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

1136

));

1137

1

});

1138

1139

1

	ParaA::execute_with(|| {

1140

		// free execution, full amount received

1141

1

		assert_eq!(

1142

1

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

1143

1

			Ok(U256::from(4000003000u64))

1144

);

1145

1

});

1146

1147

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

1148

	// again

1149

1

	Relay::execute_with(|| {

1150

		// free execution,x	 full amount received

1151

1

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

1152

1

});

1153

1154

	// Encode the call. Balances transact to para_a_account

1155

	// First index

1156

1

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

1157

1

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

1158

1

		relay_chain::Balances,

1159

1

>()

1160

1

	.unwrap() as u8;

1161

1162

1

	encoded.push(index);

1163

1164

	// Then call bytes

1165

1

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

1166

1

		dest: para_a_account(),

1167

1

		value: 100u32.into(),

1168

1

1169

1

	.encode();

1170

1

	encoded.append(&mut call_bytes);

1171

1172

1

	ParaA::execute_with(|| {

1173

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1174

1

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

1175

1

			parachain::MockTransactors::Relay,

1176

0,

1177

1

			CurrencyPayment {

1178

1

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

1179

1

					Location::parent()

1180

1

				))),

1181

1

				fee_amount: None

1182

1

},

1183

1

			encoded,

1184

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

1185

1

			TransactWeights {

1186

1

				transact_required_weight_at_most: 4000000000.into(),

1187

1

				overall_weight: None

1188

1

},

1189

			false

1190

));

1191

1

});

1192

1193

1

	Relay::execute_with(|| {

1194

		// free execution,x	 full amount received

1195

1

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

1196

1197

1

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

1198

1

});

1199

1

1200

1201

#[test]

1202

1

fn transact_through_derivative_with_custom_fee_weight() {

1203

1

	MockNet::reset();

1204

1205

1

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

1206

1

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

1207

1208

1

	let asset_metadata = parachain::AssetMetadata {

1209

1

		name: b"RelayToken".to_vec(),

1210

1

		symbol: b"Relay".to_vec(),

1211

1

		decimals: 12,

1212

1

};

1213

1214

1

	ParaA::execute_with(|| {

1215

1

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

1216

1

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

1217

1

			.try_into()

1218

1

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

1219

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1220

1

			source_id,

1221

1

			source_location_latest,

1222

1

			asset_metadata.decimals,

1223

1

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

1224

1

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

1225

));

1226

1

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

1227

1

});

1228

1229

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

1230

1231

1

	let dest: Location = AccountKey20 {

1232

1

		network: None,

1233

1

		key: PARAALICE,

1234

1

1235

1

	.into();

1236

1

	Relay::execute_with(|| {

1237

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

1238

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1239

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1240

1

			assets: Wild(All),

1241

1

			beneficiary: dest.clone(),

1242

1

		}]);

1243

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1244

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1245

1

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

1246

1

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

1247

1

			Box::new(TransferType::LocalReserve),

1248

1

			Box::new(fees_id),

1249

1

			Box::new(TransferType::LocalReserve),

1250

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1251

1

			WeightLimit::Unlimited

1252

));

1253

1

});

1254

1255

1

	ParaA::execute_with(|| {

1256

		// free execution, full amount received

1257

1

		assert_eq!(

1258

1

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

1259

1

			Ok(U256::from(4000003100u64))

1260

);

1261

1

});

1262

1263

	// Register address

1264

1

	ParaA::execute_with(|| {

1265

1

		assert_ok!(XcmTransactor::register(

1266

1

			parachain::RuntimeOrigin::root(),

1267

1

			PARAALICE.into(),

1268

0,

1269

));

1270

1

});

1271

1272

	// Send to registered address

1273

1274

1

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

1275

1

	let dest = Location {

1276

1

		parents: 1,

1277

1

		interior: [AccountId32 {

1278

1

			network: None,

1279

1

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

1280

1

}]

1281

1

		.into(),

1282

1

};

1283

1

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

1284

1285

1

	ParaA::execute_with(|| {

1286

1

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

1287

		// free execution, full amount received

1288

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1289

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1290

1

			assets: Wild(All),

1291

1

			beneficiary: beneficiary.clone(),

1292

1

		}]);

1293

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1294

1

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

1295

1

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

1296

1

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

1297

1

			Box::new(TransferType::DestinationReserve),

1298

1

			Box::new(fees_id),

1299

1

			Box::new(TransferType::DestinationReserve),

1300

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1301

1

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

1302

));

1303

1

});

1304

1305

1

	ParaA::execute_with(|| {

1306

		// free execution, full amount received

1307

1

		assert_eq!(

1308

1

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

1309

1

			Ok(U256::from(4000003000u64))

1310

);

1311

1

});

1312

1313

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

1314

	// again

1315

1

	Relay::execute_with(|| {

1316

		// free execution,x	 full amount received

1317

1

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

1318

1

});

1319

1320

	// Encode the call. Balances transact to para_a_account

1321

	// First index

1322

1

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

1323

1

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

1324

1

		relay_chain::Balances,

1325

1

>()

1326

1

	.unwrap() as u8;

1327

1328

1

	encoded.push(index);

1329

1330

	// Then call bytes

1331

1

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

1332

1

		dest: para_a_account(),

1333

1

		value: 100u32.into(),

1334

1

1335

1

	.encode();

1336

1

	encoded.append(&mut call_bytes);

1337

1338

1

	let overall_weight = 4000003000u64;

1339

1

	ParaA::execute_with(|| {

1340

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1341

1

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

1342

1

			parachain::MockTransactors::Relay,

1343

0,

1344

1

			CurrencyPayment {

1345

1

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

1346

1

					Location::parent()

1347

1

				))),

1348

1

				// 1-1 fee weight mapping

1349

1

				fee_amount: Some(overall_weight as u128)

1350

1

},

1351

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

1352

1

			encoded,

1353

1

			TransactWeights {

1354

1

				transact_required_weight_at_most: 4000000000.into(),

1355

1

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

1356

1

},

1357

			false

1358

));

1359

1

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

1360

1

			.iter()

1361

18

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

1362

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

1363

..

1364

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

1365

18

				_ => None,

1366

18

});

1367

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

1368

1

		assert!(event_found.is_none());

1369

1

});

1370

1371

1

	Relay::execute_with(|| {

1372

		// free execution,x	 full amount received

1373

1

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

1374

1375

1

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

1376

1

});

1377

1

1378

1379

#[test]

1380

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1381

1

	MockNet::reset();

1382

1383

1

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

1384

1

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

1385

1386

1

	let asset_metadata = parachain::AssetMetadata {

1387

1

		name: b"RelayToken".to_vec(),

1388

1

		symbol: b"Relay".to_vec(),

1389

1

		decimals: 12,

1390

1

};

1391

1392

1

	ParaA::execute_with(|| {

1393

1

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

1394

1

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

1395

1

			.try_into()

1396

1

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

1397

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1398

1

			source_id,

1399

1

			source_location_latest,

1400

1

			asset_metadata.decimals,

1401

1

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

1402

1

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

1403

));

1404

1

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

1405

1

});

1406

1407

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

1408

1409

1

	let dest: Location = AccountKey20 {

1410

1

		network: None,

1411

1

		key: PARAALICE,

1412

1

1413

1

	.into();

1414

1

	Relay::execute_with(|| {

1415

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

1416

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1417

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1418

1

			assets: Wild(All),

1419

1

			beneficiary: dest.clone(),

1420

1

		}]);

1421

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1422

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1423

1

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

1424

1

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

1425

1

			Box::new(TransferType::LocalReserve),

1426

1

			Box::new(fees_id),

1427

1

			Box::new(TransferType::LocalReserve),

1428

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1429

1

			WeightLimit::Unlimited

1430

));

1431

1

});

1432

1433

1

	ParaA::execute_with(|| {

1434

		// free execution, full amount received

1435

1

		assert_eq!(

1436

1

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

1437

1

			Ok(U256::from(4000009100u64))

1438

);

1439

1

});

1440

1441

	// Register address

1442

1

	ParaA::execute_with(|| {

1443

1

		assert_ok!(XcmTransactor::register(

1444

1

			parachain::RuntimeOrigin::root(),

1445

1

			PARAALICE.into(),

1446

0,

1447

));

1448

1

});

1449

1450

	// Send to registered address

1451

1452

1

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

1453

1

	let dest = Location {

1454

1

		parents: 1,

1455

1

		interior: [AccountId32 {

1456

1

			network: None,

1457

1

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

1458

1

}]

1459

1

		.into(),

1460

1

};

1461

1

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

1462

1463

1

	ParaA::execute_with(|| {

1464

1

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

1465

		// free execution, full amount received

1466

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1467

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1468

1

			assets: Wild(All),

1469

1

			beneficiary: beneficiary.clone(),

1470

1

		}]);

1471

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1472

1

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

1473

1

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

1474

1

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

1475

1

			Box::new(TransferType::DestinationReserve),

1476

1

			Box::new(fees_id),

1477

1

			Box::new(TransferType::DestinationReserve),

1478

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1479

1

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

1480

));

1481

1

});

1482

1483

1

	ParaA::execute_with(|| {

1484

		// free execution, full amount received

1485

1

		assert_eq!(

1486

1

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

1487

1

			Ok(U256::from(4000009000u64))

1488

);

1489

1

});

1490

1491

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

1492

	// again

1493

1

	Relay::execute_with(|| {

1494

		// free execution,x	 full amount received

1495

1

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

1496

1

});

1497

1498

	// Encode the call. Balances transact to para_a_account

1499

	// First index

1500

1

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

1501

1

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

1502

1

		relay_chain::Balances,

1503

1

>()

1504

1

	.unwrap() as u8;

1505

1506

1

	encoded.push(index);

1507

1508

	// Then call bytes

1509

1

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

1510

1

		dest: para_a_account(),

1511

1

		value: 100u32.into(),

1512

1

1513

1

	.encode();

1514

1

	encoded.append(&mut call_bytes);

1515

1516

1

	let overall_weight = 4000009000u64;

1517

1

	ParaA::execute_with(|| {

1518

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1519

1

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

1520

1

			parachain::MockTransactors::Relay,

1521

0,

1522

1

			CurrencyPayment {

1523

1

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

1524

1

					Location::parent()

1525

1

				))),

1526

1

				// 1-1 fee weight mapping

1527

1

				fee_amount: Some(overall_weight as u128)

1528

1

},

1529

1

			encoded,

1530

1

			TransactWeights {

1531

1

				transact_required_weight_at_most: 4000000000.into(),

1532

1

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

1533

1

},

1534

			true

1535

));

1536

1

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

1537

1

			.iter()

1538

18

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

1539

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

1540

..

1541

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

1542

18

				_ => None,

1543

18

});

1544

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

1545

1

		assert!(event_found.is_none());

1546

1

});

1547

1548

1

	Relay::execute_with(|| {

1549

		// free execution,x	 full amount received

1550

		// 4000009000 refunded + 100 transferred = 4000009100

1551

1

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

1552

1

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

1553

1

});

1554

1

1555

1556

#[test]

1557

1

fn transact_through_sovereign() {

1558

1

	MockNet::reset();

1559

1560

1

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

1561

1

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

1562

1563

1

	let asset_metadata = parachain::AssetMetadata {

1564

1

		name: b"RelayToken".to_vec(),

1565

1

		symbol: b"Relay".to_vec(),

1566

1

		decimals: 12,

1567

1

};

1568

1569

1

	ParaA::execute_with(|| {

1570

1

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

1571

1

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

1572

1

			.try_into()

1573

1

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

1574

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1575

1

			source_id,

1576

1

			source_location_latest,

1577

1

			asset_metadata.decimals,

1578

1

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

1579

1

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

1580

));

1581

1

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

1582

1583

		// Root can set transact info

1584

1

		assert_ok!(XcmTransactor::set_transact_info(

1585

1

			parachain::RuntimeOrigin::root(),

1586

1

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

1587

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

1588

1

			3000.into(),

1589

1

			20000000000.into(),

1590

1

			None

1591

));

1592

		// Root can set transact info

1593

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1594

1

			parachain::RuntimeOrigin::root(),

1595

1

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

1596

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1597

));

1598

1

});

1599

1600

1

	let dest: Location = AccountKey20 {

1601

1

		network: None,

1602

1

		key: PARAALICE,

1603

1

1604

1

	.into();

1605

1

	Relay::execute_with(|| {

1606

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1607

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1608

1

			assets: Wild(All),

1609

1

			beneficiary: dest.clone(),

1610

1

		}]);

1611

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1612

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1613

1

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

1614

1

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

1615

1

			Box::new(TransferType::LocalReserve),

1616

1

			Box::new(fees_id),

1617

1

			Box::new(TransferType::LocalReserve),

1618

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1619

1

			WeightLimit::Unlimited

1620

));

1621

1

});

1622

1623

1

	ParaA::execute_with(|| {

1624

		// free execution, full amount received

1625

1

		assert_eq!(

1626

1

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

1627

1

			Ok(U256::from(4000003100u64))

1628

);

1629

1

});

1630

1631

	// Register address

1632

1

	ParaA::execute_with(|| {

1633

1

		assert_ok!(XcmTransactor::register(

1634

1

			parachain::RuntimeOrigin::root(),

1635

1

			PARAALICE.into(),

1636

0,

1637

));

1638

1

});

1639

1640

	// Send to registered address

1641

1

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

1642

1

	let dest = Location {

1643

1

		parents: 1,

1644

1

		interior: [AccountId32 {

1645

1

			network: None,

1646

1

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

1647

1

}]

1648

1

		.into(),

1649

1

};

1650

1

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

1651

1652

1

	ParaA::execute_with(|| {

1653

1

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

1654

		// free execution, full amount received

1655

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1656

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1657

1

			assets: Wild(All),

1658

1

			beneficiary: beneficiary.clone(),

1659

1

		}]);

1660

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1661

1

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

1662

1

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

1663

1

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

1664

1

			Box::new(TransferType::DestinationReserve),

1665

1

			Box::new(fees_id),

1666

1

			Box::new(TransferType::DestinationReserve),

1667

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1668

1

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

1669

));

1670

1

});

1671

1672

1

	ParaA::execute_with(|| {

1673

		// free execution, full amount received

1674

1

		assert_eq!(

1675

1

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

1676

1

			Ok(U256::from(4000003000u64))

1677

);

1678

1

});

1679

1680

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

1681

	// again

1682

1

	Relay::execute_with(|| {

1683

		// free execution,x	 full amount received

1684

1

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

1685

1

1686

1

});

1687

1688

	// We send the xcm transact operation to parent

1689

1

	let dest = Location {

1690

1

		parents: 1,

1691

1

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

1692

1

};

1693

1694

	// Encode the call. Balances transact to para_a_account

1695

	// First index

1696

1

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

1697

1

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

1698

1

		relay_chain::Balances,

1699

1

>()

1700

1

	.unwrap() as u8;

1701

1702

1

	encoded.push(index);

1703

1704

	// Then call bytes

1705

1

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

1706

1

		dest: para_a_account(),

1707

1

		value: 100u32.into(),

1708

1

1709

1

	.encode();

1710

1

	encoded.append(&mut call_bytes);

1711

1712

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

1713

1

	ParaA::execute_with(|| {

1714

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

1715

1

			parachain::MockTransactors::Relay,

1716

1

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

1717

);

1718

1719

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1720

1

			parachain::RuntimeOrigin::root(),

1721

1

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

1722

1

			Some(PARAALICE.into()),

1723

1

			CurrencyPayment {

1724

1

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

1725

1

					Location::parent()

1726

1

				))),

1727

1

				fee_amount: None

1728

1

},

1729

1

			utility_bytes,

1730

1

			OriginKind::SovereignAccount,

1731

1

			TransactWeights {

1732

1

				transact_required_weight_at_most: 4000000000.into(),

1733

1

				overall_weight: None

1734

1

},

1735

			false

1736

));

1737

1

});

1738

1739

1

	Relay::execute_with(|| {

1740

		// free execution,x	 full amount received

1741

1

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

1742

1743

1

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

1744

1

});

1745

1

1746

1747

#[test]

1748

1

fn transact_through_sovereign_fee_payer_none() {

1749

1

	MockNet::reset();

1750

1751

1

	ParaA::execute_with(|| {

1752

		// Root can set transact info

1753

1

		assert_ok!(XcmTransactor::set_transact_info(

1754

1

			parachain::RuntimeOrigin::root(),

1755

1

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

1756

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

1757

1

			3000.into(),

1758

1

			20000000000.into(),

1759

1

			None

1760

));

1761

		// Root can set transact info

1762

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1763

1

			parachain::RuntimeOrigin::root(),

1764

1

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

1765

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1766

));

1767

1

});

1768

1769

1

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

1770

1771

1

	Relay::execute_with(|| {

1772

		// Transfer 100 tokens to derivative_address on the relay

1773

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1774

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1775

1

			derivative_address.clone(),

1776

			100u128

1777

));

1778

1779

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

1780

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1781

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1782

1

			para_a_account(),

1783

			4000003000u128

1784

));

1785

1

});

1786

1787

	// Check balances before the transact call

1788

1

	Relay::execute_with(|| {

1789

1

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

1790

1

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

1791

1

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

1792

1

});

1793

1794

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

1795

1

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

1796

1

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

1797

1

		relay_chain::Balances,

1798

1

>()

1799

1

	.unwrap() as u8;

1800

1801

1

	encoded.push(index);

1802

1803

1

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

1804

1

		dest: RELAYBOB,

1805

1

		value: 100u32.into(),

1806

1

1807

1

	.encode();

1808

1

	encoded.append(&mut call_bytes);

1809

1810

	// We send the xcm transact operation to parent

1811

1

	let dest = Location {

1812

1

		parents: 1,

1813

1

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

1814

1

};

1815

1816

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

1817

1

	ParaA::execute_with(|| {

1818

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

1819

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

1820

1

			parachain::MockTransactors::Relay,

1821

1

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

1822

);

1823

1824

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1825

1

			parachain::RuntimeOrigin::root(),

1826

1

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

1827

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

1828

1

			None,

1829

1

			CurrencyPayment {

1830

1

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

1831

1

					Location::parent()

1832

1

				))),

1833

1

				fee_amount: None

1834

1

},

1835

1

			utility_bytes,

1836

1

			OriginKind::SovereignAccount,

1837

1

			TransactWeights {

1838

1

				transact_required_weight_at_most: 4000000000.into(),

1839

1

				overall_weight: None

1840

1

},

1841

			false

1842

));

1843

1

});

1844

1845

	// Check balances after the transact call are correct

1846

1

	Relay::execute_with(|| {

1847

1

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

1848

1

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

1849

1

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

1850

1

});

1851

1

1852

1853

#[test]

1854

1

fn transact_through_sovereign_with_custom_fee_weight() {

1855

1

	MockNet::reset();

1856

1857

1

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

1858

1

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

1859

1860

1

	let asset_metadata = parachain::AssetMetadata {

1861

1

		name: b"RelayToken".to_vec(),

1862

1

		symbol: b"Relay".to_vec(),

1863

1

		decimals: 12,

1864

1

};

1865

1866

1

	ParaA::execute_with(|| {

1867

1

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

1868

1

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

1869

1

			.try_into()

1870

1

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

1871

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1872

1

			source_id,

1873

1

			source_location_latest,

1874

1

			asset_metadata.decimals,

1875

1

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

1876

1

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

1877

));

1878

1

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

1879

1

});

1880

1881

1

	let dest: Location = AccountKey20 {

1882

1

		network: None,

1883

1

		key: PARAALICE,

1884

1

1885

1

	.into();

1886

1

	Relay::execute_with(|| {

1887

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

1888

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1889

1

			assets: Wild(All),

1890

1

			beneficiary: dest.clone(),

1891

1

		}]);

1892

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1893

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1894

1

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

1895

1

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

1896

1

			Box::new(TransferType::LocalReserve),

1897

1

			Box::new(fees_id),

1898

1

			Box::new(TransferType::LocalReserve),

1899

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1900

1

			WeightLimit::Unlimited

1901

));

1902

1

});

1903

1904

1

	ParaA::execute_with(|| {

1905

		// free execution, full amount received

1906

1

		assert_eq!(

1907

1

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

1908

1

			Ok(U256::from(4000003100u64))

1909

);

1910

1

});

1911

1912

	// Register address

1913

1

	ParaA::execute_with(|| {

1914

1

		assert_ok!(XcmTransactor::register(

1915

1

			parachain::RuntimeOrigin::root(),

1916

1

			PARAALICE.into(),

1917

0,

1918

));

1919

1

});

1920

1921

	// Send to registered address

1922

1

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

1923

1

	let dest = Location {

1924

1

		parents: 1,

1925

1

		interior: [AccountId32 {

1926

1

			network: None,

1927

1

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

1928

1

}]

1929

1

		.into(),

1930

1

};

1931

1

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

1932

1933

1

	ParaA::execute_with(|| {

1934

1

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

1935

		// free execution, full amount received

1936

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1937

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1938

1

			assets: Wild(All),

1939

1

			beneficiary: beneficiary.clone(),

1940

1

		}]);

1941

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1942

1

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

1943

1

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

1944

1

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

1945

1

			Box::new(TransferType::DestinationReserve),

1946

1

			Box::new(fees_id),

1947

1

			Box::new(TransferType::DestinationReserve),

1948

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

1949

1

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

1950

));

1951

1

});

1952

1953

1

	ParaA::execute_with(|| {

1954

		// free execution, full amount received

1955

1

		assert_eq!(

1956

1

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

1957

1

			Ok(U256::from(4000003000u64))

1958

);

1959

1

});

1960

1961

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

1962

	// again

1963

1

	Relay::execute_with(|| {

1964

		// free execution,x	 full amount received

1965

1

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

1966

1

1967

1

});

1968

1969

	// We send the xcm transact operation to parent

1970

1

	let dest = Location {

1971

1

		parents: 1,

1972

1

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

1973

1

};

1974

1975

	// Encode the call. Balances transact to para_a_account

1976

	// First index

1977

1

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

1978

1

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

1979

1

		relay_chain::Balances,

1980

1

>()

1981

1

	.unwrap() as u8;

1982

1983

1

	encoded.push(index);

1984

1985

	// Then call bytes

1986

1

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

1987

1

		dest: para_a_account(),

1988

1

		value: 100u32.into(),

1989

1

1990

1

	.encode();

1991

1

	encoded.append(&mut call_bytes);

1992

1993

1

	let total_weight = 4000003000u64;

1994

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

1995

1

	ParaA::execute_with(|| {

1996

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

1997

1

			parachain::MockTransactors::Relay,

1998

1

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

1999

);

2000

2001

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2002

1

			parachain::RuntimeOrigin::root(),

2003

1

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

2004

1

			Some(PARAALICE.into()),

2005

1

			CurrencyPayment {

2006

1

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

2007

1

					Location::parent()

2008

1

				))),

2009

1

				// 1-1 fee-weight mapping

2010

1

				fee_amount: Some(total_weight as u128)

2011

1

},

2012

1

			utility_bytes,

2013

1

			OriginKind::SovereignAccount,

2014

1

			TransactWeights {

2015

1

				transact_required_weight_at_most: 4000000000.into(),

2016

1

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

2017

1

},

2018

			false

2019

));

2020

1

});

2021

2022

1

	Relay::execute_with(|| {

2023

		// free execution,x	 full amount received

2024

1

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

2025

2026

1

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

2027

1

});

2028

1

2029

2030

#[test]

2031

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2032

1

	MockNet::reset();

2033

2034

1

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

2035

1

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

2036

2037

1

	let asset_metadata = parachain::AssetMetadata {

2038

1

		name: b"RelayToken".to_vec(),

2039

1

		symbol: b"Relay".to_vec(),

2040

1

		decimals: 12,

2041

1

};

2042

2043

1

	ParaA::execute_with(|| {

2044

1

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

2045

1

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

2046

1

			.try_into()

2047

1

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

2048

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2049

1

			source_id,

2050

1

			source_location_latest,

2051

1

			asset_metadata.decimals,

2052

1

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

2053

1

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

2054

));

2055

1

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

2056

1

});

2057

2058

1

	let dest: Location = AccountKey20 {

2059

1

		network: None,

2060

1

		key: PARAALICE,

2061

1

2062

1

	.into();

2063

1

	Relay::execute_with(|| {

2064

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2065

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2066

1

			assets: Wild(All),

2067

1

			beneficiary: dest.clone(),

2068

1

		}]);

2069

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2070

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2071

1

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

2072

1

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

2073

1

			Box::new(TransferType::LocalReserve),

2074

1

			Box::new(fees_id),

2075

1

			Box::new(TransferType::LocalReserve),

2076

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2077

1

			WeightLimit::Unlimited

2078

));

2079

1

});

2080

2081

1

	ParaA::execute_with(|| {

2082

		// free execution, full amount received

2083

1

		assert_eq!(

2084

1

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

2085

1

			Ok(U256::from(4000009100u64))

2086

);

2087

1

});

2088

2089

	// Register address

2090

1

	ParaA::execute_with(|| {

2091

1

		assert_ok!(XcmTransactor::register(

2092

1

			parachain::RuntimeOrigin::root(),

2093

1

			PARAALICE.into(),

2094

0,

2095

));

2096

1

});

2097

2098

	// Send to registered address

2099

1

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

2100

1

	let dest = Location {

2101

1

		parents: 1,

2102

1

		interior: [AccountId32 {

2103

1

			network: None,

2104

1

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

2105

1

}]

2106

1

		.into(),

2107

1

};

2108

1

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

2109

2110

1

	ParaA::execute_with(|| {

2111

1

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

2112

		// free execution, full amount received

2113

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

2114

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2115

1

			assets: Wild(All),

2116

1

			beneficiary: beneficiary.clone(),

2117

1

		}]);

2118

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2119

1

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

2120

1

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

2121

1

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

2122

1

			Box::new(TransferType::DestinationReserve),

2123

1

			Box::new(fees_id),

2124

1

			Box::new(TransferType::DestinationReserve),

2125

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2126

1

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

2127

));

2128

1

});

2129

2130

1

	ParaA::execute_with(|| {

2131

		// free execution, full amount received

2132

1

		assert_eq!(

2133

1

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

2134

1

			Ok(U256::from(4000009000u64))

2135

);

2136

1

});

2137

2138

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

2139

	// again

2140

1

	Relay::execute_with(|| {

2141

		// free execution,x	 full amount received

2142

1

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

2143

1

2144

1

});

2145

2146

	// We send the xcm transact operation to parent

2147

1

	let dest = Location {

2148

1

		parents: 1,

2149

1

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

2150

1

};

2151

2152

	// Encode the call. Balances transact to para_a_account

2153

	// First index

2154

1

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

2155

1

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

2156

1

		relay_chain::Balances,

2157

1

>()

2158

1

	.unwrap() as u8;

2159

2160

1

	encoded.push(index);

2161

2162

	// Then call bytes

2163

1

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

2164

1

		dest: para_a_account(),

2165

1

		value: 100u32.into(),

2166

1

2167

1

	.encode();

2168

1

	encoded.append(&mut call_bytes);

2169

2170

1

	let total_weight = 4000009000u64;

2171

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

2172

1

	ParaA::execute_with(|| {

2173

1

		let utility_bytes = <XcmTransactor as UtilityEncodeCall>::encode_call(

2174

1

			parachain::MockTransactors::Relay,

2175

1

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

2176

);

2177

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

			true

2196

));

2197

1

});

2198

2199

1

	Relay::execute_with(|| {

2200

		// free execution, full amount received

2201

		// 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

2212

1

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

2213

1

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

2214

1

	let asset_metadata = parachain::AssetMetadata {

2215

1

		name: b"RelayToken".to_vec(),

2216

1

		symbol: b"Relay".to_vec(),

2217

1

		decimals: 12,

2218

1

};

2219

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

2220

1

	ParaA::execute_with(|| {

2221

1

		parachain::XcmVersioner::set_version(1);

2222

1

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

2223

1

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

2224

1

			.try_into()

2225

1

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

2226

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2227

1

			source_id,

2228

1

			source_location_latest,

2229

1

			asset_metadata.decimals,

2230

1

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

2231

1

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

2232

));

2233

1

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

2234

1

});

2235

2236

1

	let response = Response::Version(2);

2237

1

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

2238

2239

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

2240

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

2241

1

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

2242

1

		query_id: 0,

2243

1

		response,

2244

1

		max_weight: Weight::zero(),

2245

1

		querier: Some(querier),

2246

1

	}]);

2247

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

2248

	// it directly here

2249

	// Actually send relay asset to parachain

2250

1

	let dest: Location = AccountKey20 {

2251

1

		network: None,

2252

1

		key: PARAALICE,

2253

1

2254

1

	.into();

2255

2256

1

	Relay::execute_with(|| {

2257

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

2258

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2259

1

			relay_chain::RuntimeOrigin::root(),

2260

1

			Some(3)

2261

));

2262

2263

		// Wrap version, which sets VersionedStorage

2264

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

2265

		// this is not necessary in prod

2266

1

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

2267

1

			&Parachain(1).into(),

2268

1

			mock_message

2269

));

2270

2271

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

2272

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2273

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2274

1

			assets: Wild(All),

2275

1

			beneficiary: dest.clone(),

2276

1

		}]);

2277

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2278

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2279

1

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

2280

1

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

2281

1

			Box::new(TransferType::LocalReserve),

2282

1

			Box::new(fees_id),

2283

1

			Box::new(TransferType::LocalReserve),

2284

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2285

1

			WeightLimit::Unlimited

2286

));

2287

2288

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

2289

1

		relay_chain::relay_roll_to(2);

2290

2291

		// queries should have been updated

2292

1

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

2293

1

});

2294

2295

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2296

1

		pallet_xcm::Event::SupportedVersionChanged {

2297

1

			location: Location {

2298

1

				parents: 0,

2299

1

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

2300

1

},

2301

1

			version: 1,

2302

1

2303

1

		.into();

2304

2305

1

	Relay::execute_with(|| {

2306

		// Assert that the events vector contains the version change

2307

1

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

2308

1

});

2309

2310

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

2311

	// of the new version change

2312

1

	ParaA::execute_with(|| {

2313

		// Set version

2314

1

		parachain::XcmVersioner::set_version(2);

2315

		// Do runtime upgrade

2316

1

		parachain::on_runtime_upgrade();

2317

		// Initialize block, to call on_initialize and notify targets

2318

1

		parachain::para_roll_to(2);

2319

		// Expect the event in the parachain

2320

1

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

2321

2

e,

2322

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

2323

				result: 2,

2324

..

2325

})

2326

		)));

2327

1

});

2328

2329

	// This event should have been seen in the relay

2330

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2331

1

		pallet_xcm::Event::SupportedVersionChanged {

2332

1

			location: Location {

2333

1

				parents: 0,

2334

1

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

2335

1

},

2336

1

			version: 2,

2337

1

2338

1

		.into();

2339

2340

1

	Relay::execute_with(|| {

2341

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

2342

1

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

2343

1

});

2344

1

2345

2346

#[test]

2347

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2348

1

	MockNet::reset();

2349

2350

1

	let fresh_account = PARABOB;

2351

1

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

2352

1

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

2353

1

	let asset_metadata = parachain::AssetMetadata {

2354

1

		name: b"RelayToken".to_vec(),

2355

1

		symbol: b"Relay".to_vec(),

2356

1

		decimals: 12,

2357

1

};

2358

	// register relay asset in parachain A

2359

1

	ParaA::execute_with(|| {

2360

1

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

2361

1

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

2362

1

			.try_into()

2363

1

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

2364

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2365

1

			source_id,

2366

1

			source_location_latest,

2367

1

			asset_metadata.decimals,

2368

1

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

2369

1

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

2370

));

2371

1

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

2372

1

});

2373

2374

	// Actually send relay asset to parachain

2375

1

	let dest: Location = AccountKey20 {

2376

1

		network: None,

2377

1

		key: fresh_account,

2378

1

2379

1

	.into();

2380

1

	Relay::execute_with(|| {

2381

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2382

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2383

1

			assets: Wild(All),

2384

1

			beneficiary: dest.clone(),

2385

1

		}]);

2386

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2387

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2388

1

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

2389

1

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

2390

1

			Box::new(TransferType::LocalReserve),

2391

1

			Box::new(fees_id),

2392

1

			Box::new(TransferType::LocalReserve),

2393

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2394

1

			WeightLimit::Unlimited

2395

));

2396

1

});

2397

2398

	// parachain should have received assets

2399

1

	ParaA::execute_with(|| {

2400

		// free execution, full amount received

2401

1

		assert_eq!(

2402

1

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

2403

1

			Ok(U256::from(123))

2404

);

2405

1

});

2406

1

2407

2408

#[test]

2409

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2410

1

	MockNet::reset();

2411

2412

1

	let fresh_account = [2u8; 20];

2413

1

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

2414

1

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

2415

1

	let asset_metadata = parachain::AssetMetadata {

2416

1

		name: b"RelayToken".to_vec(),

2417

1

		symbol: b"Relay".to_vec(),

2418

1

		decimals: 12,

2419

1

};

2420

	// register relay asset in parachain A

2421

1

	ParaA::execute_with(|| {

2422

1

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

2423

1

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

2424

1

			.try_into()

2425

1

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

2426

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2427

1

			source_id,

2428

1

			source_location_latest,

2429

1

			asset_metadata.decimals,

2430

1

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

2431

1

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

2432

));

2433

1

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

2434

1

});

2435

2436

	// Actually send relay asset to parachain

2437

1

	let dest: Location = AccountKey20 {

2438

1

		network: None,

2439

1

		key: fresh_account,

2440

1

2441

1

	.into();

2442

1

	Relay::execute_with(|| {

2443

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2444

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2445

1

			assets: Wild(All),

2446

1

			beneficiary: dest.clone(),

2447

1

		}]);

2448

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2449

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2450

1

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

2451

1

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

2452

1

			Box::new(TransferType::LocalReserve),

2453

1

			Box::new(fees_id),

2454

1

			Box::new(TransferType::LocalReserve),

2455

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2456

1

			WeightLimit::Unlimited

2457

));

2458

1

});

2459

2460

	// parachain should have received assets

2461

1

	ParaA::execute_with(|| {

2462

		// free execution, full amount received

2463

1

		assert_eq!(

2464

1

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

2465

1

			Ok(U256::from(123))

2466

);

2467

1

});

2468

1

2469

2470

#[test]

2471

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2472

1

	MockNet::reset();

2473

2474

1

	let mut sufficient_account = [0u8; 20];

2475

1

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

2476

2477

1

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

2478

2479

	// Evm account is self sufficient

2480

1

	ParaA::execute_with(|| {

2481

1

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

2482

1

});

2483

2484

1

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

2485

1

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

2486

1

	let asset_metadata = parachain::AssetMetadata {

2487

1

		name: b"RelayToken".to_vec(),

2488

1

		symbol: b"Relay".to_vec(),

2489

1

		decimals: 12,

2490

1

};

2491

	// register relay asset in parachain A

2492

1

	ParaA::execute_with(|| {

2493

1

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

2494

1

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

2495

1

			.try_into()

2496

1

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

2497

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2498

1

			source_id,

2499

1

			source_location_latest,

2500

1

			asset_metadata.decimals,

2501

1

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

2502

1

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

2503

));

2504

1

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

2505

1

});

2506

2507

	// Actually send relay asset to parachain

2508

1

	let dest: Location = AccountKey20 {

2509

1

		network: None,

2510

1

		key: sufficient_account,

2511

1

2512

1

	.into();

2513

1

	Relay::execute_with(|| {

2514

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2515

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2516

1

			assets: Wild(All),

2517

1

			beneficiary: dest.clone(),

2518

1

		}]);

2519

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2520

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2521

1

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

2522

1

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

2523

1

			Box::new(TransferType::LocalReserve),

2524

1

			Box::new(fees_id),

2525

1

			Box::new(TransferType::LocalReserve),

2526

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2527

1

			WeightLimit::Unlimited

2528

));

2529

1

});

2530

2531

	// Evm account sufficient ref count increased by 1.

2532

1

	ParaA::execute_with(|| {

2533

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

2534

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

2535

		// will be implemented in a future release

2536

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

2537

1

});

2538

2539

1

	ParaA::execute_with(|| {

2540

		// Remove the account from the evm context.

2541

1

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

2542

		// Evm account sufficient ref count decreased by 1.

2543

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

2544

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

2545

		// will be implemented in a future release

2546

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

2547

1

});

2548

1

2549

2550

#[test]

2551

1

fn empty_account_should_not_be_reset() {

2552

1

	MockNet::reset();

2553

2554

	// Test account has nonce 1 on genesis.

2555

1

	let sufficient_account = PARABOB;

2556

2557

1

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

2558

2559

1

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

2560

1

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

2561

1

	let asset_metadata = parachain::AssetMetadata {

2562

1

		name: b"RelayToken".to_vec(),

2563

1

		symbol: b"Relay".to_vec(),

2564

1

		decimals: 12,

2565

1

};

2566

	// register relay asset in parachain A

2567

1

	ParaA::execute_with(|| {

2568

1

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

2569

1

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

2570

1

			.try_into()

2571

1

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

2572

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2573

1

			source_id,

2574

1

			source_location_latest,

2575

1

			asset_metadata.decimals,

2576

1

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

2577

1

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

2578

));

2579

1

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

2580

1

});

2581

2582

	// Send native token to evm_account

2583

1

	ParaA::execute_with(|| {

2584

1

		assert_ok!(ParaBalances::transfer_allow_death(

2585

1

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

2586

1

			evm_account_id,

2587

2588

));

2589

1

});

2590

2591

	// Actually send relay asset to parachain

2592

1

	let dest: Location = AccountKey20 {

2593

1

		network: None,

2594

1

		key: sufficient_account,

2595

1

2596

1

	.into();

2597

1

	Relay::execute_with(|| {

2598

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2599

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2600

1

			assets: Wild(All),

2601

1

			beneficiary: dest.clone(),

2602

1

		}]);

2603

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2604

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2605

1

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

2606

1

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

2607

1

			Box::new(TransferType::LocalReserve),

2608

1

			Box::new(fees_id),

2609

1

			Box::new(TransferType::LocalReserve),

2610

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2611

1

			WeightLimit::Unlimited

2612

));

2613

1

});

2614

2615

1

	ParaA::execute_with(|| {

2616

		// Empty the assets from the account.

2617

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

2618

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

2619

		// Transfer using EvmForeignAssets

2620

1

		assert_ok!(EvmForeignAssets::transfer(

2621

1

			source_id,

2622

1

			evm_account_id,

2623

1

			PARAALICE.into(),

2624

1

			U256::from(123)

2625

));

2626

		// Verify account asset balance is Zero.

2627

1

		assert_eq!(

2628

1

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

2629

1

			Ok(U256::from(0))

2630

);

2631

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

2632

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

2633

1

		assert_ok!(ParaBalances::force_set_balance(

2634

1

			parachain::RuntimeOrigin::root(),

2635

1

			evm_account_id,

2636

0,

2637

));

2638

		// Verify account native balance is Zero.

2639

1

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

2640

		// Remove the account from the evm context.

2641

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

2642

1

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

2643

		// Verify reference count.

2644

1

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

2645

1

		assert_eq!(account.sufficients, 0);

2646

1

		assert_eq!(account.consumers, 0);

2647

1

		assert_eq!(account.providers, 1);

2648

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

2649

1

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

2650

1

});

2651

1

2652

2653

#[test]

2654

1

fn test_statemint_like() {

2655

1

	MockNet::reset();

2656

2657

1

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

2658

2659

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2660

1

		polkadot_parachain::primitives::Sibling,

2661

1

		statemint_like::AccountId,

2662

1

	>::convert_location(&dest_para)

2663

1

	.unwrap();

2664

2665

1

	let statemint_asset_a_balances = Location::new(

2666

1,

2667

1

2668

1

			Parachain(1000),

2669

1

			PalletInstance(5),

2670

1

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

2671

1

],

2672

);

2673

1

	let source_location: AssetType = statemint_asset_a_balances

2674

1

		.try_into()

2675

1

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

2676

1

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

2677

2678

1

	let asset_metadata = parachain::AssetMetadata {

2679

1

		name: b"StatemintToken".to_vec(),

2680

1

		symbol: b"StatemintToken".to_vec(),

2681

1

		decimals: 12,

2682

1

};

2683

2684

1

	ParaA::execute_with(|| {

2685

1

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

2686

1

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

2687

1

			.try_into()

2688

1

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

2689

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2690

1

			source_id,

2691

1

			source_location_latest,

2692

1

			asset_metadata.decimals,

2693

1

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

2694

1

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

2695

));

2696

1

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

2697

1

});

2698

2699

1

	Statemint::execute_with(|| {

2700

		// Set new prefix

2701

1

		statemint_like::PrefixChanger::set_prefix(

2702

1

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

2703

);

2704

2705

1

		assert_ok!(StatemintAssets::create(

2706

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2707

0,

2708

			RELAYALICE,

2709

2710

));

2711

2712

1

		assert_ok!(StatemintAssets::mint(

2713

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2714

0,

2715

			RELAYALICE,

2716

			300000000000000

2717

));

2718

2719

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

2720

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2721

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2722

1

			sov,

2723

			100000000000000

2724

));

2725

2726

		// Actually send relay asset to parachain

2727

1

		let dest: Location = AccountKey20 {

2728

1

			network: None,

2729

1

			key: PARAALICE,

2730

1

2731

1

		.into();

2732

2733

		// Send with new prefix

2734

1

		let assets: VersionedAssets = (

2735

1

2736

1

				xcm::latest::prelude::PalletInstance(

2737

1

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

2738

1

),

2739

1

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

2740

1

],

2741

1

			123,

2742

1

2743

1

			.into();

2744

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

2745

1

0,

2746

1

2747

1

				xcm::latest::prelude::PalletInstance(

2748

1

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

2749

1

),

2750

1

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

2751

1

],

2752

1

))

2753

1

		.into();

2754

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2755

1

			assets: Wild(All),

2756

1

			beneficiary: dest.clone(),

2757

1

		}]);

2758

1

		assert_ok!(

2759

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

2760

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

2761

1

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

2762

1

				Box::new(assets),

2763

1

				Box::new(TransferType::LocalReserve),

2764

1

				Box::new(fees_id),

2765

1

				Box::new(TransferType::LocalReserve),

2766

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

2767

1

				WeightLimit::Unlimited

2768

2769

);

2770

1

});

2771

2772

1

	ParaA::execute_with(|| {

2773

1

		assert_eq!(

2774

1

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

2775

1

			Ok(U256::from(123))

2776

);

2777

1

});

2778

1

2779

2780

#[test]

2781

2782

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2783

1

	MockNet::reset();

2784

2785

	// Relay asset

2786

1

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

2787

1

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

2788

2789

1

	let relay_asset_metadata = parachain::AssetMetadata {

2790

1

		name: b"RelayToken".to_vec(),

2791

1

		symbol: b"Relay".to_vec(),

2792

1

		decimals: 12,

2793

1

};

2794

2795

	// Statemint asset

2796

1

	let statemint_asset = Location::new(

2797

1,

2798

1

2799

1

			Parachain(1000u32),

2800

1

			PalletInstance(5u8),

2801

1

			GeneralIndex(10u128),

2802

1

],

2803

);

2804

1

	let statemint_location_asset: AssetType = statemint_asset

2805

1

		.clone()

2806

1

		.try_into()

2807

1

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

2808

1

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

2809

2810

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2811

1

		name: b"USDC".to_vec(),

2812

1

		symbol: b"USDC".to_vec(),

2813

1

		decimals: 12,

2814

1

};

2815

2816

1

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

2817

2818

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2819

1

		polkadot_parachain::primitives::Sibling,

2820

1

		statemint_like::AccountId,

2821

1

	>::convert_location(&dest_para)

2822

1

	.unwrap();

2823

2824

1

	ParaA::execute_with(|| {

2825

1

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

2826

1

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

2827

1

			.try_into()

2828

1

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

2829

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2830

1

			source_relay_id,

2831

1

			source_location_latest,

2832

1

			relay_asset_metadata.decimals,

2833

1

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

2834

1

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

2835

));

2836

1

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

2837

2838

1

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

2839

1

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

2840

1

			.try_into()

2841

1

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

2842

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2843

1

			source_statemint_asset_id,

2844

1

			source_location_latest,

2845

1

			asset_metadata_statemint_asset.decimals,

2846

1

			asset_metadata_statemint_asset

2847

1

				.symbol

2848

1

				.try_into()

2849

1

				.expect("too long"),

2850

1

			asset_metadata_statemint_asset

2851

1

				.name

2852

1

				.try_into()

2853

1

				.expect("too long"),

2854

));

2855

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0u128));

2856

1

});

2857

2858

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2859

1

		network: None,

2860

1

		key: PARAALICE,

2861

1

2862

1

	.into();

2863

2864

	// Send relay chain asset to Alice in Parachain A

2865

1

	Relay::execute_with(|| {

2866

1

		let assets: VersionedAssets = ([] /* Here */, 200).into();

2867

1

		let fees_id: VersionedAssetId = AssetId(Location::here()).into();

2868

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2869

1

			assets: Wild(All),

2870

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

2871

1

		}]);

2872

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2873

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2874

1

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

2875

1

			Box::new(assets),

2876

1

			Box::new(TransferType::LocalReserve),

2877

1

			Box::new(fees_id),

2878

1

			Box::new(TransferType::LocalReserve),

2879

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

2880

1

			WeightLimit::Unlimited

2881

));

2882

1

});

2883

2884

1

	Statemint::execute_with(|| {

2885

		// Set new prefix

2886

1

		statemint_like::PrefixChanger::set_prefix(

2887

1

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

2888

);

2889

2890

1

		assert_ok!(StatemintAssets::create(

2891

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2892

10,

2893

			RELAYALICE,

2894

2895

));

2896

2897

1

		assert_ok!(StatemintAssets::mint(

2898

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2899

10,

2900

			RELAYALICE,

2901

			300000000000000

2902

));

2903

2904

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

2905

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

2906

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2907

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2908

1

			sov,

2909

			100000000000000

2910

));

2911

2912

		// Send statemint USDC asset to Alice in Parachain A

2913

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2914

1

			network: None,

2915

1

			key: PARAALICE,

2916

1

2917

1

		.into();

2918

2919

		// Send with new prefix

2920

1

		let assets: VersionedAssets = (

2921

1

2922

1

				xcm::latest::prelude::PalletInstance(

2923

1

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

2924

1

),

2925

1

				GeneralIndex(10),

2926

1

],

2927

1

			125,

2928

1

2929

1

			.into();

2930

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

2931

1

0,

2932

1

2933

1

				xcm::latest::prelude::PalletInstance(

2934

1

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

2935

1

),

2936

1

				GeneralIndex(10),

2937

1

],

2938

1

))

2939

1

		.into();

2940

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

2941

1

			assets: Wild(All),

2942

1

			beneficiary: parachain_beneficiary_from_statemint.clone(),

2943

1

		}]);

2944

1

		assert_ok!(

2945

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

2946

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

2947

1

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

2948

1

				Box::new(assets),

2949

1

				Box::new(TransferType::LocalReserve),

2950

1

				Box::new(fees_id),

2951

1

				Box::new(TransferType::LocalReserve),

2952

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

2953

1

				WeightLimit::Unlimited

2954

2955

);

2956

1

});

2957

2958

1

	let statemint_beneficiary = Location {

2959

1

		parents: 1,

2960

1

		interior: [

2961

1

			Parachain(1000),

2962

1

			AccountId32 {

2963

1

				network: None,

2964

1

				id: RELAYBOB.into(),

2965

1

},

2966

1

2967

1

		.into(),

2968

1

};

2969

2970

1

	ParaA::execute_with(|| {

2971

		// Alice has received 125 USDC

2972

1

		assert_eq!(

2973

1

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

2974

1

			Ok(U256::from(125))

2975

);

2976

2977

		// Alice has received 200 Relay assets

2978

1

		assert_eq!(

2979

1

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

2980

1

			Ok(U256::from(200))

2981

);

2982

1

});

2983

2984

1

	Statemint::execute_with(|| {

2985

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

2986

1

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

2987

1

});

2988

1

	let (chain_part, beneficiary) =

2989

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2990

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

2991

1

	ParaA::execute_with(|| {

2992

1

		let asset = currency_to_asset(

2993

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2994

			100,

2995

);

2996

1

		let asset_fee =

2997

1

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

2998

1

		let assets_to_send: XcmAssets = XcmAssets::from(vec![asset, asset_fee.clone()]);

2999

1

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

3000

3001

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3002

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3003

1

			assets: Wild(All),

3004

1

			beneficiary: beneficiary.clone(),

3005

1

		}]);

3006

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3007

1

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

3008

1

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

3009

1

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

3010

1

			Box::new(TransferType::DestinationReserve),

3011

1

			Box::new(fees_id),

3012

1

			Box::new(TransferType::DestinationReserve),

3013

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3014

1

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

3015

));

3016

1

});

3017

3018

1

	ParaA::execute_with(|| {

3019

		// Alice has 100 USDC less

3020

1

		assert_eq!(

3021

1

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

3022

1

			Ok(U256::from(25))

3023

);

3024

3025

		// Alice has 100 relay asset less

3026

1

		assert_eq!(

3027

1

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

3028

1

			Ok(U256::from(100))

3029

);

3030

1

});

3031

3032

1

	Statemint::execute_with(|| {

3033

1

		println!("STATEMINT EVENTS: {:?}", parachain::para_events());

3034

		// Check that BOB received 100 USDC on statemint

3035

1

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

3036

1

});

3037

1

3038

3039

#[test]

3040

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3041

1

	MockNet::reset();

3042

3043

	// Relay asset

3044

1

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

3045

1

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

3046

3047

1

	let relay_asset_metadata = parachain::AssetMetadata {

3048

1

		name: b"RelayToken".to_vec(),

3049

1

		symbol: b"Relay".to_vec(),

3050

1

		decimals: 12,

3051

1

};

3052

3053

1

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

3054

3055

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3056

1

		polkadot_parachain::primitives::Sibling,

3057

1

		statemint_like::AccountId,

3058

1

	>::convert_location(&dest_para)

3059

1

	.unwrap();

3060

3061

1

	ParaA::execute_with(|| {

3062

1

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

3063

1

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

3064

1

			.try_into()

3065

1

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

3066

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3067

1

			source_relay_id,

3068

1

			source_location_latest,

3069

1

			relay_asset_metadata.decimals,

3070

1

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

3071

1

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

3072

));

3073

1

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

3074

1

});

3075

3076

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3077

1

		network: None,

3078

1

		key: PARAALICE,

3079

1

3080

1

	.into();

3081

3082

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3083

1

		network: None,

3084

1

		id: RELAYALICE.into(),

3085

1

3086

1

	.into();

3087

3088

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

3089

1

	Relay::execute_with(|| {

3090

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3091

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3092

1

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

3093

1

			Box::new(

3094

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3095

1

					.clone()

3096

1

					.into()

3097

),

3098

1

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

3099

0,

3100

1

			WeightLimit::Unlimited

3101

));

3102

1

});

3103

3104

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3105

1

	Statemint::execute_with(|| {

3106

		// Check Alice received 200 tokens on AssetHub

3107

1

		assert_eq!(

3108

1

			StatemintBalances::free_balance(RELAYALICE),

3109

			INITIAL_BALANCE + 200

3110

);

3111

3112

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3113

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3114

1

			sov,

3115

			110000000000000

3116

));

3117

3118

		// Now send those tokens to ParaA

3119

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

3120

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3121

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3122

1

			assets: Wild(All),

3123

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3124

1

		}]);

3125

1

		assert_ok!(

3126

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3127

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3128

1

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

3129

1

				Box::new(assets),

3130

1

				Box::new(TransferType::LocalReserve),

3131

1

				Box::new(fees_id),

3132

1

				Box::new(TransferType::LocalReserve),

3133

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3134

1

				WeightLimit::Unlimited

3135

3136

);

3137

1

});

3138

3139

1

	ParaA::execute_with(|| {

3140

		// Alice should have received the DOTs

3141

1

		assert_eq!(

3142

1

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

3143

1

			Ok(U256::from(200))

3144

);

3145

1

});

3146

3147

1

	let dest = Location::new(

3148

1,

3149

1

3150

1

			Parachain(1000),

3151

1

			AccountId32 {

3152

1

				network: None,

3153

1

				id: RELAYBOB.into(),

3154

1

},

3155

1

],

3156

);

3157

1

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

3158

3159

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

3160

1

	ParaA::execute_with(|| {

3161

1

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

3162

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3163

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3164

1

			assets: Wild(All),

3165

1

			beneficiary: beneficiary.clone(),

3166

1

		}]);

3167

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3168

1

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

3169

1

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

3170

1

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

3171

1

			Box::new(TransferType::DestinationReserve),

3172

1

			Box::new(fees_id),

3173

1

			Box::new(TransferType::DestinationReserve),

3174

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3175

1

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

3176

));

3177

3178

1

		assert_eq!(

3179

1

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

3180

1

			Ok(U256::from(100))

3181

);

3182

1

});

3183

3184

1

	Statemint::execute_with(|| {

3185

		// Check that Bob received the tokens back in AssetHub

3186

1

		assert_eq!(

3187

1

			StatemintBalances::free_balance(RELAYBOB),

3188

			INITIAL_BALANCE + 100

3189

);

3190

1

});

3191

3192

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

3193

1

	Statemint::execute_with(|| {

3194

		// Now send those tokens to ParaA

3195

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3196

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3197

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3198

1

			assets: Wild(All),

3199

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3200

1

		}]);

3201

1

		assert_ok!(

3202

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3203

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3204

1

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

3205

1

				Box::new(assets),

3206

1

				Box::new(TransferType::LocalReserve),

3207

1

				Box::new(fees_id),

3208

1

				Box::new(TransferType::LocalReserve),

3209

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3210

1

				WeightLimit::Unlimited

3211

3212

);

3213

3214

		// 100 DOTs were deducted from Bob's account

3215

1

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

3216

1

});

3217

3218

1

	ParaA::execute_with(|| {

3219

		// Alice should have received 100 DOTs

3220

1

		assert_eq!(

3221

1

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

3222

1

			Ok(U256::from(200))

3223

);

3224

1

});

3225

1

3226

3227

#[test]

3228

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3229

1

	MockNet::reset();

3230

3231

	// Relay asset

3232

1

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

3233

1

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

3234

3235

1

	let relay_asset_metadata = parachain::AssetMetadata {

3236

1

		name: b"RelayToken".to_vec(),

3237

1

		symbol: b"Relay".to_vec(),

3238

1

		decimals: 12,

3239

1

};

3240

3241

1

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

3242

3243

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3244

1

		polkadot_parachain::primitives::Sibling,

3245

1

		statemint_like::AccountId,

3246

1

	>::convert_location(&dest_para)

3247

1

	.unwrap();

3248

3249

1

	ParaA::execute_with(|| {

3250

1

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

3251

1

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

3252

1

			.try_into()

3253

1

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

3254

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3255

1

			source_relay_id,

3256

1

			source_location_latest,

3257

1

			relay_asset_metadata.decimals,

3258

1

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

3259

1

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

3260

));

3261

1

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

3262

1

});

3263

3264

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3265

1

		network: None,

3266

1

		key: PARAALICE,

3267

1

3268

1

	.into();

3269

3270

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3271

1

		network: None,

3272

1

		id: RELAYALICE.into(),

3273

1

3274

1

	.into();

3275

3276

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

3277

1

	Relay::execute_with(|| {

3278

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3279

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3280

1

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

3281

1

			Box::new(

3282

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3283

1

					.clone()

3284

1

					.into()

3285

),

3286

1

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

3287

0,

3288

1

			WeightLimit::Unlimited

3289

));

3290

1

});

3291

3292

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3293

1

	Statemint::execute_with(|| {

3294

		// Check Alice received 200 tokens on AssetHub

3295

1

		assert_eq!(

3296

1

			StatemintBalances::free_balance(RELAYALICE),

3297

			INITIAL_BALANCE + 200

3298

);

3299

3300

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3301

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3302

1

			sov,

3303

			110000000000000

3304

));

3305

3306

		// Now send those tokens to ParaA

3307

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

3308

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3309

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3310

1

			assets: Wild(All),

3311

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3312

1

		}]);

3313

1

		assert_ok!(

3314

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3315

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3316

1

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

3317

1

				Box::new(assets),

3318

1

				Box::new(TransferType::LocalReserve),

3319

1

				Box::new(fees_id),

3320

1

				Box::new(TransferType::LocalReserve),

3321

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3322

1

				WeightLimit::Unlimited

3323

3324

);

3325

1

});

3326

3327

1

	ParaA::execute_with(|| {

3328

		// Alice should have received the DOTs

3329

1

		assert_eq!(

3330

1

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

3331

1

			Ok(U256::from(200))

3332

);

3333

1

});

3334

3335

1

	let dest = Location::new(

3336

1,

3337

1

3338

1

			Parachain(1000),

3339

1

			AccountId32 {

3340

1

				network: None,

3341

1

				id: RELAYBOB.into(),

3342

1

},

3343

1

],

3344

);

3345

1

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

3346

3347

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

3348

1

	ParaA::execute_with(|| {

3349

1

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

3350

1

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

3351

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3352

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3353

1

			assets: Wild(All),

3354

1

			beneficiary: beneficiary.clone(),

3355

1

		}]);

3356

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3357

1

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

3358

1

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

3359

1

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

3360

1

			Box::new(TransferType::DestinationReserve),

3361

1

			Box::new(fees_id),

3362

1

			Box::new(TransferType::DestinationReserve),

3363

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3364

1

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

3365

));

3366

3367

1

		assert_eq!(

3368

1

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

3369

1

			Ok(U256::from(90))

3370

);

3371

1

});

3372

3373

1

	Statemint::execute_with(|| {

3374

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

3375

1

		assert_eq!(

3376

1

			StatemintBalances::free_balance(RELAYBOB),

3377

			INITIAL_BALANCE + 110

3378

);

3379

1

});

3380

3381

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

3382

1

	Statemint::execute_with(|| {

3383

		// Now send those tokens to ParaA

3384

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3385

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3386

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3387

1

			assets: Wild(All),

3388

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3389

1

		}]);

3390

1

		assert_ok!(

3391

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3392

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3393

1

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

3394

1

				Box::new(assets),

3395

1

				Box::new(TransferType::LocalReserve),

3396

1

				Box::new(fees_id),

3397

1

				Box::new(TransferType::LocalReserve),

3398

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3399

1

				WeightLimit::Unlimited

3400

3401

);

3402

3403

		// 100 DOTs were deducted from Bob's account

3404

1

		assert_eq!(

3405

1

			StatemintBalances::free_balance(RELAYBOB),

3406

			INITIAL_BALANCE + 10

3407

);

3408

1

});

3409

3410

1

	ParaA::execute_with(|| {

3411

		// Alice should have received 100 DOTs

3412

1

		assert_eq!(

3413

1

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

3414

1

			Ok(U256::from(190))

3415

);

3416

1

});

3417

1

3418

3419

#[test]

3420

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3421

1

	MockNet::reset();

3422

3423

	// Relay asset

3424

1

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

3425

1

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

3426

3427

1

	let relay_asset_metadata = parachain::AssetMetadata {

3428

1

		name: b"RelayToken".to_vec(),

3429

1

		symbol: b"Relay".to_vec(),

3430

1

		decimals: 12,

3431

1

};

3432

3433

1

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

3434

3435

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3436

1

		polkadot_parachain::primitives::Sibling,

3437

1

		statemint_like::AccountId,

3438

1

	>::convert_location(&dest_para)

3439

1

	.unwrap();

3440

3441

1

	ParaA::execute_with(|| {

3442

1

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

3443

1

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

3444

1

			.try_into()

3445

1

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

3446

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3447

1

			source_relay_id,

3448

1

			source_location_latest,

3449

1

			relay_asset_metadata.decimals,

3450

1

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

3451

1

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

3452

));

3453

1

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

3454

1

});

3455

3456

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3457

1

		network: None,

3458

1

		key: PARAALICE,

3459

1

3460

1

	.into();

3461

3462

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3463

1

		network: None,

3464

1

		id: RELAYALICE.into(),

3465

1

3466

1

	.into();

3467

3468

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

3469

1

	Relay::execute_with(|| {

3470

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3471

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3472

1

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

3473

1

			Box::new(

3474

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3475

1

					.clone()

3476

1

					.into()

3477

),

3478

1

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

3479

0,

3480

1

			WeightLimit::Unlimited

3481

));

3482

1

});

3483

3484

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3485

1

	Statemint::execute_with(|| {

3486

		// Check Alice received 200 tokens on AssetHub

3487

1

		assert_eq!(

3488

1

			StatemintBalances::free_balance(RELAYALICE),

3489

			INITIAL_BALANCE + 200

3490

);

3491

3492

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3493

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3494

1

			sov,

3495

			110000000000000

3496

));

3497

3498

		// Now send those tokens to ParaA

3499

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

3500

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3501

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3502

1

			assets: Wild(All),

3503

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3504

1

		}]);

3505

1

		assert_ok!(

3506

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3507

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3508

1

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

3509

1

				Box::new(assets),

3510

1

				Box::new(TransferType::LocalReserve),

3511

1

				Box::new(fees_id),

3512

1

				Box::new(TransferType::LocalReserve),

3513

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3514

1

				WeightLimit::Unlimited

3515

3516

);

3517

1

});

3518

3519

1

	ParaA::execute_with(|| {

3520

		// Alice should have received the DOTs

3521

1

		assert_eq!(

3522

1

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

3523

1

			Ok(U256::from(200))

3524

);

3525

1

});

3526

3527

1

	let dest = Location::new(

3528

1,

3529

1

3530

1

			Parachain(1000),

3531

1

			AccountId32 {

3532

1

				network: None,

3533

1

				id: RELAYBOB.into(),

3534

1

},

3535

1

],

3536

);

3537

1

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

3538

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

3539

1

	ParaA::execute_with(|| {

3540

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3541

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3542

1

			assets: Wild(All),

3543

1

			beneficiary: beneficiary.clone(),

3544

1

		}]);

3545

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3546

1

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

3547

1

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

3548

1

			Box::new(VersionedAssets::from((Location::parent(), 100))),

3549

1

			Box::new(TransferType::DestinationReserve),

3550

1

			Box::new(fees_id),

3551

1

			Box::new(TransferType::DestinationReserve),

3552

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3553

1

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

3554

));

3555

3556

1

		assert_eq!(

3557

1

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

3558

1

			Ok(U256::from(100))

3559

);

3560

1

});

3561

3562

1

	Statemint::execute_with(|| {

3563

		// Check that Bob received the tokens back in AssetHub

3564

1

		assert_eq!(

3565

1

			StatemintBalances::free_balance(RELAYBOB),

3566

			INITIAL_BALANCE + 100

3567

);

3568

1

});

3569

3570

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

3571

1

	Statemint::execute_with(|| {

3572

		// Now send those tokens to ParaA

3573

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3574

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3575

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3576

1

			assets: Wild(All),

3577

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3578

1

		}]);

3579

1

		assert_ok!(

3580

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3581

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3582

1

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

3583

1

				Box::new(assets),

3584

1

				Box::new(TransferType::LocalReserve),

3585

1

				Box::new(fees_id),

3586

1

				Box::new(TransferType::LocalReserve),

3587

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3588

1

				WeightLimit::Unlimited

3589

3590

);

3591

3592

		// 100 DOTs were deducted from Bob's account

3593

1

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

3594

1

});

3595

3596

1

	ParaA::execute_with(|| {

3597

		// Alice should have received 100 DOTs

3598

1

		assert_eq!(

3599

1

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

3600

1

			Ok(U256::from(200))

3601

);

3602

1

});

3603

1

3604

3605

#[test]

3606

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3607

1

	MockNet::reset();

3608

3609

	// Relay asset

3610

1

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

3611

1

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

3612

3613

1

	let relay_asset_metadata = parachain::AssetMetadata {

3614

1

		name: b"RelayToken".to_vec(),

3615

1

		symbol: b"Relay".to_vec(),

3616

1

		decimals: 12,

3617

1

};

3618

3619

	// Statemint asset

3620

1

	let statemint_asset = Location::new(

3621

1,

3622

1

3623

1

			Parachain(1000u32),

3624

1

			PalletInstance(5u8),

3625

1

			GeneralIndex(10u128),

3626

1

],

3627

);

3628

1

	let statemint_location_asset: AssetType = statemint_asset

3629

1

		.clone()

3630

1

		.try_into()

3631

1

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

3632

1

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

3633

3634

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3635

1

		name: b"USDC".to_vec(),

3636

1

		symbol: b"USDC".to_vec(),

3637

1

		decimals: 12,

3638

1

};

3639

3640

1

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

3641

3642

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3643

1

		polkadot_parachain::primitives::Sibling,

3644

1

		statemint_like::AccountId,

3645

1

	>::convert_location(&dest_para)

3646

1

	.unwrap();

3647

3648

1

	ParaA::execute_with(|| {

3649

1

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

3650

1

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

3651

1

			.try_into()

3652

1

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

3653

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3654

1

			source_relay_id,

3655

1

			source_location_latest,

3656

1

			relay_asset_metadata.decimals,

3657

1

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

3658

1

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

3659

));

3660

1

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

3661

3662

1

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

3663

1

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

3664

1

			.try_into()

3665

1

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

3666

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3667

1

			source_statemint_asset_id,

3668

1

			source_location_latest,

3669

1

			asset_metadata_statemint_asset.decimals,

3670

1

			asset_metadata_statemint_asset

3671

1

				.symbol

3672

1

				.try_into()

3673

1

				.expect("too long"),

3674

1

			asset_metadata_statemint_asset

3675

1

				.name

3676

1

				.try_into()

3677

1

				.expect("too long"),

3678

));

3679

1

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

3680

1

});

3681

3682

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3683

1

		network: None,

3684

1

		key: PARAALICE,

3685

1

3686

1

	.into();

3687

3688

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3689

1

		network: None,

3690

1

		id: RELAYALICE.into(),

3691

1

3692

1

	.into();

3693

3694

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

3695

1

	Relay::execute_with(|| {

3696

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3697

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3698

1

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

3699

1

			Box::new(

3700

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3701

1

					.clone()

3702

1

					.into()

3703

),

3704

1

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

3705

0,

3706

1

			WeightLimit::Unlimited

3707

));

3708

1

});

3709

3710

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

3711

1

	Statemint::execute_with(|| {

3712

		// Check Alice received 200 tokens on AssetHub

3713

1

		assert_eq!(

3714

1

			StatemintBalances::free_balance(RELAYALICE),

3715

			INITIAL_BALANCE + 200

3716

);

3717

3718

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3719

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3720

1

			sov,

3721

			110000000000000

3722

));

3723

3724

1

		statemint_like::PrefixChanger::set_prefix(

3725

1

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

3726

);

3727

3728

1

		assert_ok!(StatemintAssets::create(

3729

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3730

10,

3731

			RELAYALICE,

3732

3733

));

3734

3735

1

		assert_ok!(StatemintAssets::mint(

3736

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3737

10,

3738

			RELAYALICE,

3739

			300000000000000

3740

));

3741

3742

		// Now send relay tokens to ParaA

3743

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

3744

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3745

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3746

1

			assets: Wild(All),

3747

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3748

1

		}]);

3749

1

		assert_ok!(

3750

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3751

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3752

1

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

3753

1

				Box::new(assets),

3754

1

				Box::new(TransferType::LocalReserve),

3755

1

				Box::new(fees_id),

3756

1

				Box::new(TransferType::LocalReserve),

3757

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3758

1

				WeightLimit::Unlimited

3759

3760

);

3761

3762

		// Send USDC

3763

1

		let assets: VersionedAssets = (

3764

1

3765

1

				xcm::latest::prelude::PalletInstance(

3766

1

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

3767

1

),

3768

1

				GeneralIndex(10),

3769

1

],

3770

1

			125,

3771

1

3772

1

			.into();

3773

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

3774

1

0,

3775

1

3776

1

				xcm::latest::prelude::PalletInstance(

3777

1

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

3778

1

),

3779

1

				GeneralIndex(10),

3780

1

],

3781

1

))

3782

1

		.into();

3783

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3784

1

			assets: Wild(All),

3785

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3786

1

		}]);

3787

1

		assert_ok!(

3788

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3789

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3790

1

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

3791

1

				Box::new(assets),

3792

1

				Box::new(TransferType::LocalReserve),

3793

1

				Box::new(fees_id),

3794

1

				Box::new(TransferType::LocalReserve),

3795

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3796

1

				WeightLimit::Unlimited

3797

3798

);

3799

1

});

3800

3801

1

	ParaA::execute_with(|| {

3802

		// Alice should have received the DOTs

3803

1

		assert_eq!(

3804

1

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

3805

1

			Ok(U256::from(200))

3806

);

3807

3808

		// Alice has received 125 USDC

3809

1

		assert_eq!(

3810

1

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

3811

1

			Ok(U256::from(125))

3812

);

3813

1

});

3814

3815

1

	let dest = Location::new(

3816

1,

3817

1

3818

1

			Parachain(1000),

3819

1

			AccountId32 {

3820

1

				network: None,

3821

1

				id: RELAYBOB.into(),

3822

1

},

3823

1

],

3824

);

3825

3826

1

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

3827

3828

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

3829

1

	ParaA::execute_with(|| {

3830

1

		let asset_1 = currency_to_asset(

3831

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3832

			100,

3833

);

3834

1

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

3835

1

		let assets_to_send = vec![asset_1, asset_2];

3836

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3837

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3838

1

			assets: Wild(All),

3839

1

			beneficiary: beneficiary.clone(),

3840

1

		}]);

3841

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3842

1

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

3843

1

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

3844

1

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

3845

1

			Box::new(TransferType::DestinationReserve),

3846

1

			Box::new(fees_id),

3847

1

			Box::new(TransferType::DestinationReserve),

3848

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3849

1

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

3850

));

3851

3852

1

		assert_eq!(

3853

1

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

3854

1

			Ok(U256::from(100))

3855

);

3856

1

});

3857

3858

1

	Statemint::execute_with(|| {

3859

		// Check that Bob received relay tokens back in AssetHub

3860

1

		assert_eq!(

3861

1

			StatemintBalances::free_balance(RELAYBOB),

3862

			INITIAL_BALANCE + 100

3863

);

3864

3865

		// Check that BOB received 100 USDC on AssetHub

3866

1

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

3867

1

});

3868

3869

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

3870

1

	Statemint::execute_with(|| {

3871

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3872

3873

		// Now send those tokens to ParaA

3874

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3875

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3876

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3877

1

			assets: Wild(All),

3878

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3879

1

		}]);

3880

1

		assert_ok!(

3881

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3882

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3883

1

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

3884

1

				Box::new(assets),

3885

1

				Box::new(TransferType::LocalReserve),

3886

1

				Box::new(fees_id),

3887

1

				Box::new(TransferType::LocalReserve),

3888

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3889

1

				WeightLimit::Unlimited

3890

3891

);

3892

3893

		// 100 DOTs were deducted from Bob's account

3894

1

		assert_eq!(

3895

1

			StatemintBalances::free_balance(RELAYBOB),

3896

1

			bob_previous_balance - 100

3897

);

3898

1

});

3899

3900

1

	ParaA::execute_with(|| {

3901

		// Alice should have received 100 DOTs

3902

1

		assert_eq!(

3903

1

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

3904

1

			Ok(U256::from(200))

3905

);

3906

1

});

3907

1

3908

3909

#[test]

3910

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3911

1

	MockNet::reset();

3912

3913

	// Relay asset

3914

1

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

3915

1

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

3916

3917

1

	let relay_asset_metadata = parachain::AssetMetadata {

3918

1

		name: b"RelayToken".to_vec(),

3919

1

		symbol: b"Relay".to_vec(),

3920

1

		decimals: 12,

3921

1

};

3922

3923

	// Statemint asset

3924

1

	let statemint_asset = Location::new(

3925

1,

3926

1

3927

1

			Parachain(1000u32),

3928

1

			PalletInstance(5u8),

3929

1

			GeneralIndex(10u128),

3930

1

],

3931

);

3932

1

	let statemint_location_asset: AssetType = statemint_asset

3933

1

		.clone()

3934

1

		.try_into()

3935

1

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

3936

1

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

3937

3938

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3939

1

		name: b"USDC".to_vec(),

3940

1

		symbol: b"USDC".to_vec(),

3941

1

		decimals: 12,

3942

1

};

3943

3944

1

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

3945

3946

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3947

1

		polkadot_parachain::primitives::Sibling,

3948

1

		statemint_like::AccountId,

3949

1

	>::convert_location(&dest_para)

3950

1

	.unwrap();

3951

3952

1

	ParaA::execute_with(|| {

3953

1

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

3954

1

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

3955

1

			.try_into()

3956

1

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

3957

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3958

1

			source_relay_id,

3959

1

			source_location_latest,

3960

1

			relay_asset_metadata.decimals,

3961

1

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

3962

1

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

3963

));

3964

1

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

3965

3966

1

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

3967

1

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

3968

1

			.try_into()

3969

1

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

3970

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3971

1

			source_statemint_asset_id,

3972

1

			source_location_latest,

3973

1

			asset_metadata_statemint_asset.decimals,

3974

1

			asset_metadata_statemint_asset

3975

1

				.symbol

3976

1

				.try_into()

3977

1

				.expect("too long"),

3978

1

			asset_metadata_statemint_asset

3979

1

				.name

3980

1

				.try_into()

3981

1

				.expect("too long"),

3982

));

3983

1

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

3984

1

});

3985

3986

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3987

1

		network: None,

3988

1

		key: PARAALICE,

3989

1

3990

1

	.into();

3991

3992

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3993

1

		network: None,

3994

1

		id: RELAYALICE.into(),

3995

1

3996

1

	.into();

3997

3998

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

3999

1

	Relay::execute_with(|| {

4000

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4001

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4002

1

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

4003

1

			Box::new(

4004

1

				VersionedLocation::from(statemint_beneficiary_absolute)

4005

1

					.clone()

4006

1

					.into()

4007

),

4008

1

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

4009

0,

4010

1

			WeightLimit::Unlimited

4011

));

4012

1

});

4013

4014

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

4015

1

	Statemint::execute_with(|| {

4016

		// Check Alice received 200 tokens on AssetHub

4017

1

		assert_eq!(

4018

1

			StatemintBalances::free_balance(RELAYALICE),

4019

			INITIAL_BALANCE + 200

4020

);

4021

4022

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4023

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4024

1

			sov,

4025

			110000000000000

4026

));

4027

4028

1

		statemint_like::PrefixChanger::set_prefix(

4029

1

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

4030

);

4031

4032

1

		assert_ok!(StatemintAssets::create(

4033

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4034

10,

4035

			RELAYALICE,

4036

4037

));

4038

4039

1

		assert_ok!(StatemintAssets::mint(

4040

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4041

10,

4042

			RELAYALICE,

4043

			300000000000000

4044

));

4045

4046

		// Now send relay tokens to ParaA

4047

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

4048

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4049

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4050

1

			assets: Wild(All),

4051

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4052

1

		}]);

4053

1

		assert_ok!(

4054

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4055

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4056

1

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

4057

1

				Box::new(assets),

4058

1

				Box::new(TransferType::LocalReserve),

4059

1

				Box::new(fees_id),

4060

1

				Box::new(TransferType::LocalReserve),

4061

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4062

1

				WeightLimit::Unlimited

4063

4064

);

4065

4066

		// Send USDC

4067

1

		let assets: VersionedAssets = (

4068

1

4069

1

				xcm::latest::prelude::PalletInstance(

4070

1

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

4071

1

),

4072

1

				GeneralIndex(10),

4073

1

],

4074

1

			125,

4075

1

4076

1

			.into();

4077

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4078

1

0,

4079

1

4080

1

				xcm::latest::prelude::PalletInstance(

4081

1

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

4082

1

),

4083

1

				GeneralIndex(10),

4084

1

],

4085

1

))

4086

1

		.into();

4087

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4088

1

			assets: Wild(All),

4089

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4090

1

		}]);

4091

1

		assert_ok!(

4092

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4093

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4094

1

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

4095

1

				Box::new(assets),

4096

1

				Box::new(TransferType::LocalReserve),

4097

1

				Box::new(fees_id),

4098

1

				Box::new(TransferType::LocalReserve),

4099

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4100

1

				WeightLimit::Unlimited

4101

4102

);

4103

1

});

4104

4105

1

	ParaA::execute_with(|| {

4106

		// Alice should have received the DOTs

4107

1

		assert_eq!(

4108

1

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

4109

1

			Ok(U256::from(200))

4110

);

4111

4112

		// Alice has received 125 USDC

4113

1

		assert_eq!(

4114

1

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

4115

1

			Ok(U256::from(125))

4116

);

4117

1

});

4118

4119

1

	let dest = Location::new(

4120

1,

4121

1

4122

1

			Parachain(1000),

4123

1

			AccountId32 {

4124

1

				network: None,

4125

1

				id: RELAYBOB.into(),

4126

1

},

4127

1

],

4128

);

4129

4130

1

	let statemint_asset_to_send = Asset {

4131

1

		id: AssetId(statemint_asset),

4132

1

		fun: Fungible(100),

4133

1

};

4134

4135

1

	let relay_asset_to_send = Asset {

4136

1

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

4137

1

		fun: Fungible(100),

4138

1

};

4139

4140

1

	let assets_to_send: XcmAssets =

4141

1

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

4142

1

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

4143

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

4144

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

4145

1

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

4146

4147

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

4148

1

	ParaA::execute_with(|| {

4149

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4150

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4151

1

			assets: Wild(All),

4152

1

			beneficiary: beneficiary.clone(),

4153

1

		}]);

4154

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4155

1

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

4156

1

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

4157

1

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

4158

1

			Box::new(TransferType::DestinationReserve),

4159

1

			Box::new(fees_id),

4160

1

			Box::new(TransferType::DestinationReserve),

4161

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4162

1

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

4163

));

4164

4165

1

		assert_eq!(

4166

1

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

4167

1

			Ok(U256::from(100))

4168

);

4169

1

});

4170

4171

1

	Statemint::execute_with(|| {

4172

		// Check that Bob received relay tokens back in AssetHub

4173

1

		assert_eq!(

4174

1

			StatemintBalances::free_balance(RELAYBOB),

4175

			INITIAL_BALANCE + 100

4176

);

4177

4178

		// Check that BOB received 100 USDC on AssetHub

4179

1

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

4180

1

});

4181

4182

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

4183

1

	Statemint::execute_with(|| {

4184

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4185

4186

		// Now send those tokens to ParaA

4187

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

4188

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4189

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4190

1

			assets: Wild(All),

4191

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4192

1

		}]);

4193

1

		assert_ok!(

4194

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4195

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4196

1

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

4197

1

				Box::new(assets),

4198

1

				Box::new(TransferType::LocalReserve),

4199

1

				Box::new(fees_id),

4200

1

				Box::new(TransferType::LocalReserve),

4201

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4202

1

				WeightLimit::Unlimited

4203

4204

);

4205

4206

		// 100 DOTs were deducted from Bob's account

4207

1

		assert_eq!(

4208

1

			StatemintBalances::free_balance(RELAYBOB),

4209

1

			bob_previous_balance - 100

4210

);

4211

1

});

4212

4213

1

	ParaA::execute_with(|| {

4214

		// Alice should have received 100 DOTs

4215

1

		assert_eq!(

4216

1

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

4217

1

			Ok(U256::from(200))

4218

);

4219

1

});

4220

1

4221

4222

#[test]

4223

1

fn transact_through_signed_multilocation() {

4224

1

	MockNet::reset();

4225

1

	let mut ancestry = Location::parent();

4226

4227

1

	ParaA::execute_with(|| {

4228

		// Root can set transact info

4229

1

		assert_ok!(XcmTransactor::set_transact_info(

4230

1

			parachain::RuntimeOrigin::root(),

4231

1

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

4232

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

4233

1

			3000.into(),

4234

1

			20000000000.into(),

4235

			// 4 instructions in transact through signed

4236

1

			Some(4000.into())

4237

));

4238

		// Root can set transact info

4239

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4240

1

			parachain::RuntimeOrigin::root(),

4241

1

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

4242

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

4243

));

4244

1

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

4245

1

});

4246

4247

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

4248

1

	let signed_origin: Junctions = [AccountKey20 {

4249

1

		network: None,

4250

1

		key: PARAALICE,

4251

1

}]

4252

1

	.into();

4253

4254

1

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

4255

1

	descend_origin_multilocation

4256

1

		.append_with(signed_origin)

4257

1

		.unwrap();

4258

4259

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

4260

1

	descend_origin_multilocation

4261

1

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

4262

1

		.unwrap();

4263

4264

1

	let derived = xcm_builder::Account32Hash::<

4265

1

		relay_chain::KusamaNetwork,

4266

1

		relay_chain::AccountId,

4267

1

	>::convert_location(&descend_origin_multilocation)

4268

1

	.unwrap();

4269

4270

1

	Relay::execute_with(|| {

4271

		// free execution, full amount received

4272

1

		assert_ok!(RelayBalances::transfer_allow_death(

4273

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4274

1

			derived.clone(),

4275

			4000004100u128,

4276

));

4277

		// derived account has all funds

4278

1

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

4279

		// sovereign account has 0 funds

4280

1

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

4281

1

});

4282

4283

	// Encode the call. Balances transact to para_a_account

4284

	// First index

4285

1

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

4286

1

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

4287

1

		relay_chain::Balances,

4288

1

>()

4289

1

	.unwrap() as u8;

4290

4291

1

	encoded.push(index);

4292

4293

	// Then call bytes

4294

1

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

4295

1

		// 100 to sovereign

4296

1

		dest: para_a_account(),

4297

1

		value: 100u32.into(),

4298

1

4299

1

	.encode();

4300

1

	encoded.append(&mut call_bytes);

4301

4302

1

	ParaA::execute_with(|| {

4303

1

		assert_ok!(XcmTransactor::transact_through_signed(

4304

1

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

4305

1

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

4306

1

			CurrencyPayment {

4307

1

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

4308

1

					Location::parent()

4309

1

				))),

4310

1

				fee_amount: None

4311

1

},

4312

1

			encoded,

4313

			// 4000000000 for transfer + 4000 for XCM

4314

1

			TransactWeights {

4315

1

				transact_required_weight_at_most: 4000000000.into(),

4316

1

				overall_weight: None

4317

1

},

4318

			false

4319

));

4320

1

});

4321

4322

1

	Relay::execute_with(|| {

4323

1

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

4324

4325

1

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

4326

1

});

4327

1

4328

4329

#[test]

4330

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4331

1

	MockNet::reset();

4332

1

	let mut ancestry = Location::parent();

4333

4334

1

	ParaA::execute_with(|| {

4335

1

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

4336

1

});

4337

4338

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

4339

1

	let signed_origin: Junctions = [AccountKey20 {

4340

1

		network: None,

4341

1

		key: PARAALICE,

4342

1

}]

4343

1

	.into();

4344

4345

1

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

4346

1

	descend_origin_multilocation

4347

1

		.append_with(signed_origin)

4348

1

		.unwrap();

4349

4350

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

4351

1

	descend_origin_multilocation

4352

1

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

4353

1

		.unwrap();

4354

4355

1

	let derived = xcm_builder::Account32Hash::<

4356

1

		relay_chain::KusamaNetwork,

4357

1

		relay_chain::AccountId,

4358

1

	>::convert_location(&descend_origin_multilocation)

4359

1

	.unwrap();

4360

4361

1

	Relay::execute_with(|| {

4362

		// free execution, full amount received

4363

1

		assert_ok!(RelayBalances::transfer_allow_death(

4364

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4365

1

			derived.clone(),

4366

			4000004100u128,

4367

));

4368

		// derived account has all funds

4369

1

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

4370

		// sovereign account has 0 funds

4371

1

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

4372

1

});

4373

4374

	// Encode the call. Balances transact to para_a_account

4375

	// First index

4376

1

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

4377

1

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

4378

1

		relay_chain::Balances,

4379

1

>()

4380

1

	.unwrap() as u8;

4381

4382

1

	encoded.push(index);

4383

4384

	// Then call bytes

4385

1

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

4386

1

		// 100 to sovereign

4387

1

		dest: para_a_account(),

4388

1

		value: 100u32.into(),

4389

1

4390

1

	.encode();

4391

1

	encoded.append(&mut call_bytes);

4392

4393

1

	let total_weight = 4000004000u64;

4394

1

	ParaA::execute_with(|| {

4395

1

		assert_ok!(XcmTransactor::transact_through_signed(

4396

1

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

4397

1

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

4398

1

			CurrencyPayment {

4399

1

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

4400

1

					Location::parent()

4401

1

				))),

4402

1

				fee_amount: Some(total_weight as u128)

4403

1

},

4404

1

			encoded,

4405

			// 4000000000 for transfer + 4000 for XCM

4406

1

			TransactWeights {

4407

1

				transact_required_weight_at_most: 4000000000.into(),

4408

1

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

4409

1

},

4410

			false

4411

));

4412

1

});

4413

4414

1

	Relay::execute_with(|| {

4415

1

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

4416

4417

1

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

4418

1

});

4419

1

4420

4421

#[test]

4422

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4423

1

	MockNet::reset();

4424

1

	let mut ancestry = Location::parent();

4425

4426

1

	ParaA::execute_with(|| {

4427

1

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

4428

1

});

4429

4430

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

4431

1

	let signed_origin: Junctions = [AccountKey20 {

4432

1

		network: None,

4433

1

		key: PARAALICE,

4434

1

}]

4435

1

	.into();

4436

4437

1

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

4438

1

	descend_origin_multilocation

4439

1

		.append_with(signed_origin)

4440

1

		.unwrap();

4441

4442

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

4443

1

	descend_origin_multilocation

4444

1

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

4445

1

		.unwrap();

4446

4447

1

	let derived = xcm_builder::Account32Hash::<

4448

1

		relay_chain::KusamaNetwork,

4449

1

		relay_chain::AccountId,

4450

1

	>::convert_location(&descend_origin_multilocation)

4451

1

	.unwrap();

4452

4453

1

	Relay::execute_with(|| {

4454

		// free execution, full amount received

4455

1

		assert_ok!(RelayBalances::transfer_allow_death(

4456

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4457

1

			derived.clone(),

4458

			4000009100u128,

4459

));

4460

		// derived account has all funds

4461

1

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

4462

		// sovereign account has 0 funds

4463

1

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

4464

1

});

4465

4466

	// Encode the call. Balances transact to para_a_account

4467

	// First index

4468

1

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

4469

1

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

4470

1

		relay_chain::Balances,

4471

1

>()

4472

1

	.unwrap() as u8;

4473

4474

1

	encoded.push(index);

4475

4476

	// Then call bytes

4477

1

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

4478

1

		// 100 to sovereign

4479

1

		dest: para_a_account(),

4480

1

		value: 100u32.into(),

4481

1

4482

1

	.encode();

4483

1

	encoded.append(&mut call_bytes);

4484

4485

1

	let total_weight = 4000009000u64;

4486

1

	ParaA::execute_with(|| {

4487

1

		assert_ok!(XcmTransactor::transact_through_signed(

4488

1

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

4489

1

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

4490

1

			CurrencyPayment {

4491

1

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

4492

1

					Location::parent()

4493

1

				))),

4494

1

				fee_amount: Some(total_weight as u128)

4495

1

},

4496

1

			encoded,

4497

			// 4000000000 for transfer + 9000 for XCM

4498

1

			TransactWeights {

4499

1

				transact_required_weight_at_most: 4000000000.into(),

4500

1

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

4501

1

},

4502

			true

4503

));

4504

1

});

4505

4506

1

	Relay::execute_with(|| {

4507

		// 100 transferred

4508

1

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

4509

4510

		// 4000009000 refunded

4511

1

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

4512

1

});

4513

1

4514

4515

#[test]

4516

1

fn transact_through_signed_multilocation_para_to_para() {

4517

1

	MockNet::reset();

4518

1

	let mut ancestry = Location::parent();

4519

4520

1

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

4521

4522

1

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

4523

4524

1

	ParaA::execute_with(|| {

4525

		// Root can set transact info

4526

1

		assert_ok!(XcmTransactor::set_transact_info(

4527

1

			parachain::RuntimeOrigin::root(),

4528

			// ParaB

4529

1

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

4530

			// Para charges 1000 for every instruction, and we have 3, so 3

4531

1

			3.into(),

4532

1

			20000000000.into(),

4533

			// 4 instructions in transact through signed

4534

1

			Some(4.into())

4535

));

4536

		// Root can set transact info

4537

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4538

1

			parachain::RuntimeOrigin::root(),

4539

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4540

1

			parachain::ParaTokensPerSecond::get(),

4541

));

4542

1

		ancestry = parachain::UniversalLocation::get().into();

4543

1

});

4544

4545

	// Let's construct the Junction that we will append with DescendOrigin

4546

1

	let signed_origin: Junctions = [AccountKey20 {

4547

1

		network: None,

4548

1

		key: PARAALICE,

4549

1

}]

4550

1

	.into();

4551

4552

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4553

1

	descend_origin_location.append_with(signed_origin).unwrap();

4554

4555

	// To convert it to what the paraB will see instead of us

4556

1

	descend_origin_location

4557

1

		.reanchor(&para_b_location, &ancestry.interior)

4558

1

		.unwrap();

4559

4560

1

	let derived = xcm_builder::HashedDescription::<

4561

1

		parachain::AccountId,

4562

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4563

1

	>::convert_location(&descend_origin_location)

4564

1

	.unwrap();

4565

4566

1

	ParaB::execute_with(|| {

4567

		// free execution, full amount received

4568

1

		assert_ok!(ParaBalances::transfer_allow_death(

4569

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4570

1

			derived.clone(),

4571

			4000000104u128,

4572

));

4573

		// derived account has all funds

4574

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4575

		// sovereign account has 0 funds

4576

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4577

1

});

4578

4579

	// Encode the call. Balances transact to para_a_account

4580

	// First index

4581

1

	let mut encoded: Vec<u8> = Vec::new();

4582

1

	let index =

4583

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4584

1

			.unwrap() as u8;

4585

4586

1

	encoded.push(index);

4587

4588

	// Then call bytes

4589

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4590

1

		// 100 to sovereign

4591

1

		dest: para_a_account_20(),

4592

1

		value: 100u32.into(),

4593

1

4594

1

	.encode();

4595

1

	encoded.append(&mut call_bytes);

4596

4597

1

	ParaA::execute_with(|| {

4598

1

		assert_ok!(XcmTransactor::transact_through_signed(

4599

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4600

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4601

1

			CurrencyPayment {

4602

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4603

1

					para_b_balances

4604

1

				))),

4605

1

				fee_amount: None

4606

1

},

4607

1

			encoded,

4608

			// 4000000000 for transfer + 4000 for XCM

4609

			// 1-1 to fee

4610

1

			TransactWeights {

4611

1

				transact_required_weight_at_most: 4000000000.into(),

4612

1

				overall_weight: None

4613

1

},

4614

			false

4615

));

4616

1

});

4617

4618

1

	ParaB::execute_with(|| {

4619

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4620

4621

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4622

1

});

4623

1

4624

4625

#[test]

4626

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4627

1

	MockNet::reset();

4628

1

	let mut ancestry = Location::parent();

4629

4630

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4631

4632

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4633

4634

1

	ParaA::execute_with(|| {

4635

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4636

1

			parachain::RuntimeOrigin::root(),

4637

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4638

1

			parachain::ParaTokensPerSecond::get(),

4639

));

4640

1

		ancestry = parachain::UniversalLocation::get().into();

4641

1

});

4642

4643

	// Let's construct the Junction that we will append with DescendOrigin

4644

1

	let signed_origin: Junctions = [AccountKey20 {

4645

1

		network: None,

4646

1

		key: PARAALICE,

4647

1

}]

4648

1

	.into();

4649

4650

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4651

1

	descend_origin_location.append_with(signed_origin).unwrap();

4652

4653

	// To convert it to what the paraB will see instead of us

4654

1

	descend_origin_location

4655

1

		.reanchor(&para_b_location, &ancestry.interior)

4656

1

		.unwrap();

4657

4658

1

	let derived = xcm_builder::HashedDescription::<

4659

1

		parachain::AccountId,

4660

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4661

1

	>::convert_location(&descend_origin_location)

4662

1

	.unwrap();

4663

4664

1

	ParaB::execute_with(|| {

4665

		// free execution, full amount received

4666

1

		assert_ok!(ParaBalances::transfer_allow_death(

4667

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4668

1

			derived.clone(),

4669

			4000009100u128,

4670

));

4671

		// derived account has all funds

4672

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4673

		// sovereign account has 0 funds

4674

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4675

1

});

4676

4677

	// Encode the call. Balances transact to para_a_account

4678

	// First index

4679

1

	let mut encoded: Vec<u8> = Vec::new();

4680

1

	let index =

4681

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4682

1

			.unwrap() as u8;

4683

4684

1

	encoded.push(index);

4685

4686

	// Then call bytes

4687

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4688

1

		// 100 to sovereign

4689

1

		dest: para_a_account_20(),

4690

1

		value: 100u32.into(),

4691

1

4692

1

	.encode();

4693

1

	encoded.append(&mut call_bytes);

4694

4695

1

	let overall_weight = 4000009000u64;

4696

1

	ParaA::execute_with(|| {

4697

1

		assert_ok!(XcmTransactor::transact_through_signed(

4698

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4699

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4700

1

			CurrencyPayment {

4701

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4702

1

					para_b_balances

4703

1

				))),

4704

1

				fee_amount: Some(overall_weight as u128)

4705

1

},

4706

1

			encoded,

4707

			// 4000000000 for transfer + 9000 for XCM

4708

1

			TransactWeights {

4709

1

				transact_required_weight_at_most: 4000000000.into(),

4710

1

				overall_weight: Some(Limited(overall_weight.into()))

4711

1

},

4712

			true

4713

));

4714

1

});

4715

4716

1

	ParaB::execute_with(|| {

4717

		// Check the derived account was refunded

4718

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4719

4720

		// Check the transfer was executed

4721

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4722

1

});

4723

1

4724

4725

#[test]

4726

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4727

1

	MockNet::reset();

4728

1

	let mut ancestry = Location::parent();

4729

4730

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4731

4732

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4733

4734

1

	ParaA::execute_with(|| {

4735

		// Root can set transact info

4736

1

		assert_ok!(XcmTransactor::set_transact_info(

4737

1

			parachain::RuntimeOrigin::root(),

4738

			// ParaB

4739

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4740

			// Para charges 1000 for every instruction, and we have 3, so 3

4741

1

			3.into(),

4742

1

			20000000000.into(),

4743

			// 4 instructions in transact through signed

4744

1

			Some(4.into())

4745

));

4746

		// Root can set transact info

4747

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4748

1

			parachain::RuntimeOrigin::root(),

4749

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4750

1

			parachain::ParaTokensPerSecond::get(),

4751

));

4752

1

		ancestry = parachain::UniversalLocation::get().into();

4753

1

});

4754

4755

	// Let's construct the Junction that we will append with DescendOrigin

4756

1

	let signed_origin: Junctions = [AccountKey20 {

4757

1

		network: None,

4758

1

		key: PARAALICE,

4759

1

}]

4760

1

	.into();

4761

4762

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4763

1

	descend_origin_location.append_with(signed_origin).unwrap();

4764

4765

	// To convert it to what the paraB will see instead of us

4766

1

	descend_origin_location

4767

1

		.reanchor(&para_b_location, &ancestry.interior)

4768

1

		.unwrap();

4769

4770

1

	let derived = xcm_builder::HashedDescription::<

4771

1

		parachain::AccountId,

4772

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4773

1

	>::convert_location(&descend_origin_location)

4774

1

	.unwrap();

4775

4776

1

	let mut parachain_b_alice_balances_before = 0;

4777

1

	ParaB::execute_with(|| {

4778

1

		assert_ok!(ParaBalances::transfer_allow_death(

4779

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4780

1

			derived.clone(),

4781

			4000000104u128,

4782

));

4783

		// derived account has all funds

4784

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4785

		// sovereign account has 0 funds

4786

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4787

4788

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4789

1

});

4790

4791

	// Encode the call. Balances transact to para_a_account

4792

	// First index

4793

1

	let mut encoded: Vec<u8> = Vec::new();

4794

1

	let index =

4795

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4796

1

			.unwrap() as u8;

4797

4798

1

	encoded.push(index);

4799

4800

	use sp_core::U256;

4801

	// Let's do a EVM transfer

4802

1

	let eth_tx =

4803

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4804

1

			gas_limit: U256::from(21000),

4805

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4806

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4807

1

			value: U256::from(100),

4808

1

			input: BoundedVec::<

4809

1

u8,

4810

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4811

1

			>::try_from(vec![]).unwrap(),

4812

1

			access_list: None,

4813

1

});

4814

4815

	// Then call bytes

4816

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4817

1

		xcm_transaction: eth_tx,

4818

1

4819

1

	.encode();

4820

1

	encoded.append(&mut call_bytes);

4821

4822

1

	ParaA::execute_with(|| {

4823

1

		assert_ok!(XcmTransactor::transact_through_signed(

4824

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4825

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4826

1

			CurrencyPayment {

4827

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4828

1

					para_b_balances

4829

1

				))),

4830

1

				fee_amount: None

4831

1

},

4832

1

			encoded,

4833

			// 4000000000 for transfer + 4000 for XCM

4834

			// 1-1 to fee

4835

1

			TransactWeights {

4836

1

				transact_required_weight_at_most: 4000000000.into(),

4837

1

				overall_weight: None

4838

1

},

4839

			false

4840

));

4841

1

});

4842

4843

1

	ParaB::execute_with(|| {

4844

		// Make sure the EVM transfer went through

4845

1

		assert!(

4846

1

			ParaBalances::free_balance(&PARAALICE.into())

4847

1

				== parachain_b_alice_balances_before + 100

4848

);

4849

1

});

4850

1

4851

4852

#[test]

4853

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4854

1

	MockNet::reset();

4855

1

	let mut ancestry = Location::parent();

4856

4857

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4858

4859

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4860

4861

1

	ParaA::execute_with(|| {

4862

		// Root can set transact info

4863

1

		assert_ok!(XcmTransactor::set_transact_info(

4864

1

			parachain::RuntimeOrigin::root(),

4865

			// ParaB

4866

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4867

			// Para charges 1000 for every instruction, and we have 3, so 3

4868

1

			3.into(),

4869

1

			20000000000.into(),

4870

			// 4 instructions in transact through signed

4871

1

			Some(4.into())

4872

));

4873

		// Root can set transact info

4874

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4875

1

			parachain::RuntimeOrigin::root(),

4876

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4877

1

			parachain::ParaTokensPerSecond::get(),

4878

));

4879

1

		ancestry = parachain::UniversalLocation::get().into();

4880

1

});

4881

4882

	// Let's construct the Junction that we will append with DescendOrigin

4883

1

	let signed_origin: Junctions = [AccountKey20 {

4884

1

		network: None,

4885

1

		key: PARAALICE,

4886

1

}]

4887

1

	.into();

4888

4889

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4890

1

	descend_origin_location.append_with(signed_origin).unwrap();

4891

4892

	// To convert it to what the paraB will see instead of us

4893

1

	descend_origin_location

4894

1

		.reanchor(&para_b_location, &ancestry.interior)

4895

1

		.unwrap();

4896

4897

1

	let derived = xcm_builder::HashedDescription::<

4898

1

		parachain::AccountId,

4899

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4900

1

	>::convert_location(&descend_origin_location)

4901

1

	.unwrap();

4902

4903

1

	let mut parachain_b_alice_balances_before = 0;

4904

1

	ParaB::execute_with(|| {

4905

1

		assert_ok!(ParaBalances::transfer_allow_death(

4906

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4907

1

			derived.clone(),

4908

			4000000104u128,

4909

));

4910

		// derived account has all funds

4911

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4912

		// sovereign account has 0 funds

4913

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4914

4915

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4916

1

});

4917

4918

	// Encode the call. Balances transact to para_a_account

4919

	// First index

4920

1

	let mut encoded: Vec<u8> = Vec::new();

4921

1

	let index =

4922

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4923

1

			.unwrap() as u8;

4924

4925

1

	encoded.push(index);

4926

4927

	use sp_core::U256;

4928

	// Let's do a EVM transfer

4929

1

	let eth_tx =

4930

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4931

1

			gas_limit: U256::from(21000),

4932

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4933

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4934

1

			value: U256::from(100),

4935

1

			input: BoundedVec::<

4936

1

u8,

4937

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4938

1

			>::try_from(vec![]).unwrap(),

4939

1

			access_list: None,

4940

1

});

4941

4942

	// Then call bytes

4943

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4944

1

		transact_as: PARAALICE.into(),

4945

1

		xcm_transaction: eth_tx,

4946

1

4947

1

	.encode();

4948

1

	encoded.append(&mut call_bytes);

4949

4950

1

	ParaA::execute_with(|| {

4951

1

		assert_ok!(XcmTransactor::transact_through_signed(

4952

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4953

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4954

1

			CurrencyPayment {

4955

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4956

1

					para_b_balances

4957

1

				))),

4958

1

				fee_amount: None

4959

1

},

4960

1

			encoded,

4961

1

			TransactWeights {

4962

1

				transact_required_weight_at_most: 4000000000.into(),

4963

1

				overall_weight: None

4964

1

},

4965

			false

4966

));

4967

1

});

4968

4969

1

	ParaB::execute_with(|| {

4970

		// Make sure the EVM transfer wasn't executed

4971

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4972

1

});

4973

1

4974

4975

#[test]

4976

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4977

1

	MockNet::reset();

4978

1

	let mut ancestry = Location::parent();

4979

4980

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4981

4982

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4983

4984

1

	ParaA::execute_with(|| {

4985

		// Root can set transact info

4986

1

		assert_ok!(XcmTransactor::set_transact_info(

4987

1

			parachain::RuntimeOrigin::root(),

4988

			// ParaB

4989

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4990

			// Para charges 1000 for every instruction, and we have 3, so 3

4991

1

			3.into(),

4992

1

			20000000000.into(),

4993

			// 4 instructions in transact through signed

4994

1

			Some(4.into())

4995

));

4996

		// Root can set transact info

4997

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4998

1

			parachain::RuntimeOrigin::root(),

4999

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5000

1

			parachain::ParaTokensPerSecond::get(),

5001

));

5002

1

		ancestry = parachain::UniversalLocation::get().into();

5003

1

});

5004

5005

	// Let's construct the Junction that we will append with DescendOrigin

5006

1

	let signed_origin: Junctions = [AccountKey20 {

5007

1

		network: None,

5008

1

		key: PARAALICE,

5009

1

}]

5010

1

	.into();

5011

5012

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5013

1

	descend_origin_location.append_with(signed_origin).unwrap();

5014

5015

	// To convert it to what the paraB will see instead of us

5016

1

	descend_origin_location

5017

1

		.reanchor(&para_b_location, &ancestry.interior)

5018

1

		.unwrap();

5019

5020

1

	let derived = xcm_builder::HashedDescription::<

5021

1

		parachain::AccountId,

5022

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5023

1

	>::convert_location(&descend_origin_location)

5024

1

	.unwrap();

5025

5026

1

	let transfer_recipient = evm_account();

5027

1

	let mut transfer_recipient_balance_before = 0;

5028

1

	ParaB::execute_with(|| {

5029

1

		assert_ok!(ParaBalances::transfer_allow_death(

5030

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5031

1

			derived.clone(),

5032

			4000000104u128,

5033

));

5034

		// derived account has all funds

5035

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5036

		// sovereign account has 0 funds

5037

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5038

5039

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5040

5041

		// Add proxy ALICE  -> derived

5042

1

		let _ = parachain::Proxy::add_proxy_delegate(

5043

1

			&PARAALICE.into(),

5044

1

			derived,

5045

1

			parachain::ProxyType::Any,

5046

1

0,

5047

1

);

5048

1

});

5049

5050

	// Encode the call. Balances transact to para_a_account

5051

	// First index

5052

1

	let mut encoded: Vec<u8> = Vec::new();

5053

1

	let index =

5054

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5055

1

			.unwrap() as u8;

5056

5057

1

	encoded.push(index);

5058

5059

	use sp_core::U256;

5060

	// Let's do a EVM transfer

5061

1

	let eth_tx =

5062

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5063

1

			gas_limit: U256::from(21000),

5064

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5065

1

			value: U256::from(100),

5066

1

			input: BoundedVec::<

5067

1

u8,

5068

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5069

1

			>::try_from(vec![]).unwrap(),

5070

1

			access_list: None,

5071

1

});

5072

5073

	// Then call bytes

5074

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5075

1

		transact_as: PARAALICE.into(),

5076

1

		xcm_transaction: eth_tx,

5077

1

5078

1

	.encode();

5079

1

	encoded.append(&mut call_bytes);

5080

5081

1

	ParaA::execute_with(|| {

5082

1

		assert_ok!(XcmTransactor::transact_through_signed(

5083

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5084

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5085

1

			CurrencyPayment {

5086

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5087

1

					para_b_balances

5088

1

				))),

5089

1

				fee_amount: None

5090

1

},

5091

1

			encoded,

5092

1

			TransactWeights {

5093

1

				transact_required_weight_at_most: 4000000000.into(),

5094

1

				overall_weight: None

5095

1

},

5096

			false

5097

));

5098

1

});

5099

5100

1

	ParaB::execute_with(|| {

5101

		// Make sure the EVM transfer was executed

5102

1

		assert!(

5103

1

			ParaBalances::free_balance(&transfer_recipient.into())

5104

1

				== transfer_recipient_balance_before + 100

5105

);

5106

1

});

5107

1

5108

5109

#[test]

5110

1

fn hrmp_init_accept_through_root() {

5111

1

	MockNet::reset();

5112

5113

1

	Relay::execute_with(|| {

5114

1

		assert_ok!(RelayBalances::transfer_allow_death(

5115

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5116

1

			para_a_account(),

5117

			1000u128

5118

));

5119

1

		assert_ok!(RelayBalances::transfer_allow_death(

5120

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5121

1

			para_b_account(),

5122

			1000u128

5123

));

5124

1

});

5125

5126

1

	ParaA::execute_with(|| {

5127

1

		let total_fee = 1_000u128;

5128

1

		let total_weight: u64 = 1_000_000_000;

5129

1

		let tx_weight: u64 = 500_000_000;

5130

		// Root can send hrmp init channel

5131

1

		assert_ok!(XcmTransactor::hrmp_manage(

5132

1

			parachain::RuntimeOrigin::root(),

5133

1

			HrmpOperation::InitOpen(HrmpInitParams {

5134

1

				para_id: 2u32.into(),

5135

1

				proposed_max_capacity: 1,

5136

1

				proposed_max_message_size: 1

5137

1

}),

5138

1

			CurrencyPayment {

5139

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5140

1

					Location::parent()

5141

1

				))),

5142

1

				fee_amount: Some(total_fee)

5143

1

},

5144

1

			TransactWeights {

5145

1

				transact_required_weight_at_most: tx_weight.into(),

5146

1

				overall_weight: Some(Limited(total_weight.into()))

5147

1

5148

));

5149

1

});

5150

1

	Relay::execute_with(|| {

5151

1

		let expected_event: relay_chain::RuntimeEvent =

5152

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5153

1

				sender: 1u32.into(),

5154

1

				recipient: 2u32.into(),

5155

1

				proposed_max_capacity: 1u32,

5156

1

				proposed_max_message_size: 1u32,

5157

1

5158

1

			.into();

5159

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5160

1

});

5161

1

	ParaB::execute_with(|| {

5162

1

		let total_fee = 1_000u128;

5163

1

		let total_weight: u64 = 1_000_000_000;

5164

1

		let tx_weight: u64 = 500_000_000;

5165

		// Root can send hrmp accept channel

5166

1

		assert_ok!(XcmTransactor::hrmp_manage(

5167

1

			parachain::RuntimeOrigin::root(),

5168

1

			HrmpOperation::Accept {

5169

1

				para_id: 1u32.into()

5170

1

},

5171

1

			CurrencyPayment {

5172

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5173

1

					Location::parent()

5174

1

				))),

5175

1

				fee_amount: Some(total_fee)

5176

1

},

5177

1

			TransactWeights {

5178

1

				transact_required_weight_at_most: tx_weight.into(),

5179

1

				overall_weight: Some(Limited(total_weight.into()))

5180

1

5181

));

5182

1

});

5183

5184

1

	Relay::execute_with(|| {

5185

1

		let expected_event: relay_chain::RuntimeEvent =

5186

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5187

1

				sender: 1u32.into(),

5188

1

				recipient: 2u32.into(),

5189

1

5190

1

			.into();

5191

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5192

1

});

5193

1

5194

5195

#[test]

5196

1

fn hrmp_close_works() {

5197

1

	MockNet::reset();

5198

5199

1

	Relay::execute_with(|| {

5200

1

		assert_ok!(RelayBalances::transfer_allow_death(

5201

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5202

1

			para_a_account(),

5203

			1000u128

5204

));

5205

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5206

1

			relay_chain::RuntimeOrigin::root(),

5207

1

			1u32.into(),

5208

1

			2u32.into(),

5209

			1u32,

5210

			1u32

5211

));

5212

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5213

1

			relay_chain::RuntimeOrigin::root(),

5214

			1u32

5215

));

5216

1

});

5217

5218

1

	ParaA::execute_with(|| {

5219

1

		let total_fee = 1_000u128;

5220

1

		let total_weight: u64 = 1_000_000_000;

5221

1

		let tx_weight: u64 = 500_000_000;

5222

		// Root can send hrmp close

5223

1

		assert_ok!(XcmTransactor::hrmp_manage(

5224

1

			parachain::RuntimeOrigin::root(),

5225

1

			HrmpOperation::Close(HrmpChannelId {

5226

1

				sender: 1u32.into(),

5227

1

				recipient: 2u32.into()

5228

1

}),

5229

1

			CurrencyPayment {

5230

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5231

1

					Location::parent()

5232

1

				))),

5233

1

				fee_amount: Some(total_fee)

5234

1

},

5235

1

			TransactWeights {

5236

1

				transact_required_weight_at_most: tx_weight.into(),

5237

1

				overall_weight: Some(Limited(total_weight.into()))

5238

1

5239

));

5240

1

});

5241

1

	Relay::execute_with(|| {

5242

1

		let expected_event: relay_chain::RuntimeEvent =

5243

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5244

1

				by_parachain: 1u32.into(),

5245

1

				channel_id: HrmpChannelId {

5246

1

					sender: 1u32.into(),

5247

1

					recipient: 2u32.into(),

5248

1

},

5249

1

5250

1

			.into();

5251

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5252

1

});

5253

1

5254

5255

use crate::xcm_mock::parachain::XcmWeightTrader;

5256

use parity_scale_codec::{Decode, Encode};

5257

use sp_io::hashing::blake2_256;

5258

5259

// Helper to derive accountIds

5260

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5261

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5262

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5263

7