Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonriver Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{PalletInfo, PalletInfoAccess},

23

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

24

	BoundedVec,

25

};

26

use moonriver_runtime::xcm_config::AssetType;

27

use sp_core::ConstU32;

28

use sp_core::U256;

29

use sp_runtime::traits::Convert;

30

use xcm::{

31

	latest::prelude::{

32

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

33

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

34

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

35

		WeightLimit, WithdrawAsset, Xcm,

36

},

37

	IntoVersion, VersionedAssets, VersionedLocation, WrapVersion,

38

};

39

use xcm_executor::traits::ConvertLocation;

40

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

41

use xcm_mock::relay_chain;

42

use xcm_mock::*;

43

use xcm_simulator::TestExt;

44

mod common;

45

use cumulus_primitives_core::relay_chain::HrmpChannelId;

46

use pallet_xcm_transactor::{

47

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

48

};

49

use xcm_primitives::{

50

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

51

};

52

53

28

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

54

28

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

55

28

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

56

28

		.into_version(xcm::latest::VERSION)

57

28

		.map_err(|_| ())?

58

	else {

59

		return Err(());

60

};

61

	use frame_support::weights::WeightToFee as _;

62

28

	let native_amount_per_second: u128 =

63

28

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

64

28

			&Weight::from_parts(

65

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

66

28

0,

67

28

),

68

28

69

28

		.try_into()

70

28

		.map_err(|_| ())?;

71

28

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

72

28

	let relative_price: u128 = if units_per_second > 0u128 {

73

10

		native_amount_per_second

74

10

			.saturating_mul(precision_factor)

75

10

			.saturating_div(units_per_second)

76

	} else {

77

18

		0u128

78

};

79

28

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

80

28

		location_v5,

81

28

		(true, relative_price),

82

28

);

83

28

	Ok(())

84

28

85

86

25

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

87

25

	Asset {

88

25

		id: AssetId(

89

25

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

90

25

				currency_id,

91

25

92

25

			.unwrap(),

93

25

),

94

25

		fun: Fungibility::Fungible(amount),

95

25

96

25

97

98

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

99

#[test]

100

1

fn receive_relay_asset_from_relay() {

101

1

	MockNet::reset();

102

1

103

1

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

104

1

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

105

1

	let asset_metadata = parachain::AssetMetadata {

106

1

		name: b"RelayToken".to_vec(),

107

1

		symbol: b"Relay".to_vec(),

108

1

		decimals: 12,

109

1

};

110

1

	// Register relay asset in parachain A

111

1

	ParaA::execute_with(|| {

112

1

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

113

1

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

114

1

			.try_into()

115

1

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

116

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

117

1

			source_id,

118

1

			source_location_latest,

119

1

			asset_metadata.decimals,

120

1

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

121

1

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

122

1

));

123

1

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

124

1

});

125

1

126

1

	// Actually send relay asset to parachain

127

1

	let dest: Location = AccountKey20 {

128

1

		network: None,

129

1

		key: PARAALICE,

130

1

131

1

	.into();

132

1

	Relay::execute_with(|| {

133

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

134

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

135

1

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

136

1

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

137

1

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

138

1

0,

139

1

			WeightLimit::Unlimited

140

1

));

141

1

});

142

1

143

1

	// Verify that parachain received the asset

144

1

	ParaA::execute_with(|| {

145

1

		// free execution, full amount received

146

1

		assert_eq!(

147

1

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

148

1

			Ok(U256::from(123))

149

1

);

150

1

});

151

1

152

153

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

154

#[test]

155

1

fn send_relay_asset_to_relay() {

156

1

	MockNet::reset();

157

1

158

1

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

159

1

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

160

1

161

1

	let asset_metadata = parachain::AssetMetadata {

162

1

		name: b"RelayToken".to_vec(),

163

1

		symbol: b"Relay".to_vec(),

164

1

		decimals: 12,

165

1

};

166

1

167

1

	// Register relay asset in paraA

168

1

	ParaA::execute_with(|| {

169

1

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

170

1

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

171

1

			.try_into()

172

1

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

173

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

174

1

			source_id,

175

1

			source_location_latest,

176

1

			asset_metadata.decimals,

177

1

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

178

1

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

179

1

));

180

		// free execution

181

1

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

182

1

});

183

1

184

1

	let dest: Location = Junction::AccountKey20 {

185

1

		network: None,

186

1

		key: PARAALICE,

187

1

188

1

	.into();

189

1

190

1

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

191

1

	Relay::execute_with(|| {

192

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

193

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

194

1

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

195

1

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

196

1

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

197

1

0,

198

1

			WeightLimit::Unlimited

199

1

));

200

1

});

201

1

202

1

	ParaA::execute_with(|| {

203

1

		// Free execution, full amount received

204

1

		assert_eq!(

205

1

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

206

1

			Ok(U256::from(123))

207

1

);

208

1

});

209

1

210

1

	// Lets gather the balance before sending back money

211

1

	let mut balance_before_sending = 0;

212

1

	Relay::execute_with(|| {

213

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

214

1

});

215

1

216

1

	// We now send back some money to the relay

217

1

	let dest = Location {

218

1

		parents: 1,

219

1

		interior: [AccountId32 {

220

1

			network: None,

221

1

			id: RELAYALICE.into(),

222

1

}]

223

1

		.into(),

224

1

};

225

1

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

226

1

227

1

	ParaA::execute_with(|| {

228

1

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

229

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

230

1

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

231

1

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

232

1

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

233

1

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

234

1

0,

235

1

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

236

1

));

237

1

});

238

1

239

1

	// The balances in paraAlice should have been substracted

240

1

	ParaA::execute_with(|| {

241

1

		assert_eq!(

242

1

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

243

1

			Ok(U256::from(0))

244

1

);

245

1

});

246

1

247

1

	// Balances in the relay should have been received

248

1

	Relay::execute_with(|| {

249

1

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

250

1

});

251

1

252

253

#[test]

254

1

fn send_relay_asset_to_para_b() {

255

1

	MockNet::reset();

256

1

257

1

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

258

1

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

259

1

260

1

	let asset_metadata = parachain::AssetMetadata {

261

1

		name: b"RelayToken".to_vec(),

262

1

		symbol: b"Relay".to_vec(),

263

1

		decimals: 12,

264

1

};

265

1

266

1

	// Register asset in paraA. Free execution

267

1

	ParaA::execute_with(|| {

268

1

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

269

1

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

270

1

			.try_into()

271

1

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

272

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

273

1

			source_id,

274

1

			source_location_latest,

275

1

			asset_metadata.decimals,

276

1

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

277

1

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

278

1

));

279

1

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

280

1

});

281

1

282

1

	// Register asset in paraB. Free execution

283

1

	ParaB::execute_with(|| {

284

1

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

285

1

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

286

1

			.try_into()

287

1

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

288

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

289

1

			source_id,

290

1

			source_location_latest,

291

1

			asset_metadata.decimals,

292

1

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

293

1

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

294

1

));

295

1

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

296

1

});

297

1

298

1

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

299

1

	let dest: Location = Junction::AccountKey20 {

300

1

		network: None,

301

1

		key: PARAALICE,

302

1

303

1

	.into();

304

1

	Relay::execute_with(|| {

305

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

306

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

307

1

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

308

1

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

309

1

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

310

1

0,

311

1

			WeightLimit::Unlimited

312

1

));

313

1

});

314

1

315

1

	ParaA::execute_with(|| {

316

1

		assert_eq!(

317

1

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

318

1

			Ok(U256::from(123))

319

1

);

320

1

});

321

1

322

1

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

323

1

	let dest = Location {

324

1

		parents: 1,

325

1

		interior: [

326

1

			Parachain(2),

327

1

			AccountKey20 {

328

1

				network: None,

329

1

				key: PARAALICE.into(),

330

1

},

331

1

332

1

		.into(),

333

1

};

334

1

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

335

1

336

1

	ParaA::execute_with(|| {

337

1

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

338

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

339

1

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

340

1

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

341

1

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

342

1

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

343

1

0,

344

1

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

345

1

));

346

1

});

347

1

348

1

	// Para A balances should have been substracted

349

1

	ParaA::execute_with(|| {

350

1

		assert_eq!(

351

1

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

352

1

			Ok(U256::from(23))

353

1

);

354

1

});

355

1

356

1

	// Para B balances should have been credited

357

1

	ParaB::execute_with(|| {

358

1

		assert_eq!(

359

1

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

360

1

			Ok(U256::from(100))

361

1

);

362

1

});

363

1

364

365

#[test]

366

1

fn send_para_a_asset_to_para_b() {

367

1

	MockNet::reset();

368

1

369

1

	// This represents the asset in paraA

370

1

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

371

1

	let source_location: AssetType = para_a_balances

372

1

		.try_into()

373

1

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

374

1

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

375

1

376

1

	let asset_metadata = parachain::AssetMetadata {

377

1

		name: b"ParaAToken".to_vec(),

378

1

		symbol: b"ParaA".to_vec(),

379

1

		decimals: 18,

380

1

};

381

1

382

1

	// Register asset in paraB. Free execution

383

1

	ParaB::execute_with(|| {

384

1

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

385

1

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

386

1

			.try_into()

387

1

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

388

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

389

1

			source_id,

390

1

			source_location_latest,

391

1

			asset_metadata.decimals,

392

1

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

393

1

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

394

1

));

395

1

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

396

1

});

397

1

398

1

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

399

1

	let dest = Location {

400

1

		parents: 1,

401

1

		interior: [

402

1

			Parachain(2),

403

1

			AccountKey20 {

404

1

				network: None,

405

1

				key: PARAALICE.into(),

406

1

},

407

1

408

1

		.into(),

409

1

};

410

1

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

411

1

412

1

	ParaA::execute_with(|| {

413

1

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

414

1

		assert_ok!(PolkadotXcm::transfer_assets(

415

1

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

416

1

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

417

1

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

418

1

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

419

1

0,

420

1

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

421

1

));

422

1

});

423

1

424

1

	// Native token is substracted in paraA

425

1

	ParaA::execute_with(|| {

426

1

		// free execution, full amount received

427

1

		assert_eq!(

428

1

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

429

1

			INITIAL_BALANCE - 100

430

1

);

431

1

});

432

1

433

1

	// Asset is minted in paraB

434

1

	ParaB::execute_with(|| {

435

1

		// free execution, full amount received

436

1

		assert_eq!(

437

1

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

438

1

			Ok(U256::from(100))

439

1

);

440

1

});

441

1

442

443

#[test]

444

1

fn send_para_a_asset_from_para_b_to_para_c() {

445

1

	MockNet::reset();

446

1

447

1

	// Represents para A asset

448

1

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

449

1

	let source_location: AssetType = para_a_balances

450

1

		.try_into()

451

1

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

452

1

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

453

1

454

1

	let asset_metadata = parachain::AssetMetadata {

455

1

		name: b"ParaAToken".to_vec(),

456

1

		symbol: b"ParaA".to_vec(),

457

1

		decimals: 18,

458

1

};

459

1

460

1

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

461

1

	ParaB::execute_with(|| {

462

1

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

463

1

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

464

1

			.try_into()

465

1

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

466

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

467

1

			source_id,

468

1

			source_location_latest,

469

1

			asset_metadata.decimals,

470

1

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

471

1

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

472

1

));

473

1

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

474

1

});

475

1

476

1

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

477

1

	ParaC::execute_with(|| {

478

1

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

479

1

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

480

1

			.try_into()

481

1

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

482

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

483

1

			source_id,

484

1

			source_location_latest,

485

1

			asset_metadata.decimals,

486

1

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

487

1

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

488

1

));

489

1

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

490

1

});

491

1

492

1

	// Send para A asset to para B

493

1

	let dest = Location {

494

1

		parents: 1,

495

1

		interior: [

496

1

			Parachain(2),

497

1

			AccountKey20 {

498

1

				network: None,

499

1

				key: PARAALICE.into(),

500

1

},

501

1

502

1

		.into(),

503

1

};

504

1

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

505

1

506

1

	ParaA::execute_with(|| {

507

1

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

508

1

		assert_ok!(PolkadotXcm::transfer_assets(

509

1

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

510

1

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

511

1

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

512

1

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

513

1

0,

514

1

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

515

1

));

516

1

});

517

1

518

1

	// Para A balances have been substracted

519

1

	ParaA::execute_with(|| {

520

1

		assert_eq!(

521

1

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

522

1

			INITIAL_BALANCE - 100

523

1

);

524

1

});

525

1

526

1

	// Para B balances have been credited

527

1

	ParaB::execute_with(|| {

528

1

		assert_eq!(

529

1

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

530

1

			Ok(U256::from(100))

531

1

);

532

1

});

533

1

534

1

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

535

1

	let dest = Location {

536

1

		parents: 1,

537

1

		interior: [

538

1

			Parachain(3),

539

1

			AccountKey20 {

540

1

				network: None,

541

1

				key: PARAALICE.into(),

542

1

},

543

1

544

1

		.into(),

545

1

};

546

1

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

547

1

548

1

	ParaB::execute_with(|| {

549

1

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

550

1

		assert_ok!(PolkadotXcm::transfer_assets(

551

1

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

552

1

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

553

1

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

554

1

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

555

1

0,

556

1

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

557

1

));

558

1

});

559

1

560

1

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

561

1

	ParaC::execute_with(|| {

562

1

		// free execution, full amount received

563

1

		assert_eq!(

564

1

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

565

1

			Ok(U256::from(95))

566

1

);

567

1

});

568

1

569

570

#[test]

571

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

572

1

	MockNet::reset();

573

1

574

1

	// Para A asset

575

1

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

576

1

	let source_location: AssetType = para_a_balances

577

1

		.try_into()

578

1

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

579

1

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

580

1

581

1

	let asset_metadata = parachain::AssetMetadata {

582

1

		name: b"ParaAToken".to_vec(),

583

1

		symbol: b"ParaA".to_vec(),

584

1

		decimals: 18,

585

1

};

586

1

587

1

	// Register para A asset in para B

588

1

	ParaB::execute_with(|| {

589

1

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

590

1

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

591

1

			.try_into()

592

1

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

593

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

594

1

			source_id,

595

1

			source_location_latest,

596

1

			asset_metadata.decimals,

597

1

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

598

1

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

599

1

));

600

1

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

601

1

});

602

1

603

1

	// Send para A asset to para B

604

1

	let dest = Location {

605

1

		parents: 1,

606

1

		interior: [

607

1

			Parachain(2),

608

1

			AccountKey20 {

609

1

				network: None,

610

1

				key: PARAALICE.into(),

611

1

},

612

1

613

1

		.into(),

614

1

};

615

1

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

616

1

617

1

	ParaA::execute_with(|| {

618

1

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

619

1

		assert_ok!(PolkadotXcm::transfer_assets(

620

1

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

621

1

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

622

1

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

623

1

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

624

1

0,

625

1

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

626

1

));

627

1

});

628

1

629

1

	// Balances have been substracted

630

1

	ParaA::execute_with(|| {

631

1

		assert_eq!(

632

1

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

633

1

			INITIAL_BALANCE - 100

634

1

);

635

1

});

636

1

637

1

	// Para B balances have been credited

638

1

	ParaB::execute_with(|| {

639

1

		assert_eq!(

640

1

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

641

1

			Ok(U256::from(100))

642

1

);

643

1

});

644

1

645

1

	// Send back para A asset to para A

646

1

	let dest = Location {

647

1

		parents: 1,

648

1

		interior: [

649

1

			Parachain(1),

650

1

			AccountKey20 {

651

1

				network: None,

652

1

				key: PARAALICE.into(),

653

1

},

654

1

655

1

		.into(),

656

1

};

657

1

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

658

1

659

1

	ParaB::execute_with(|| {

660

1

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

661

1

		assert_ok!(PolkadotXcm::transfer_assets(

662

1

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

663

1

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

664

1

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

665

1

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

666

1

0,

667

1

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

668

1

));

669

1

});

670

1

671

1

	// Para A asset has been credited

672

1

	ParaA::execute_with(|| {

673

1

		// Weight used is 4

674

1

		assert_eq!(

675

1

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

676

1

			INITIAL_BALANCE - 4

677

1

);

678

1

});

679

1

680

681

#[test]

682

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

683

1

	MockNet::reset();

684

1

685

1

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

686

1

	let source_location: AssetType = para_a_balances

687

1

		.try_into()

688

1

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

689

1

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

690

1

691

1

	let asset_metadata = parachain::AssetMetadata {

692

1

		name: b"ParaAToken".to_vec(),

693

1

		symbol: b"ParaA".to_vec(),

694

1

		decimals: 18,

695

1

};

696

1

697

1

	ParaB::execute_with(|| {

698

1

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

699

1

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

700

1

			.try_into()

701

1

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

702

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

703

1

			source_id,

704

1

			source_location_latest,

705

1

			asset_metadata.decimals,

706

1

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

707

1

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

708

1

));

709

1

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

710

1

});

711

1

712

1

	let dest = Location {

713

1

		parents: 1,

714

1

		interior: [

715

1

			Parachain(2),

716

1

			AccountKey20 {

717

1

				network: None,

718

1

				key: PARAALICE.into(),

719

1

},

720

1

721

1

		.into(),

722

1

};

723

1

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

724

1

725

1

	ParaA::execute_with(|| {

726

1

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

727

1

		assert_ok!(PolkadotXcm::transfer_assets(

728

1

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

729

1

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

730

1

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

731

1

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

732

1

0,

733

1

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

734

1

));

735

1

});

736

1

737

1

	ParaA::execute_with(|| {

738

1

		// Free execution, full amount received

739

1

		assert_eq!(

740

1

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

741

1

			INITIAL_BALANCE - 100

742

1

);

743

1

});

744

1

745

1

	ParaB::execute_with(|| {

746

1

		// Free execution, full amount received

747

1

		assert_eq!(

748

1

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

749

1

			Ok(U256::from(100))

750

1

);

751

1

});

752

1

753

1

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

754

1

	// Message through polkadotXCM pallet

755

1

756

1

	let dest = Location {

757

1

		parents: 1,

758

1

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

759

1

};

760

1

761

1

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

762

1

763

1

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

764

1

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

765

1

		ClearOrigin,

766

1

		BuyExecution {

767

1

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

768

1

			weight_limit: Limited(80.into()),

769

1

},

770

1

		DepositAsset {

771

1

			assets: All.into(),

772

1

			beneficiary: Location::new(

773

1

0,

774

1

				[AccountKey20 {

775

1

					network: None,

776

1

					key: PARAALICE,

777

1

}],

778

1

),

779

1

},

780

1

	]));

781

1

	ParaB::execute_with(|| {

782

1

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

783

1

		// and deposit asset

784

1

		assert_ok!(ParachainPalletXcm::send(

785

1

			parachain::RuntimeOrigin::root(),

786

1

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

787

1

			Box::new(message),

788

1

));

789

1

});

790

1

791

1

	ParaB::execute_with(|| {

792

1

		// free execution, full amount received

793

1

		assert_eq!(

794

1

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

795

1

			Ok(U256::from(100))

796

1

);

797

1

});

798

1

799

1

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

800

1

	// Message through polkadotXCM pallet

801

1

802

1

	let dest = Location {

803

1

		parents: 1,

804

1

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

805

1

};

806

1

807

1

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

808

1

809

1

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

810

1

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

811

1

		ClearOrigin,

812

1

		BuyExecution {

813

1

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

814

1

			weight_limit: Limited(80.into()),

815

1

},

816

1

		DepositAsset {

817

1

			assets: All.into(),

818

1

			beneficiary: Location::new(

819

1

0,

820

1

				[AccountKey20 {

821

1

					network: None,

822

1

					key: PARAALICE,

823

1

}],

824

1

),

825

1

},

826

1

	]));

827

1

	ParaB::execute_with(|| {

828

1

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

829

1

		// and deposit asset

830

1

		assert_ok!(ParachainPalletXcm::send(

831

1

			parachain::RuntimeOrigin::root(),

832

1

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

833

1

			Box::new(message),

834

1

));

835

1

});

836

1

837

1

	ParaA::execute_with(|| {

838

1

		// Weight used is 4

839

1

		assert_eq!(

840

1

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

841

1

			INITIAL_BALANCE - 4

842

1

);

843

1

});

844

1

845

846

#[test]

847

1

fn receive_relay_asset_with_trader() {

848

1

	MockNet::reset();

849

1

850

1

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

851

1

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

852

1

853

1

	let asset_metadata = parachain::AssetMetadata {

854

1

		name: b"RelayToken".to_vec(),

855

1

		symbol: b"Relay".to_vec(),

856

1

		decimals: 12,

857

1

};

858

1

859

1

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

860

1

	// we know later we will divide by 1e12

861

1

	// Lets put 1e6 as units per second

862

1

	ParaA::execute_with(|| {

863

1

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

864

1

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

865

1

			.try_into()

866

1

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

867

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

868

1

			source_id,

869

1

			source_location_latest,

870

1

			asset_metadata.decimals,

871

1

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

872

1

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

873

1

));

874

1

		assert_ok!(add_supported_asset(

875

1

			source_location.clone(),

876

1

			2500000000000u128

877

1

));

878

1

});

879

1

880

1

	let dest: Location = Junction::AccountKey20 {

881

1

		network: None,

882

1

		key: PARAALICE,

883

1

884

1

	.into();

885

1

	// We are sending 100 tokens from relay.

886

1

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

887

1

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

888

1

	// Units per second should be 2_500_000_000_000_000

889

1

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

890

1

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

891

1

	Relay::execute_with(|| {

892

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

893

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

894

1

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

895

1

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

896

1

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

897

1

0,

898

1

			WeightLimit::Unlimited

899

1

));

900

1

});

901

1

902

1

	ParaA::execute_with(|| {

903

1

		// non-free execution, not full amount received

904

1

		assert_eq!(

905

1

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

906

1

			Ok(U256::from(90))

907

1

);

908

		// Fee should have been received by treasury

909

1

		assert_eq!(

910

1

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

911

1

			Ok(U256::from(10))

912

1

);

913

1

});

914

1

915

916

#[test]

917

1

fn send_para_a_asset_to_para_b_with_trader() {

918

1

	MockNet::reset();

919

1

920

1

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

921

1

	let source_location: AssetType = para_a_balances

922

1

		.try_into()

923

1

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

924

1

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

925

1

926

1

	let asset_metadata = parachain::AssetMetadata {

927

1

		name: b"ParaAToken".to_vec(),

928

1

		symbol: b"ParaA".to_vec(),

929

1

		decimals: 18,

930

1

};

931

1

932

1

	ParaB::execute_with(|| {

933

1

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

934

1

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

935

1

			.try_into()

936

1

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

937

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

938

1

			source_id,

939

1

			source_location_latest,

940

1

			asset_metadata.decimals,

941

1

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

942

1

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

943

1

));

944

1

		assert_ok!(add_supported_asset(

945

1

			source_location.clone(),

946

1

			2500000000000u128

947

1

));

948

1

});

949

1

950

1

	let dest = Location {

951

1

		parents: 1,

952

1

		interior: [

953

1

			Parachain(2),

954

1

			AccountKey20 {

955

1

				network: None,

956

1

				key: PARAALICE.into(),

957

1

},

958

1

959

1

		.into(),

960

1

};

961

1

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

962

1

963

1

	// In destination chain, we only need 4 weight

964

1

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

965

1

	ParaA::execute_with(|| {

966

1

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

967

1

		assert_ok!(PolkadotXcm::transfer_assets(

968

1

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

969

1

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

970

1

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

971

1

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

972

1

0,

973

1

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

974

1

));

975

1

});

976

1

	ParaA::execute_with(|| {

977

1

		// free execution, full amount received

978

1

		assert_eq!(

979

1

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

980

1

			INITIAL_BALANCE - 100

981

1

);

982

1

});

983

1

984

1

	// We are sending 100 tokens from para A.

985

1

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

986

1

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

987

1

	// Units per second should be 2_500_000_000_000_000

988

1

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

989

1

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

990

1

	// will be 4

991

1

	ParaB::execute_with(|| {

992

1

		assert_eq!(

993

1

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

994

1

			Ok(U256::from(90))

995

1

);

996

		// Fee should have been received by treasury

997

1

		assert_eq!(

998

1

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

999

1

			Ok(U256::from(10))

1000

1

);

1001

1

});

1002

1

1003

1004

#[test]

1005

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1006

1

	MockNet::reset();

1007

1

1008

1

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

1009

1

	let source_location: AssetType = para_a_balances

1010

1

		.try_into()

1011

1

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

1012

1

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

1013

1

1014

1

	let asset_metadata = parachain::AssetMetadata {

1015

1

		name: b"ParaAToken".to_vec(),

1016

1

		symbol: b"ParaA".to_vec(),

1017

1

		decimals: 18,

1018

1

};

1019

1

1020

1

	ParaB::execute_with(|| {

1021

1

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

1022

1

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

1023

1

			.try_into()

1024

1

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

1025

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1026

1

			source_id,

1027

1

			source_location_latest,

1028

1

			asset_metadata.decimals,

1029

1

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

1030

1

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

1031

1

));

1032

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

1033

1

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

1034

1

});

1035

1

1036

1

	let dest = Location {

1037

1

		parents: 1,

1038

1

		interior: [

1039

1

			Parachain(2),

1040

1

			AccountKey20 {

1041

1

				network: None,

1042

1

				key: PARAALICE.into(),

1043

1

},

1044

1

1045

1

		.into(),

1046

1

};

1047

1

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

1048

1

1049

1

	// we use transfer_with_fee

1050

1

	ParaA::execute_with(|| {

1051

1

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

1052

1

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

1053

1

		assert_ok!(PolkadotXcm::transfer_assets(

1054

1

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

1055

1

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

1056

1

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

1057

1

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

1058

1

0,

1059

1

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

1060

1

));

1061

1

});

1062

1

	ParaA::execute_with(|| {

1063

1

		// 100 tokens transferred plus 1 taken from fees

1064

1

		assert_eq!(

1065

1

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

1066

1

			INITIAL_BALANCE - 100 - 1

1067

1

);

1068

1

});

1069

1

1070

1

	ParaB::execute_with(|| {

1071

1

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

1072

1

		// what it is specified

1073

1

		assert_eq!(

1074

1

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

1075

1

			Ok(U256::from(101))

1076

1

);

1077

1

});

1078

1

1079

1080

#[test]

1081

1

fn error_when_not_paying_enough() {

1082

1

	MockNet::reset();

1083

1

1084

1

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

1085

1

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

1086

1

1087

1

	let asset_metadata = parachain::AssetMetadata {

1088

1

		name: b"RelayToken".to_vec(),

1089

1

		symbol: b"Relay".to_vec(),

1090

1

		decimals: 12,

1091

1

};

1092

1

1093

1

	let dest: Location = Junction::AccountKey20 {

1094

1

		network: None,

1095

1

		key: PARAALICE,

1096

1

1097

1

	.into();

1098

1

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

1099

1

	// we know later we will divide by 1e12

1100

1

	// Lets put 1e6 as units per second

1101

1

	ParaA::execute_with(|| {

1102

1

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

1103

1

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

1104

1

			.try_into()

1105

1

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

1106

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1107

1

			source_id,

1108

1

			source_location_latest,

1109

1

			asset_metadata.decimals,

1110

1

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

1111

1

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

1112

1

));

1113

1

		assert_ok!(add_supported_asset(

1114

1

			source_location.clone(),

1115

1

			2500000000000u128

1116

1

));

1117

1

});

1118

1

1119

1

	// We are sending 100 tokens from relay.

1120

1

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

1121

1

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

1122

1

	Relay::execute_with(|| {

1123

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1124

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1125

1

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

1126

1

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

1127

1

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

1128

1

0,

1129

1

			WeightLimit::Unlimited

1130

1

));

1131

1

});

1132

1

1133

1

	ParaA::execute_with(|| {

1134

1

		// amount not received as it is not paying enough

1135

1

		assert_eq!(

1136

1

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

1137

1

			Ok(U256::from(0))

1138

1

);

1139

1

});

1140

1

1141

1142

#[test]

1143

1

fn transact_through_derivative_multilocation() {

1144

1

	MockNet::reset();

1145

1

1146

1

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

1147

1

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

1148

1

1149

1

	let asset_metadata = parachain::AssetMetadata {

1150

1

		name: b"RelayToken".to_vec(),

1151

1

		symbol: b"Relay".to_vec(),

1152

1

		decimals: 12,

1153

1

};

1154

1

1155

1

	ParaA::execute_with(|| {

1156

1

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

1157

1

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

1158

1

			.try_into()

1159

1

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

1160

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1161

1

			source_id,

1162

1

			source_location_latest,

1163

1

			asset_metadata.decimals,

1164

1

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

1165

1

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

1166

1

));

1167

1

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

1168

1169

		// Root can set transact info

1170

1

		assert_ok!(XcmTransactor::set_transact_info(

1171

1

			parachain::RuntimeOrigin::root(),

1172

1

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

1173

1

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

1174

1

			3000.into(),

1175

1

			20000000000.into(),

1176

1

			None

1177

1

));

1178

		// Root can set transact info

1179

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1180

1

			parachain::RuntimeOrigin::root(),

1181

1

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

1182

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1183

1

));

1184

1

});

1185

1

1186

1

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

1187

1

1188

1

	let dest: Location = AccountKey20 {

1189

1

		network: None,

1190

1

		key: PARAALICE,

1191

1

1192

1

	.into();

1193

1

	Relay::execute_with(|| {

1194

1

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

1195

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1196

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1197

1

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

1198

1

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

1199

1

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

1200

1

0,

1201

1

			WeightLimit::Unlimited

1202

1

));

1203

1

});

1204

1

1205

1

	ParaA::execute_with(|| {

1206

1

		// free execution, full amount received

1207

1

		assert_eq!(

1208

1

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

1209

1

			Ok(U256::from(4000003100u64))

1210

1

);

1211

1

});

1212

1

1213

1

	// Register address

1214

1

	ParaA::execute_with(|| {

1215

1

		assert_ok!(XcmTransactor::register(

1216

1

			parachain::RuntimeOrigin::root(),

1217

1

			PARAALICE.into(),

1218

1

0,

1219

1

));

1220

1

});

1221

1

1222

1

	// Send to registered address

1223

1

1224

1

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

1225

1

	let dest = Location {

1226

1

		parents: 1,

1227

1

		interior: [AccountId32 {

1228

1

			network: None,

1229

1

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

1230

1

}]

1231

1

		.into(),

1232

1

};

1233

1

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

1234

1

1235

1

	ParaA::execute_with(|| {

1236

1

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

1237

1

		// free execution, full amount received

1238

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1239

1

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

1240

1

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

1241

1

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

1242

1

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

1243

1

0,

1244

1

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

1245

1

));

1246

1

});

1247

1

1248

1

	ParaA::execute_with(|| {

1249

1

		// free execution, full amount received

1250

1

		assert_eq!(

1251

1

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

1252

1

			Ok(U256::from(4000003000u64))

1253

1

);

1254

1

});

1255

1

1256

1

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

1257

1

	// again

1258

1

	Relay::execute_with(|| {

1259

1

		// free execution,x	 full amount received

1260

1

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

1261

1

});

1262

1

1263

1

	// Encode the call. Balances transact to para_a_account

1264

1

	// First index

1265

1

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

1266

1

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

1267

1

		relay_chain::Balances,

1268

1

>()

1269

1

	.unwrap() as u8;

1270

1

1271

1

	encoded.push(index);

1272

1

1273

1

	// Then call bytes

1274

1

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

1275

1

		dest: para_a_account(),

1276

1

		value: 100u32.into(),

1277

1

1278

1

	.encode();

1279

1

	encoded.append(&mut call_bytes);

1280

1

1281

1

	ParaA::execute_with(|| {

1282

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1283

1

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

1284

1

			parachain::MockTransactors::Relay,

1285

1

0,

1286

1

			CurrencyPayment {

1287

1

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

1288

1

					Location::parent()

1289

1

				))),

1290

1

				fee_amount: None

1291

1

},

1292

1

			encoded,

1293

1

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

1294

1

			TransactWeights {

1295

1

				transact_required_weight_at_most: 4000000000.into(),

1296

1

				overall_weight: None

1297

1

},

1298

1

			false

1299

1

));

1300

1

});

1301

1

1302

1

	Relay::execute_with(|| {

1303

1

		// free execution,x	 full amount received

1304

1

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

1305

1306

1

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

1307

1

});

1308

1

1309

1310

#[test]

1311

1

fn transact_through_derivative_with_custom_fee_weight() {

1312

1

	MockNet::reset();

1313

1

1314

1

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

1315

1

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

1316

1

1317

1

	let asset_metadata = parachain::AssetMetadata {

1318

1

		name: b"RelayToken".to_vec(),

1319

1

		symbol: b"Relay".to_vec(),

1320

1

		decimals: 12,

1321

1

};

1322

1

1323

1

	ParaA::execute_with(|| {

1324

1

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

1325

1

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

1326

1

			.try_into()

1327

1

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

1328

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1329

1

			source_id,

1330

1

			source_location_latest,

1331

1

			asset_metadata.decimals,

1332

1

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

1333

1

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

1334

1

));

1335

1

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

1336

1

});

1337

1

1338

1

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

1339

1

1340

1

	let dest: Location = AccountKey20 {

1341

1

		network: None,

1342

1

		key: PARAALICE,

1343

1

1344

1

	.into();

1345

1

	Relay::execute_with(|| {

1346

1

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

1347

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1348

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1349

1

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

1350

1

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

1351

1

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

1352

1

0,

1353

1

			WeightLimit::Unlimited

1354

1

));

1355

1

});

1356

1

1357

1

	ParaA::execute_with(|| {

1358

1

		// free execution, full amount received

1359

1

		assert_eq!(

1360

1

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

1361

1

			Ok(U256::from(4000003100u64))

1362

1

);

1363

1

});

1364

1

1365

1

	// Register address

1366

1

	ParaA::execute_with(|| {

1367

1

		assert_ok!(XcmTransactor::register(

1368

1

			parachain::RuntimeOrigin::root(),

1369

1

			PARAALICE.into(),

1370

1

0,

1371

1

));

1372

1

});

1373

1

1374

1

	// Send to registered address

1375

1

1376

1

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

1377

1

	let dest = Location {

1378

1

		parents: 1,

1379

1

		interior: [AccountId32 {

1380

1

			network: None,

1381

1

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

1382

1

}]

1383

1

		.into(),

1384

1

};

1385

1

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

1386

1

1387

1

	ParaA::execute_with(|| {

1388

1

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

1389

1

		// free execution, full amount received

1390

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1391

1

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

1392

1

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

1393

1

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

1394

1

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

1395

1

0,

1396

1

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

1397

1

));

1398

1

});

1399

1

1400

1

	ParaA::execute_with(|| {

1401

1

		// free execution, full amount received

1402

1

		assert_eq!(

1403

1

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

1404

1

			Ok(U256::from(4000003000u64))

1405

1

);

1406

1

});

1407

1

1408

1

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

1409

1

	// again

1410

1

	Relay::execute_with(|| {

1411

1

		// free execution,x	 full amount received

1412

1

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

1413

1

});

1414

1

1415

1

	// Encode the call. Balances transact to para_a_account

1416

1

	// First index

1417

1

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

1418

1

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

1419

1

		relay_chain::Balances,

1420

1

>()

1421

1

	.unwrap() as u8;

1422

1

1423

1

	encoded.push(index);

1424

1

1425

1

	// Then call bytes

1426

1

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

1427

1

		dest: para_a_account(),

1428

1

		value: 100u32.into(),

1429

1

1430

1

	.encode();

1431

1

	encoded.append(&mut call_bytes);

1432

1

1433

1

	let overall_weight = 4000003000u64;

1434

1

	ParaA::execute_with(|| {

1435

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1436

1

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

1437

1

			parachain::MockTransactors::Relay,

1438

1

0,

1439

1

			CurrencyPayment {

1440

1

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

1441

1

					Location::parent()

1442

1

				))),

1443

1

				// 1-1 fee weight mapping

1444

1

				fee_amount: Some(overall_weight as u128)

1445

1

},

1446

1

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

1447

1

			encoded,

1448

1

			TransactWeights {

1449

1

				transact_required_weight_at_most: 4000000000.into(),

1450

1

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

1451

1

},

1452

1

			false

1453

1

));

1454

1

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

1455

1

			.iter()

1456

18

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

1457

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

1458

..

1459

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

1460

18

				_ => None,

1461

18

});

1462

1

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

1463

1

		assert!(event_found.is_none());

1464

1

});

1465

1

1466

1

	Relay::execute_with(|| {

1467

1

		// free execution,x	 full amount received

1468

1

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

1469

1470

1

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

1471

1

});

1472

1

1473

1474

#[test]

1475

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1476

1

	MockNet::reset();

1477

1

1478

1

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

1479

1

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

1480

1

1481

1

	let asset_metadata = parachain::AssetMetadata {

1482

1

		name: b"RelayToken".to_vec(),

1483

1

		symbol: b"Relay".to_vec(),

1484

1

		decimals: 12,

1485

1

};

1486

1

1487

1

	ParaA::execute_with(|| {

1488

1

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

1489

1

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

1490

1

			.try_into()

1491

1

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

1492

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1493

1

			source_id,

1494

1

			source_location_latest,

1495

1

			asset_metadata.decimals,

1496

1

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

1497

1

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

1498

1

));

1499

1

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

1500

1

});

1501

1

1502

1

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

1503

1

1504

1

	let dest: Location = AccountKey20 {

1505

1

		network: None,

1506

1

		key: PARAALICE,

1507

1

1508

1

	.into();

1509

1

	Relay::execute_with(|| {

1510

1

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

1511

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1512

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1513

1

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

1514

1

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

1515

1

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

1516

1

0,

1517

1

			WeightLimit::Unlimited

1518

1

));

1519

1

});

1520

1

1521

1

	ParaA::execute_with(|| {

1522

1

		// free execution, full amount received

1523

1

		assert_eq!(

1524

1

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

1525

1

			Ok(U256::from(4000009100u64))

1526

1

);

1527

1

});

1528

1

1529

1

	// Register address

1530

1

	ParaA::execute_with(|| {

1531

1

		assert_ok!(XcmTransactor::register(

1532

1

			parachain::RuntimeOrigin::root(),

1533

1

			PARAALICE.into(),

1534

1

0,

1535

1

));

1536

1

});

1537

1

1538

1

	// Send to registered address

1539

1

1540

1

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

1541

1

	let dest = Location {

1542

1

		parents: 1,

1543

1

		interior: [AccountId32 {

1544

1

			network: None,

1545

1

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

1546

1

}]

1547

1

		.into(),

1548

1

};

1549

1

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

1550

1

1551

1

	ParaA::execute_with(|| {

1552

1

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

1553

1

		// free execution, full amount received

1554

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1555

1

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

1556

1

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

1557

1

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

1558

1

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

1559

1

0,

1560

1

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

1561

1

));

1562

1

});

1563

1

1564

1

	ParaA::execute_with(|| {

1565

1

		// free execution, full amount received

1566

1

		assert_eq!(

1567

1

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

1568

1

			Ok(U256::from(4000009000u64))

1569

1

);

1570

1

});

1571

1

1572

1

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

1573

1

	// again

1574

1

	Relay::execute_with(|| {

1575

1

		// free execution,x	 full amount received

1576

1

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

1577

1

});

1578

1

1579

1

	// Encode the call. Balances transact to para_a_account

1580

1

	// First index

1581

1

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

1582

1

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

1583

1

		relay_chain::Balances,

1584

1

>()

1585

1

	.unwrap() as u8;

1586

1

1587

1

	encoded.push(index);

1588

1

1589

1

	// Then call bytes

1590

1

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

1591

1

		dest: para_a_account(),

1592

1

		value: 100u32.into(),

1593

1

1594

1

	.encode();

1595

1

	encoded.append(&mut call_bytes);

1596

1

1597

1

	let overall_weight = 4000009000u64;

1598

1

	ParaA::execute_with(|| {

1599

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1600

1

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

1601

1

			parachain::MockTransactors::Relay,

1602

1

0,

1603

1

			CurrencyPayment {

1604

1

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

1605

1

					Location::parent()

1606

1

				))),

1607

1

				// 1-1 fee weight mapping

1608

1

				fee_amount: Some(overall_weight as u128)

1609

1

},

1610

1

			encoded,

1611

1

			TransactWeights {

1612

1

				transact_required_weight_at_most: 4000000000.into(),

1613

1

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

1614

1

},

1615

1

			true

1616

1

));

1617

1

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

1618

1

			.iter()

1619

18

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

1620

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

1621

..

1622

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

1623

18

				_ => None,

1624

18

});

1625

1

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

1626

1

		assert!(event_found.is_none());

1627

1

});

1628

1

1629

1

	Relay::execute_with(|| {

1630

1

		// free execution,x	 full amount received

1631

1

		// 4000009000 refunded + 100 transferred = 4000009100

1632

1

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

1633

1

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

1634

1

});

1635

1

1636

1637

#[test]

1638

1

fn transact_through_sovereign() {

1639

1

	MockNet::reset();

1640

1

1641

1

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

1642

1

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

1643

1

1644

1

	let asset_metadata = parachain::AssetMetadata {

1645

1

		name: b"RelayToken".to_vec(),

1646

1

		symbol: b"Relay".to_vec(),

1647

1

		decimals: 12,

1648

1

};

1649

1

1650

1

	ParaA::execute_with(|| {

1651

1

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

1652

1

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

1653

1

			.try_into()

1654

1

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

1655

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1656

1

			source_id,

1657

1

			source_location_latest,

1658

1

			asset_metadata.decimals,

1659

1

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

1660

1

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

1661

1

));

1662

1

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

1663

1664

		// Root can set transact info

1665

1

		assert_ok!(XcmTransactor::set_transact_info(

1666

1

			parachain::RuntimeOrigin::root(),

1667

1

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

1668

1

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

1669

1

			3000.into(),

1670

1

			20000000000.into(),

1671

1

			None

1672

1

));

1673

		// Root can set transact info

1674

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1675

1

			parachain::RuntimeOrigin::root(),

1676

1

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

1677

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1678

1

));

1679

1

});

1680

1

1681

1

	let dest: Location = AccountKey20 {

1682

1

		network: None,

1683

1

		key: PARAALICE,

1684

1

1685

1

	.into();

1686

1

	Relay::execute_with(|| {

1687

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1688

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1689

1

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

1690

1

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

1691

1

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

1692

1

0,

1693

1

			WeightLimit::Unlimited

1694

1

));

1695

1

});

1696

1

1697

1

	ParaA::execute_with(|| {

1698

1

		// free execution, full amount received

1699

1

		assert_eq!(

1700

1

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

1701

1

			Ok(U256::from(4000003100u64))

1702

1

);

1703

1

});

1704

1

1705

1

	// Register address

1706

1

	ParaA::execute_with(|| {

1707

1

		assert_ok!(XcmTransactor::register(

1708

1

			parachain::RuntimeOrigin::root(),

1709

1

			PARAALICE.into(),

1710

1

0,

1711

1

));

1712

1

});

1713

1

1714

1

	// Send to registered address

1715

1

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

1716

1

	let dest = Location {

1717

1

		parents: 1,

1718

1

		interior: [AccountId32 {

1719

1

			network: None,

1720

1

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

1721

1

}]

1722

1

		.into(),

1723

1

};

1724

1

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

1725

1

1726

1

	ParaA::execute_with(|| {

1727

1

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

1728

1

		// free execution, full amount received

1729

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1730

1

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

1731

1

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

1732

1

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

1733

1

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

1734

1

0,

1735

1

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

1736

1

));

1737

1

});

1738

1

1739

1

	ParaA::execute_with(|| {

1740

1

		// free execution, full amount received

1741

1

		assert_eq!(

1742

1

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

1743

1

			Ok(U256::from(4000003000u64))

1744

1

);

1745

1

});

1746

1

1747

1

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

1748

1

	// again

1749

1

	Relay::execute_with(|| {

1750

1

		// free execution,x	 full amount received

1751

1

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

1752

1

1753

1

});

1754

1

1755

1

	// We send the xcm transact operation to parent

1756

1

	let dest = Location {

1757

1

		parents: 1,

1758

1

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

1759

1

};

1760

1

1761

1

	// Encode the call. Balances transact to para_a_account

1762

1

	// First index

1763

1

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

1764

1

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

1765

1

		relay_chain::Balances,

1766

1

>()

1767

1

	.unwrap() as u8;

1768

1

1769

1

	encoded.push(index);

1770

1

1771

1

	// Then call bytes

1772

1

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

1773

1

		dest: para_a_account(),

1774

1

		value: 100u32.into(),

1775

1

1776

1

	.encode();

1777

1

	encoded.append(&mut call_bytes);

1778

1

1779

1

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

1780

1

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

1781

1

);

1782

1

1783

1

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

1784

1

	ParaA::execute_with(|| {

1785

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1786

1

			parachain::RuntimeOrigin::root(),

1787

1

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

1788

1

			Some(PARAALICE.into()),

1789

1

			CurrencyPayment {

1790

1

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

1791

1

					Location::parent()

1792

1

				))),

1793

1

				fee_amount: None

1794

1

},

1795

1

			utility_bytes,

1796

1

			OriginKind::SovereignAccount,

1797

1

			TransactWeights {

1798

1

				transact_required_weight_at_most: 4000000000.into(),

1799

1

				overall_weight: None

1800

1

},

1801

1

			false

1802

1

));

1803

1

});

1804

1

1805

1

	Relay::execute_with(|| {

1806

1

		// free execution,x	 full amount received

1807

1

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

1808

1809

1

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

1810

1

});

1811

1

1812

1813

#[test]

1814

1

fn transact_through_sovereign_fee_payer_none() {

1815

1

	MockNet::reset();

1816

1

1817

1

	ParaA::execute_with(|| {

1818

1

		// Root can set transact info

1819

1

		assert_ok!(XcmTransactor::set_transact_info(

1820

1

			parachain::RuntimeOrigin::root(),

1821

1

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

1822

1

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

1823

1

			3000.into(),

1824

1

			20000000000.into(),

1825

1

			None

1826

1

));

1827

		// Root can set transact info

1828

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1829

1

			parachain::RuntimeOrigin::root(),

1830

1

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

1831

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1832

1

));

1833

1

});

1834

1

1835

1

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

1836

1

1837

1

	Relay::execute_with(|| {

1838

1

		// Transfer 100 tokens to derivative_address on the relay

1839

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1840

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1841

1

			derivative_address.clone(),

1842

1

			100u128

1843

1

));

1844

1845

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

1846

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1847

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1848

1

			para_a_account(),

1849

1

			4000003000u128

1850

1

));

1851

1

});

1852

1

1853

1

	// Check balances before the transact call

1854

1

	Relay::execute_with(|| {

1855

1

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

1856

1

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

1857

1

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

1858

1

});

1859

1

1860

1

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

1861

1

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

1862

1

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

1863

1

		relay_chain::Balances,

1864

1

>()

1865

1

	.unwrap() as u8;

1866

1

1867

1

	encoded.push(index);

1868

1

1869

1

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

1870

1

		dest: RELAYBOB,

1871

1

		value: 100u32.into(),

1872

1

1873

1

	.encode();

1874

1

	encoded.append(&mut call_bytes);

1875

1

1876

1

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

1877

1

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

1878

1

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

1879

1

);

1880

1

1881

1

	// We send the xcm transact operation to parent

1882

1

	let dest = Location {

1883

1

		parents: 1,

1884

1

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

1885

1

};

1886

1

1887

1

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

1888

1

	ParaA::execute_with(|| {

1889

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1890

1

			parachain::RuntimeOrigin::root(),

1891

1

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

1892

1

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

1893

1

			None,

1894

1

			CurrencyPayment {

1895

1

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

1896

1

					Location::parent()

1897

1

				))),

1898

1

				fee_amount: None

1899

1

},

1900

1

			utility_bytes,

1901

1

			OriginKind::SovereignAccount,

1902

1

			TransactWeights {

1903

1

				transact_required_weight_at_most: 4000000000.into(),

1904

1

				overall_weight: None

1905

1

},

1906

1

			false

1907

1

));

1908

1

});

1909

1

1910

1

	// Check balances after the transact call are correct

1911

1

	Relay::execute_with(|| {

1912

1

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

1913

1

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

1914

1

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

1915

1

});

1916

1

1917

1918

#[test]

1919

1

fn transact_through_sovereign_with_custom_fee_weight() {

1920

1

	MockNet::reset();

1921

1

1922

1

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

1923

1

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

1924

1

1925

1

	let asset_metadata = parachain::AssetMetadata {

1926

1

		name: b"RelayToken".to_vec(),

1927

1

		symbol: b"Relay".to_vec(),

1928

1

		decimals: 12,

1929

1

};

1930

1

1931

1

	ParaA::execute_with(|| {

1932

1

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

1933

1

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

1934

1

			.try_into()

1935

1

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

1936

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1937

1

			source_id,

1938

1

			source_location_latest,

1939

1

			asset_metadata.decimals,

1940

1

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

1941

1

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

1942

1

));

1943

1

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

1944

1

});

1945

1

1946

1

	let dest: Location = AccountKey20 {

1947

1

		network: None,

1948

1

		key: PARAALICE,

1949

1

1950

1

	.into();

1951

1

	Relay::execute_with(|| {

1952

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1953

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1954

1

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

1955

1

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

1956

1

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

1957

1

0,

1958

1

			WeightLimit::Unlimited

1959

1

));

1960

1

});

1961

1

1962

1

	ParaA::execute_with(|| {

1963

1

		// free execution, full amount received

1964

1

		assert_eq!(

1965

1

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

1966

1

			Ok(U256::from(4000003100u64))

1967

1

);

1968

1

});

1969

1

1970

1

	// Register address

1971

1

	ParaA::execute_with(|| {

1972

1

		assert_ok!(XcmTransactor::register(

1973

1

			parachain::RuntimeOrigin::root(),

1974

1

			PARAALICE.into(),

1975

1

0,

1976

1

));

1977

1

});

1978

1

1979

1

	// Send to registered address

1980

1

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

1981

1

	let dest = Location {

1982

1

		parents: 1,

1983

1

		interior: [AccountId32 {

1984

1

			network: None,

1985

1

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

1986

1

}]

1987

1

		.into(),

1988

1

};

1989

1

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

1990

1

1991

1

	ParaA::execute_with(|| {

1992

1

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

1993

1

		// free execution, full amount received

1994

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1995

1

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

1996

1

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

1997

1

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

1998

1

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

1999

1

0,

2000

1

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

2001

1

));

2002

1

});

2003

1

2004

1

	ParaA::execute_with(|| {

2005

1

		// free execution, full amount received

2006

1

		assert_eq!(

2007

1

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

2008

1

			Ok(U256::from(4000003000u64))

2009

1

);

2010

1

});

2011

1

2012

1

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

2013

1

	// again

2014

1

	Relay::execute_with(|| {

2015

1

		// free execution,x	 full amount received

2016

1

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

2017

1

2018

1

});

2019

1

2020

1

	// We send the xcm transact operation to parent

2021

1

	let dest = Location {

2022

1

		parents: 1,

2023

1

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

2024

1

};

2025

1

2026

1

	// Encode the call. Balances transact to para_a_account

2027

1

	// First index

2028

1

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

2029

1

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

2030

1

		relay_chain::Balances,

2031

1

>()

2032

1

	.unwrap() as u8;

2033

1

2034

1

	encoded.push(index);

2035

1

2036

1

	// Then call bytes

2037

1

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

2038

1

		dest: para_a_account(),

2039

1

		value: 100u32.into(),

2040

1

2041

1

	.encode();

2042

1

	encoded.append(&mut call_bytes);

2043

1

2044

1

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

2045

1

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

2046

1

);

2047

1

2048

1

	let total_weight = 4000003000u64;

2049

1

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

2050

1

	ParaA::execute_with(|| {

2051

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2052

1

			parachain::RuntimeOrigin::root(),

2053

1

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

2054

1

			Some(PARAALICE.into()),

2055

1

			CurrencyPayment {

2056

1

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

2057

1

					Location::parent()

2058

1

				))),

2059

1

				// 1-1 fee-weight mapping

2060

1

				fee_amount: Some(total_weight as u128)

2061

1

},

2062

1

			utility_bytes,

2063

1

			OriginKind::SovereignAccount,

2064

1

			TransactWeights {

2065

1

				transact_required_weight_at_most: 4000000000.into(),

2066

1

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

2067

1

},

2068

1

			false

2069

1

));

2070

1

});

2071

1

2072

1

	Relay::execute_with(|| {

2073

1

		// free execution,x	 full amount received

2074

1

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

2075

2076

1

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

2077

1

});

2078

1

2079

2080

#[test]

2081

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2082

1

	MockNet::reset();

2083

1

2084

1

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

2085

1

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

2086

1

2087

1

	let asset_metadata = parachain::AssetMetadata {

2088

1

		name: b"RelayToken".to_vec(),

2089

1

		symbol: b"Relay".to_vec(),

2090

1

		decimals: 12,

2091

1

};

2092

1

2093

1

	ParaA::execute_with(|| {

2094

1

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

2095

1

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

2096

1

			.try_into()

2097

1

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

2098

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2099

1

			source_id,

2100

1

			source_location_latest,

2101

1

			asset_metadata.decimals,

2102

1

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

2103

1

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

2104

1

));

2105

1

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

2106

1

});

2107

1

2108

1

	let dest: Location = AccountKey20 {

2109

1

		network: None,

2110

1

		key: PARAALICE,

2111

1

2112

1

	.into();

2113

1

	Relay::execute_with(|| {

2114

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2115

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2116

1

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

2117

1

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

2118

1

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

2119

1

0,

2120

1

			WeightLimit::Unlimited

2121

1

));

2122

1

});

2123

1

2124

1

	ParaA::execute_with(|| {

2125

1

		// free execution, full amount received

2126

1

		assert_eq!(

2127

1

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

2128

1

			Ok(U256::from(4000009100u64))

2129

1

);

2130

1

});

2131

1

2132

1

	// Register address

2133

1

	ParaA::execute_with(|| {

2134

1

		assert_ok!(XcmTransactor::register(

2135

1

			parachain::RuntimeOrigin::root(),

2136

1

			PARAALICE.into(),

2137

1

0,

2138

1

));

2139

1

});

2140

1

2141

1

	// Send to registered address

2142

1

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

2143

1

	let dest = Location {

2144

1

		parents: 1,

2145

1

		interior: [AccountId32 {

2146

1

			network: None,

2147

1

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

2148

1

}]

2149

1

		.into(),

2150

1

};

2151

1

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

2152

1

2153

1

	ParaA::execute_with(|| {

2154

1

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

2155

1

		// free execution, full amount received

2156

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

2157

1

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

2158

1

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

2159

1

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

2160

1

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

2161

1

0,

2162

1

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

2163

1

));

2164

1

});

2165

1

2166

1

	ParaA::execute_with(|| {

2167

1

		// free execution, full amount received

2168

1

		assert_eq!(

2169

1

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

2170

1

			Ok(U256::from(4000009000u64))

2171

1

);

2172

1

});

2173

1

2174

1

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

2175

1

	// again

2176

1

	Relay::execute_with(|| {

2177

1

		// free execution,x	 full amount received

2178

1

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

2179

1

2180

1

});

2181

1

2182

1

	// We send the xcm transact operation to parent

2183

1

	let dest = Location {

2184

1

		parents: 1,

2185

1

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

2186

1

};

2187

1

2188

1

	// Encode the call. Balances transact to para_a_account

2189

1

	// First index

2190

1

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

2191

1

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

2192

1

		relay_chain::Balances,

2193

1

>()

2194

1

	.unwrap() as u8;

2195

1

2196

1

	encoded.push(index);

2197

1

2198

1

	// Then call bytes

2199

1

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

2200

1

		dest: para_a_account(),

2201

1

		value: 100u32.into(),

2202

1

2203

1

	.encode();

2204

1

	encoded.append(&mut call_bytes);

2205

1

2206

1

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

2207

1

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

2208

1

);

2209

1

2210

1

	let total_weight = 4000009000u64;

2211

1

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

2212

1

	ParaA::execute_with(|| {

2213

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2214

1

			parachain::RuntimeOrigin::root(),

2215

1

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

2216

1

			Some(PARAALICE.into()),

2217

1

			CurrencyPayment {

2218

1

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

2219

1

					Location::parent()

2220

1

				))),

2221

1

				// 1-1 fee-weight mapping

2222

1

				fee_amount: Some(total_weight as u128)

2223

1

},

2224

1

			utility_bytes,

2225

1

			OriginKind::SovereignAccount,

2226

1

			TransactWeights {

2227

1

				transact_required_weight_at_most: 4000000000.into(),

2228

1

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

2229

1

},

2230

1

			true

2231

1

));

2232

1

});

2233

1

2234

1

	Relay::execute_with(|| {

2235

1

		// free execution, full amount received

2236

1

		// 4000009000 refunded + 100 transferred = 4000009100

2237

1

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

2238

2239

1

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

2240

1

});

2241

1

2242

2243

#[test]

2244

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2245

1

	MockNet::reset();

2246

1

2247

1

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

2248

1

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

2249

1

	let asset_metadata = parachain::AssetMetadata {

2250

1

		name: b"RelayToken".to_vec(),

2251

1

		symbol: b"Relay".to_vec(),

2252

1

		decimals: 12,

2253

1

};

2254

1

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

2255

1

	ParaA::execute_with(|| {

2256

1

		parachain::XcmVersioner::set_version(1);

2257

1

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

2258

1

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

2259

1

			.try_into()

2260

1

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

2261

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2262

1

			source_id,

2263

1

			source_location_latest,

2264

1

			asset_metadata.decimals,

2265

1

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

2266

1

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

2267

1

));

2268

1

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

2269

1

});

2270

1

2271

1

	let response = Response::Version(2);

2272

1

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

2273

1

2274

1

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

2275

1

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

2276

1

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

2277

1

		query_id: 0,

2278

1

		response,

2279

1

		max_weight: Weight::zero(),

2280

1

		querier: Some(querier),

2281

1

	}]);

2282

1

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

2283

1

	// it directly here

2284

1

	// Actually send relay asset to parachain

2285

1

	let dest: Location = AccountKey20 {

2286

1

		network: None,

2287

1

		key: PARAALICE,

2288

1

2289

1

	.into();

2290

1

2291

1

	Relay::execute_with(|| {

2292

1

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

2293

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2294

1

			relay_chain::RuntimeOrigin::root(),

2295

1

			Some(3)

2296

1

));

2297

2298

		// Wrap version, which sets VersionedStorage

2299

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

2300

		// this is not necessary in prod

2301

1

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

2302

1

			&Parachain(1).into(),

2303

1

			mock_message

2304

1

));

2305

2306

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

2307

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2308

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2309

1

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

2310

1

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

2311

1

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

2312

1

0,

2313

1

			WeightLimit::Unlimited

2314

1

));

2315

2316

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

2317

1

		relay_chain::relay_roll_to(2);

2318

1

2319

1

		// queries should have been updated

2320

1

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

2321

1

});

2322

1

2323

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2324

1

		pallet_xcm::Event::SupportedVersionChanged {

2325

1

			location: Location {

2326

1

				parents: 0,

2327

1

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

2328

1

},

2329

1

			version: 1,

2330

1

2331

1

		.into();

2332

1

2333

1

	Relay::execute_with(|| {

2334

1

		// Assert that the events vector contains the version change

2335

1

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

2336

1

});

2337

1

2338

1

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

2339

1

	// of the new version change

2340

1

	ParaA::execute_with(|| {

2341

1

		// Set version

2342

1

		parachain::XcmVersioner::set_version(2);

2343

1

		// Do runtime upgrade

2344

1

		parachain::on_runtime_upgrade();

2345

1

		// Initialize block, to call on_initialize and notify targets

2346

1

		parachain::para_roll_to(2);

2347

1

		// Expect the event in the parachain

2348

1

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

2349

2

e,

2350

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

2351

				result: 2,

2352

..

2353

})

2354

1

		)));

2355

1

});

2356

1

2357

1

	// This event should have been seen in the relay

2358

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2359

1

		pallet_xcm::Event::SupportedVersionChanged {

2360

1

			location: Location {

2361

1

				parents: 0,

2362

1

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

2363

1

},

2364

1

			version: 2,

2365

1

2366

1

		.into();

2367

1

2368

1

	Relay::execute_with(|| {

2369

1

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

2370

1

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

2371

1

});

2372

1

2373

2374

#[test]

2375

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2376

1

	MockNet::reset();

2377

1

2378

1

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

2379

1

	let source_location: AssetType = para_a_balances

2380

1

		.try_into()

2381

1

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

2382

1

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

2383

1

2384

1

	let asset_metadata = parachain::AssetMetadata {

2385

1

		name: b"ParaAToken".to_vec(),

2386

1

		symbol: b"ParaA".to_vec(),

2387

1

		decimals: 18,

2388

1

};

2389

1

	let response = Response::Version(2);

2390

1

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

2391

1

		.into();

2392

1

2393

1

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

2394

1

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

2395

1

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

2396

1

		query_id: 0,

2397

1

		response,

2398

1

		max_weight: Weight::zero(),

2399

1

		querier: Some(querier),

2400

1

	}]);

2401

1

2402

1

	ParaA::execute_with(|| {

2403

1

		// advertised version

2404

1

		parachain::XcmVersioner::set_version(2);

2405

1

});

2406

1

2407

1

	ParaB::execute_with(|| {

2408

1

		// Let's try with v0

2409

1

		parachain::XcmVersioner::set_version(0);

2410

1

2411

1

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

2412

1

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

2413

1

			.try_into()

2414

1

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

2415

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2416

1

			source_id,

2417

1

			source_location_latest,

2418

1

			asset_metadata.decimals,

2419

1

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

2420

1

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

2421

1

));

2422

1

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

2423

1

});

2424

1

2425

1

	ParaA::execute_with(|| {

2426

1

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

2427

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2428

1

			parachain::RuntimeOrigin::root(),

2429

1

			Some(3)

2430

1

));

2431

		// Wrap version, which sets VersionedStorage

2432

1

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

2433

1

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

2434

1

			mock_message

2435

1

));

2436

2437

1

		parachain::para_roll_to(2);

2438

1

2439

1

		// queries should have been updated

2440

1

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

2441

1

});

2442

1

2443

1

	let expected_supported_version: parachain::RuntimeEvent =

2444

1

		pallet_xcm::Event::SupportedVersionChanged {

2445

1

			location: Location {

2446

1

				parents: 1,

2447

1

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

2448

1

},

2449

1

			version: 0,

2450

1

2451

1

		.into();

2452

1

2453

1

	ParaA::execute_with(|| {

2454

1

		// Assert that the events vector contains the version change

2455

1

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

2456

1

});

2457

1

2458

1

	// Let's ensure talking in v0 works

2459

1

	let dest = Location {

2460

1

		parents: 1,

2461

1

		interior: [

2462

1

			Parachain(2),

2463

1

			AccountKey20 {

2464

1

				network: None,

2465

1

				key: PARAALICE.into(),

2466

1

},

2467

1

2468

1

		.into(),

2469

1

};

2470

1

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

2471

1

	ParaA::execute_with(|| {

2472

1

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

2473

1

		// free execution, full amount received

2474

1

		assert_ok!(PolkadotXcm::transfer_assets(

2475

1

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

2476

1

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

2477

1

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

2478

1

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

2479

1

0,

2480

1

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

2481

1

));

2482

		// free execution, full amount received

2483

1

		assert_eq!(

2484

1

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

2485

1

			INITIAL_BALANCE - 100

2486

1

);

2487

1

});

2488

1

2489

1

	ParaB::execute_with(|| {

2490

1

		// free execution, full amount received

2491

1

		assert_eq!(

2492

1

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

2493

1

			Ok(U256::from(100))

2494

1

);

2495

1

});

2496

1

2497

1

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

2498

1

	// of the new version change

2499

1

	ParaB::execute_with(|| {

2500

1

		// Set version

2501

1

		parachain::XcmVersioner::set_version(2);

2502

1

		// Do runtime upgrade

2503

1

		parachain::on_runtime_upgrade();

2504

1

		// Initialize block, to call on_initialize and notify targets

2505

1

		parachain::para_roll_to(2);

2506

1

		// Expect the event in the parachain

2507

1

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

2508

2

e,

2509

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

2510

				result: 2,

2511

..

2512

})

2513

1

		)));

2514

1

});

2515

1

2516

1

	// This event should have been seen in para A

2517

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2518

1

		pallet_xcm::Event::SupportedVersionChanged {

2519

1

			location: Location {

2520

1

				parents: 1,

2521

1

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

2522

1

},

2523

1

			version: 2,

2524

1

2525

1

		.into();

2526

1

2527

1

	// Para A should have received the version change

2528

1

	ParaA::execute_with(|| {

2529

1

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

2530

1

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

2531

1

});

2532

1

2533

2534

#[test]

2535

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2536

1

	MockNet::reset();

2537

1

2538

1

	let fresh_account = PARABOB;

2539

1

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

2540

1

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

2541

1

	let asset_metadata = parachain::AssetMetadata {

2542

1

		name: b"RelayToken".to_vec(),

2543

1

		symbol: b"Relay".to_vec(),

2544

1

		decimals: 12,

2545

1

};

2546

1

	// register relay asset in parachain A

2547

1

	ParaA::execute_with(|| {

2548

1

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

2549

1

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

2550

1

			.try_into()

2551

1

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

2552

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2553

1

			source_id,

2554

1

			source_location_latest,

2555

1

			asset_metadata.decimals,

2556

1

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

2557

1

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

2558

1

));

2559

1

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

2560

1

});

2561

1

2562

1

	// Actually send relay asset to parachain

2563

1

	let dest: Location = AccountKey20 {

2564

1

		network: None,

2565

1

		key: fresh_account,

2566

1

2567

1

	.into();

2568

1

	Relay::execute_with(|| {

2569

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2570

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2571

1

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

2572

1

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

2573

1

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

2574

1

0,

2575

1

			WeightLimit::Unlimited

2576

1

));

2577

1

});

2578

1

2579

1

	// parachain should have received assets

2580

1

	ParaA::execute_with(|| {

2581

1

		// free execution, full amount received

2582

1

		assert_eq!(

2583

1

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

2584

1

			Ok(U256::from(123))

2585

1

);

2586

1

});

2587

1

2588

2589

#[test]

2590

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2591

1

	MockNet::reset();

2592

1

2593

1

	let fresh_account = [2u8; 20];

2594

1

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

2595

1

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

2596

1

	let asset_metadata = parachain::AssetMetadata {

2597

1

		name: b"RelayToken".to_vec(),

2598

1

		symbol: b"Relay".to_vec(),

2599

1

		decimals: 12,

2600

1

};

2601

1

	// register relay asset in parachain A

2602

1

	ParaA::execute_with(|| {

2603

1

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

2604

1

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

2605

1

			.try_into()

2606

1

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

2607

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2608

1

			source_id,

2609

1

			source_location_latest,

2610

1

			asset_metadata.decimals,

2611

1

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

2612

1

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

2613

1

));

2614

1

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

2615

1

});

2616

1

2617

1

	// Actually send relay asset to parachain

2618

1

	let dest: Location = AccountKey20 {

2619

1

		network: None,

2620

1

		key: fresh_account,

2621

1

2622

1

	.into();

2623

1

	Relay::execute_with(|| {

2624

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2625

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2626

1

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

2627

1

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

2628

1

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

2629

1

0,

2630

1

			WeightLimit::Unlimited

2631

1

));

2632

1

});

2633

1

2634

1

	// parachain should have received assets

2635

1

	ParaA::execute_with(|| {

2636

1

		// free execution, full amount received

2637

1

		assert_eq!(

2638

1

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

2639

1

			Ok(U256::from(123))

2640

1

);

2641

1

});

2642

1

2643

2644

#[test]

2645

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2646

1

	MockNet::reset();

2647

1

2648

1

	let mut sufficient_account = [0u8; 20];

2649

1

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

2650

1

2651

1

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

2652

1

2653

1

	// Evm account is self sufficient

2654

1

	ParaA::execute_with(|| {

2655

1

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

2656

1

});

2657

1

2658

1

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

2659

1

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

2660

1

	let asset_metadata = parachain::AssetMetadata {

2661

1

		name: b"RelayToken".to_vec(),

2662

1

		symbol: b"Relay".to_vec(),

2663

1

		decimals: 12,

2664

1

};

2665

1

	// register relay asset in parachain A

2666

1

	ParaA::execute_with(|| {

2667

1

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

2668

1

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

2669

1

			.try_into()

2670

1

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

2671

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2672

1

			source_id,

2673

1

			source_location_latest,

2674

1

			asset_metadata.decimals,

2675

1

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

2676

1

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

2677

1

));

2678

1

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

2679

1

});

2680

1

2681

1

	// Actually send relay asset to parachain

2682

1

	let dest: Location = AccountKey20 {

2683

1

		network: None,

2684

1

		key: sufficient_account,

2685

1

2686

1

	.into();

2687

1

	Relay::execute_with(|| {

2688

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2689

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2690

1

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

2691

1

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

2692

1

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

2693

1

0,

2694

1

			WeightLimit::Unlimited

2695

1

));

2696

1

});

2697

1

2698

1

	// Evm account sufficient ref count increased by 1.

2699

1

	ParaA::execute_with(|| {

2700

1

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

2701

1

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

2702

1

		// will be implemented in a future release

2703

1

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

2704

1

});

2705

1

2706

1

	ParaA::execute_with(|| {

2707

1

		// Remove the account from the evm context.

2708

1

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

2709

1

		// Evm account sufficient ref count decreased by 1.

2710

1

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

2711

1

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

2712

1

		// will be implemented in a future release

2713

1

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

2714

1

});

2715

1

2716

2717

#[test]

2718

1

fn empty_account_should_not_be_reset() {

2719

1

	MockNet::reset();

2720

1

2721

1

	// Test account has nonce 1 on genesis.

2722

1

	let sufficient_account = PARABOB;

2723

1

2724

1

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

2725

1

2726

1

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

2727

1

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

2728

1

	let asset_metadata = parachain::AssetMetadata {

2729

1

		name: b"RelayToken".to_vec(),

2730

1

		symbol: b"Relay".to_vec(),

2731

1

		decimals: 12,

2732

1

};

2733

1

	// register relay asset in parachain A

2734

1

	ParaA::execute_with(|| {

2735

1

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

2736

1

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

2737

1

			.try_into()

2738

1

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

2739

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2740

1

			source_id,

2741

1

			source_location_latest,

2742

1

			asset_metadata.decimals,

2743

1

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

2744

1

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

2745

1

));

2746

1

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

2747

1

});

2748

1

2749

1

	// Send native token to evm_account

2750

1

	ParaA::execute_with(|| {

2751

1

		assert_ok!(ParaBalances::transfer_allow_death(

2752

1

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

2753

1

			evm_account_id,

2754

1

2755

1

));

2756

1

});

2757

1

2758

1

	// Actually send relay asset to parachain

2759

1

	let dest: Location = AccountKey20 {

2760

1

		network: None,

2761

1

		key: sufficient_account,

2762

1

2763

1

	.into();

2764

1

	Relay::execute_with(|| {

2765

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2766

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2767

1

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

2768

1

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

2769

1

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

2770

1

0,

2771

1

			WeightLimit::Unlimited

2772

1

));

2773

1

});

2774

1

2775

1

	ParaA::execute_with(|| {

2776

1

		// Empty the assets from the account.

2777

1

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

2778

1

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

2779

1

		// Transfer the assets from evm_account to PARAALICE

2780

1

		assert_ok!(EvmForeignAssets::transfer(

2781

1

			source_id,

2782

1

			evm_account_id,

2783

1

			PARAALICE.into(),

2784

1

			U256::from(123)

2785

1

));

2786

		// Verify account asset balance is Zero.

2787

1

		assert_eq!(

2788

1

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

2789

1

			Ok(U256::from(0))

2790

1

);

2791

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

2792

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

2793

1

		assert_ok!(ParaBalances::force_set_balance(

2794

1

			parachain::RuntimeOrigin::root(),

2795

1

			evm_account_id,

2796

1

0,

2797

1

));

2798

		// Verify account native balance is Zero.

2799

1

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

2800

		// Remove the account from the evm context.

2801

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

2802

1

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

2803

1

		// Verify reference count.

2804

1

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

2805

1

		assert_eq!(account.sufficients, 0);

2806

1

		assert_eq!(account.consumers, 0);

2807

1

		assert_eq!(account.providers, 1);

2808

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

2809

1

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

2810

1

});

2811

1

2812

2813

#[test]

2814

1

fn test_statemine_like() {

2815

1

	MockNet::reset();

2816

1

2817

1

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

2818

1

2819

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2820

1

		polkadot_parachain::primitives::Sibling,

2821

1

		statemine_like::AccountId,

2822

1

	>::convert_location(&dest_para)

2823

1

	.unwrap();

2824

1

2825

1

	let statemine_asset_a_balances = Location::new(

2826

1

1,

2827

1

2828

1

			Parachain(1000),

2829

1

			PalletInstance(5),

2830

1

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

2831

1

],

2832

1

);

2833

1

	let source_location: AssetType = statemine_asset_a_balances

2834

1

		.try_into()

2835

1

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

2836

1

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

2837

1

2838

1

	let asset_metadata = parachain::AssetMetadata {

2839

1

		name: b"StatemineToken".to_vec(),

2840

1

		symbol: b"StatemineToken".to_vec(),

2841

1

		decimals: 12,

2842

1

};

2843

1

2844

1

	ParaA::execute_with(|| {

2845

1

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

2846

1

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

2847

1

			.try_into()

2848

1

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

2849

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2850

1

			source_id,

2851

1

			source_location_latest,

2852

1

			asset_metadata.decimals,

2853

1

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

2854

1

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

2855

1

));

2856

1

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

2857

1

});

2858

1

2859

1

	Statemine::execute_with(|| {

2860

1

		// Set new prefix

2861

1

		statemine_like::PrefixChanger::set_prefix(

2862

1

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

2863

1

);

2864

1

		assert_ok!(StatemineAssets::create(

2865

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2866

1

0,

2867

1

			RELAYALICE,

2868

1

2869

1

));

2870

2871

1

		assert_ok!(StatemineAssets::mint(

2872

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2873

1

0,

2874

1

			RELAYALICE,

2875

1

			300000000000000

2876

1

));

2877

2878

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

2879

1

		assert_ok!(StatemineBalances::transfer_allow_death(

2880

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2881

1

			sov,

2882

1

			100000000000000

2883

1

));

2884

2885

		// Actually send relay asset to parachain

2886

1

		let dest: Location = AccountKey20 {

2887

1

			network: None,

2888

1

			key: PARAALICE,

2889

1

2890

1

		.into();

2891

1

2892

1

		// Send with new prefix

2893

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

2894

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

2895

1

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

2896

1

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

2897

1

			Box::new(

2898

1

2899

1

2900

1

						xcm::latest::prelude::PalletInstance(

2901

1

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

2902

1

),

2903

1

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

2904

1

],

2905

1

2906

1

2907

1

					.into()

2908

1

),

2909

1

0,

2910

1

			WeightLimit::Unlimited

2911

1

));

2912

1

});

2913

1

2914

1

	ParaA::execute_with(|| {

2915

1

		assert_eq!(

2916

1

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

2917

1

			Ok(U256::from(123))

2918

1

);

2919

1

});

2920

1

2921

2922

#[test]

2923

1

fn send_statemine_asset_from_para_a_to_statemine_with_relay_fee() {

2924

1

	MockNet::reset();

2925

1

2926

1

	// Relay asset

2927

1

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

2928

1

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

2929

1

2930

1

	let relay_asset_metadata = parachain::AssetMetadata {

2931

1

		name: b"RelayToken".to_vec(),

2932

1

		symbol: b"Relay".to_vec(),

2933

1

		decimals: 12,

2934

1

};

2935

1

2936

1

	// Statemine asset

2937

1

	let statemine_asset = Location::new(

2938

1

1,

2939

1

2940

1

			Parachain(1000u32),

2941

1

			PalletInstance(5u8),

2942

1

			GeneralIndex(10u128),

2943

1

],

2944

1

);

2945

1

	let statemine_location_asset: AssetType = statemine_asset

2946

1

		.clone()

2947

1

		.try_into()

2948

1

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

2949

1

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

2950

1

2951

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

2952

1

		name: b"USDC".to_vec(),

2953

1

		symbol: b"USDC".to_vec(),

2954

1

		decimals: 12,

2955

1

};

2956

1

2957

1

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

2958

1

2959

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2960

1

		polkadot_parachain::primitives::Sibling,

2961

1

		statemine_like::AccountId,

2962

1

	>::convert_location(&dest_para)

2963

1

	.unwrap();

2964

1

2965

1

	ParaA::execute_with(|| {

2966

1

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

2967

1

		let relay_location_latest: Location = xcm::VersionedLocation::V3(relay_location_v3)

2968

1

			.try_into()

2969

1

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

2970

1

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

2971

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2972

1

			relay_id,

2973

1

			relay_location_latest,

2974

1

			relay_asset_metadata.decimals,

2975

1

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

2976

1

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

2977

1

));

2978

1

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

2979

2980

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

2981

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

2982

1

			.try_into()

2983

1

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

2984

1

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

2985

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2986

1

			statemine_id,

2987

1

			statemine_location_latest,

2988

1

			asset_metadata_statemine_asset.decimals,

2989

1

			asset_metadata_statemine_asset

2990

1

				.symbol

2991

1

				.try_into()

2992

1

				.expect("too long"),

2993

1

			asset_metadata_statemine_asset

2994

1

				.name

2995

1

				.try_into()

2996

1

				.expect("too long"),

2997

1

));

2998

1

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

2999

1

});

3000

1

3001

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3002

1

		network: None,

3003

1

		key: PARAALICE,

3004

1

3005

1

	.into();

3006

1

3007

1

	// Send relay chain asset to Alice in Parachain A

3008

1

	Relay::execute_with(|| {

3009

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

3010

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3011

1

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

3012

1

			Box::new(

3013

1

				VersionedLocation::from(parachain_beneficiary_from_relay)

3014

1

					.clone()

3015

1

					.into()

3016

1

),

3017

1

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

3018

1

0,

3019

1

			WeightLimit::Unlimited

3020

1

));

3021

1

});

3022

1

3023

1

	Statemine::execute_with(|| {

3024

1

		// Set new prefix

3025

1

		statemine_like::PrefixChanger::set_prefix(

3026

1

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

3027

1

);

3028

1

3029

1

		assert_ok!(StatemineAssets::create(

3030

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3031

1

10,

3032

1

			RELAYALICE,

3033

1

3034

1

));

3035

3036

1

		assert_ok!(StatemineAssets::mint(

3037

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3038

1

10,

3039

1

			RELAYALICE,

3040

1

			300000000000000

3041

1

));

3042

3043

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

3044

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

3045

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3046

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3047

1

			sov,

3048

1

			100000000000000

3049

1

));

3050

3051

		// Send statemine USDC asset to Alice in Parachain A

3052

1

		let parachain_beneficiary_from_statemine: Location = AccountKey20 {

3053

1

			network: None,

3054

1

			key: PARAALICE,

3055

1

3056

1

		.into();

3057

1

3058

1

		// Send with new prefix

3059

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3060

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3061

1

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

3062

1

			Box::new(

3063

1

				VersionedLocation::from(parachain_beneficiary_from_statemine)

3064

1

					.clone()

3065

1

					.into()

3066

1

),

3067

1

			Box::new(

3068

1

3069

1

3070

1

						xcm::latest::prelude::PalletInstance(

3071

1

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

3072

1

),

3073

1

						GeneralIndex(10),

3074

1

],

3075

1

3076

1

3077

1

					.into()

3078

1

),

3079

1

0,

3080

1

			WeightLimit::Unlimited

3081

1

));

3082

1

});

3083

1

3084

1

	let statemine_beneficiary = Location {

3085

1

		parents: 1,

3086

1

		interior: [

3087

1

			Parachain(1000),

3088

1

			AccountId32 {

3089

1

				network: None,

3090

1

				id: RELAYBOB.into(),

3091

1

},

3092

1

3093

1

		.into(),

3094

1

};

3095

1

3096

1

	ParaA::execute_with(|| {

3097

1

		// Alice has received 125 USDC

3098

1

		assert_eq!(

3099

1

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

3100

1

			Ok(U256::from(125))

3101

1

);

3102

3103

		// Alice has received 200 Relay assets

3104

1

		assert_eq!(

3105

1

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

3106

1

			Ok(U256::from(200))

3107

1

);

3108

1

});

3109

1

3110

1

	Statemine::execute_with(|| {

3111

1

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

3112

1

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

3113

1

});

3114

1

	let (chain_part, beneficiary) =

3115

1

		split_location_into_chain_part_and_beneficiary(statemine_beneficiary).unwrap();

3116

1

3117

1

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

3118

1

	ParaA::execute_with(|| {

3119

1

		let asset_1 = currency_to_asset(

3120

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3121

1

			100,

3122

1

);

3123

1

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

3124

1

		let assets_to_send = vec![asset_1, asset_2];

3125

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3126

1

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

3127

1

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

3128

1

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

3129

1

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

3130

1

1,

3131

1

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

3132

1

));

3133

1

});

3134

1

3135

1

	ParaA::execute_with(|| {

3136

1

		// Alice has 100 USDC less

3137

1

		assert_eq!(

3138

1

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

3139

1

			Ok(U256::from(25))

3140

1

);

3141

3142

		// Alice has 100 relay asset less

3143

1

		assert_eq!(

3144

1

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

3145

1

			Ok(U256::from(100))

3146

1

);

3147

1

});

3148

1

3149

1

	Statemine::execute_with(|| {

3150

1

		// Check that BOB received 100 USDC on statemine

3151

1

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

3152

1

});

3153

1

3154

3155

#[test]

3156

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer() {

3157

1

	MockNet::reset();

3158

1

3159

1

	// Relay asset

3160

1

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

3161

1

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

3162

1

3163

1

	let relay_asset_metadata = parachain::AssetMetadata {

3164

1

		name: b"RelayToken".to_vec(),

3165

1

		symbol: b"Relay".to_vec(),

3166

1

		decimals: 12,

3167

1

};

3168

1

3169

1

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

3170

1

3171

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3172

1

		polkadot_parachain::primitives::Sibling,

3173

1

		statemine_like::AccountId,

3174

1

	>::convert_location(&dest_para)

3175

1

	.unwrap();

3176

1

3177

1

	ParaA::execute_with(|| {

3178

1

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

3179

1

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

3180

1

			.try_into()

3181

1

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

3182

1

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

3183

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3184

1

			source_id,

3185

1

			source_location_latest,

3186

1

			relay_asset_metadata.decimals,

3187

1

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

3188

1

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

3189

1

));

3190

1

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

3191

1

});

3192

1

3193

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3194

1

		network: None,

3195

1

		key: PARAALICE,

3196

1

3197

1

	.into();

3198

1

3199

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3200

1

		network: None,

3201

1

		id: RELAYALICE.into(),

3202

1

3203

1

	.into();

3204

1

3205

1

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

3206

1

	Relay::execute_with(|| {

3207

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3208

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3209

1

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

3210

1

			Box::new(

3211

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3212

1

					.clone()

3213

1

					.into()

3214

1

),

3215

1

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

3216

1

0,

3217

1

			WeightLimit::Unlimited

3218

1

));

3219

1

});

3220

1

3221

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3222

1

	Statemine::execute_with(|| {

3223

1

		// Check Alice received 200 tokens on AssetHub

3224

1

		assert_eq!(

3225

1

			StatemineBalances::free_balance(RELAYALICE),

3226

1

			INITIAL_BALANCE + 200

3227

1

);

3228

3229

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3230

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3231

1

			sov,

3232

1

			110000000000000

3233

1

));

3234

3235

		// Now send those tokens to ParaA

3236

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3237

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3238

1

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

3239

1

			Box::new(

3240

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3241

1

					.clone()

3242

1

					.into()

3243

1

),

3244

1

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

3245

1

0,

3246

1

			WeightLimit::Unlimited

3247

1

));

3248

1

});

3249

1

3250

1

	ParaA::execute_with(|| {

3251

1

		// Alice should have received the DOTs

3252

1

		assert_eq!(

3253

1

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

3254

1

			Ok(U256::from(200))

3255

1

);

3256

1

});

3257

1

3258

1

	let dest = Location::new(

3259

1

1,

3260

1

3261

1

			Parachain(1000),

3262

1

			AccountId32 {

3263

1

				network: None,

3264

1

				id: RELAYBOB.into(),

3265

1

},

3266

1

],

3267

1

);

3268

1

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

3269

1

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

3270

1

	ParaA::execute_with(|| {

3271

1

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

3272

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3273

1

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

3274

1

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

3275

1

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

3276

1

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

3277

1

0,

3278

1

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

3279

1

));

3280

3281

1

		assert_eq!(

3282

1

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

3283

1

			Ok(U256::from(100))

3284

1

);

3285

1

});

3286

1

3287

1

	Statemine::execute_with(|| {

3288

1

		// Check that Bob received the tokens back in AssetHub

3289

1

		assert_eq!(

3290

1

			StatemineBalances::free_balance(RELAYBOB),

3291

1

			INITIAL_BALANCE + 100

3292

1

);

3293

1

});

3294

1

3295

1

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

3296

1

	Statemine::execute_with(|| {

3297

1

		// Now send those tokens to ParaA

3298

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3299

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3300

1

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

3301

1

			Box::new(

3302

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3303

1

					.clone()

3304

1

					.into()

3305

1

),

3306

1

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

3307

1

0,

3308

1

			WeightLimit::Unlimited

3309

1

));

3310

3311

		// 100 DOTs were deducted from Bob's account

3312

1

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

3313

1

});

3314

1

3315

1

	ParaA::execute_with(|| {

3316

1

		// Alice should have received 100 DOTs

3317

1

		assert_eq!(

3318

1

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

3319

1

			Ok(U256::from(200))

3320

1

);

3321

1

});

3322

1

3323

3324

#[test]

3325

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_with_fee() {

3326

1

	MockNet::reset();

3327

1

3328

1

	// Relay asset

3329

1

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

3330

1

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

3331

1

3332

1

	let relay_asset_metadata = parachain::AssetMetadata {

3333

1

		name: b"RelayToken".to_vec(),

3334

1

		symbol: b"Relay".to_vec(),

3335

1

		decimals: 12,

3336

1

};

3337

1

3338

1

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

3339

1

3340

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3341

1

		polkadot_parachain::primitives::Sibling,

3342

1

		statemine_like::AccountId,

3343

1

	>::convert_location(&dest_para)

3344

1

	.unwrap();

3345

1

3346

1

	ParaA::execute_with(|| {

3347

1

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

3348

1

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

3349

1

			.try_into()

3350

1

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

3351

1

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

3352

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3353

1

			source_id,

3354

1

			source_location_latest,

3355

1

			relay_asset_metadata.decimals,

3356

1

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

3357

1

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

3358

1

));

3359

1

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

3360

1

});

3361

1

3362

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3363

1

		network: None,

3364

1

		key: PARAALICE,

3365

1

3366

1

	.into();

3367

1

3368

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3369

1

		network: None,

3370

1

		id: RELAYALICE.into(),

3371

1

3372

1

	.into();

3373

1

3374

1

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

3375

1

	Relay::execute_with(|| {

3376

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3377

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3378

1

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

3379

1

			Box::new(

3380

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3381

1

					.clone()

3382

1

					.into()

3383

1

),

3384

1

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

3385

1

0,

3386

1

			WeightLimit::Unlimited

3387

1

));

3388

1

});

3389

1

3390

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3391

1

	Statemine::execute_with(|| {

3392

1

		// Check Alice received 200 tokens on AssetHub

3393

1

		assert_eq!(

3394

1

			StatemineBalances::free_balance(RELAYALICE),

3395

1

			INITIAL_BALANCE + 200

3396

1

);

3397

3398

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3399

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3400

1

			sov,

3401

1

			110000000000000

3402

1

));

3403

3404

		// Now send those tokens to ParaA

3405

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3406

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3407

1

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

3408

1

			Box::new(

3409

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3410

1

					.clone()

3411

1

					.into()

3412

1

),

3413

1

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

3414

1

0,

3415

1

			WeightLimit::Unlimited

3416

1

));

3417

1

});

3418

1

3419

1

	ParaA::execute_with(|| {

3420

1

		// Alice should have received the DOTs

3421

1

		assert_eq!(

3422

1

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

3423

1

			Ok(U256::from(200))

3424

1

);

3425

1

});

3426

1

3427

1

	let dest = Location::new(

3428

1

1,

3429

1

3430

1

			Parachain(1000),

3431

1

			AccountId32 {

3432

1

				network: None,

3433

1

				id: RELAYBOB.into(),

3434

1

},

3435

1

],

3436

1

);

3437

1

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

3438

1

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

3439

1

	ParaA::execute_with(|| {

3440

1

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

3441

1

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

3442

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3443

1

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

3444

1

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

3445

1

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

3446

1

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

3447

1

0,

3448

1

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

3449

1

));

3450

3451

1

		assert_eq!(

3452

1

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

3453

1

			Ok(U256::from(90))

3454

1

);

3455

1

});

3456

1

3457

1

	Statemine::execute_with(|| {

3458

1

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

3459

1

		assert_eq!(

3460

1

			StatemineBalances::free_balance(RELAYBOB),

3461

1

			INITIAL_BALANCE + 110

3462

1

);

3463

1

});

3464

1

3465

1

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

3466

1

	Statemine::execute_with(|| {

3467

1

		// Now send those tokens to ParaA

3468

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3469

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3470

1

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

3471

1

			Box::new(

3472

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3473

1

					.clone()

3474

1

					.into()

3475

1

),

3476

1

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

3477

1

0,

3478

1

			WeightLimit::Unlimited

3479

1

));

3480

3481

		// 100 DOTs were deducted from Bob's account

3482

1

		assert_eq!(

3483

1

			StatemineBalances::free_balance(RELAYBOB),

3484

1

			INITIAL_BALANCE + 10

3485

1

);

3486

1

});

3487

1

3488

1

	ParaA::execute_with(|| {

3489

1

		// Alice should have received 100 DOTs

3490

1

		assert_eq!(

3491

1

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

3492

1

			Ok(U256::from(190))

3493

1

);

3494

1

});

3495

1

3496

3497

#[test]

3498

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiasset() {

3499

1

	MockNet::reset();

3500

1

3501

1

	// Relay asset

3502

1

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

3503

1

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

3504

1

3505

1

	let relay_asset_metadata = parachain::AssetMetadata {

3506

1

		name: b"RelayToken".to_vec(),

3507

1

		symbol: b"Relay".to_vec(),

3508

1

		decimals: 12,

3509

1

};

3510

1

3511

1

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

3512

1

3513

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3514

1

		polkadot_parachain::primitives::Sibling,

3515

1

		statemine_like::AccountId,

3516

1

	>::convert_location(&dest_para)

3517

1

	.unwrap();

3518

1

3519

1

	ParaA::execute_with(|| {

3520

1

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

3521

1

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

3522

1

			.try_into()

3523

1

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

3524

1

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

3525

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3526

1

			source_id,

3527

1

			source_location_latest,

3528

1

			relay_asset_metadata.decimals,

3529

1

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

3530

1

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

3531

1

));

3532

1

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

3533

1

});

3534

1

3535

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3536

1

		network: None,

3537

1

		key: PARAALICE,

3538

1

3539

1

	.into();

3540

1

3541

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3542

1

		network: None,

3543

1

		id: RELAYALICE.into(),

3544

1

3545

1

	.into();

3546

1

3547

1

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

3548

1

	Relay::execute_with(|| {

3549

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3550

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3551

1

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

3552

1

			Box::new(

3553

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3554

1

					.clone()

3555

1

					.into()

3556

1

),

3557

1

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

3558

1

0,

3559

1

			WeightLimit::Unlimited

3560

1

));

3561

1

});

3562

1

3563

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3564

1

	Statemine::execute_with(|| {

3565

1

		// Check Alice received 200 tokens on AssetHub

3566

1

		assert_eq!(

3567

1

			StatemineBalances::free_balance(RELAYALICE),

3568

1

			INITIAL_BALANCE + 200

3569

1

);

3570

3571

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3572

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3573

1

			sov,

3574

1

			110000000000000

3575

1

));

3576

3577

		// Now send those tokens to ParaA

3578

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3579

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3580

1

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

3581

1

			Box::new(

3582

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3583

1

					.clone()

3584

1

					.into()

3585

1

),

3586

1

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

3587

1

0,

3588

1

			WeightLimit::Unlimited

3589

1

));

3590

1

});

3591

1

3592

1

	ParaA::execute_with(|| {

3593

1

		// Alice should have received the DOTs

3594

1

		assert_eq!(

3595

1

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

3596

1

			Ok(U256::from(200))

3597

1

);

3598

1

});

3599

1

3600

1

	let dest = Location::new(

3601

1

1,

3602

1

3603

1

			Parachain(1000),

3604

1

			AccountId32 {

3605

1

				network: None,

3606

1

				id: RELAYBOB.into(),

3607

1

},

3608

1

],

3609

1

);

3610

1

3611

1

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

3612

1

3613

1

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

3614

1

	ParaA::execute_with(|| {

3615

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3616

1

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

3617

1

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

3618

1

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

3619

1

			Box::new(VersionedAssets::from(

3620

1

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

3621

1

)),

3622

1

0,

3623

1

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

3624

1

));

3625

3626

1

		assert_eq!(

3627

1

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

3628

1

			Ok(U256::from(100))

3629

1

);

3630

1

});

3631

1

3632

1

	Statemine::execute_with(|| {

3633

1

		// Check that Bob received the tokens back in AssetHub

3634

1

		assert_eq!(

3635

1

			StatemineBalances::free_balance(RELAYBOB),

3636

1

			INITIAL_BALANCE + 100

3637

1

);

3638

1

});

3639

1

3640

1

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

3641

1

	Statemine::execute_with(|| {

3642

1

		// Now send those tokens to ParaA

3643

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3644

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3645

1

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

3646

1

			Box::new(

3647

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3648

1

					.clone()

3649

1

					.into()

3650

1

),

3651

1

			Box::new((Location::parent(), 100).into()),

3652

1

0,

3653

1

			WeightLimit::Unlimited

3654

1

));

3655

3656

		// 100 DOTs were deducted from Bob's account

3657

1

		assert_eq!(StatemineBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3658

1

});

3659

1

3660

1

	ParaA::execute_with(|| {

3661

1

		// Alice should have received 100 DOTs

3662

1

		assert_eq!(

3663

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3664

1

			Ok(U256::from(200))

3665

1

);

3666

1

});

3667

1

3668

3669

#[test]

3670

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multicurrencies() {

3671

1

	MockNet::reset();

3672

1

3673

1

	// Relay asset

3674

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3675

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3676

1

3677

1

	let relay_asset_metadata = parachain::AssetMetadata {

3678

1

		name: b"RelayToken".to_vec(),

3679

1

		symbol: b"Relay".to_vec(),

3680

1

		decimals: 12,

3681

1

};

3682

1

3683

1

	// Statemine asset

3684

1

	let statemine_asset = Location::new(

3685

1

1,

3686

1

3687

1

			Parachain(1000u32),

3688

1

			PalletInstance(5u8),

3689

1

			GeneralIndex(10u128),

3690

1

],

3691

1

);

3692

1

	let statemine_location_asset: AssetType = statemine_asset

3693

1

		.clone()

3694

1

		.try_into()

3695

1

		.expect("Location convertion to AssetType should succeed");

3696

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

3697

1

3698

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3699

1

		name: b"USDC".to_vec(),

3700

1

		symbol: b"USDC".to_vec(),

3701

1

		decimals: 12,

3702

1

};

3703

1

3704

1

	let dest_para = Location::new(1, [Parachain(1)]);

3705

1

3706

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3707

1

		polkadot_parachain::primitives::Sibling,

3708

1

		statemine_like::AccountId,

3709

1

	>::convert_location(&dest_para)

3710

1

	.unwrap();

3711

1

3712

1

	ParaA::execute_with(|| {

3713

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3714

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3715

1

			.try_into()

3716

1

			.expect("v3 to latest location conversion failed");

3717

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3718

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3719

1

			source_id,

3720

1

			source_location_latest,

3721

1

			relay_asset_metadata.decimals,

3722

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3723

1

			relay_asset_metadata.name.try_into().expect("too long"),

3724

1

));

3725

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3726

1

3727

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

3728

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

3729

1

			.try_into()

3730

1

			.expect("v3 to latest location conversion failed");

3731

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

3732

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3733

1

			statemine_id,

3734

1

			statemine_location_latest,

3735

1

			asset_metadata_statemine_asset.decimals,

3736

1

			asset_metadata_statemine_asset

3737

1

				.symbol

3738

1

				.try_into()

3739

1

				.expect("too long"),

3740

1

			asset_metadata_statemine_asset

3741

1

				.name

3742

1

				.try_into()

3743

1

				.expect("too long"),

3744

1

));

3745

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

3746

1

});

3747

1

3748

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3749

1

		network: None,

3750

1

		key: PARAALICE,

3751

1

3752

1

	.into();

3753

1

3754

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3755

1

		network: None,

3756

1

		id: RELAYALICE.into(),

3757

1

3758

1

	.into();

3759

1

3760

1

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3761

1

	Relay::execute_with(|| {

3762

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3763

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3764

1

			Box::new(Parachain(1000).into()),

3765

1

			Box::new(

3766

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3767

1

					.clone()

3768

1

					.into()

3769

1

),

3770

1

			Box::new(([], 200).into()),

3771

1

0,

3772

1

			WeightLimit::Unlimited

3773

1

));

3774

1

});

3775

1

3776

1

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3777

1

	Statemine::execute_with(|| {

3778

1

		// Check Alice received 200 tokens on AssetHub

3779

1

		assert_eq!(

3780

1

			StatemineBalances::free_balance(RELAYALICE),

3781

1

			INITIAL_BALANCE + 200

3782

1

);

3783

3784

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3785

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3786

1

			sov,

3787

1

			110000000000000

3788

1

));

3789

3790

1

		statemine_like::PrefixChanger::set_prefix(

3791

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

3792

1

);

3793

1

3794

1

		assert_ok!(StatemineAssets::create(

3795

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3796

1

10,

3797

1

			RELAYALICE,

3798

1

3799

1

));

3800

3801

1

		assert_ok!(StatemineAssets::mint(

3802

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3803

1

10,

3804

1

			RELAYALICE,

3805

1

			300000000000000

3806

1

));

3807

3808

		// Now send relay tokens to ParaA

3809

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3810

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3811

1

			Box::new(Location::new(1, [Parachain(1)]).into()),

3812

1

			Box::new(

3813

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3814

1

					.clone()

3815

1

					.into()

3816

1

),

3817

1

			Box::new((Location::parent(), 200).into()),

3818

1

0,

3819

1

			WeightLimit::Unlimited

3820

1

));

3821

3822

		// Send USDC

3823

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3824

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3825

1

			Box::new(Location::new(1, [Parachain(1)]).into()),

3826

1

			Box::new(

3827

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3828

1

					.clone()

3829

1

					.into()

3830

1

),

3831

1

			Box::new(

3832

1

3833

1

3834

1

						xcm::latest::prelude::PalletInstance(

3835

1

							<StatemineAssets as PalletInfoAccess>::index() as u8

3836

1

),

3837

1

						GeneralIndex(10),

3838

1

],

3839

1

3840

1

3841

1

					.into()

3842

1

),

3843

1

0,

3844

1

			WeightLimit::Unlimited

3845

1

));

3846

1

});

3847

1

3848

1

	ParaA::execute_with(|| {

3849

1

		// Alice should have received the DOTs

3850

1

		assert_eq!(

3851

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3852

1

			Ok(U256::from(200))

3853

1

);

3854

3855

		// Alice has received 125 USDC

3856

1

		assert_eq!(

3857

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

3858

1

			Ok(U256::from(125))

3859

1

);

3860

1

});

3861

1

3862

1

	let dest = Location::new(

3863

1

1,

3864

1

3865

1

			Parachain(1000),

3866

1

			AccountId32 {

3867

1

				network: None,

3868

1

				id: RELAYBOB.into(),

3869

1

},

3870

1

],

3871

1

);

3872

1

3873

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3874

1

3875

1

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3876

1

	ParaA::execute_with(|| {

3877

1

		let asset_1 = currency_to_asset(

3878

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3879

1

			100,

3880

1

);

3881

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3882

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3883

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3884

1

			Box::new(VersionedLocation::from(chain_part)),

3885

1

			Box::new(VersionedLocation::from(beneficiary)),

3886

1

			Box::new(VersionedAssets::from(vec![asset_1, asset_2])),

3887

1

1,

3888

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

3889

1

));

3890

3891

1

		assert_eq!(

3892

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3893

1

			Ok(U256::from(100))

3894

1

);

3895

1

});

3896

1

3897

1

	Statemine::execute_with(|| {

3898

1

		// Check that Bob received relay tokens back in AssetHub

3899

1

		// (100 - MinXcmFee)

3900

1

		assert_eq!(

3901

1

			StatemineBalances::free_balance(RELAYBOB),

3902

1

			INITIAL_BALANCE + 100

3903

1

);

3904

3905

		// Check that BOB received 100 USDC on AssetHub

3906

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

3907

1

});

3908

1

3909

1

	// Send back tokens from AH to ParaA from Bob's account

3910

1

	Statemine::execute_with(|| {

3911

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

3912

1

3913

1

		// Now send those tokens to ParaA

3914

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

3915

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

3916

1

			Box::new(Location::new(1, [Parachain(1)]).into()),

3917

1

			Box::new(

3918

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3919

1

					.clone()

3920

1

					.into()

3921

1

),

3922

1

			Box::new((Location::parent(), 100).into()),

3923

1

0,

3924

1

			WeightLimit::Unlimited

3925

1

));

3926

3927

		// 100 DOTs were deducted from Bob's account

3928

1

		assert_eq!(

3929

1

			StatemineBalances::free_balance(RELAYBOB),

3930

1

			bob_previous_balance - 100

3931

1

);

3932

1

});

3933

1

3934

1

	ParaA::execute_with(|| {

3935

1

		// Alice should have received 100 DOTs

3936

1

		assert_eq!(

3937

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3938

1

			Ok(U256::from(200))

3939

1

);

3940

1

});

3941

1

3942

3943

#[test]

3944

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiassets() {

3945

1

	MockNet::reset();

3946

1

3947

1

	// Relay asset

3948

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3949

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3950

1

3951

1

	let relay_asset_metadata = parachain::AssetMetadata {

3952

1

		name: b"RelayToken".to_vec(),

3953

1

		symbol: b"Relay".to_vec(),

3954

1

		decimals: 12,

3955

1

};

3956

1

3957

1

	// Statemine asset

3958

1

	let statemine_asset = Location::new(

3959

1

1,

3960

1

3961

1

			Parachain(1000u32),

3962

1

			PalletInstance(5u8),

3963

1

			GeneralIndex(10u128),

3964

1

],

3965

1

);

3966

1

	let statemine_location_asset: AssetType = statemine_asset

3967

1

		.clone()

3968

1

		.try_into()

3969

1

		.expect("Location convertion to AssetType should succeed");

3970

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

3971

1

3972

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3973

1

		name: b"USDC".to_vec(),

3974

1

		symbol: b"USDC".to_vec(),

3975

1

		decimals: 12,

3976

1

};

3977

1

3978

1

	let dest_para = Location::new(1, [Parachain(1)]);

3979

1

3980

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3981

1

		polkadot_parachain::primitives::Sibling,

3982

1

		statemine_like::AccountId,

3983

1

	>::convert_location(&dest_para)

3984

1

	.unwrap();

3985

1

3986

1

	ParaA::execute_with(|| {

3987

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3988

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3989

1

			.try_into()

3990

1

			.expect("v3 to latest location conversion failed");

3991

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3992

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3993

1

			source_id,

3994

1

			source_location_latest,

3995

1

			relay_asset_metadata.decimals,

3996

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3997

1

			relay_asset_metadata.name.try_into().expect("too long"),

3998

1

));

3999

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4000

1

4001

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

4002

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

4003

1

			.try_into()

4004

1

			.expect("v3 to latest location conversion failed");

4005

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

4006

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4007

1

			statemine_id,

4008

1

			statemine_location_latest,

4009

1

			asset_metadata_statemine_asset.decimals,

4010

1

			asset_metadata_statemine_asset

4011

1

				.symbol

4012

1

				.try_into()

4013

1

				.expect("too long"),

4014

1

			asset_metadata_statemine_asset

4015

1

				.name

4016

1

				.try_into()

4017

1

				.expect("too long"),

4018

1

));

4019

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

4020

1

});

4021

1

4022

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4023

1

		network: None,

4024

1

		key: PARAALICE,

4025

1

4026

1

	.into();

4027

1

4028

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

4029

1

		network: None,

4030

1

		id: RELAYALICE.into(),

4031

1

4032

1

	.into();

4033

1

4034

1

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4035

1

	Relay::execute_with(|| {

4036

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4037

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4038

1

			Box::new(Parachain(1000).into()),

4039

1

			Box::new(

4040

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4041

1

					.clone()

4042

1

					.into()

4043

1

),

4044

1

			Box::new(([], 200).into()),

4045

1

0,

4046

1

			WeightLimit::Unlimited

4047

1

));

4048

1

});

4049

1

4050

1

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4051

1

	Statemine::execute_with(|| {

4052

1

		// Check Alice received 200 tokens on AssetHub

4053

1

		assert_eq!(

4054

1

			StatemineBalances::free_balance(RELAYALICE),

4055

1

			INITIAL_BALANCE + 200

4056

1

);

4057

4058

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4059

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4060

1

			sov,

4061

1

			110000000000000

4062

1

));

4063

4064

1

		statemine_like::PrefixChanger::set_prefix(

4065

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4066

1

);

4067

1

4068

1

		assert_ok!(StatemineAssets::create(

4069

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4070

1

10,

4071

1

			RELAYALICE,

4072

1

4073

1

));

4074

4075

1

		assert_ok!(StatemineAssets::mint(

4076

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4077

1

10,

4078

1

			RELAYALICE,

4079

1

			300000000000000

4080

1

));

4081

4082

		// Now send relay tokens to ParaA

4083

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

4084

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4085

1

			Box::new(Location::new(1, [Parachain(1)]).into()),

4086

1

			Box::new(

4087

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

4088

1

					.clone()

4089

1

					.into()

4090

1

),

4091

1

			Box::new((Location::parent(), 200).into()),

4092

1

0,

4093

1

			WeightLimit::Unlimited

4094

1

));

4095

4096

		// Send USDC

4097

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

4098

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4099

1

			Box::new(Location::new(1, [Parachain(1)]).into()),

4100

1

			Box::new(

4101

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

4102

1

					.clone()

4103

1

					.into()

4104

1

),

4105

1

			Box::new(

4106

1

4107

1

4108

1

						xcm::latest::prelude::PalletInstance(

4109

1

							<StatemineAssets as PalletInfoAccess>::index() as u8

4110

1

),

4111

1

						GeneralIndex(10),

4112

1

],

4113

1

4114

1

4115

1

					.into()

4116

1

),

4117

1

0,

4118

1

			WeightLimit::Unlimited

4119

1

));

4120

1

});

4121

1

4122

1

	ParaA::execute_with(|| {

4123

1

		// Alice should have received the DOTs

4124

1

		assert_eq!(

4125

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4126

1

			Ok(U256::from(200))

4127

1

);

4128

4129

		// Alice has received 125 USDC

4130

1

		assert_eq!(

4131

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4132

1

			Ok(U256::from(125))

4133

1

);

4134

1

});

4135

1

4136

1

	let dest = Location::new(

4137

1

1,

4138

1

4139

1

			Parachain(1000),

4140

1

			AccountId32 {

4141

1

				network: None,

4142

1

				id: RELAYBOB.into(),

4143

1

},

4144

1

],

4145

1

);

4146

1

4147

1

	let statemine_asset_to_send = Asset {

4148

1

		id: AssetId(statemine_asset),

4149

1

		fun: Fungibility::Fungible(100),

4150

1

};

4151

1

4152

1

	let relay_asset_to_send = Asset {

4153

1

		id: AssetId(Location::parent()),

4154

1

		fun: Fungibility::Fungible(100),

4155

1

};

4156

1

4157

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4158

1

	let assets_to_send: XcmAssets =

4159

1

		XcmAssets::from(vec![statemine_asset_to_send, relay_asset_to_send.clone()]);

4160

1

	// For some reason the order of the assets is inverted when creating the array above.

4161

1

	// We need to use relay asset for fees, so we pick index 0.

4162

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4163

4164

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4165

1

	ParaA::execute_with(|| {

4166

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

4167

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4168

1

			Box::new(VersionedLocation::from(chain_part)),

4169

1

			Box::new(VersionedLocation::from(beneficiary)),

4170

1

			Box::new(VersionedAssets::from(assets_to_send)),

4171

1

0,

4172

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4173

1

));

4174

4175

1

		assert_eq!(

4176

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4177

1

			Ok(U256::from(100))

4178

1

);

4179

1

});

4180

1

4181

1

	Statemine::execute_with(|| {

4182

1

		// Check that Bob received relay tokens back in AssetHub

4183

1

		// (100 - MinXcmFee)

4184

1

		assert_eq!(

4185

1

			StatemineBalances::free_balance(RELAYBOB),

4186

1

			INITIAL_BALANCE + 100

4187

1

);

4188

4189

		// Check that BOB received 100 USDC on AssetHub

4190

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4191

1

});

4192

1

4193

1

	// Send back tokens from AH to ParaA from Bob's account

4194

1

	Statemine::execute_with(|| {

4195

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4196

1

4197

1

		// Now send those tokens to ParaA

4198

1

		assert_ok!(StatemineChainPalletXcm::limited_reserve_transfer_assets(

4199

1

			statemine_like::RuntimeOrigin::signed(RELAYBOB),

4200

1

			Box::new(Location::new(1, [Parachain(1)]).into()),

4201

1

			Box::new(

4202

1

				VersionedLocation::from(parachain_beneficiary_absolute)

4203

1

					.clone()

4204

1

					.into()

4205

1

),

4206

1

			Box::new((Location::parent(), 100).into()),

4207

1

0,

4208

1

			WeightLimit::Unlimited

4209

1

));

4210

4211

		// 100 DOTs were deducted from Bob's account

4212

1

		assert_eq!(

4213

1

			StatemineBalances::free_balance(RELAYBOB),

4214

1

			bob_previous_balance - 100

4215

1

);

4216

1

});

4217

1

4218

1

	ParaA::execute_with(|| {

4219

1

		// Alice should have received 100 DOTs

4220

1

		assert_eq!(

4221

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4222

1

			Ok(U256::from(200))

4223

1

);

4224

1

});

4225

1

4226

4227

#[test]

4228

1

fn transact_through_signed_multilocation() {

4229

1

	MockNet::reset();

4230

1

	let mut ancestry = Location::parent();

4231

1

4232

1

	ParaA::execute_with(|| {

4233

1

		// Root can set transact info

4234

1

		assert_ok!(XcmTransactor::set_transact_info(

4235

1

			parachain::RuntimeOrigin::root(),

4236

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4237

1

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4238

1

			3000.into(),

4239

1

			20000000000.into(),

4240

1

			// 4 instructions in transact through signed

4241

1

			Some(4000.into())

4242

1

));

4243

		// Root can set transact info

4244

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4245

1

			parachain::RuntimeOrigin::root(),

4246

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4247

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

4248

1

));

4249

1

		ancestry = parachain::UniversalLocation::get().into();

4250

1

});

4251

1

4252

1

	// Let's construct the Junction that we will append with DescendOrigin

4253

1

	let signed_origin: Junctions = [AccountKey20 {

4254

1

		network: None,

4255

1

		key: PARAALICE,

4256

1

}]

4257

1

	.into();

4258

1

4259

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4260

1

	descend_origin_multilocation

4261

1

		.append_with(signed_origin)

4262

1

		.unwrap();

4263

1

4264

1

	// To convert it to what the relay will see instead of us

4265

1

	descend_origin_multilocation

4266

1

		.reanchor(&Location::parent(), &ancestry.interior)

4267

1

		.unwrap();

4268

1

4269

1

	let derived = xcm_builder::Account32Hash::<

4270

1

		relay_chain::KusamaNetwork,

4271

1

		relay_chain::AccountId,

4272

1

	>::convert_location(&descend_origin_multilocation)

4273

1

	.unwrap();

4274

1

4275

1

	Relay::execute_with(|| {

4276

1

		// free execution, full amount received

4277

1

		assert_ok!(RelayBalances::transfer_allow_death(

4278

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4279

1

			derived.clone(),

4280

1

			4000004100u128,

4281

1

));

4282

		// derived account has all funds

4283

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4284

		// sovereign account has 0 funds

4285

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4286

1

});

4287

1

4288

1

	// Encode the call. Balances transact to para_a_account

4289

1

	// First index

4290

1

	let mut encoded: Vec<u8> = Vec::new();

4291

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4292

1

		relay_chain::Balances,

4293

1

>()

4294

1

	.unwrap() as u8;

4295

1

4296

1

	encoded.push(index);

4297

1

4298

1

	// Then call bytes

4299

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4300

1

		// 100 to sovereign

4301

1

		dest: para_a_account(),

4302

1

		value: 100u32.into(),

4303

1

4304

1

	.encode();

4305

1

	encoded.append(&mut call_bytes);

4306

1

4307

1

	ParaA::execute_with(|| {

4308

1

		assert_ok!(XcmTransactor::transact_through_signed(

4309

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4310

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4311

1

			CurrencyPayment {

4312

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4313

1

					Location::parent()

4314

1

				))),

4315

1

				fee_amount: None

4316

1

},

4317

1

			encoded,

4318

1

			// 4000000000 for transfer + 4000 for XCM

4319

1

			// 1-1 to fee

4320

1

			TransactWeights {

4321

1

				transact_required_weight_at_most: 4000000000.into(),

4322

1

				overall_weight: None

4323

1

},

4324

1

			false

4325

1

));

4326

1

});

4327

1

4328

1

	Relay::execute_with(|| {

4329

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4330

4331

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4332

1

});

4333

1

4334

4335

#[test]

4336

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4337

1

	MockNet::reset();

4338

1

	let mut ancestry = Location::parent();

4339

1

4340

1

	ParaA::execute_with(|| {

4341

1

		ancestry = parachain::UniversalLocation::get().into();

4342

1

});

4343

1

4344

1

	// Let's construct the Junction that we will append with DescendOrigin

4345

1

	let signed_origin: Junctions = [AccountKey20 {

4346

1

		network: None,

4347

1

		key: PARAALICE,

4348

1

}]

4349

1

	.into();

4350

1

4351

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4352

1

	descend_origin_multilocation

4353

1

		.append_with(signed_origin)

4354

1

		.unwrap();

4355

1

4356

1

	// To convert it to what the relay will see instead of us

4357

1

	descend_origin_multilocation

4358

1

		.reanchor(&Location::parent(), &ancestry.interior)

4359

1

		.unwrap();

4360

1

4361

1

	let derived = xcm_builder::Account32Hash::<

4362

1

		relay_chain::KusamaNetwork,

4363

1

		relay_chain::AccountId,

4364

1

	>::convert_location(&descend_origin_multilocation)

4365

1

	.unwrap();

4366

1

4367

1

	Relay::execute_with(|| {

4368

1

		// free execution, full amount received

4369

1

		assert_ok!(RelayBalances::transfer_allow_death(

4370

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4371

1

			derived.clone(),

4372

1

			4000004100u128,

4373

1

));

4374

		// derived account has all funds

4375

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4376

		// sovereign account has 0 funds

4377

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4378

1

});

4379

1

4380

1

	// Encode the call. Balances transact to para_a_account

4381

1

	// First index

4382

1

	let mut encoded: Vec<u8> = Vec::new();

4383

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4384

1

		relay_chain::Balances,

4385

1

>()

4386

1

	.unwrap() as u8;

4387

1

4388

1

	encoded.push(index);

4389

1

4390

1

	// Then call bytes

4391

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4392

1

		// 100 to sovereign

4393

1

		dest: para_a_account(),

4394

1

		value: 100u32.into(),

4395

1

4396

1

	.encode();

4397

1

	encoded.append(&mut call_bytes);

4398

1

4399

1

	let total_weight = 4000004000u64;

4400

1

	ParaA::execute_with(|| {

4401

1

		assert_ok!(XcmTransactor::transact_through_signed(

4402

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4403

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4404

1

			CurrencyPayment {

4405

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4406

1

					Location::parent()

4407

1

				))),

4408

1

				fee_amount: Some(total_weight as u128)

4409

1

},

4410

1

			encoded,

4411

1

			// 4000000000 for transfer + 4000 for XCM

4412

1

			TransactWeights {

4413

1

				transact_required_weight_at_most: 4000000000.into(),

4414

1

				overall_weight: Some(Limited(total_weight.into()))

4415

1

},

4416

1

			false

4417

1

));

4418

1

});

4419

1

4420

1

	Relay::execute_with(|| {

4421

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4422

4423

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4424

1

});

4425

1

4426

4427

#[test]

4428

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4429

1

	MockNet::reset();

4430

1

	let mut ancestry = Location::parent();

4431

1

4432

1

	ParaA::execute_with(|| {

4433

1

		ancestry = parachain::UniversalLocation::get().into();

4434

1

});

4435

1

4436

1

	// Let's construct the Junction that we will append with DescendOrigin

4437

1

	let signed_origin: Junctions = [AccountKey20 {

4438

1

		network: None,

4439

1

		key: PARAALICE,

4440

1

}]

4441

1

	.into();

4442

1

4443

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4444

1

	descend_origin_multilocation

4445

1

		.append_with(signed_origin)

4446

1

		.unwrap();

4447

1

4448

1

	// To convert it to what the relay will see instead of us

4449

1

	descend_origin_multilocation

4450

1

		.reanchor(&Location::parent(), &ancestry.interior)

4451

1

		.unwrap();

4452

1

4453

1

	let derived = xcm_builder::Account32Hash::<

4454

1

		relay_chain::KusamaNetwork,

4455

1

		relay_chain::AccountId,

4456

1

	>::convert_location(&descend_origin_multilocation)

4457

1

	.unwrap();

4458

1

4459

1

	Relay::execute_with(|| {

4460

1

		// free execution, full amount received

4461

1

		assert_ok!(RelayBalances::transfer_allow_death(

4462

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4463

1

			derived.clone(),

4464

1

			4000009100u128,

4465

1

));

4466

		// derived account has all funds

4467

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4468

		// sovereign account has 0 funds

4469

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4470

1

});

4471

1

4472

1

	// Encode the call. Balances transact to para_a_account

4473

1

	// First index

4474

1

	let mut encoded: Vec<u8> = Vec::new();

4475

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4476

1

		relay_chain::Balances,

4477

1

>()

4478

1

	.unwrap() as u8;

4479

1

4480

1

	encoded.push(index);

4481

1

4482

1

	// Then call bytes

4483

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4484

1

		// 100 to sovereign

4485

1

		dest: para_a_account(),

4486

1

		value: 100u32.into(),

4487

1

4488

1

	.encode();

4489

1

	encoded.append(&mut call_bytes);

4490

1

4491

1

	let total_weight = 4000009000u64;

4492

1

	ParaA::execute_with(|| {

4493

1

		assert_ok!(XcmTransactor::transact_through_signed(

4494

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4495

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4496

1

			CurrencyPayment {

4497

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4498

1

					Location::parent()

4499

1

				))),

4500

1

				fee_amount: Some(total_weight as u128)

4501

1

},

4502

1

			encoded,

4503

1

			// 4000000000 for transfer + 9000 for XCM

4504

1

			TransactWeights {

4505

1

				transact_required_weight_at_most: 4000000000.into(),

4506

1

				overall_weight: Some(Limited(total_weight.into()))

4507

1

},

4508

1

			true

4509

1

));

4510

1

});

4511

1

4512

1

	Relay::execute_with(|| {

4513

1

		// 100 transferred

4514

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4515

4516

		// 4000009000 refunded

4517

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4518

1

});

4519

1

4520

4521

#[test]

4522

1

fn transact_through_signed_multilocation_para_to_para() {

4523

1

	MockNet::reset();

4524

1

	let mut ancestry = Location::parent();

4525

1

4526

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4527

1

4528

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4529

1

4530

1

	ParaA::execute_with(|| {

4531

1

		// Root can set transact info

4532

1

		assert_ok!(XcmTransactor::set_transact_info(

4533

1

			parachain::RuntimeOrigin::root(),

4534

1

			// ParaB

4535

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4536

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4537

1

			3.into(),

4538

1

			20000000000.into(),

4539

1

			// 4 instructions in transact through signed

4540

1

			Some(4.into())

4541

1

));

4542

		// Root can set transact info

4543

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4544

1

			parachain::RuntimeOrigin::root(),

4545

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4546

1

			parachain::ParaTokensPerSecond::get(),

4547

1

));

4548

1

		ancestry = parachain::UniversalLocation::get().into();

4549

1

});

4550

1

4551

1

	// Let's construct the Junction that we will append with DescendOrigin

4552

1

	let signed_origin: Junctions = [AccountKey20 {

4553

1

		network: None,

4554

1

		key: PARAALICE,

4555

1

}]

4556

1

	.into();

4557

1

4558

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4559

1

	descend_origin_location.append_with(signed_origin).unwrap();

4560

1

4561

1

	// To convert it to what the paraB will see instead of us

4562

1

	descend_origin_location

4563

1

		.reanchor(&para_b_location, &ancestry.interior)

4564

1

		.unwrap();

4565

1

4566

1

	let derived = xcm_builder::HashedDescription::<

4567

1

		parachain::AccountId,

4568

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4569

1

	>::convert_location(&descend_origin_location)

4570

1

	.unwrap();

4571

1

4572

1

	ParaB::execute_with(|| {

4573

1

		// free execution, full amount received

4574

1

		assert_ok!(ParaBalances::transfer_allow_death(

4575

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4576

1

			derived.clone(),

4577

1

			4000000104u128,

4578

1

));

4579

		// derived account has all funds

4580

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4581

		// sovereign account has 0 funds

4582

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4583

1

});

4584

1

4585

1

	// Encode the call. Balances transact to para_a_account

4586

1

	// First index

4587

1

	let mut encoded: Vec<u8> = Vec::new();

4588

1

	let index =

4589

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4590

1

			.unwrap() as u8;

4591

1

4592

1

	encoded.push(index);

4593

1

4594

1

	// Then call bytes

4595

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4596

1

		// 100 to sovereign

4597

1

		dest: para_a_account_20(),

4598

1

		value: 100u32.into(),

4599

1

4600

1

	.encode();

4601

1

	encoded.append(&mut call_bytes);

4602

1

4603

1

	ParaA::execute_with(|| {

4604

1

		assert_ok!(XcmTransactor::transact_through_signed(

4605

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4606

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4607

1

			CurrencyPayment {

4608

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4609

1

					para_b_balances

4610

1

				))),

4611

1

				fee_amount: None

4612

1

},

4613

1

			encoded,

4614

1

			// 4000000000 for transfer + 4000 for XCM

4615

1

			// 1-1 to fee

4616

1

			TransactWeights {

4617

1

				transact_required_weight_at_most: 4000000000.into(),

4618

1

				overall_weight: None

4619

1

},

4620

1

			false

4621

1

));

4622

1

});

4623

1

4624

1

	ParaB::execute_with(|| {

4625

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4626

4627

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4628

1

});

4629

1

4630

4631

#[test]

4632

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4633

1

	MockNet::reset();

4634

1

	let mut ancestry = Location::parent();

4635

1

4636

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4637

1

4638

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4639

1

4640

1

	ParaA::execute_with(|| {

4641

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4642

1

			parachain::RuntimeOrigin::root(),

4643

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4644

1

			parachain::ParaTokensPerSecond::get(),

4645

1

));

4646

1

		ancestry = parachain::UniversalLocation::get().into();

4647

1

});

4648

1

4649

1

	// Let's construct the Junction that we will append with DescendOrigin

4650

1

	let signed_origin: Junctions = [AccountKey20 {

4651

1

		network: None,

4652

1

		key: PARAALICE,

4653

1

}]

4654

1

	.into();

4655

1

4656

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4657

1

	descend_origin_location.append_with(signed_origin).unwrap();

4658

1

4659

1

	// To convert it to what the paraB will see instead of us

4660

1

	descend_origin_location

4661

1

		.reanchor(&para_b_location, &ancestry.interior)

4662

1

		.unwrap();

4663

1

4664

1

	let derived = xcm_builder::HashedDescription::<

4665

1

		parachain::AccountId,

4666

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4667

1

	>::convert_location(&descend_origin_location)

4668

1

	.unwrap();

4669

1

4670

1

	ParaB::execute_with(|| {

4671

1

		// free execution, full amount received

4672

1

		assert_ok!(ParaBalances::transfer_allow_death(

4673

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4674

1

			derived.clone(),

4675

1

			4000009100u128,

4676

1

));

4677

		// derived account has all funds

4678

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4679

		// sovereign account has 0 funds

4680

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4681

1

});

4682

1

4683

1

	// Encode the call. Balances transact to para_a_account

4684

1

	// First index

4685

1

	let mut encoded: Vec<u8> = Vec::new();

4686

1

	let index =

4687

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4688

1

			.unwrap() as u8;

4689

1

4690

1

	encoded.push(index);

4691

1

4692

1

	// Then call bytes

4693

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4694

1

		// 100 to sovereign

4695

1

		dest: para_a_account_20(),

4696

1

		value: 100u32.into(),

4697

1

4698

1

	.encode();

4699

1

	encoded.append(&mut call_bytes);

4700

1

4701

1

	let overall_weight = 4000009000u64;

4702

1

	ParaA::execute_with(|| {

4703

1

		assert_ok!(XcmTransactor::transact_through_signed(

4704

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4705

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4706

1

			CurrencyPayment {

4707

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4708

1

					para_b_balances

4709

1

				))),

4710

1

				fee_amount: Some(overall_weight as u128)

4711

1

},

4712

1

			encoded,

4713

1

			// 4000000000 for transfer + 9000 for XCM

4714

1

			TransactWeights {

4715

1

				transact_required_weight_at_most: 4000000000.into(),

4716

1

				overall_weight: Some(Limited(overall_weight.into()))

4717

1

},

4718

1

			true

4719

1

));

4720

1

});

4721

1

4722

1

	ParaB::execute_with(|| {

4723

1

		// Check the derived account was refunded

4724

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4725

4726

		// Check the transfer was executed

4727

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4728

1

});

4729

1

4730

4731

#[test]

4732

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4733

1

	MockNet::reset();

4734

1

	let mut ancestry = Location::parent();

4735

1

4736

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4737

1

4738

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4739

1

4740

1

	ParaA::execute_with(|| {

4741

1

		// Root can set transact info

4742

1

		assert_ok!(XcmTransactor::set_transact_info(

4743

1

			parachain::RuntimeOrigin::root(),

4744

1

			// ParaB

4745

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4746

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4747

1

			3.into(),

4748

1

			20000000000.into(),

4749

1

			// 4 instructions in transact through signed

4750

1

			Some(4.into())

4751

1

));

4752

		// Root can set transact info

4753

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4754

1

			parachain::RuntimeOrigin::root(),

4755

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4756

1

			parachain::ParaTokensPerSecond::get(),

4757

1

));

4758

1

		ancestry = parachain::UniversalLocation::get().into();

4759

1

});

4760

1

4761

1

	// Let's construct the Junction that we will append with DescendOrigin

4762

1

	let signed_origin: Junctions = [AccountKey20 {

4763

1

		network: None,

4764

1

		key: PARAALICE,

4765

1

}]

4766

1

	.into();

4767

1

4768

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4769

1

	descend_origin_location.append_with(signed_origin).unwrap();

4770

1

4771

1

	// To convert it to what the paraB will see instead of us

4772

1

	descend_origin_location

4773

1

		.reanchor(&para_b_location, &ancestry.interior)

4774

1

		.unwrap();

4775

1

4776

1

	let derived = xcm_builder::HashedDescription::<

4777

1

		parachain::AccountId,

4778

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4779

1

	>::convert_location(&descend_origin_location)

4780

1

	.unwrap();

4781

1

4782

1

	let mut parachain_b_alice_balances_before = 0;

4783

1

	ParaB::execute_with(|| {

4784

1

		assert_ok!(ParaBalances::transfer_allow_death(

4785

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4786

1

			derived.clone(),

4787

1

			4000000104u128,

4788

1

));

4789

		// derived account has all funds

4790

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4791

		// sovereign account has 0 funds

4792

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4793

4794

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4795

1

});

4796

1

4797

1

	// Encode the call. Balances transact to para_a_account

4798

1

	// First index

4799

1

	let mut encoded: Vec<u8> = Vec::new();

4800

1

	let index =

4801

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4802

1

			.unwrap() as u8;

4803

1

4804

1

	encoded.push(index);

4805

4806

	use sp_core::U256;

4807

	// Let's do a EVM transfer

4808

1

	let eth_tx =

4809

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4810

1

			gas_limit: U256::from(21000),

4811

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4812

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4813

1

			value: U256::from(100),

4814

1

			input: BoundedVec::<

4815

1

u8,

4816

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4817

1

			>::try_from(vec![]).unwrap(),

4818

1

			access_list: None,

4819

1

});

4820

1

4821

1

	// Then call bytes

4822

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4823

1

		xcm_transaction: eth_tx,

4824

1

4825

1

	.encode();

4826

1

	encoded.append(&mut call_bytes);

4827

1

4828

1

	ParaA::execute_with(|| {

4829

1

		assert_ok!(XcmTransactor::transact_through_signed(

4830

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4831

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4832

1

			CurrencyPayment {

4833

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4834

1

					para_b_balances

4835

1

				))),

4836

1

				fee_amount: None

4837

1

},

4838

1

			encoded,

4839

1

			// 4000000000 for transfer + 4000 for XCM

4840

1

			// 1-1 to fee

4841

1

			TransactWeights {

4842

1

				transact_required_weight_at_most: 4000000000.into(),

4843

1

				overall_weight: None

4844

1

},

4845

1

			false

4846

1

));

4847

1

});

4848

1

4849

1

	ParaB::execute_with(|| {

4850

1

		// Make sure the EVM transfer went through

4851

1

		assert!(

4852

1

			ParaBalances::free_balance(&PARAALICE.into())

4853

1

				== parachain_b_alice_balances_before + 100

4854

1

);

4855

1

});

4856

1

4857

4858

#[test]

4859

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4860

1

	MockNet::reset();

4861

1

	let mut ancestry = Location::parent();

4862

1

4863

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4864

1

4865

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4866

1

4867

1

	ParaA::execute_with(|| {

4868

1

		// Root can set transact info

4869

1

		assert_ok!(XcmTransactor::set_transact_info(

4870

1

			parachain::RuntimeOrigin::root(),

4871

1

			// ParaB

4872

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4873

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4874

1

			3.into(),

4875

1

			20000000000.into(),

4876

1

			// 4 instructions in transact through signed

4877

1

			Some(4.into())

4878

1

));

4879

		// Root can set transact info

4880

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4881

1

			parachain::RuntimeOrigin::root(),

4882

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4883

1

			parachain::ParaTokensPerSecond::get(),

4884

1

));

4885

1

		ancestry = parachain::UniversalLocation::get().into();

4886

1

});

4887

1

4888

1

	// Let's construct the Junction that we will append with DescendOrigin

4889

1

	let signed_origin: Junctions = [AccountKey20 {

4890

1

		network: None,

4891

1

		key: PARAALICE,

4892

1

}]

4893

1

	.into();

4894

1

4895

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4896

1

	descend_origin_location.append_with(signed_origin).unwrap();

4897

1

4898

1

	// To convert it to what the paraB will see instead of us

4899

1

	descend_origin_location

4900

1

		.reanchor(&para_b_location, &ancestry.interior)

4901

1

		.unwrap();

4902

1

4903

1

	let derived = xcm_builder::HashedDescription::<

4904

1

		parachain::AccountId,

4905

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4906

1

	>::convert_location(&descend_origin_location)

4907

1

	.unwrap();

4908

1

4909

1

	let mut parachain_b_alice_balances_before = 0;

4910

1

	ParaB::execute_with(|| {

4911

1

		assert_ok!(ParaBalances::transfer_allow_death(

4912

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4913

1

			derived.clone(),

4914

1

			4000000104u128,

4915

1

));

4916

		// derived account has all funds

4917

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4918

		// sovereign account has 0 funds

4919

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4920

4921

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4922

1

});

4923

1

4924

1

	// Encode the call. Balances transact to para_a_account

4925

1

	// First index

4926

1

	let mut encoded: Vec<u8> = Vec::new();

4927

1

	let index =

4928

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4929

1

			.unwrap() as u8;

4930

1

4931

1

	encoded.push(index);

4932

4933

	use sp_core::U256;

4934

	// Let's do a EVM transfer

4935

1

	let eth_tx =

4936

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4937

1

			gas_limit: U256::from(21000),

4938

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4939

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4940

1

			value: U256::from(100),

4941

1

			input: BoundedVec::<

4942

1

u8,

4943

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4944

1

			>::try_from(vec![]).unwrap(),

4945

1

			access_list: None,

4946

1

});

4947

1

4948

1

	// Then call bytes

4949

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4950

1

		transact_as: PARAALICE.into(),

4951

1

		xcm_transaction: eth_tx,

4952

1

4953

1

	.encode();

4954

1

	encoded.append(&mut call_bytes);

4955

1

4956

1

	ParaA::execute_with(|| {

4957

1

		assert_ok!(XcmTransactor::transact_through_signed(

4958

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4959

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4960

1

			CurrencyPayment {

4961

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4962

1

					para_b_balances

4963

1

				))),

4964

1

				fee_amount: None

4965

1

},

4966

1

			encoded,

4967

1

			TransactWeights {

4968

1

				transact_required_weight_at_most: 4000000000.into(),

4969

1

				overall_weight: None

4970

1

},

4971

1

			false

4972

1

));

4973

1

});

4974

1

4975

1

	ParaB::execute_with(|| {

4976

1

		// Make sure the EVM transfer wasn't executed

4977

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4978

1

});

4979

1

4980

4981

#[test]

4982

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4983

1

	MockNet::reset();

4984

1

	let mut ancestry = Location::parent();

4985

1

4986

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4987

1

4988

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4989

1

4990

1

	ParaA::execute_with(|| {

4991

1

		// Root can set transact info

4992

1

		assert_ok!(XcmTransactor::set_transact_info(

4993

1

			parachain::RuntimeOrigin::root(),

4994

1

			// ParaB

4995

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4996

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4997

1

			3.into(),

4998

1

			20000000000.into(),

4999

1

			// 4 instructions in transact through signed

5000

1

			Some(4.into())

5001

1

));

5002

		// Root can set transact info

5003

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5004

1

			parachain::RuntimeOrigin::root(),

5005

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5006

1

			parachain::ParaTokensPerSecond::get(),

5007

1

));

5008

1

		ancestry = parachain::UniversalLocation::get().into();

5009

1

});

5010

1

5011

1

	// Let's construct the Junction that we will append with DescendOrigin

5012

1

	let signed_origin: Junctions = [AccountKey20 {

5013

1

		network: None,

5014

1

		key: PARAALICE,

5015

1

}]

5016

1

	.into();

5017

1

5018

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5019

1

	descend_origin_location.append_with(signed_origin).unwrap();

5020

1

5021

1

	// To convert it to what the paraB will see instead of us

5022

1

	descend_origin_location

5023

1

		.reanchor(&para_b_location, &ancestry.interior)

5024

1

		.unwrap();

5025

1

5026

1

	let derived = xcm_builder::HashedDescription::<

5027

1

		parachain::AccountId,

5028

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5029

1

	>::convert_location(&descend_origin_location)

5030

1

	.unwrap();

5031

1

5032

1

	let transfer_recipient = evm_account();

5033

1

	let mut transfer_recipient_balance_before = 0;

5034

1

	ParaB::execute_with(|| {

5035

1

		assert_ok!(ParaBalances::transfer_allow_death(

5036

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5037

1

			derived.clone(),

5038

1

			4000000104u128,

5039

1

));

5040

		// derived account has all funds

5041

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5042

		// sovereign account has 0 funds

5043

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5044

5045

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5046

1

5047

1

		// Add proxy ALICE  -> derived

5048

1

		let _ = parachain::Proxy::add_proxy_delegate(

5049

1

			&PARAALICE.into(),

5050

1

			derived,

5051

1

			parachain::ProxyType::Any,

5052

1

0,

5053

1

);

5054

1

});

5055

1

5056

1

	// Encode the call. Balances transact to para_a_account

5057

1

	// First index

5058

1

	let mut encoded: Vec<u8> = Vec::new();

5059

1

	let index =

5060

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5061

1

			.unwrap() as u8;

5062

1

5063

1

	encoded.push(index);

5064

5065

	use sp_core::U256;

5066

	// Let's do a EVM transfer

5067

1

	let eth_tx =

5068

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5069

1

			gas_limit: U256::from(21000),

5070

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5071

1

			value: U256::from(100),

5072

1

			input: BoundedVec::<

5073

1

u8,

5074

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5075

1

			>::try_from(vec![]).unwrap(),

5076

1

			access_list: None,

5077

1

});

5078

1

5079

1

	// Then call bytes

5080

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5081

1

		transact_as: PARAALICE.into(),

5082

1

		xcm_transaction: eth_tx,

5083

1

5084

1

	.encode();

5085

1

	encoded.append(&mut call_bytes);

5086

1

5087

1

	ParaA::execute_with(|| {

5088

1

		assert_ok!(XcmTransactor::transact_through_signed(

5089

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5090

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5091

1

			CurrencyPayment {

5092

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5093

1

					para_b_balances

5094

1

				))),

5095

1

				fee_amount: None

5096

1

},

5097

1

			encoded,

5098

1

			TransactWeights {

5099

1

				transact_required_weight_at_most: 4000000000.into(),

5100

1

				overall_weight: None

5101

1

},

5102

1

			false

5103

1

));

5104

1

});

5105

1

5106

1

	ParaB::execute_with(|| {

5107

1

		// Make sure the EVM transfer was executed

5108

1

		assert!(

5109

1

			ParaBalances::free_balance(&transfer_recipient.into())

5110

1

				== transfer_recipient_balance_before + 100

5111

1

);

5112

1

});

5113

1

5114

5115

#[test]

5116

1

fn hrmp_init_accept_through_root() {

5117

1

	MockNet::reset();

5118

1

5119

1

	Relay::execute_with(|| {

5120

1

		assert_ok!(RelayBalances::transfer_allow_death(

5121

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5122

1

			para_a_account(),

5123

1

			1000u128

5124

1

));

5125

1

		assert_ok!(RelayBalances::transfer_allow_death(

5126

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5127

1

			para_b_account(),

5128

1

			1000u128

5129

1

));

5130

1

});

5131

1

5132

1

	ParaA::execute_with(|| {

5133

1

		let total_fee = 1_000u128;

5134

1

		let total_weight: u64 = 1_000_000_000;

5135

1

		let tx_weight: u64 = 500_000_000;

5136

1

		// Root can send hrmp init channel

5137

1

		assert_ok!(XcmTransactor::hrmp_manage(

5138

1

			parachain::RuntimeOrigin::root(),

5139

1

			HrmpOperation::InitOpen(HrmpInitParams {

5140

1

				para_id: 2u32.into(),

5141

1

				proposed_max_capacity: 1,

5142

1

				proposed_max_message_size: 1

5143

1

}),

5144

1

			CurrencyPayment {

5145

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5146

1

					Location::parent()

5147

1

				))),

5148

1

				fee_amount: Some(total_fee)

5149

1

},

5150

1

			TransactWeights {

5151

1

				transact_required_weight_at_most: tx_weight.into(),

5152

1

				overall_weight: Some(Limited(total_weight.into()))

5153

1

5154

1

));

5155

1

});

5156

1

	Relay::execute_with(|| {

5157

1

		let expected_event: relay_chain::RuntimeEvent =

5158

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5159

1

				sender: 1u32.into(),

5160

1

				recipient: 2u32.into(),

5161

1

				proposed_max_capacity: 1u32,

5162

1

				proposed_max_message_size: 1u32,

5163

1

5164

1

			.into();

5165

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5166

1

});

5167

1

	ParaB::execute_with(|| {

5168

1

		let total_fee = 1_000u128;

5169

1

		let total_weight: u64 = 1_000_000_000;

5170

1

		let tx_weight: u64 = 500_000_000;

5171

1

		// Root can send hrmp accept channel

5172

1

		assert_ok!(XcmTransactor::hrmp_manage(

5173

1

			parachain::RuntimeOrigin::root(),

5174

1

			HrmpOperation::Accept {

5175

1

				para_id: 1u32.into()

5176

1

},

5177

1

			CurrencyPayment {

5178

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5179

1

					Location::parent()

5180

1

				))),

5181

1

				fee_amount: Some(total_fee)

5182

1

},

5183

1

			TransactWeights {

5184

1

				transact_required_weight_at_most: tx_weight.into(),

5185

1

				overall_weight: Some(Limited(total_weight.into()))

5186

1

5187

1

));

5188

1

});

5189

1

5190

1

	Relay::execute_with(|| {

5191

1

		let expected_event: relay_chain::RuntimeEvent =

5192

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5193

1

				sender: 1u32.into(),

5194

1

				recipient: 2u32.into(),

5195

1

5196

1

			.into();

5197

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5198

1

});

5199

1

5200

5201

#[test]

5202

1

fn hrmp_close_works() {

5203

1

	MockNet::reset();

5204

1

5205

1

	Relay::execute_with(|| {

5206

1

		assert_ok!(RelayBalances::transfer_allow_death(

5207

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5208

1

			para_a_account(),

5209

1

			1000u128

5210

1

));

5211

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5212

1

			relay_chain::RuntimeOrigin::root(),

5213

1

			1u32.into(),

5214

1

			2u32.into(),

5215

1

			1u32,

5216

1

			1u32

5217

1

));

5218

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5219

1

			relay_chain::RuntimeOrigin::root(),

5220

1

			1u32

5221

1

));

5222

1

});

5223

1

5224

1

	ParaA::execute_with(|| {

5225

1

		let total_fee = 1_000u128;

5226

1

		let total_weight: u64 = 1_000_000_000;

5227

1

		let tx_weight: u64 = 500_000_000;

5228

1

		// Root can send hrmp close

5229

1

		assert_ok!(XcmTransactor::hrmp_manage(

5230

1

			parachain::RuntimeOrigin::root(),

5231

1

			HrmpOperation::Close(HrmpChannelId {

5232

1

				sender: 1u32.into(),

5233

1

				recipient: 2u32.into()

5234

1

}),

5235

1

			CurrencyPayment {

5236

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5237

1

					Location::parent()

5238

1

				))),

5239

1

				fee_amount: Some(total_fee)

5240

1

},

5241

1

			TransactWeights {

5242

1

				transact_required_weight_at_most: tx_weight.into(),

5243

1

				overall_weight: Some(Limited(total_weight.into()))

5244

1

5245

1

));

5246

1

});

5247

1

	Relay::execute_with(|| {

5248

1

		let expected_event: relay_chain::RuntimeEvent =

5249

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5250

1

				by_parachain: 1u32.into(),

5251

1

				channel_id: HrmpChannelId {

5252

1

					sender: 1u32.into(),

5253

1

					recipient: 2u32.into(),

5254

1

},

5255

1

5256

1

			.into();

5257

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5258

1

});

5259

1

5260

5261

use crate::xcm_mock::parachain::XcmWeightTrader;

5262

use parity_scale_codec::{Decode, Encode};

5263

use sp_io::hashing::blake2_256;

5264

5265

// Helper to derive accountIds

5266

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5267

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5268

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5269

7