Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonbeam Runtime Xcm Tests

18

19

mod xcm_mock;

20

21

use cumulus_primitives_core::relay_chain::HrmpChannelId;

22

use frame_support::{

23

	assert_ok,

24

	traits::{PalletInfo, PalletInfoAccess},

25

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

26

	BoundedVec,

27

};

28

use moonbeam_runtime::xcm_config::AssetType;

29

use pallet_xcm_transactor::{

30

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

31

};

32

use sp_core::ConstU32;

33

use sp_core::U256;

34

use sp_runtime::traits::Convert;

35

use xcm::{

36

	latest::prelude::{

37

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

38

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

39

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

40

},

41

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

42

};

43

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

44

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

45

use xcm_mock::relay_chain;

46

use xcm_mock::*;

47

use xcm_primitives::{

48

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

49

};

50

use xcm_simulator::TestExt;

51

52

26

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

53

26

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

54

26

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

55

26

		.into_version(xcm::latest::VERSION)

56

26

		.map_err(|_| ())?

57

	else {

58

		return Err(());

59

};

60

	use frame_support::weights::WeightToFee as _;

61

26

	let native_amount_per_second: u128 =

62

26

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

63

26

			&Weight::from_parts(

64

26

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

65

26

0,

66

26

),

67

68

26

		.try_into()

69

26

		.map_err(|_| ())?;

70

26

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

71

26

	let relative_price: u128 = if units_per_second > 0u128 {

72

10

		native_amount_per_second

73

10

			.saturating_mul(precision_factor)

74

10

			.saturating_div(units_per_second)

75

	} else {

76

16

		0u128

77

};

78

26

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

79

26

		location_v5,

80

26

		(true, relative_price),

81

);

82

26

	Ok(())

83

26

84

85

/// Helper function to set fee per second for an asset location (for compatibility with old tests).

86

/// Converts fee_per_second to relative_price and adds/edits the asset in the weight-trader.

87

9

fn set_fee_per_second_for_location(location: Location, fee_per_second: u128) -> Result<(), ()> {

88

	use moonbeam_tests_primitives::MemoryFeeTrader;

89

	use xcm_primitives::XcmFeeTrader;

90

91

	// Configure fees for XcmTransactor via the in-memory fee trader only, so that

92

	// the initial funding XCM transfers stay free and only transactor calls pay fees.

93

9

	<MemoryFeeTrader as XcmFeeTrader>::set_asset_price(location, fee_per_second).map_err(|_| ())

94

9

95

96

23

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

97

23

	Asset {

98

23

		id: AssetId(

99

23

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

100

23

				currency_id,

101

23

102

23

			.unwrap(),

103

23

),

104

23

		fun: Fungibility::Fungible(amount),

105

23

106

23

107

108

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

109

#[test]

110

1

fn receive_relay_asset_from_relay() {

111

1

	MockNet::reset();

112

113

1

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

114

1

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

115

1

	let asset_metadata = parachain::AssetMetadata {

116

1

		name: b"RelayToken".to_vec(),

117

1

		symbol: b"Relay".to_vec(),

118

1

		decimals: 12,

119

1

};

120

121

	// Register relay asset in paraA

122

1

	ParaA::execute_with(|| {

123

1

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

124

1

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

125

1

			.try_into()

126

1

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

127

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

128

1

			source_id,

129

1

			source_location_latest,

130

1

			asset_metadata.decimals,

131

1

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

132

1

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

133

));

134

1

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

135

1

});

136

137

	// Actually send relay asset to parachain

138

1

	let dest: Location = AccountKey20 {

139

1

		network: None,

140

1

		key: PARAALICE,

141

1

142

1

	.into();

143

144

	// First send relay chain asset to Parachain

145

1

	Relay::execute_with(|| {

146

1

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

147

1

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

148

1

			assets: Wild(All),

149

1

			beneficiary: dest.clone(),

150

1

		}]);

151

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

152

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

153

1

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

154

1

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

155

1

			Box::new(TransferType::LocalReserve),

156

1

			Box::new(fees_id),

157

1

			Box::new(TransferType::LocalReserve),

158

1

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

159

1

			WeightLimit::Unlimited

160

));

161

1

});

162

163

	// Verify that parachain received the asset

164

1

	ParaA::execute_with(|| {

165

		// free execution, full amount received

166

1

		assert_eq!(

167

1

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

168

1

			Ok(U256::from(123))

169

);

170

1

});

171

1

172

173

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

174

#[test]

175

1

fn send_relay_asset_to_relay() {

176

1

	MockNet::reset();

177

178

1

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

179

1

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

180

181

1

	let asset_metadata = parachain::AssetMetadata {

182

1

		name: b"RelayToken".to_vec(),

183

1

		symbol: b"Relay".to_vec(),

184

1

		decimals: 12,

185

1

};

186

187

	// Register relay asset in paraA

188

1

	ParaA::execute_with(|| {

189

1

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

190

1

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

191

1

			.try_into()

192

1

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

193

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

194

1

			source_id,

195

1

			source_location_latest,

196

1

			asset_metadata.decimals,

197

1

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

198

1

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

199

));

200

		// Free execution

201

1

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

202

1

});

203

204

1

	let dest: Location = Junction::AccountKey20 {

205

1

		network: None,

206

1

		key: PARAALICE,

207

1

208

1

	.into();

209

210

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

211

1

	Relay::execute_with(|| {

212

1

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

213

1

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

214

1

			assets: Wild(All),

215

1

			beneficiary: dest.clone(),

216

1

		}]);

217

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

218

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

219

1

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

220

1

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

221

1

			Box::new(TransferType::LocalReserve),

222

1

			Box::new(fees_id),

223

1

			Box::new(TransferType::LocalReserve),

224

1

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

225

1

			WeightLimit::Unlimited

226

));

227

1

});

228

229

1

	ParaA::execute_with(|| {

230

		// Free execution, full amount received

231

1

		assert_eq!(

232

1

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

233

1

			Ok(U256::from(123))

234

);

235

1

});

236

237

	// Lets gather the balance before sending back money

238

1

	let mut balance_before_sending = 0;

239

1

	Relay::execute_with(|| {

240

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

241

1

});

242

243

	// We now send back some money to the relay

244

1

	let dest = Location {

245

1

		parents: 1,

246

1

		interior: [AccountId32 {

247

1

			network: None,

248

1

			id: RELAYALICE.into(),

249

1

}]

250

1

		.into(),

251

1

};

252

1

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

253

1

	ParaA::execute_with(|| {

254

1

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

255

1

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

256

1

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

257

1

			assets: Wild(All),

258

1

			beneficiary: beneficiary.clone(),

259

1

		}]);

260

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

261

1

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

262

1

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

263

1

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

264

1

			Box::new(TransferType::DestinationReserve),

265

1

			Box::new(fees_id),

266

1

			Box::new(TransferType::DestinationReserve),

267

1

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

268

1

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

269

));

270

1

});

271

272

	// The balances in paraAlice should have been substracted

273

1

	ParaA::execute_with(|| {

274

1

		assert_eq!(

275

1

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

276

1

			Ok(U256::from(0))

277

);

278

1

});

279

280

	// Balances in the relay should have been received

281

1

	Relay::execute_with(|| {

282

		// free execution,x	 full amount received

283

1

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

284

1

});

285

1

286

287

#[test]

288

1

fn send_relay_asset_to_para_b() {

289

1

	MockNet::reset();

290

291

1

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

292

1

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

293

294

1

	let asset_metadata = parachain::AssetMetadata {

295

1

		name: b"RelayToken".to_vec(),

296

1

		symbol: b"Relay".to_vec(),

297

1

		decimals: 12,

298

1

};

299

300

	// Register asset in paraA. Free execution

301

1

	ParaA::execute_with(|| {

302

1

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

303

1

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

304

1

			.try_into()

305

1

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

306

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

307

1

			source_id,

308

1

			source_location_latest,

309

1

			asset_metadata.decimals,

310

1

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

311

1

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

312

));

313

1

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

314

1

});

315

316

	// Register asset in paraB. Free execution

317

1

	ParaB::execute_with(|| {

318

1

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

319

1

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

320

1

			.try_into()

321

1

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

322

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

323

1

			source_id,

324

1

			source_location_latest,

325

1

			asset_metadata.decimals,

326

1

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

327

1

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

328

));

329

1

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

330

1

});

331

332

1

	let dest: Location = Junction::AccountKey20 {

333

1

		network: None,

334

1

		key: PARAALICE,

335

1

336

1

	.into();

337

1

	Relay::execute_with(|| {

338

1

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

339

1

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

340

1

			assets: Wild(All),

341

1

			beneficiary: dest.clone(),

342

1

		}]);

343

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

344

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

345

1

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

346

1

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

347

1

			Box::new(TransferType::LocalReserve),

348

1

			Box::new(fees_id),

349

1

			Box::new(TransferType::LocalReserve),

350

1

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

351

1

			WeightLimit::Unlimited

352

));

353

1

});

354

355

1

	ParaA::execute_with(|| {

356

		// free execution, full amount received

357

1

		assert_eq!(

358

1

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

359

1

			Ok(U256::from(123))

360

);

361

1

});

362

363

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

364

1

	let dest = Location {

365

1

		parents: 1,

366

1

		interior: [

367

1

			Parachain(2),

368

1

			AccountKey20 {

369

1

				network: None,

370

1

				key: PARAALICE.into(),

371

1

},

372

1

373

1

		.into(),

374

1

};

375

1

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

376

1

	ParaA::execute_with(|| {

377

1

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

378

1

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

379

1

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

380

1

			assets: Wild(All),

381

1

			beneficiary: beneficiary.clone(),

382

1

		}]);

383

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

384

1

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

385

1

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

386

1

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

387

1

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

388

1

			Box::new(fees_id),

389

1

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

390

1

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

391

1

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

392

));

393

1

});

394

395

	// Para A balances should have been substracted

396

1

	ParaA::execute_with(|| {

397

1

		assert_eq!(

398

1

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

399

1

			Ok(U256::from(23))

400

);

401

1

});

402

403

	// Para B balances should have been credited

404

1

	ParaB::execute_with(|| {

405

1

		assert_eq!(

406

1

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

407

1

			Ok(U256::from(100))

408

);

409

1

});

410

1

411

412

#[test]

413

1

fn send_para_a_asset_to_para_b() {

414

1

	MockNet::reset();

415

416

	// This represents the asset in paraA

417

1

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

418

1

	let source_location: AssetType = para_a_balances

419

1

		.try_into()

420

1

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

421

1

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

422

423

1

	let asset_metadata = parachain::AssetMetadata {

424

1

		name: b"ParaAToken".to_vec(),

425

1

		symbol: b"ParaA".to_vec(),

426

1

		decimals: 18,

427

1

};

428

429

	// Register asset in paraB. Free execution

430

1

	ParaB::execute_with(|| {

431

1

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

432

1

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

433

1

			.try_into()

434

1

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

435

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

436

1

			source_id,

437

1

			source_location_latest,

438

1

			asset_metadata.decimals,

439

1

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

440

1

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

441

));

442

1

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

443

1

});

444

445

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

446

1

	let dest = Location {

447

1

		parents: 1,

448

1

		interior: [

449

1

			Parachain(2),

450

1

			AccountKey20 {

451

1

				network: None,

452

1

				key: PARAALICE.into(),

453

1

},

454

1

455

1

		.into(),

456

1

};

457

458

1

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

459

	// Native token is substracted in paraA

460

1

	ParaA::execute_with(|| {

461

1

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

462

		// Free execution, full amount received

463

1

		assert_ok!(PolkadotXcm::transfer_assets(

464

1

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

465

1

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

466

1

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

467

1

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

468

0,

469

1

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

470

));

471

1

});

472

473

1

	ParaA::execute_with(|| {

474

1

		assert_eq!(

475

1

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

476

			INITIAL_BALANCE - 100

477

);

478

1

});

479

480

	// Asset is minted in paraB

481

1

	ParaB::execute_with(|| {

482

		// Free execution, full amount received

483

1

		assert_eq!(

484

1

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

485

1

			Ok(U256::from(100))

486

);

487

1

});

488

1

489

490

#[test]

491

1

fn send_para_a_asset_from_para_b_to_para_c() {

492

1

	MockNet::reset();

493

494

	// Represents para A asset

495

1

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

496

1

	let source_location: AssetType = para_a_balances

497

1

		.try_into()

498

1

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

499

1

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

500

501

1

	let asset_metadata = parachain::AssetMetadata {

502

1

		name: b"ParaAToken".to_vec(),

503

1

		symbol: b"ParaA".to_vec(),

504

1

		decimals: 18,

505

1

};

506

507

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

508

1

	ParaB::execute_with(|| {

509

1

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

510

1

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

511

1

			.try_into()

512

1

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

513

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

514

1

			source_id,

515

1

			source_location_latest,

516

1

			asset_metadata.decimals,

517

1

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

518

1

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

519

));

520

1

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

521

1

});

522

523

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

524

1

	ParaC::execute_with(|| {

525

1

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

526

1

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

527

1

			.try_into()

528

1

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

529

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

530

1

			source_id,

531

1

			source_location_latest,

532

1

			asset_metadata.decimals,

533

1

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

534

1

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

535

));

536

1

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

537

1

});

538

539

1

	let dest = Location {

540

1

		parents: 1,

541

1

		interior: [

542

1

			Parachain(2),

543

1

			AccountKey20 {

544

1

				network: None,

545

1

				key: PARAALICE.into(),

546

1

},

547

1

548

1

		.into(),

549

1

};

550

1

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

551

1

	ParaA::execute_with(|| {

552

1

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

553

1

		assert_ok!(PolkadotXcm::transfer_assets(

554

1

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

555

1

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

556

1

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

557

1

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

558

0,

559

1

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

560

));

561

1

});

562

563

	// Para A balances have been substracted

564

1

	ParaA::execute_with(|| {

565

1

		assert_eq!(

566

1

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

567

			INITIAL_BALANCE - 100

568

);

569

1

});

570

571

	// Para B balances have been credited

572

1

	ParaB::execute_with(|| {

573

1

		assert_eq!(

574

1

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

575

1

			Ok(U256::from(100))

576

);

577

1

});

578

579

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

580

1

	let dest = Location {

581

1

		parents: 1,

582

1

		interior: [

583

1

			Parachain(3),

584

1

			AccountKey20 {

585

1

				network: None,

586

1

				key: PARAALICE.into(),

587

1

},

588

1

589

1

		.into(),

590

1

};

591

1

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

592

1

	ParaB::execute_with(|| {

593

1

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

594

1

		assert_ok!(PolkadotXcm::transfer_assets(

595

1

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

596

1

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

597

1

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

598

1

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

599

0,

600

1

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

601

));

602

1

});

603

604

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

605

1

	ParaC::execute_with(|| {

606

1

		assert_eq!(

607

1

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

608

1

			Ok(U256::from(95))

609

);

610

1

});

611

1

612

613

#[test]

614

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

615

1

	MockNet::reset();

616

617

	// para A asset

618

1

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

619

1

	let source_location: AssetType = para_a_balances

620

1

		.try_into()

621

1

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

622

1

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

623

624

1

	let asset_metadata = parachain::AssetMetadata {

625

1

		name: b"ParaAToken".to_vec(),

626

1

		symbol: b"ParaA".to_vec(),

627

1

		decimals: 18,

628

1

};

629

630

	// Register para A asset in para B

631

1

	ParaB::execute_with(|| {

632

1

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

633

1

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

634

1

			.try_into()

635

1

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

636

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

637

1

			source_id,

638

1

			source_location_latest,

639

1

			asset_metadata.decimals,

640

1

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

641

1

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

642

));

643

1

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

644

1

});

645

646

	// Send para A asset to para B

647

1

	let dest = Location {

648

1

		parents: 1,

649

1

		interior: [

650

1

			Parachain(2),

651

1

			AccountKey20 {

652

1

				network: None,

653

1

				key: PARAALICE.into(),

654

1

},

655

1

656

1

		.into(),

657

1

};

658

1

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

659

1

	ParaA::execute_with(|| {

660

1

		let asset = currency_to_asset(parachain::CurrencyId::SelfReserve, 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(asset)),

666

0,

667

1

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

668

));

669

1

});

670

671

	// Balances have been substracted

672

1

	ParaA::execute_with(|| {

673

1

		assert_eq!(

674

1

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

675

			INITIAL_BALANCE - 100

676

);

677

1

});

678

679

	// Para B balances have been credited

680

1

	ParaB::execute_with(|| {

681

1

		assert_eq!(

682

1

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

683

1

			Ok(U256::from(100))

684

);

685

1

});

686

687

	// Send back para A asset to para A

688

1

	let dest = Location {

689

1

		parents: 1,

690

1

		interior: [

691

1

			Parachain(1),

692

1

			AccountKey20 {

693

1

				network: None,

694

1

				key: PARAALICE.into(),

695

1

},

696

1

697

1

		.into(),

698

1

};

699

1

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

700

1

	ParaB::execute_with(|| {

701

1

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

702

1

		assert_ok!(PolkadotXcm::transfer_assets(

703

1

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

704

1

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

705

1

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

706

1

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

707

0,

708

1

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

709

));

710

1

});

711

712

1

	ParaA::execute_with(|| {

713

		// Weight used is 4

714

1

		assert_eq!(

715

1

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

716

			INITIAL_BALANCE - 4

717

);

718

1

});

719

1

720

721

#[test]

722

1

fn receive_relay_asset_with_trader() {

723

1

	MockNet::reset();

724

725

1

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

726

1

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

727

728

1

	let asset_metadata = parachain::AssetMetadata {

729

1

		name: b"RelayToken".to_vec(),

730

1

		symbol: b"Relay".to_vec(),

731

1

		decimals: 12,

732

1

};

733

734

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

735

	// we know later we will divide by 1e12

736

	// Lets put 1e6 as units per second

737

1

	ParaA::execute_with(|| {

738

1

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

739

1

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

740

1

			.try_into()

741

1

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

742

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

743

1

			source_id,

744

1

			source_location_latest,

745

1

			asset_metadata.decimals,

746

1

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

747

1

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

748

));

749

1

		assert_ok!(add_supported_asset(

750

1

			source_location.clone(),

751

			2500000000000u128

752

));

753

1

});

754

755

1

	let dest: Location = Junction::AccountKey20 {

756

1

		network: None,

757

1

		key: PARAALICE,

758

1

759

1

	.into();

760

	// We are sending 100 tokens from relay.

761

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

762

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

763

	// Units per second should be 2_500_000_000_000_000

764

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

765

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

766

1

	Relay::execute_with(|| {

767

1

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

768

1

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

769

1

			assets: Wild(All),

770

1

			beneficiary: dest.clone(),

771

1

		}]);

772

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

773

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

774

1

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

775

1

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

776

1

			Box::new(TransferType::LocalReserve),

777

1

			Box::new(fees_id),

778

1

			Box::new(TransferType::LocalReserve),

779

1

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

780

1

			WeightLimit::Unlimited

781

));

782

1

});

783

784

1

	ParaA::execute_with(|| {

785

		// non-free execution, not full amount received

786

1

		assert_eq!(

787

1

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

788

1

			Ok(U256::from(90))

789

);

790

		// Fee should have been received by treasury

791

1

		assert_eq!(

792

1

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

793

1

			Ok(U256::from(10))

794

);

795

1

});

796

1

797

798

#[test]

799

1

fn send_para_a_asset_to_para_b_with_trader() {

800

1

	MockNet::reset();

801

802

1

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

803

1

	let source_location: AssetType = para_a_balances

804

1

		.try_into()

805

1

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

806

1

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

807

808

1

	let asset_metadata = parachain::AssetMetadata {

809

1

		name: b"ParaAToken".to_vec(),

810

1

		symbol: b"ParaA".to_vec(),

811

1

		decimals: 18,

812

1

};

813

814

1

	ParaB::execute_with(|| {

815

1

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

816

1

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

817

1

			.try_into()

818

1

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

819

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

820

1

			source_id,

821

1

			source_location_latest,

822

1

			asset_metadata.decimals,

823

1

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

824

1

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

825

));

826

1

		assert_ok!(add_supported_asset(

827

1

			source_location.clone(),

828

			2500000000000u128

829

));

830

1

});

831

832

1

	let dest = Location {

833

1

		parents: 1,

834

1

		interior: [

835

1

			Parachain(2),

836

1

			AccountKey20 {

837

1

				network: None,

838

1

				key: PARAALICE.into(),

839

1

},

840

1

841

1

		.into(),

842

1

};

843

844

1

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

845

	// In destination chain, we only need 4 weight

846

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

847

1

	ParaA::execute_with(|| {

848

1

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

849

1

		assert_ok!(PolkadotXcm::transfer_assets(

850

1

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

851

1

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

852

1

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

853

1

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

854

0,

855

1

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

856

));

857

1

});

858

1

	ParaA::execute_with(|| {

859

		// free execution, full amount received

860

1

		assert_eq!(

861

1

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

862

			INITIAL_BALANCE - 100

863

);

864

1

});

865

866

	// We are sending 100 tokens from para A.

867

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

868

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

869

	// Units per second should be 2_500_000_000_000_000

870

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

871

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

872

	// will be 4

873

1

	ParaB::execute_with(|| {

874

1

		assert_eq!(

875

1

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

876

1

			Ok(U256::from(90))

877

);

878

		// Fee should have been received by treasury

879

1

		assert_eq!(

880

1

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

881

1

			Ok(U256::from(10))

882

);

883

1

});

884

1

885

886

#[test]

887

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

888

1

	MockNet::reset();

889

890

1

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

891

1

	let source_location: AssetType = para_a_balances

892

1

		.try_into()

893

1

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

894

1

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

895

896

1

	let asset_metadata = parachain::AssetMetadata {

897

1

		name: b"ParaAToken".to_vec(),

898

1

		symbol: b"ParaA".to_vec(),

899

1

		decimals: 18,

900

1

};

901

902

1

	ParaB::execute_with(|| {

903

1

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

904

1

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

905

1

			.try_into()

906

1

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

907

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

908

1

			source_id,

909

1

			source_location_latest,

910

1

			asset_metadata.decimals,

911

1

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

912

1

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

913

));

914

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

915

1

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

916

1

});

917

918

1

	let dest = Location {

919

1

		parents: 1,

920

1

		interior: [

921

1

			Parachain(2),

922

1

			AccountKey20 {

923

1

				network: None,

924

1

				key: PARAALICE.into(),

925

1

},

926

1

927

1

		.into(),

928

1

};

929

1

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

930

	// we use transfer_with_fee

931

1

	ParaA::execute_with(|| {

932

1

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

933

1

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

934

1

		assert_ok!(PolkadotXcm::transfer_assets(

935

1

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

936

1

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

937

1

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

938

1

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

939

0,

940

1

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

941

));

942

1

});

943

1

	ParaA::execute_with(|| {

944

		// 100 tokens transferred plus 1 taken from fees

945

1

		assert_eq!(

946

1

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

947

			INITIAL_BALANCE - 100 - 1

948

);

949

1

});

950

951

1

	ParaB::execute_with(|| {

952

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

953

		// what it is specified

954

1

		assert_eq!(

955

1

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

956

1

			Ok(U256::from(101))

957

);

958

1

});

959

1

960

961

#[test]

962

1

fn error_when_not_paying_enough() {

963

1

	MockNet::reset();

964

965

1

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

966

1

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

967

968

1

	let asset_metadata = parachain::AssetMetadata {

969

1

		name: b"RelayToken".to_vec(),

970

1

		symbol: b"Relay".to_vec(),

971

1

		decimals: 12,

972

1

};

973

974

1

	let dest: Location = Junction::AccountKey20 {

975

1

		network: None,

976

1

		key: PARAALICE,

977

1

978

1

	.into();

979

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

980

	// we know later we will divide by 1e12

981

	// Lets put 1e6 as units per second

982

1

	ParaA::execute_with(|| {

983

1

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

984

1

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

985

1

			.try_into()

986

1

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

987

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

988

1

			source_id,

989

1

			source_location_latest,

990

1

			asset_metadata.decimals,

991

1

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

992

1

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

993

));

994

1

		assert_ok!(add_supported_asset(

995

1

			source_location.clone(),

996

			2500000000000u128

997

));

998

1

});

999

1000

	// We are sending 100 tokens from relay.

1001

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

1002

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

1003

1

	Relay::execute_with(|| {

1004

1

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

1005

1

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

1006

1

			assets: Wild(All),

1007

1

			beneficiary: dest.clone(),

1008

1

		}]);

1009

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1010

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1011

1

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

1012

1

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

1013

1

			Box::new(TransferType::LocalReserve),

1014

1

			Box::new(fees_id),

1015

1

			Box::new(TransferType::LocalReserve),

1016

1

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

1017

1

			WeightLimit::Unlimited

1018

));

1019

1

});

1020

1021

1

	ParaA::execute_with(|| {

1022

		// amount not received as it is not paying enough

1023

1

		assert_eq!(

1024

1

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

1025

1

			Ok(U256::from(0))

1026

);

1027

1

});

1028

1

1029

1030

#[test]

1031

1

fn transact_through_derivative_multilocation() {

1032

1

	MockNet::reset();

1033

1034

1

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

1035

1

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

1036

1037

1

	let asset_metadata = parachain::AssetMetadata {

1038

1

		name: b"RelayToken".to_vec(),

1039

1

		symbol: b"Relay".to_vec(),

1040

1

		decimals: 12,

1041

1

};

1042

1043

1

	ParaA::execute_with(|| {

1044

1

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

1045

1

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

1046

1

			.try_into()

1047

1

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

1048

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1049

1

			source_id,

1050

1

			source_location_latest,

1051

1

			asset_metadata.decimals,

1052

1

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

1053

1

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

1054

));

1055

1

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

1056

1057

		// Root can set transact info

1058

1

		assert_ok!(XcmTransactor::set_transact_info(

1059

1

			parachain::RuntimeOrigin::root(),

1060

1

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

1061

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

1062

1

			3000.into(),

1063

1

			20000000000.into(),

1064

1

			None

1065

));

1066

		// Root can set transact info

1067

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

1068

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

1069

1

			.expect("must succeed");

1070

1

});

1071

1072

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

1073

1074

1

	let dest: Location = AccountKey20 {

1075

1

		network: None,

1076

1

		key: PARAALICE,

1077

1

1078

1

	.into();

1079

1

	Relay::execute_with(|| {

1080

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

1081

1

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

1082

1

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

1083

1

			assets: Wild(All),

1084

1

			beneficiary: dest.clone(),

1085

1

		}]);

1086

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1087

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1088

1

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

1089

1

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

1090

1

			Box::new(TransferType::LocalReserve),

1091

1

			Box::new(fees_id),

1092

1

			Box::new(TransferType::LocalReserve),

1093

1

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

1094

1

			WeightLimit::Unlimited

1095

));

1096

1

});

1097

1098

1

	ParaA::execute_with(|| {

1099

		// free execution, full amount received

1100

1

		assert_eq!(

1101

1

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

1102

1

			Ok(U256::from(4000003100u64))

1103

);

1104

1

});

1105

1106

	// Register address

1107

1

	ParaA::execute_with(|| {

1108

1

		assert_ok!(XcmTransactor::register(

1109

1

			parachain::RuntimeOrigin::root(),

1110

1

			PARAALICE.into(),

1111

0,

1112

));

1113

1

});

1114

1115

	// Send to registered address

1116

1117

1

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

1118

1

	let dest = Location {

1119

1

		parents: 1,

1120

1

		interior: [AccountId32 {

1121

1

			network: None,

1122

1

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

1123

1

}]

1124

1

		.into(),

1125

1

};

1126

1

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

1127

1128

1

	ParaA::execute_with(|| {

1129

1

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

1130

		// free execution, full amount received

1131

1

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

1132

1

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

1133

1

			assets: Wild(All),

1134

1

			beneficiary: beneficiary.clone(),

1135

1

		}]);

1136

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1137

1

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

1138

1

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

1139

1

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

1140

1

			Box::new(TransferType::DestinationReserve),

1141

1

			Box::new(fees_id),

1142

1

			Box::new(TransferType::DestinationReserve),

1143

1

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

1144

1

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

1145

));

1146

1

});

1147

1148

1

	ParaA::execute_with(|| {

1149

		// free execution, full amount received

1150

1

		assert_eq!(

1151

1

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

1152

1

			Ok(U256::from(4000003000u64))

1153

);

1154

1

});

1155

1156

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

1157

	// again

1158

1

	Relay::execute_with(|| {

1159

		// free execution,x	 full amount received

1160

1

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

1161

1

});

1162

1163

	// Encode the call. Balances transact to para_a_account

1164

	// First index

1165

1

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

1166

1

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

1167

1

		relay_chain::Balances,

1168

1

>()

1169

1

	.unwrap() as u8;

1170

1171

1

	encoded.push(index);

1172

1173

	// Then call bytes

1174

1

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

1175

1

		dest: para_a_account(),

1176

1

		value: 100u32.into(),

1177

1

1178

1

	.encode();

1179

1

	encoded.append(&mut call_bytes);

1180

1181

1

	ParaA::execute_with(|| {

1182

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1183

1

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

1184

1

			parachain::MockTransactors::Relay,

1185

0,

1186

1

			CurrencyPayment {

1187

1

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

1188

1

					Location::parent()

1189

1

				))),

1190

1

				fee_amount: None

1191

1

},

1192

1

			encoded,

1193

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

1194

1

			TransactWeights {

1195

1

				transact_required_weight_at_most: 4000000000.into(),

1196

1

				overall_weight: None

1197

1

},

1198

			false

1199

));

1200

1

});

1201

1202

1

	Relay::execute_with(|| {

1203

		// free execution,x	 full amount received

1204

1

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

1205

1206

1

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

1207

1

});

1208

1

1209

1210

#[test]

1211

1

fn transact_through_derivative_with_custom_fee_weight() {

1212

1

	MockNet::reset();

1213

1214

1

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

1215

1

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

1216

1217

1

	let asset_metadata = parachain::AssetMetadata {

1218

1

		name: b"RelayToken".to_vec(),

1219

1

		symbol: b"Relay".to_vec(),

1220

1

		decimals: 12,

1221

1

};

1222

1223

1

	ParaA::execute_with(|| {

1224

1

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

1225

1

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

1226

1

			.try_into()

1227

1

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

1228

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1229

1

			source_id,

1230

1

			source_location_latest,

1231

1

			asset_metadata.decimals,

1232

1

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

1233

1

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

1234

));

1235

1

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

1236

1

});

1237

1238

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

1239

1240

1

	let dest: Location = AccountKey20 {

1241

1

		network: None,

1242

1

		key: PARAALICE,

1243

1

1244

1

	.into();

1245

1

	Relay::execute_with(|| {

1246

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

1247

1

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

1248

1

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

1249

1

			assets: Wild(All),

1250

1

			beneficiary: dest.clone(),

1251

1

		}]);

1252

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1253

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1254

1

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

1255

1

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

1256

1

			Box::new(TransferType::LocalReserve),

1257

1

			Box::new(fees_id),

1258

1

			Box::new(TransferType::LocalReserve),

1259

1

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

1260

1

			WeightLimit::Unlimited

1261

));

1262

1

});

1263

1264

1

	ParaA::execute_with(|| {

1265

		// free execution, full amount received

1266

1

		assert_eq!(

1267

1

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

1268

1

			Ok(U256::from(4000003100u64))

1269

);

1270

1

});

1271

1272

	// Register address

1273

1

	ParaA::execute_with(|| {

1274

1

		assert_ok!(XcmTransactor::register(

1275

1

			parachain::RuntimeOrigin::root(),

1276

1

			PARAALICE.into(),

1277

0,

1278

));

1279

1

});

1280

1281

	// Send to registered address

1282

1283

1

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

1284

1

	let dest = Location {

1285

1

		parents: 1,

1286

1

		interior: [AccountId32 {

1287

1

			network: None,

1288

1

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

1289

1

}]

1290

1

		.into(),

1291

1

};

1292

1

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

1293

1294

1

	ParaA::execute_with(|| {

1295

1

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

1296

		// free execution, full amount received

1297

1

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

1298

1

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

1299

1

			assets: Wild(All),

1300

1

			beneficiary: beneficiary.clone(),

1301

1

		}]);

1302

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1303

1

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

1304

1

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

1305

1

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

1306

1

			Box::new(TransferType::DestinationReserve),

1307

1

			Box::new(fees_id),

1308

1

			Box::new(TransferType::DestinationReserve),

1309

1

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

1310

1

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

1311

));

1312

1

});

1313

1314

1

	ParaA::execute_with(|| {

1315

		// free execution, full amount received

1316

1

		assert_eq!(

1317

1

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

1318

1

			Ok(U256::from(4000003000u64))

1319

);

1320

1

});

1321

1322

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

1323

	// again

1324

1

	Relay::execute_with(|| {

1325

		// free execution,x	 full amount received

1326

1

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

1327

1

});

1328

1329

	// Encode the call. Balances transact to para_a_account

1330

	// First index

1331

1

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

1332

1

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

1333

1

		relay_chain::Balances,

1334

1

>()

1335

1

	.unwrap() as u8;

1336

1337

1

	encoded.push(index);

1338

1339

	// Then call bytes

1340

1

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

1341

1

		dest: para_a_account(),

1342

1

		value: 100u32.into(),

1343

1

1344

1

	.encode();

1345

1

	encoded.append(&mut call_bytes);

1346

1347

1

	let overall_weight = 4000003000u64;

1348

1

	ParaA::execute_with(|| {

1349

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1350

1

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

1351

1

			parachain::MockTransactors::Relay,

1352

0,

1353

1

			CurrencyPayment {

1354

1

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

1355

1

					Location::parent()

1356

1

				))),

1357

1

				// 1-1 fee weight mapping

1358

1

				fee_amount: Some(overall_weight as u128)

1359

1

},

1360

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

1361

1

			encoded,

1362

1

			TransactWeights {

1363

1

				transact_required_weight_at_most: 4000000000.into(),

1364

1

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

1365

1

},

1366

			false

1367

));

1368

1

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

1369

1

			.iter()

1370

18

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

1371

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

1372

..

1373

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

1374

18

				_ => None,

1375

18

});

1376

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

1377

1

		assert!(event_found.is_none());

1378

1

});

1379

1380

1

	Relay::execute_with(|| {

1381

		// free execution,x	 full amount received

1382

1

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

1383

1384

1

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

1385

1

});

1386

1

1387

1388

#[test]

1389

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1390

1

	MockNet::reset();

1391

1392

1

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

1393

1

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

1394

1395

1

	let asset_metadata = parachain::AssetMetadata {

1396

1

		name: b"RelayToken".to_vec(),

1397

1

		symbol: b"Relay".to_vec(),

1398

1

		decimals: 12,

1399

1

};

1400

1401

1

	ParaA::execute_with(|| {

1402

1

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

1403

1

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

1404

1

			.try_into()

1405

1

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

1406

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1407

1

			source_id,

1408

1

			source_location_latest,

1409

1

			asset_metadata.decimals,

1410

1

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

1411

1

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

1412

));

1413

1

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

1414

1

});

1415

1416

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

1417

1418

1

	let dest: Location = AccountKey20 {

1419

1

		network: None,

1420

1

		key: PARAALICE,

1421

1

1422

1

	.into();

1423

1

	Relay::execute_with(|| {

1424

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

1425

1

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

1426

1

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

1427

1

			assets: Wild(All),

1428

1

			beneficiary: dest.clone(),

1429

1

		}]);

1430

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1431

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1432

1

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

1433

1

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

1434

1

			Box::new(TransferType::LocalReserve),

1435

1

			Box::new(fees_id),

1436

1

			Box::new(TransferType::LocalReserve),

1437

1

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

1438

1

			WeightLimit::Unlimited

1439

));

1440

1

});

1441

1442

1

	ParaA::execute_with(|| {

1443

		// free execution, full amount received

1444

1

		assert_eq!(

1445

1

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

1446

1

			Ok(U256::from(4000009100u64))

1447

);

1448

1

});

1449

1450

	// Register address

1451

1

	ParaA::execute_with(|| {

1452

1

		assert_ok!(XcmTransactor::register(

1453

1

			parachain::RuntimeOrigin::root(),

1454

1

			PARAALICE.into(),

1455

0,

1456

));

1457

1

});

1458

1459

	// Send to registered address

1460

1461

1

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

1462

1

	let dest = Location {

1463

1

		parents: 1,

1464

1

		interior: [AccountId32 {

1465

1

			network: None,

1466

1

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

1467

1

}]

1468

1

		.into(),

1469

1

};

1470

1

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

1471

1472

1

	ParaA::execute_with(|| {

1473

1

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

1474

		// free execution, full amount received

1475

1

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

1476

1

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

1477

1

			assets: Wild(All),

1478

1

			beneficiary: beneficiary.clone(),

1479

1

		}]);

1480

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1481

1

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

1482

1

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

1483

1

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

1484

1

			Box::new(TransferType::DestinationReserve),

1485

1

			Box::new(fees_id),

1486

1

			Box::new(TransferType::DestinationReserve),

1487

1

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

1488

1

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

1489

));

1490

1

});

1491

1492

1

	ParaA::execute_with(|| {

1493

		// free execution, full amount received

1494

1

		assert_eq!(

1495

1

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

1496

1

			Ok(U256::from(4000009000u64))

1497

);

1498

1

});

1499

1500

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

1501

	// again

1502

1

	Relay::execute_with(|| {

1503

		// free execution,x	 full amount received

1504

1

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

1505

1

});

1506

1507

	// Encode the call. Balances transact to para_a_account

1508

	// First index

1509

1

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

1510

1

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

1511

1

		relay_chain::Balances,

1512

1

>()

1513

1

	.unwrap() as u8;

1514

1515

1

	encoded.push(index);

1516

1517

	// Then call bytes

1518

1

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

1519

1

		dest: para_a_account(),

1520

1

		value: 100u32.into(),

1521

1

1522

1

	.encode();

1523

1

	encoded.append(&mut call_bytes);

1524

1525

1

	let overall_weight = 4000009000u64;

1526

1

	ParaA::execute_with(|| {

1527

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1528

1

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

1529

1

			parachain::MockTransactors::Relay,

1530

0,

1531

1

			CurrencyPayment {

1532

1

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

1533

1

					Location::parent()

1534

1

				))),

1535

1

				// 1-1 fee weight mapping

1536

1

				fee_amount: Some(overall_weight as u128)

1537

1

},

1538

1

			encoded,

1539

1

			TransactWeights {

1540

1

				transact_required_weight_at_most: 4000000000.into(),

1541

1

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

1542

1

},

1543

			true

1544

));

1545

1

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

1546

1

			.iter()

1547

18

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

1548

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

1549

..

1550

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

1551

18

				_ => None,

1552

18

});

1553

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

1554

1

		assert!(event_found.is_none());

1555

1

});

1556

1557

1

	Relay::execute_with(|| {

1558

		// free execution,x	 full amount received

1559

		// 4000009000 refunded + 100 transferred = 4000009100

1560

1

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

1561

1

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

1562

1

});

1563

1

1564

1565

#[test]

1566

1

fn transact_through_sovereign() {

1567

1

	MockNet::reset();

1568

1569

1

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

1570

1

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

1571

1572

1

	let asset_metadata = parachain::AssetMetadata {

1573

1

		name: b"RelayToken".to_vec(),

1574

1

		symbol: b"Relay".to_vec(),

1575

1

		decimals: 12,

1576

1

};

1577

1578

1

	ParaA::execute_with(|| {

1579

1

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

1580

1

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

1581

1

			.try_into()

1582

1

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

1583

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1584

1

			source_id,

1585

1

			source_location_latest,

1586

1

			asset_metadata.decimals,

1587

1

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

1588

1

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

1589

));

1590

1

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

1591

1592

		// Root can set transact info

1593

1

		assert_ok!(XcmTransactor::set_transact_info(

1594

1

			parachain::RuntimeOrigin::root(),

1595

1

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

1596

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

1597

1

			3000.into(),

1598

1

			20000000000.into(),

1599

1

			None

1600

));

1601

		// Root can set transact info

1602

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

1603

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

1604

1

			.expect("must succeed");

1605

1

});

1606

1607

1

	let dest: Location = AccountKey20 {

1608

1

		network: None,

1609

1

		key: PARAALICE,

1610

1

1611

1

	.into();

1612

1

	Relay::execute_with(|| {

1613

1

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

1614

1

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

1615

1

			assets: Wild(All),

1616

1

			beneficiary: dest.clone(),

1617

1

		}]);

1618

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1619

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1620

1

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

1621

1

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

1622

1

			Box::new(TransferType::LocalReserve),

1623

1

			Box::new(fees_id),

1624

1

			Box::new(TransferType::LocalReserve),

1625

1

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

1626

1

			WeightLimit::Unlimited

1627

));

1628

1

});

1629

1630

1

	ParaA::execute_with(|| {

1631

		// free execution, full amount received

1632

1

		assert_eq!(

1633

1

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

1634

1

			Ok(U256::from(4000003100u64))

1635

);

1636

1

});

1637

1638

	// Register address

1639

1

	ParaA::execute_with(|| {

1640

1

		assert_ok!(XcmTransactor::register(

1641

1

			parachain::RuntimeOrigin::root(),

1642

1

			PARAALICE.into(),

1643

0,

1644

));

1645

1

});

1646

1647

	// Send to registered address

1648

1

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

1649

1

	let dest = Location {

1650

1

		parents: 1,

1651

1

		interior: [AccountId32 {

1652

1

			network: None,

1653

1

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

1654

1

}]

1655

1

		.into(),

1656

1

};

1657

1

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

1658

1659

1

	ParaA::execute_with(|| {

1660

1

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

1661

		// free execution, full amount received

1662

1

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

1663

1

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

1664

1

			assets: Wild(All),

1665

1

			beneficiary: beneficiary.clone(),

1666

1

		}]);

1667

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1668

1

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

1669

1

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

1670

1

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

1671

1

			Box::new(TransferType::DestinationReserve),

1672

1

			Box::new(fees_id),

1673

1

			Box::new(TransferType::DestinationReserve),

1674

1

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

1675

1

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

1676

));

1677

1

});

1678

1679

1

	ParaA::execute_with(|| {

1680

		// free execution, full amount received

1681

1

		assert_eq!(

1682

1

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

1683

1

			Ok(U256::from(4000003000u64))

1684

);

1685

1

});

1686

1687

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

1688

	// again

1689

1

	Relay::execute_with(|| {

1690

		// free execution,x	 full amount received

1691

1

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

1692

1

1693

1

});

1694

1695

	// We send the xcm transact operation to parent

1696

1

	let dest = Location {

1697

1

		parents: 1,

1698

1

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

1699

1

};

1700

1701

	// Encode the call. Balances transact to para_a_account

1702

	// First index

1703

1

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

1704

1

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

1705

1

		relay_chain::Balances,

1706

1

>()

1707

1

	.unwrap() as u8;

1708

1709

1

	encoded.push(index);

1710

1711

	// Then call bytes

1712

1

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

1713

1

		dest: para_a_account(),

1714

1

		value: 100u32.into(),

1715

1

1716

1

	.encode();

1717

1

	encoded.append(&mut call_bytes);

1718

1719

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

1720

1

	ParaA::execute_with(|| {

1721

1

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

1722

1

			parachain::MockTransactors::Relay,

1723

1

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

1724

);

1725

1726

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1727

1

			parachain::RuntimeOrigin::root(),

1728

1

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

1729

1

			Some(PARAALICE.into()),

1730

1

			CurrencyPayment {

1731

1

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

1732

1

					Location::parent()

1733

1

				))),

1734

1

				fee_amount: None

1735

1

},

1736

1

			utility_bytes,

1737

1

			OriginKind::SovereignAccount,

1738

1

			TransactWeights {

1739

1

				transact_required_weight_at_most: 4000000000.into(),

1740

1

				overall_weight: None

1741

1

},

1742

			false

1743

));

1744

1

});

1745

1746

1

	Relay::execute_with(|| {

1747

		// free execution,x	 full amount received

1748

1

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

1749

1750

1

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

1751

1

});

1752

1

1753

1754

#[test]

1755

1

fn transact_through_sovereign_fee_payer_none() {

1756

1

	MockNet::reset();

1757

1758

1

	ParaA::execute_with(|| {

1759

		// Root can set transact info

1760

1

		assert_ok!(XcmTransactor::set_transact_info(

1761

1

			parachain::RuntimeOrigin::root(),

1762

1

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

1763

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

1764

1

			3000.into(),

1765

1

			20000000000.into(),

1766

1

			None

1767

));

1768

		// Root can set transact info

1769

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

1770

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

1771

1

			.expect("must succeed");

1772

1

});

1773

1774

1

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

1775

1776

1

	Relay::execute_with(|| {

1777

		// Transfer 100 tokens to derivative_address on the relay

1778

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1779

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1780

1

			derivative_address.clone(),

1781

			100u128

1782

));

1783

1784

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

1785

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1786

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1787

1

			para_a_account(),

1788

			4000003000u128

1789

));

1790

1

});

1791

1792

	// Check balances before the transact call

1793

1

	Relay::execute_with(|| {

1794

1

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

1795

1

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

1796

1

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

1797

1

});

1798

1799

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

1800

1

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

1801

1

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

1802

1

		relay_chain::Balances,

1803

1

>()

1804

1

	.unwrap() as u8;

1805

1806

1

	encoded.push(index);

1807

1808

1

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

1809

1

		dest: RELAYBOB,

1810

1

		value: 100u32.into(),

1811

1

1812

1

	.encode();

1813

1

	encoded.append(&mut call_bytes);

1814

1815

	// We send the xcm transact operation to parent

1816

1

	let dest = Location {

1817

1

		parents: 1,

1818

1

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

1819

1

};

1820

1821

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

1822

1

	ParaA::execute_with(|| {

1823

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

1824

1

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

1825

1

			parachain::MockTransactors::Relay,

1826

1

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

1827

);

1828

1829

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1830

1

			parachain::RuntimeOrigin::root(),

1831

1

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

1832

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

1833

1

			None,

1834

1

			CurrencyPayment {

1835

1

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

1836

1

					Location::parent()

1837

1

				))),

1838

1

				fee_amount: None

1839

1

},

1840

1

			utility_bytes,

1841

1

			OriginKind::SovereignAccount,

1842

1

			TransactWeights {

1843

1

				transact_required_weight_at_most: 4000000000.into(),

1844

1

				overall_weight: None

1845

1

},

1846

			false

1847

));

1848

1

});

1849

1850

	// Check balances after the transact call are correct

1851

1

	Relay::execute_with(|| {

1852

1

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

1853

1

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

1854

1

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

1855

1

});

1856

1

1857

1858

#[test]

1859

1

fn transact_through_sovereign_with_custom_fee_weight() {

1860

1

	MockNet::reset();

1861

1862

1

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

1863

1

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

1864

1865

1

	let asset_metadata = parachain::AssetMetadata {

1866

1

		name: b"RelayToken".to_vec(),

1867

1

		symbol: b"Relay".to_vec(),

1868

1

		decimals: 12,

1869

1

};

1870

1871

1

	ParaA::execute_with(|| {

1872

1

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

1873

1

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

1874

1

			.try_into()

1875

1

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

1876

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1877

1

			source_id,

1878

1

			source_location_latest,

1879

1

			asset_metadata.decimals,

1880

1

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

1881

1

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

1882

));

1883

1

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

1884

1

});

1885

1886

1

	let dest: Location = AccountKey20 {

1887

1

		network: None,

1888

1

		key: PARAALICE,

1889

1

1890

1

	.into();

1891

1

	Relay::execute_with(|| {

1892

1

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

1893

1

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

1894

1

			assets: Wild(All),

1895

1

			beneficiary: dest.clone(),

1896

1

		}]);

1897

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1898

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1899

1

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

1900

1

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

1901

1

			Box::new(TransferType::LocalReserve),

1902

1

			Box::new(fees_id),

1903

1

			Box::new(TransferType::LocalReserve),

1904

1

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

1905

1

			WeightLimit::Unlimited

1906

));

1907

1

});

1908

1909

1

	ParaA::execute_with(|| {

1910

		// free execution, full amount received

1911

1

		assert_eq!(

1912

1

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

1913

1

			Ok(U256::from(4000003100u64))

1914

);

1915

1

});

1916

1917

	// Register address

1918

1

	ParaA::execute_with(|| {

1919

1

		assert_ok!(XcmTransactor::register(

1920

1

			parachain::RuntimeOrigin::root(),

1921

1

			PARAALICE.into(),

1922

0,

1923

));

1924

1

});

1925

1926

	// Send to registered address

1927

1

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

1928

1

	let dest = Location {

1929

1

		parents: 1,

1930

1

		interior: [AccountId32 {

1931

1

			network: None,

1932

1

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

1933

1

}]

1934

1

		.into(),

1935

1

};

1936

1

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

1937

1938

1

	ParaA::execute_with(|| {

1939

1

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

1940

		// free execution, full amount received

1941

1

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

1942

1

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

1943

1

			assets: Wild(All),

1944

1

			beneficiary: beneficiary.clone(),

1945

1

		}]);

1946

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1947

1

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

1948

1

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

1949

1

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

1950

1

			Box::new(TransferType::DestinationReserve),

1951

1

			Box::new(fees_id),

1952

1

			Box::new(TransferType::DestinationReserve),

1953

1

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

1954

1

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

1955

));

1956

1

});

1957

1958

1

	ParaA::execute_with(|| {

1959

		// free execution, full amount received

1960

1

		assert_eq!(

1961

1

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

1962

1

			Ok(U256::from(4000003000u64))

1963

);

1964

1

});

1965

1966

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

1967

	// again

1968

1

	Relay::execute_with(|| {

1969

		// free execution,x	 full amount received

1970

1

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

1971

1

1972

1

});

1973

1974

	// We send the xcm transact operation to parent

1975

1

	let dest = Location {

1976

1

		parents: 1,

1977

1

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

1978

1

};

1979

1980

	// Encode the call. Balances transact to para_a_account

1981

	// First index

1982

1

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

1983

1

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

1984

1

		relay_chain::Balances,

1985

1

>()

1986

1

	.unwrap() as u8;

1987

1988

1

	encoded.push(index);

1989

1990

	// Then call bytes

1991

1

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

1992

1

		dest: para_a_account(),

1993

1

		value: 100u32.into(),

1994

1

1995

1

	.encode();

1996

1

	encoded.append(&mut call_bytes);

1997

1998

1

	let total_weight = 4000003000u64;

1999

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

2000

1

	ParaA::execute_with(|| {

2001

1

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

2002

1

			parachain::MockTransactors::Relay,

2003

1

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

2004

);

2005

2006

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2007

1

			parachain::RuntimeOrigin::root(),

2008

1

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

2009

1

			Some(PARAALICE.into()),

2010

1

			CurrencyPayment {

2011

1

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

2012

1

					Location::parent()

2013

1

				))),

2014

1

				// 1-1 fee-weight mapping

2015

1

				fee_amount: Some(total_weight as u128)

2016

1

},

2017

1

			utility_bytes,

2018

1

			OriginKind::SovereignAccount,

2019

1

			TransactWeights {

2020

1

				transact_required_weight_at_most: 4000000000.into(),

2021

1

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

2022

1

},

2023

			false

2024

));

2025

1

});

2026

2027

1

	Relay::execute_with(|| {

2028

		// free execution,x	 full amount received

2029

1

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

2030

2031

1

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

2032

1

});

2033

1

2034

2035

#[test]

2036

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2037

1

	MockNet::reset();

2038

2039

1

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

2040

1

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

2041

2042

1

	let asset_metadata = parachain::AssetMetadata {

2043

1

		name: b"RelayToken".to_vec(),

2044

1

		symbol: b"Relay".to_vec(),

2045

1

		decimals: 12,

2046

1

};

2047

2048

1

	ParaA::execute_with(|| {

2049

1

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

2050

1

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

2051

1

			.try_into()

2052

1

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

2053

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2054

1

			source_id,

2055

1

			source_location_latest,

2056

1

			asset_metadata.decimals,

2057

1

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

2058

1

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

2059

));

2060

1

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

2061

1

});

2062

2063

1

	let dest: Location = AccountKey20 {

2064

1

		network: None,

2065

1

		key: PARAALICE,

2066

1

2067

1

	.into();

2068

1

	Relay::execute_with(|| {

2069

1

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

2070

1

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

2071

1

			assets: Wild(All),

2072

1

			beneficiary: dest.clone(),

2073

1

		}]);

2074

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2075

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2076

1

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

2077

1

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

2078

1

			Box::new(TransferType::LocalReserve),

2079

1

			Box::new(fees_id),

2080

1

			Box::new(TransferType::LocalReserve),

2081

1

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

2082

1

			WeightLimit::Unlimited

2083

));

2084

1

});

2085

2086

1

	ParaA::execute_with(|| {

2087

		// free execution, full amount received

2088

1

		assert_eq!(

2089

1

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

2090

1

			Ok(U256::from(4000009100u64))

2091

);

2092

1

});

2093

2094

	// Register address

2095

1

	ParaA::execute_with(|| {

2096

1

		assert_ok!(XcmTransactor::register(

2097

1

			parachain::RuntimeOrigin::root(),

2098

1

			PARAALICE.into(),

2099

0,

2100

));

2101

1

});

2102

2103

	// Send to registered address

2104

1

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

2105

1

	let dest = Location {

2106

1

		parents: 1,

2107

1

		interior: [AccountId32 {

2108

1

			network: None,

2109

1

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

2110

1

}]

2111

1

		.into(),

2112

1

};

2113

1

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

2114

2115

1

	ParaA::execute_with(|| {

2116

1

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

2117

		// free execution, full amount received

2118

1

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

2119

1

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

2120

1

			assets: Wild(All),

2121

1

			beneficiary: beneficiary.clone(),

2122

1

		}]);

2123

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2124

1

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

2125

1

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

2126

1

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

2127

1

			Box::new(TransferType::DestinationReserve),

2128

1

			Box::new(fees_id),

2129

1

			Box::new(TransferType::DestinationReserve),

2130

1

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

2131

1

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

2132

));

2133

1

});

2134

2135

1

	ParaA::execute_with(|| {

2136

		// free execution, full amount received

2137

1

		assert_eq!(

2138

1

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

2139

1

			Ok(U256::from(4000009000u64))

2140

);

2141

1

});

2142

2143

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

2144

	// again

2145

1

	Relay::execute_with(|| {

2146

		// free execution,x	 full amount received

2147

1

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

2148

1

2149

1

});

2150

2151

	// We send the xcm transact operation to parent

2152

1

	let dest = Location {

2153

1

		parents: 1,

2154

1

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

2155

1

};

2156

2157

	// Encode the call. Balances transact to para_a_account

2158

	// First index

2159

1

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

2160

1

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

2161

1

		relay_chain::Balances,

2162

1

>()

2163

1

	.unwrap() as u8;

2164

2165

1

	encoded.push(index);

2166

2167

	// Then call bytes

2168

1

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

2169

1

		dest: para_a_account(),

2170

1

		value: 100u32.into(),

2171

1

2172

1

	.encode();

2173

1

	encoded.append(&mut call_bytes);

2174

2175

1

	let total_weight = 4000009000u64;

2176

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

2177

1

	ParaA::execute_with(|| {

2178

1

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

2179

1

			parachain::MockTransactors::Relay,

2180

1

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

2181

);

2182

2183

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2184

1

			parachain::RuntimeOrigin::root(),

2185

1

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

2186

1

			Some(PARAALICE.into()),

2187

1

			CurrencyPayment {

2188

1

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

2189

1

					Location::parent()

2190

1

				))),

2191

1

				// 1-1 fee-weight mapping

2192

1

				fee_amount: Some(total_weight as u128)

2193

1

},

2194

1

			utility_bytes,

2195

1

			OriginKind::SovereignAccount,

2196

1

			TransactWeights {

2197

1

				transact_required_weight_at_most: 4000000000.into(),

2198

1

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

2199

1

},

2200

			true

2201

));

2202

1

});

2203

2204

1

	Relay::execute_with(|| {

2205

		// free execution, full amount received

2206

		// 4000009000 refunded + 100 transferred = 4000009100

2207

1

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

2208

2209

1

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

2210

1

});

2211

1

2212

2213

#[test]

2214

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2215

1

	MockNet::reset();

2216

2217

1

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

2218

1

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

2219

1

	let asset_metadata = parachain::AssetMetadata {

2220

1

		name: b"RelayToken".to_vec(),

2221

1

		symbol: b"Relay".to_vec(),

2222

1

		decimals: 12,

2223

1

};

2224

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

2225

1

	ParaA::execute_with(|| {

2226

1

		parachain::XcmVersioner::set_version(1);

2227

1

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

2228

1

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

2229

1

			.try_into()

2230

1

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

2231

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2232

1

			source_id,

2233

1

			source_location_latest,

2234

1

			asset_metadata.decimals,

2235

1

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

2236

1

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

2237

));

2238

1

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

2239

1

});

2240

2241

1

	let response = Response::Version(2);

2242

1

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

2243

2244

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

2245

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

2246

1

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

2247

1

		query_id: 0,

2248

1

		response,

2249

1

		max_weight: Weight::zero(),

2250

1

		querier: Some(querier),

2251

1

	}]);

2252

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

2253

	// it directly here

2254

	// Actually send relay asset to parachain

2255

1

	let dest: Location = AccountKey20 {

2256

1

		network: None,

2257

1

		key: PARAALICE,

2258

1

2259

1

	.into();

2260

2261

1

	Relay::execute_with(|| {

2262

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

2263

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2264

1

			relay_chain::RuntimeOrigin::root(),

2265

1

			Some(3)

2266

));

2267

2268

		// Wrap version, which sets VersionedStorage

2269

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

2270

		// this is not necessary in prod

2271

1

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

2272

1

			&Parachain(1).into(),

2273

1

			mock_message

2274

));

2275

2276

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

2277

1

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

2278

1

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

2279

1

			assets: Wild(All),

2280

1

			beneficiary: dest.clone(),

2281

1

		}]);

2282

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2283

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2284

1

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

2285

1

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

2286

1

			Box::new(TransferType::LocalReserve),

2287

1

			Box::new(fees_id),

2288

1

			Box::new(TransferType::LocalReserve),

2289

1

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

2290

1

			WeightLimit::Unlimited

2291

));

2292

2293

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

2294

1

		relay_chain::relay_roll_to(2);

2295

2296

		// queries should have been updated

2297

1

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

2298

1

});

2299

2300

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2301

1

		pallet_xcm::Event::SupportedVersionChanged {

2302

1

			location: Location {

2303

1

				parents: 0,

2304

1

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

2305

1

},

2306

1

			version: 1,

2307

1

2308

1

		.into();

2309

2310

1

	Relay::execute_with(|| {

2311

		// Assert that the events vector contains the version change

2312

1

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

2313

1

});

2314

2315

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

2316

	// of the new version change

2317

1

	ParaA::execute_with(|| {

2318

		// Set version

2319

1

		parachain::XcmVersioner::set_version(2);

2320

		// Do runtime upgrade

2321

1

		parachain::on_runtime_upgrade();

2322

		// Initialize block, to call on_initialize and notify targets

2323

1

		parachain::para_roll_to(2);

2324

		// Expect the event in the parachain

2325

1

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

2326

2

e,

2327

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

2328

				result: 2,

2329

..

2330

})

2331

		)));

2332

1

});

2333

2334

	// This event should have been seen in the relay

2335

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2336

1

		pallet_xcm::Event::SupportedVersionChanged {

2337

1

			location: Location {

2338

1

				parents: 0,

2339

1

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

2340

1

},

2341

1

			version: 2,

2342

1

2343

1

		.into();

2344

2345

1

	Relay::execute_with(|| {

2346

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

2347

1

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

2348

1

});

2349

1

2350

2351

#[test]

2352

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2353

1

	MockNet::reset();

2354

2355

1

	let fresh_account = PARABOB;

2356

1

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

2357

1

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

2358

1

	let asset_metadata = parachain::AssetMetadata {

2359

1

		name: b"RelayToken".to_vec(),

2360

1

		symbol: b"Relay".to_vec(),

2361

1

		decimals: 12,

2362

1

};

2363

	// register relay asset in parachain A

2364

1

	ParaA::execute_with(|| {

2365

1

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

2366

1

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

2367

1

			.try_into()

2368

1

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

2369

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2370

1

			source_id,

2371

1

			source_location_latest,

2372

1

			asset_metadata.decimals,

2373

1

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

2374

1

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

2375

));

2376

1

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

2377

1

});

2378

2379

	// Actually send relay asset to parachain

2380

1

	let dest: Location = AccountKey20 {

2381

1

		network: None,

2382

1

		key: fresh_account,

2383

1

2384

1

	.into();

2385

1

	Relay::execute_with(|| {

2386

1

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

2387

1

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

2388

1

			assets: Wild(All),

2389

1

			beneficiary: dest.clone(),

2390

1

		}]);

2391

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2392

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2393

1

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

2394

1

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

2395

1

			Box::new(TransferType::LocalReserve),

2396

1

			Box::new(fees_id),

2397

1

			Box::new(TransferType::LocalReserve),

2398

1

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

2399

1

			WeightLimit::Unlimited

2400

));

2401

1

});

2402

2403

	// parachain should have received assets

2404

1

	ParaA::execute_with(|| {

2405

		// free execution, full amount received

2406

1

		assert_eq!(

2407

1

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

2408

1

			Ok(U256::from(123))

2409

);

2410

1

});

2411

1

2412

2413

#[test]

2414

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2415

1

	MockNet::reset();

2416

2417

1

	let fresh_account = [2u8; 20];

2418

1

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

2419

1

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

2420

1

	let asset_metadata = parachain::AssetMetadata {

2421

1

		name: b"RelayToken".to_vec(),

2422

1

		symbol: b"Relay".to_vec(),

2423

1

		decimals: 12,

2424

1

};

2425

	// register relay asset in parachain A

2426

1

	ParaA::execute_with(|| {

2427

1

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

2428

1

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

2429

1

			.try_into()

2430

1

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

2431

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2432

1

			source_id,

2433

1

			source_location_latest,

2434

1

			asset_metadata.decimals,

2435

1

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

2436

1

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

2437

));

2438

1

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

2439

1

});

2440

2441

	// Actually send relay asset to parachain

2442

1

	let dest: Location = AccountKey20 {

2443

1

		network: None,

2444

1

		key: fresh_account,

2445

1

2446

1

	.into();

2447

1

	Relay::execute_with(|| {

2448

1

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

2449

1

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

2450

1

			assets: Wild(All),

2451

1

			beneficiary: dest.clone(),

2452

1

		}]);

2453

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2454

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2455

1

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

2456

1

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

2457

1

			Box::new(TransferType::LocalReserve),

2458

1

			Box::new(fees_id),

2459

1

			Box::new(TransferType::LocalReserve),

2460

1

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

2461

1

			WeightLimit::Unlimited

2462

));

2463

1

});

2464

2465

	// parachain should have received assets

2466

1

	ParaA::execute_with(|| {

2467

		// free execution, full amount received

2468

1

		assert_eq!(

2469

1

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

2470

1

			Ok(U256::from(123))

2471

);

2472

1

});

2473

1

2474

2475

#[test]

2476

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2477

1

	MockNet::reset();

2478

2479

1

	let mut sufficient_account = [0u8; 20];

2480

1

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

2481

2482

1

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

2483

2484

	// Evm account is self sufficient

2485

1

	ParaA::execute_with(|| {

2486

1

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

2487

1

});

2488

2489

1

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

2490

1

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

2491

1

	let asset_metadata = parachain::AssetMetadata {

2492

1

		name: b"RelayToken".to_vec(),

2493

1

		symbol: b"Relay".to_vec(),

2494

1

		decimals: 12,

2495

1

};

2496

	// register relay asset in parachain A

2497

1

	ParaA::execute_with(|| {

2498

1

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

2499

1

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

2500

1

			.try_into()

2501

1

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

2502

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2503

1

			source_id,

2504

1

			source_location_latest,

2505

1

			asset_metadata.decimals,

2506

1

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

2507

1

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

2508

));

2509

1

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

2510

1

});

2511

2512

	// Actually send relay asset to parachain

2513

1

	let dest: Location = AccountKey20 {

2514

1

		network: None,

2515

1

		key: sufficient_account,

2516

1

2517

1

	.into();

2518

1

	Relay::execute_with(|| {

2519

1

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

2520

1

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

2521

1

			assets: Wild(All),

2522

1

			beneficiary: dest.clone(),

2523

1

		}]);

2524

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2525

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2526

1

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

2527

1

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

2528

1

			Box::new(TransferType::LocalReserve),

2529

1

			Box::new(fees_id),

2530

1

			Box::new(TransferType::LocalReserve),

2531

1

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

2532

1

			WeightLimit::Unlimited

2533

));

2534

1

});

2535

2536

	// Evm account sufficient ref count increased by 1.

2537

1

	ParaA::execute_with(|| {

2538

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

2539

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

2540

		// will be implemented in a future release

2541

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

2542

1

});

2543

2544

1

	ParaA::execute_with(|| {

2545

		// Remove the account from the evm context.

2546

1

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

2547

		// Evm account sufficient ref count decreased by 1.

2548

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

2549

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

2550

		// will be implemented in a future release

2551

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

2552

1

});

2553

1

2554

2555

#[test]

2556

1

fn empty_account_should_not_be_reset() {

2557

1

	MockNet::reset();

2558

2559

	// Test account has nonce 1 on genesis.

2560

1

	let sufficient_account = PARABOB;

2561

2562

1

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

2563

2564

1

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

2565

1

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

2566

1

	let asset_metadata = parachain::AssetMetadata {

2567

1

		name: b"RelayToken".to_vec(),

2568

1

		symbol: b"Relay".to_vec(),

2569

1

		decimals: 12,

2570

1

};

2571

	// register relay asset in parachain A

2572

1

	ParaA::execute_with(|| {

2573

1

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

2574

1

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

2575

1

			.try_into()

2576

1

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

2577

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2578

1

			source_id,

2579

1

			source_location_latest,

2580

1

			asset_metadata.decimals,

2581

1

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

2582

1

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

2583

));

2584

1

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

2585

1

});

2586

2587

	// Send native token to evm_account

2588

1

	ParaA::execute_with(|| {

2589

1

		assert_ok!(ParaBalances::transfer_allow_death(

2590

1

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

2591

1

			evm_account_id,

2592

2593

));

2594

1

});

2595

2596

	// Actually send relay asset to parachain

2597

1

	let dest: Location = AccountKey20 {

2598

1

		network: None,

2599

1

		key: sufficient_account,

2600

1

2601

1

	.into();

2602

1

	Relay::execute_with(|| {

2603

1

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

2604

1

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

2605

1

			assets: Wild(All),

2606

1

			beneficiary: dest.clone(),

2607

1

		}]);

2608

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2609

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2610

1

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

2611

1

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

2612

1

			Box::new(TransferType::LocalReserve),

2613

1

			Box::new(fees_id),

2614

1

			Box::new(TransferType::LocalReserve),

2615

1

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

2616

1

			WeightLimit::Unlimited

2617

));

2618

1

});

2619

2620

1

	ParaA::execute_with(|| {

2621

		// Empty the assets from the account.

2622

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

2623

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

2624

		// Transfer using EvmForeignAssets

2625

1

		assert_ok!(EvmForeignAssets::transfer(

2626

1

			source_id,

2627

1

			evm_account_id,

2628

1

			PARAALICE.into(),

2629

1

			U256::from(123)

2630

));

2631

		// Verify account asset balance is Zero.

2632

1

		assert_eq!(

2633

1

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

2634

1

			Ok(U256::from(0))

2635

);

2636

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

2637

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

2638

1

		assert_ok!(ParaBalances::force_set_balance(

2639

1

			parachain::RuntimeOrigin::root(),

2640

1

			evm_account_id,

2641

0,

2642

));

2643

		// Verify account native balance is Zero.

2644

1

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

2645

		// Remove the account from the evm context.

2646

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

2647

1

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

2648

		// Verify reference count.

2649

1

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

2650

1

		assert_eq!(account.sufficients, 0);

2651

1

		assert_eq!(account.consumers, 0);

2652

1

		assert_eq!(account.providers, 1);

2653

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

2654

1

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

2655

1

});

2656

1

2657

2658

#[test]

2659

1

fn test_statemint_like() {

2660

1

	MockNet::reset();

2661

2662

1

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

2663

2664

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2665

1

		polkadot_parachain::primitives::Sibling,

2666

1

		statemint_like::AccountId,

2667

1

	>::convert_location(&dest_para)

2668

1

	.unwrap();

2669

2670

1

	let statemint_asset_a_balances = Location::new(

2671

1,

2672

1

2673

1

			Parachain(1000),

2674

1

			PalletInstance(5),

2675

1

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

2676

1

],

2677

);

2678

1

	let source_location: AssetType = statemint_asset_a_balances

2679

1

		.try_into()

2680

1

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

2681

1

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

2682

2683

1

	let asset_metadata = parachain::AssetMetadata {

2684

1

		name: b"StatemintToken".to_vec(),

2685

1

		symbol: b"StatemintToken".to_vec(),

2686

1

		decimals: 12,

2687

1

};

2688

2689

1

	ParaA::execute_with(|| {

2690

1

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

2691

1

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

2692

1

			.try_into()

2693

1

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

2694

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2695

1

			source_id,

2696

1

			source_location_latest,

2697

1

			asset_metadata.decimals,

2698

1

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

2699

1

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

2700

));

2701

1

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

2702

1

});

2703

2704

1

	Statemint::execute_with(|| {

2705

		// Set new prefix

2706

1

		statemint_like::PrefixChanger::set_prefix(

2707

1

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

2708

);

2709

2710

1

		assert_ok!(StatemintAssets::create(

2711

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2712

0,

2713

			RELAYALICE,

2714

2715

));

2716

2717

1

		assert_ok!(StatemintAssets::mint(

2718

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2719

0,

2720

			RELAYALICE,

2721

			300000000000000

2722

));

2723

2724

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

2725

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2726

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2727

1

			sov,

2728

			100000000000000

2729

));

2730

2731

		// Actually send relay asset to parachain

2732

1

		let dest: Location = AccountKey20 {

2733

1

			network: None,

2734

1

			key: PARAALICE,

2735

1

2736

1

		.into();

2737

2738

		// Send with new prefix

2739

1

		let assets: VersionedAssets = (

2740

1

2741

1

				xcm::latest::prelude::PalletInstance(

2742

1

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

2743

1

),

2744

1

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

2745

1

],

2746

1

			123,

2747

1

2748

1

			.into();

2749

1

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

2750

1

0,

2751

1

2752

1

				xcm::latest::prelude::PalletInstance(

2753

1

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

2754

1

),

2755

1

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

2756

1

],

2757

1

))

2758

1

		.into();

2759

1

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

2760

1

			assets: Wild(All),

2761

1

			beneficiary: dest.clone(),

2762

1

		}]);

2763

1

		assert_ok!(

2764

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

2765

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

2766

1

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

2767

1

				Box::new(assets),

2768

1

				Box::new(TransferType::LocalReserve),

2769

1

				Box::new(fees_id),

2770

1

				Box::new(TransferType::LocalReserve),

2771

1

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

2772

1

				WeightLimit::Unlimited

2773

2774

);

2775

1

});

2776

2777

1

	ParaA::execute_with(|| {

2778

1

		assert_eq!(

2779

1

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

2780

1

			Ok(U256::from(123))

2781

);

2782

1

});

2783

1

2784

2785

#[test]

2786

2787

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2788

1

	MockNet::reset();

2789

2790

	// Relay asset

2791

1

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

2792

1

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

2793

2794

1

	let relay_asset_metadata = parachain::AssetMetadata {

2795

1

		name: b"RelayToken".to_vec(),

2796

1

		symbol: b"Relay".to_vec(),

2797

1

		decimals: 12,

2798

1

};

2799

2800

	// Statemint asset

2801

1

	let statemint_asset = Location::new(

2802

1,

2803

1

2804

1

			Parachain(1000u32),

2805

1

			PalletInstance(5u8),

2806

1

			GeneralIndex(10u128),

2807

1

],

2808

);

2809

1

	let statemint_location_asset: AssetType = statemint_asset

2810

1

		.clone()

2811

1

		.try_into()

2812

1

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

2813

1

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

2814

2815

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2816

1

		name: b"USDC".to_vec(),

2817

1

		symbol: b"USDC".to_vec(),

2818

1

		decimals: 12,

2819

1

};

2820

2821

1

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

2822

2823

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2824

1

		polkadot_parachain::primitives::Sibling,

2825

1

		statemint_like::AccountId,

2826

1

	>::convert_location(&dest_para)

2827

1

	.unwrap();

2828

2829

1

	ParaA::execute_with(|| {

2830

1

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

2831

1

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

2832

1

			.try_into()

2833

1

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

2834

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2835

1

			source_relay_id,

2836

1

			source_location_latest,

2837

1

			relay_asset_metadata.decimals,

2838

1

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

2839

1

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

2840

));

2841

1

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

2842

2843

1

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

2844

1

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

2845

1

			.try_into()

2846

1

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

2847

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2848

1

			source_statemint_asset_id,

2849

1

			source_location_latest,

2850

1

			asset_metadata_statemint_asset.decimals,

2851

1

			asset_metadata_statemint_asset

2852

1

				.symbol

2853

1

				.try_into()

2854

1

				.expect("too long"),

2855

1

			asset_metadata_statemint_asset

2856

1

				.name

2857

1

				.try_into()

2858

1

				.expect("too long"),

2859

));

2860

1

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

2861

1

});

2862

2863

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2864

1

		network: None,

2865

1

		key: PARAALICE,

2866

1

2867

1

	.into();

2868

2869

	// Send relay chain asset to Alice in Parachain A

2870

1

	Relay::execute_with(|| {

2871

1

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

2872

1

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

2873

1

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

2874

1

			assets: Wild(All),

2875

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

2876

1

		}]);

2877

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2878

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2879

1

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

2880

1

			Box::new(assets),

2881

1

			Box::new(TransferType::LocalReserve),

2882

1

			Box::new(fees_id),

2883

1

			Box::new(TransferType::LocalReserve),

2884

1

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

2885

1

			WeightLimit::Unlimited

2886

));

2887

1

});

2888

2889

1

	Statemint::execute_with(|| {

2890

		// Set new prefix

2891

1

		statemint_like::PrefixChanger::set_prefix(

2892

1

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

2893

);

2894

2895

1

		assert_ok!(StatemintAssets::create(

2896

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2897

10,

2898

			RELAYALICE,

2899

2900

));

2901

2902

1

		assert_ok!(StatemintAssets::mint(

2903

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2904

10,

2905

			RELAYALICE,

2906

			300000000000000

2907

));

2908

2909

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

2910

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

2911

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2912

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2913

1

			sov,

2914

			100000000000000

2915

));

2916

2917

		// Send statemint USDC asset to Alice in Parachain A

2918

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2919

1

			network: None,

2920

1

			key: PARAALICE,

2921

1

2922

1

		.into();

2923

2924

		// Send with new prefix

2925

1

		let assets: VersionedAssets = (

2926

1

2927

1

				xcm::latest::prelude::PalletInstance(

2928

1

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

2929

1

),

2930

1

				GeneralIndex(10),

2931

1

],

2932

1

			125,

2933

1

2934

1

			.into();

2935

1

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

2936

1

0,

2937

1

2938

1

				xcm::latest::prelude::PalletInstance(

2939

1

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

2940

1

),

2941

1

				GeneralIndex(10),

2942

1

],

2943

1

))

2944

1

		.into();

2945

1

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

2946

1

			assets: Wild(All),

2947

1

			beneficiary: parachain_beneficiary_from_statemint.clone(),

2948

1

		}]);

2949

1

		assert_ok!(

2950

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

2951

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

2952

1

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

2953

1

				Box::new(assets),

2954

1

				Box::new(TransferType::LocalReserve),

2955

1

				Box::new(fees_id),

2956

1

				Box::new(TransferType::LocalReserve),

2957

1

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

2958

1

				WeightLimit::Unlimited

2959

2960

);

2961

1

});

2962

2963

1

	let statemint_beneficiary = Location {

2964

1

		parents: 1,

2965

1

		interior: [

2966

1

			Parachain(1000),

2967

1

			AccountId32 {

2968

1

				network: None,

2969

1

				id: RELAYBOB.into(),

2970

1

},

2971

1

2972

1

		.into(),

2973

1

};

2974

2975

1

	ParaA::execute_with(|| {

2976

		// Alice has received 125 USDC

2977

1

		assert_eq!(

2978

1

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

2979

1

			Ok(U256::from(125))

2980

);

2981

2982

		// Alice has received 200 Relay assets

2983

1

		assert_eq!(

2984

1

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

2985

1

			Ok(U256::from(200))

2986

);

2987

1

});

2988

2989

1

	Statemint::execute_with(|| {

2990

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

2991

1

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

2992

1

});

2993

1

	let (chain_part, beneficiary) =

2994

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2995

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

2996

1

	ParaA::execute_with(|| {

2997

1

		let asset = currency_to_asset(

2998

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2999

			100,

3000

);

3001

1

		let asset_fee =

3002

1

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

3003

1

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

3004

1

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

3005

3006

1

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

3007

1

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

3008

1

			assets: Wild(All),

3009

1

			beneficiary: beneficiary.clone(),

3010

1

		}]);

3011

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3012

1

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

3013

1

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

3014

1

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

3015

1

			Box::new(TransferType::DestinationReserve),

3016

1

			Box::new(fees_id),

3017

1

			Box::new(TransferType::DestinationReserve),

3018

1

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

3019

1

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

3020

));

3021

1

});

3022

3023

1

	ParaA::execute_with(|| {

3024

		// Alice has 100 USDC less

3025

1

		assert_eq!(

3026

1

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

3027

1

			Ok(U256::from(25))

3028

);

3029

3030

		// Alice has 100 relay asset less

3031

1

		assert_eq!(

3032

1

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

3033

1

			Ok(U256::from(100))

3034

);

3035

1

});

3036

3037

1

	Statemint::execute_with(|| {

3038

1

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

3039

		// Check that BOB received 100 USDC on statemint

3040

1

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

3041

1

});

3042

1

3043

3044

#[test]

3045

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3046

1

	MockNet::reset();

3047

3048

	// Relay asset

3049

1

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

3050

1

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

3051

3052

1

	let relay_asset_metadata = parachain::AssetMetadata {

3053

1

		name: b"RelayToken".to_vec(),

3054

1

		symbol: b"Relay".to_vec(),

3055

1

		decimals: 12,

3056

1

};

3057

3058

1

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

3059

3060

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3061

1

		polkadot_parachain::primitives::Sibling,

3062

1

		statemint_like::AccountId,

3063

1

	>::convert_location(&dest_para)

3064

1

	.unwrap();

3065

3066

1

	ParaA::execute_with(|| {

3067

1

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

3068

1

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

3069

1

			.try_into()

3070

1

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

3071

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3072

1

			source_relay_id,

3073

1

			source_location_latest,

3074

1

			relay_asset_metadata.decimals,

3075

1

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

3076

1

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

3077

));

3078

1

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

3079

1

});

3080

3081

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3082

1

		network: None,

3083

1

		key: PARAALICE,

3084

1

3085

1

	.into();

3086

3087

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3088

1

		network: None,

3089

1

		id: RELAYALICE.into(),

3090

1

3091

1

	.into();

3092

3093

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

3094

1

	Relay::execute_with(|| {

3095

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3096

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3097

1

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

3098

1

			Box::new(

3099

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3100

1

					.clone()

3101

1

					.into()

3102

),

3103

1

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

3104

0,

3105

1

			WeightLimit::Unlimited

3106

));

3107

1

});

3108

3109

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3110

1

	Statemint::execute_with(|| {

3111

		// Check Alice received 200 tokens on AssetHub

3112

1

		assert_eq!(

3113

1

			StatemintBalances::free_balance(RELAYALICE),

3114

			INITIAL_BALANCE + 200

3115

);

3116

3117

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3118

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3119

1

			sov,

3120

			110000000000000

3121

));

3122

3123

		// Now send those tokens to ParaA

3124

1

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

3125

1

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

3126

1

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

3127

1

			assets: Wild(All),

3128

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3129

1

		}]);

3130

1

		assert_ok!(

3131

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3132

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3133

1

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

3134

1

				Box::new(assets),

3135

1

				Box::new(TransferType::LocalReserve),

3136

1

				Box::new(fees_id),

3137

1

				Box::new(TransferType::LocalReserve),

3138

1

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

3139

1

				WeightLimit::Unlimited

3140

3141

);

3142

1

});

3143

3144

1

	ParaA::execute_with(|| {

3145

		// Alice should have received the DOTs

3146

1

		assert_eq!(

3147

1

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

3148

1

			Ok(U256::from(200))

3149

);

3150

1

});

3151

3152

1

	let dest = Location::new(

3153

1,

3154

1

3155

1

			Parachain(1000),

3156

1

			AccountId32 {

3157

1

				network: None,

3158

1

				id: RELAYBOB.into(),

3159

1

},

3160

1

],

3161

);

3162

1

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

3163

3164

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

3165

1

	ParaA::execute_with(|| {

3166

1

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

3167

1

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

3168

1

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

3169

1

			assets: Wild(All),

3170

1

			beneficiary: beneficiary.clone(),

3171

1

		}]);

3172

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3173

1

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

3174

1

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

3175

1

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

3176

1

			Box::new(TransferType::DestinationReserve),

3177

1

			Box::new(fees_id),

3178

1

			Box::new(TransferType::DestinationReserve),

3179

1

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

3180

1

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

3181

));

3182

3183

1

		assert_eq!(

3184

1

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

3185

1

			Ok(U256::from(100))

3186

);

3187

1

});

3188

3189

1

	Statemint::execute_with(|| {

3190

		// Check that Bob received the tokens back in AssetHub

3191

1

		assert_eq!(

3192

1

			StatemintBalances::free_balance(RELAYBOB),

3193

			INITIAL_BALANCE + 100

3194

);

3195

1

});

3196

3197

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

3198

1

	Statemint::execute_with(|| {

3199

		// Now send those tokens to ParaA

3200

1

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

3201

1

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

3202

1

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

3203

1

			assets: Wild(All),

3204

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3205

1

		}]);

3206

1

		assert_ok!(

3207

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3208

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3209

1

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

3210

1

				Box::new(assets),

3211

1

				Box::new(TransferType::LocalReserve),

3212

1

				Box::new(fees_id),

3213

1

				Box::new(TransferType::LocalReserve),

3214

1

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

3215

1

				WeightLimit::Unlimited

3216

3217

);

3218

3219

		// 100 DOTs were deducted from Bob's account

3220

1

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

3221

1

});

3222

3223

1

	ParaA::execute_with(|| {

3224

		// Alice should have received 100 DOTs

3225

1

		assert_eq!(

3226

1

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

3227

1

			Ok(U256::from(200))

3228

);

3229

1

});

3230

1

3231

3232

#[test]

3233

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3234

1

	MockNet::reset();

3235

3236

	// Relay asset

3237

1

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

3238

1

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

3239

3240

1

	let relay_asset_metadata = parachain::AssetMetadata {

3241

1

		name: b"RelayToken".to_vec(),

3242

1

		symbol: b"Relay".to_vec(),

3243

1

		decimals: 12,

3244

1

};

3245

3246

1

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

3247

3248

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3249

1

		polkadot_parachain::primitives::Sibling,

3250

1

		statemint_like::AccountId,

3251

1

	>::convert_location(&dest_para)

3252

1

	.unwrap();

3253

3254

1

	ParaA::execute_with(|| {

3255

1

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

3256

1

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

3257

1

			.try_into()

3258

1

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

3259

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3260

1

			source_relay_id,

3261

1

			source_location_latest,

3262

1

			relay_asset_metadata.decimals,

3263

1

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

3264

1

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

3265

));

3266

1

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

3267

1

});

3268

3269

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3270

1

		network: None,

3271

1

		key: PARAALICE,

3272

1

3273

1

	.into();

3274

3275

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3276

1

		network: None,

3277

1

		id: RELAYALICE.into(),

3278

1

3279

1

	.into();

3280

3281

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

3282

1

	Relay::execute_with(|| {

3283

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3284

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3285

1

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

3286

1

			Box::new(

3287

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3288

1

					.clone()

3289

1

					.into()

3290

),

3291

1

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

3292

0,

3293

1

			WeightLimit::Unlimited

3294

));

3295

1

});

3296

3297

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3298

1

	Statemint::execute_with(|| {

3299

		// Check Alice received 200 tokens on AssetHub

3300

1

		assert_eq!(

3301

1

			StatemintBalances::free_balance(RELAYALICE),

3302

			INITIAL_BALANCE + 200

3303

);

3304

3305

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3306

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3307

1

			sov,

3308

			110000000000000

3309

));

3310

3311

		// Now send those tokens to ParaA

3312

1

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

3313

1

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

3314

1

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

3315

1

			assets: Wild(All),

3316

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3317

1

		}]);

3318

1

		assert_ok!(

3319

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3320

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3321

1

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

3322

1

				Box::new(assets),

3323

1

				Box::new(TransferType::LocalReserve),

3324

1

				Box::new(fees_id),

3325

1

				Box::new(TransferType::LocalReserve),

3326

1

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

3327

1

				WeightLimit::Unlimited

3328

3329

);

3330

1

});

3331

3332

1

	ParaA::execute_with(|| {

3333

		// Alice should have received the DOTs

3334

1

		assert_eq!(

3335

1

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

3336

1

			Ok(U256::from(200))

3337

);

3338

1

});

3339

3340

1

	let dest = Location::new(

3341

1,

3342

1

3343

1

			Parachain(1000),

3344

1

			AccountId32 {

3345

1

				network: None,

3346

1

				id: RELAYBOB.into(),

3347

1

},

3348

1

],

3349

);

3350

1

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

3351

3352

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

3353

1

	ParaA::execute_with(|| {

3354

1

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

3355

1

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

3356

1

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

3357

1

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

3358

1

			assets: Wild(All),

3359

1

			beneficiary: beneficiary.clone(),

3360

1

		}]);

3361

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3362

1

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

3363

1

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

3364

1

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

3365

1

			Box::new(TransferType::DestinationReserve),

3366

1

			Box::new(fees_id),

3367

1

			Box::new(TransferType::DestinationReserve),

3368

1

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

3369

1

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

3370

));

3371

3372

1

		assert_eq!(

3373

1

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

3374

1

			Ok(U256::from(90))

3375

);

3376

1

});

3377

3378

1

	Statemint::execute_with(|| {

3379

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

3380

1

		assert_eq!(

3381

1

			StatemintBalances::free_balance(RELAYBOB),

3382

			INITIAL_BALANCE + 110

3383

);

3384

1

});

3385

3386

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

3387

1

	Statemint::execute_with(|| {

3388

		// Now send those tokens to ParaA

3389

1

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

3390

1

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

3391

1

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

3392

1

			assets: Wild(All),

3393

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3394

1

		}]);

3395

1

		assert_ok!(

3396

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3397

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3398

1

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

3399

1

				Box::new(assets),

3400

1

				Box::new(TransferType::LocalReserve),

3401

1

				Box::new(fees_id),

3402

1

				Box::new(TransferType::LocalReserve),

3403

1

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

3404

1

				WeightLimit::Unlimited

3405

3406

);

3407

3408

		// 100 DOTs were deducted from Bob's account

3409

1

		assert_eq!(

3410

1

			StatemintBalances::free_balance(RELAYBOB),

3411

			INITIAL_BALANCE + 10

3412

);

3413

1

});

3414

3415

1

	ParaA::execute_with(|| {

3416

		// Alice should have received 100 DOTs

3417

1

		assert_eq!(

3418

1

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

3419

1

			Ok(U256::from(190))

3420

);

3421

1

});

3422

1

3423

3424

#[test]

3425

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3426

1

	MockNet::reset();

3427

3428

	// Relay asset

3429

1

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

3430

1

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

3431

3432

1

	let relay_asset_metadata = parachain::AssetMetadata {

3433

1

		name: b"RelayToken".to_vec(),

3434

1

		symbol: b"Relay".to_vec(),

3435

1

		decimals: 12,

3436

1

};

3437

3438

1

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

3439

3440

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3441

1

		polkadot_parachain::primitives::Sibling,

3442

1

		statemint_like::AccountId,

3443

1

	>::convert_location(&dest_para)

3444

1

	.unwrap();

3445

3446

1

	ParaA::execute_with(|| {

3447

1

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

3448

1

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

3449

1

			.try_into()

3450

1

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

3451

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3452

1

			source_relay_id,

3453

1

			source_location_latest,

3454

1

			relay_asset_metadata.decimals,

3455

1

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

3456

1

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

3457

));

3458

1

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

3459

1

});

3460

3461

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3462

1

		network: None,

3463

1

		key: PARAALICE,

3464

1

3465

1

	.into();

3466

3467

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3468

1

		network: None,

3469

1

		id: RELAYALICE.into(),

3470

1

3471

1

	.into();

3472

3473

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

3474

1

	Relay::execute_with(|| {

3475

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3476

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3477

1

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

3478

1

			Box::new(

3479

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3480

1

					.clone()

3481

1

					.into()

3482

),

3483

1

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

3484

0,

3485

1

			WeightLimit::Unlimited

3486

));

3487

1

});

3488

3489

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3490

1

	Statemint::execute_with(|| {

3491

		// Check Alice received 200 tokens on AssetHub

3492

1

		assert_eq!(

3493

1

			StatemintBalances::free_balance(RELAYALICE),

3494

			INITIAL_BALANCE + 200

3495

);

3496

3497

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3498

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3499

1

			sov,

3500

			110000000000000

3501

));

3502

3503

		// Now send those tokens to ParaA

3504

1

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

3505

1

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

3506

1

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

3507

1

			assets: Wild(All),

3508

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3509

1

		}]);

3510

1

		assert_ok!(

3511

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3512

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3513

1

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

3514

1

				Box::new(assets),

3515

1

				Box::new(TransferType::LocalReserve),

3516

1

				Box::new(fees_id),

3517

1

				Box::new(TransferType::LocalReserve),

3518

1

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

3519

1

				WeightLimit::Unlimited

3520

3521

);

3522

1

});

3523

3524

1

	ParaA::execute_with(|| {

3525

		// Alice should have received the DOTs

3526

1

		assert_eq!(

3527

1

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

3528

1

			Ok(U256::from(200))

3529

);

3530

1

});

3531

3532

1

	let dest = Location::new(

3533

1,

3534

1

3535

1

			Parachain(1000),

3536

1

			AccountId32 {

3537

1

				network: None,

3538

1

				id: RELAYBOB.into(),

3539

1

},

3540

1

],

3541

);

3542

1

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

3543

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

3544

1

	ParaA::execute_with(|| {

3545

1

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

3546

1

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

3547

1

			assets: Wild(All),

3548

1

			beneficiary: beneficiary.clone(),

3549

1

		}]);

3550

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3551

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3552

1

			Box::new(VersionedLocation::from(chain_part)),

3553

1

			Box::new(VersionedAssets::from((Location::parent(), 100))),

3554

1

			Box::new(TransferType::DestinationReserve),

3555

1

			Box::new(fees_id),

3556

1

			Box::new(TransferType::DestinationReserve),

3557

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3558

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3559

));

3560

3561

1

		assert_eq!(

3562

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3563

1

			Ok(U256::from(100))

3564

);

3565

1

});

3566

3567

1

	Statemint::execute_with(|| {

3568

		// Check that Bob received the tokens back in AssetHub

3569

1

		assert_eq!(

3570

1

			StatemintBalances::free_balance(RELAYBOB),

3571

			INITIAL_BALANCE + 100

3572

);

3573

1

});

3574

3575

	// Send back tokens from AH to ParaA from Bob's account

3576

1

	Statemint::execute_with(|| {

3577

		// Now send those tokens to ParaA

3578

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3579

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3580

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3581

1

			assets: Wild(All),

3582

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3583

1

		}]);

3584

1

		assert_ok!(

3585

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3586

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3587

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3588

1

				Box::new(assets),

3589

1

				Box::new(TransferType::LocalReserve),

3590

1

				Box::new(fees_id),

3591

1

				Box::new(TransferType::LocalReserve),

3592

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3593

1

				WeightLimit::Unlimited

3594

3595

);

3596

3597

		// 100 DOTs were deducted from Bob's account

3598

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3599

1

});

3600

3601

1

	ParaA::execute_with(|| {

3602

		// Alice should have received 100 DOTs

3603

1

		assert_eq!(

3604

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3605

1

			Ok(U256::from(200))

3606

);

3607

1

});

3608

1

3609

3610

#[test]

3611

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3612

1

	MockNet::reset();

3613

3614

	// Relay asset

3615

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3616

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3617

3618

1

	let relay_asset_metadata = parachain::AssetMetadata {

3619

1

		name: b"RelayToken".to_vec(),

3620

1

		symbol: b"Relay".to_vec(),

3621

1

		decimals: 12,

3622

1

};

3623

3624

	// Statemint asset

3625

1

	let statemint_asset = Location::new(

3626

1,

3627

1

3628

1

			Parachain(1000u32),

3629

1

			PalletInstance(5u8),

3630

1

			GeneralIndex(10u128),

3631

1

],

3632

);

3633

1

	let statemint_location_asset: AssetType = statemint_asset

3634

1

		.clone()

3635

1

		.try_into()

3636

1

		.expect("Location convertion to AssetType should succeed");

3637

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3638

3639

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3640

1

		name: b"USDC".to_vec(),

3641

1

		symbol: b"USDC".to_vec(),

3642

1

		decimals: 12,

3643

1

};

3644

3645

1

	let dest_para = Location::new(1, [Parachain(1)]);

3646

3647

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3648

1

		polkadot_parachain::primitives::Sibling,

3649

1

		statemint_like::AccountId,

3650

1

	>::convert_location(&dest_para)

3651

1

	.unwrap();

3652

3653

1

	ParaA::execute_with(|| {

3654

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3655

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3656

1

			.try_into()

3657

1

			.expect("v3 to latest location conversion failed");

3658

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3659

1

			source_relay_id,

3660

1

			source_location_latest,

3661

1

			relay_asset_metadata.decimals,

3662

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3663

1

			relay_asset_metadata.name.try_into().expect("too long"),

3664

));

3665

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3666

3667

1

		let parachain::AssetType::Xcm(source_location_v3) = statemint_location_asset.clone();

3668

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3669

1

			.try_into()

3670

1

			.expect("v3 to latest location conversion failed");

3671

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3672

1

			source_statemint_asset_id,

3673

1

			source_location_latest,

3674

1

			asset_metadata_statemint_asset.decimals,

3675

1

			asset_metadata_statemint_asset

3676

1

				.symbol

3677

1

				.try_into()

3678

1

				.expect("too long"),

3679

1

			asset_metadata_statemint_asset

3680

1

				.name

3681

1

				.try_into()

3682

1

				.expect("too long"),

3683

));

3684

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

3685

1

});

3686

3687

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3688

1

		network: None,

3689

1

		key: PARAALICE,

3690

1

3691

1

	.into();

3692

3693

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3694

1

		network: None,

3695

1

		id: RELAYALICE.into(),

3696

1

3697

1

	.into();

3698

3699

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3700

1

	Relay::execute_with(|| {

3701

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3702

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3703

1

			Box::new(Parachain(1000).into()),

3704

1

			Box::new(

3705

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3706

1

					.clone()

3707

1

					.into()

3708

),

3709

1

			Box::new(([], 200).into()),

3710

0,

3711

1

			WeightLimit::Unlimited

3712

));

3713

1

});

3714

3715

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3716

1

	Statemint::execute_with(|| {

3717

		// Check Alice received 200 tokens on AssetHub

3718

1

		assert_eq!(

3719

1

			StatemintBalances::free_balance(RELAYALICE),

3720

			INITIAL_BALANCE + 200

3721

);

3722

3723

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3724

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3725

1

			sov,

3726

			110000000000000

3727

));

3728

3729

1

		statemint_like::PrefixChanger::set_prefix(

3730

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

3731

);

3732

3733

1

		assert_ok!(StatemintAssets::create(

3734

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3735

10,

3736

			RELAYALICE,

3737

3738

));

3739

3740

1

		assert_ok!(StatemintAssets::mint(

3741

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3742

10,

3743

			RELAYALICE,

3744

			300000000000000

3745

));

3746

3747

		// Now send relay tokens to ParaA

3748

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

3749

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3750

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3751

1

			assets: Wild(All),

3752

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3753

1

		}]);

3754

1

		assert_ok!(

3755

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3756

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3757

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3758

1

				Box::new(assets),

3759

1

				Box::new(TransferType::LocalReserve),

3760

1

				Box::new(fees_id),

3761

1

				Box::new(TransferType::LocalReserve),

3762

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3763

1

				WeightLimit::Unlimited

3764

3765

);

3766

3767

		// Send USDC

3768

1

		let assets: VersionedAssets = (

3769

1

3770

1

				xcm::latest::prelude::PalletInstance(

3771

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

3772

1

),

3773

1

				GeneralIndex(10),

3774

1

],

3775

1

			125,

3776

1

3777

1

			.into();

3778

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

3779

1

0,

3780

1

3781

1

				xcm::latest::prelude::PalletInstance(

3782

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

3783

1

),

3784

1

				GeneralIndex(10),

3785

1

],

3786

1

))

3787

1

		.into();

3788

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3789

1

			assets: Wild(All),

3790

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3791

1

		}]);

3792

1

		assert_ok!(

3793

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3794

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3795

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3796

1

				Box::new(assets),

3797

1

				Box::new(TransferType::LocalReserve),

3798

1

				Box::new(fees_id),

3799

1

				Box::new(TransferType::LocalReserve),

3800

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3801

1

				WeightLimit::Unlimited

3802

3803

);

3804

1

});

3805

3806

1

	ParaA::execute_with(|| {

3807

		// Alice should have received the DOTs

3808

1

		assert_eq!(

3809

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3810

1

			Ok(U256::from(200))

3811

);

3812

3813

		// Alice has received 125 USDC

3814

1

		assert_eq!(

3815

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

3816

1

			Ok(U256::from(125))

3817

);

3818

1

});

3819

3820

1

	let dest = Location::new(

3821

1,

3822

1

3823

1

			Parachain(1000),

3824

1

			AccountId32 {

3825

1

				network: None,

3826

1

				id: RELAYBOB.into(),

3827

1

},

3828

1

],

3829

);

3830

3831

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3832

3833

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3834

1

	ParaA::execute_with(|| {

3835

1

		let asset_1 = currency_to_asset(

3836

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3837

			100,

3838

);

3839

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3840

1

		let assets_to_send = vec![asset_1, asset_2];

3841

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3842

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3843

1

			assets: Wild(All),

3844

1

			beneficiary: beneficiary.clone(),

3845

1

		}]);

3846

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3847

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3848

1

			Box::new(VersionedLocation::from(chain_part)),

3849

1

			Box::new(VersionedAssets::from(assets_to_send)),

3850

1

			Box::new(TransferType::DestinationReserve),

3851

1

			Box::new(fees_id),

3852

1

			Box::new(TransferType::DestinationReserve),

3853

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3854

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

3855

));

3856

3857

1

		assert_eq!(

3858

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3859

1

			Ok(U256::from(100))

3860

);

3861

1

});

3862

3863

1

	Statemint::execute_with(|| {

3864

		// Check that Bob received relay tokens back in AssetHub

3865

1

		assert_eq!(

3866

1

			StatemintBalances::free_balance(RELAYBOB),

3867

			INITIAL_BALANCE + 100

3868

);

3869

3870

		// Check that BOB received 100 USDC on AssetHub

3871

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

3872

1

});

3873

3874

	// Send back tokens from AH to ParaA from Bob's account

3875

1

	Statemint::execute_with(|| {

3876

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3877

3878

		// Now send those tokens to ParaA

3879

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3880

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3881

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3882

1

			assets: Wild(All),

3883

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3884

1

		}]);

3885

1

		assert_ok!(

3886

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3887

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3888

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3889

1

				Box::new(assets),

3890

1

				Box::new(TransferType::LocalReserve),

3891

1

				Box::new(fees_id),

3892

1

				Box::new(TransferType::LocalReserve),

3893

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3894

1

				WeightLimit::Unlimited

3895

3896

);

3897

3898

		// 100 DOTs were deducted from Bob's account

3899

1

		assert_eq!(

3900

1

			StatemintBalances::free_balance(RELAYBOB),

3901

1

			bob_previous_balance - 100

3902

);

3903

1

});

3904

3905

1

	ParaA::execute_with(|| {

3906

		// Alice should have received 100 DOTs

3907

1

		assert_eq!(

3908

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3909

1

			Ok(U256::from(200))

3910

);

3911

1

});

3912

1

3913

3914

#[test]

3915

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3916

1

	MockNet::reset();

3917

3918

	// Relay asset

3919

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3920

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3921

3922

1

	let relay_asset_metadata = parachain::AssetMetadata {

3923

1

		name: b"RelayToken".to_vec(),

3924

1

		symbol: b"Relay".to_vec(),

3925

1

		decimals: 12,

3926

1

};

3927

3928

	// Statemint asset

3929

1

	let statemint_asset = Location::new(

3930

1,

3931

1

3932

1

			Parachain(1000u32),

3933

1

			PalletInstance(5u8),

3934

1

			GeneralIndex(10u128),

3935

1

],

3936

);

3937

1

	let statemint_location_asset: AssetType = statemint_asset

3938

1

		.clone()

3939

1

		.try_into()

3940

1

		.expect("Location convertion to AssetType should succeed");

3941

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3942

3943

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3944

1

		name: b"USDC".to_vec(),

3945

1

		symbol: b"USDC".to_vec(),

3946

1

		decimals: 12,

3947

1

};

3948

3949

1

	let dest_para = Location::new(1, [Parachain(1)]);

3950

3951

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3952

1

		polkadot_parachain::primitives::Sibling,

3953

1

		statemint_like::AccountId,

3954

1

	>::convert_location(&dest_para)

3955

1

	.unwrap();

3956

3957

1

	ParaA::execute_with(|| {

3958

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3959

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3960

1

			.try_into()

3961

1

			.expect("v3 to latest location conversion failed");

3962

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3963

1

			source_relay_id,

3964

1

			source_location_latest,

3965

1

			relay_asset_metadata.decimals,

3966

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3967

1

			relay_asset_metadata.name.try_into().expect("too long"),

3968

));

3969

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3970

3971

1

		let parachain::AssetType::Xcm(source_location_v3) = statemint_location_asset.clone();

3972

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3973

1

			.try_into()

3974

1

			.expect("v3 to latest location conversion failed");

3975

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3976

1

			source_statemint_asset_id,

3977

1

			source_location_latest,

3978

1

			asset_metadata_statemint_asset.decimals,

3979

1

			asset_metadata_statemint_asset

3980

1

				.symbol

3981

1

				.try_into()

3982

1

				.expect("too long"),

3983

1

			asset_metadata_statemint_asset

3984

1

				.name

3985

1

				.try_into()

3986

1

				.expect("too long"),

3987

));

3988

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

3989

1

});

3990

3991

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3992

1

		network: None,

3993

1

		key: PARAALICE,

3994

1

3995

1

	.into();

3996

3997

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3998

1

		network: None,

3999

1

		id: RELAYALICE.into(),

4000

1

4001

1

	.into();

4002

4003

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4004

1

	Relay::execute_with(|| {

4005

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4006

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4007

1

			Box::new(Parachain(1000).into()),

4008

1

			Box::new(

4009

1

				VersionedLocation::from(statemint_beneficiary_absolute)

4010

1

					.clone()

4011

1

					.into()

4012

),

4013

1

			Box::new(([], 200).into()),

4014

0,

4015

1

			WeightLimit::Unlimited

4016

));

4017

1

});

4018

4019

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4020

1

	Statemint::execute_with(|| {

4021

		// Check Alice received 200 tokens on AssetHub

4022

1

		assert_eq!(

4023

1

			StatemintBalances::free_balance(RELAYALICE),

4024

			INITIAL_BALANCE + 200

4025

);

4026

4027

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4028

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4029

1

			sov,

4030

			110000000000000

4031

));

4032

4033

1

		statemint_like::PrefixChanger::set_prefix(

4034

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4035

);

4036

4037

1

		assert_ok!(StatemintAssets::create(

4038

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4039

10,

4040

			RELAYALICE,

4041

4042

));

4043

4044

1

		assert_ok!(StatemintAssets::mint(

4045

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4046

10,

4047

			RELAYALICE,

4048

			300000000000000

4049

));

4050

4051

		// Now send relay tokens to ParaA

4052

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

4053

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4054

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4055

1

			assets: Wild(All),

4056

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4057

1

		}]);

4058

1

		assert_ok!(

4059

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4060

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4061

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4062

1

				Box::new(assets),

4063

1

				Box::new(TransferType::LocalReserve),

4064

1

				Box::new(fees_id),

4065

1

				Box::new(TransferType::LocalReserve),

4066

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4067

1

				WeightLimit::Unlimited

4068

4069

);

4070

4071

		// Send USDC

4072

1

		let assets: VersionedAssets = (

4073

1

4074

1

				xcm::latest::prelude::PalletInstance(

4075

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4076

1

),

4077

1

				GeneralIndex(10),

4078

1

],

4079

1

			125,

4080

1

4081

1

			.into();

4082

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4083

1

0,

4084

1

4085

1

				xcm::latest::prelude::PalletInstance(

4086

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4087

1

),

4088

1

				GeneralIndex(10),

4089

1

],

4090

1

))

4091

1

		.into();

4092

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4093

1

			assets: Wild(All),

4094

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4095

1

		}]);

4096

1

		assert_ok!(

4097

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4098

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4099

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4100

1

				Box::new(assets),

4101

1

				Box::new(TransferType::LocalReserve),

4102

1

				Box::new(fees_id),

4103

1

				Box::new(TransferType::LocalReserve),

4104

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4105

1

				WeightLimit::Unlimited

4106

4107

);

4108

1

});

4109

4110

1

	ParaA::execute_with(|| {

4111

		// Alice should have received the DOTs

4112

1

		assert_eq!(

4113

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4114

1

			Ok(U256::from(200))

4115

);

4116

4117

		// Alice has received 125 USDC

4118

1

		assert_eq!(

4119

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4120

1

			Ok(U256::from(125))

4121

);

4122

1

});

4123

4124

1

	let dest = Location::new(

4125

1,

4126

1

4127

1

			Parachain(1000),

4128

1

			AccountId32 {

4129

1

				network: None,

4130

1

				id: RELAYBOB.into(),

4131

1

},

4132

1

],

4133

);

4134

4135

1

	let statemint_asset_to_send = Asset {

4136

1

		id: AssetId(statemint_asset),

4137

1

		fun: Fungible(100),

4138

1

};

4139

4140

1

	let relay_asset_to_send = Asset {

4141

1

		id: AssetId(Location::parent()),

4142

1

		fun: Fungible(100),

4143

1

};

4144

4145

1

	let assets_to_send: XcmAssets =

4146

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

4147

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4148

	// For some reason the order of the assets is inverted when creating the array above.

4149

	// We need to use relay asset for fees, so we pick index 0.

4150

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4151

4152

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4153

1

	ParaA::execute_with(|| {

4154

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4155

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4156

1

			assets: Wild(All),

4157

1

			beneficiary: beneficiary.clone(),

4158

1

		}]);

4159

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4160

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4161

1

			Box::new(VersionedLocation::from(chain_part)),

4162

1

			Box::new(VersionedAssets::from(assets_to_send)),

4163

1

			Box::new(TransferType::DestinationReserve),

4164

1

			Box::new(fees_id),

4165

1

			Box::new(TransferType::DestinationReserve),

4166

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4167

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4168

));

4169

4170

1

		assert_eq!(

4171

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4172

1

			Ok(U256::from(100))

4173

);

4174

1

});

4175

4176

1

	Statemint::execute_with(|| {

4177

		// Check that Bob received relay tokens back in AssetHub

4178

1

		assert_eq!(

4179

1

			StatemintBalances::free_balance(RELAYBOB),

4180

			INITIAL_BALANCE + 100

4181

);

4182

4183

		// Check that BOB received 100 USDC on AssetHub

4184

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4185

1

});

4186

4187

	// Send back tokens from AH to ParaA from Bob's account

4188

1

	Statemint::execute_with(|| {

4189

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4190

4191

		// Now send those tokens to ParaA

4192

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

4193

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4194

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4195

1

			assets: Wild(All),

4196

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4197

1

		}]);

4198

1

		assert_ok!(

4199

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4200

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4201

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4202

1

				Box::new(assets),

4203

1

				Box::new(TransferType::LocalReserve),

4204

1

				Box::new(fees_id),

4205

1

				Box::new(TransferType::LocalReserve),

4206

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4207

1

				WeightLimit::Unlimited

4208

4209

);

4210

4211

		// 100 DOTs were deducted from Bob's account

4212

1

		assert_eq!(

4213

1

			StatemintBalances::free_balance(RELAYBOB),

4214

1

			bob_previous_balance - 100

4215

);

4216

1

});

4217

4218

1

	ParaA::execute_with(|| {

4219

		// 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

);

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

4232

1

	ParaA::execute_with(|| {

4233

		// 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

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4238

1

			3000.into(),

4239

1

			20000000000.into(),

4240

			// 4 instructions in transact through signed

4241

1

			Some(4000.into())

4242

));

4243

		// Root can set transact info

4244

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4245

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

4246

1

			.expect("must succeed");

4247

1

		ancestry = parachain::UniversalLocation::get().into();

4248

1

});

4249

4250

	// Let's construct the Junction that we will append with DescendOrigin

4251

1

	let signed_origin: Junctions = [AccountKey20 {

4252

1

		network: None,

4253

1

		key: PARAALICE,

4254

1

}]

4255

1

	.into();

4256

4257

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4258

1

	descend_origin_multilocation

4259

1

		.append_with(signed_origin)

4260

1

		.unwrap();

4261

4262

	// To convert it to what the relay will see instead of us

4263

1

	descend_origin_multilocation

4264

1

		.reanchor(&Location::parent(), &ancestry.interior)

4265

1

		.unwrap();

4266

4267

1

	let derived = xcm_builder::Account32Hash::<

4268

1

		relay_chain::KusamaNetwork,

4269

1

		relay_chain::AccountId,

4270

1

	>::convert_location(&descend_origin_multilocation)

4271

1

	.unwrap();

4272

4273

1

	Relay::execute_with(|| {

4274

		// free execution, full amount received

4275

1

		assert_ok!(RelayBalances::transfer_allow_death(

4276

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4277

1

			derived.clone(),

4278

			4000004100u128,

4279

));

4280

		// derived account has all funds

4281

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4282

		// sovereign account has 0 funds

4283

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4284

1

});

4285

4286

	// Encode the call. Balances transact to para_a_account

4287

	// First index

4288

1

	let mut encoded: Vec<u8> = Vec::new();

4289

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4290

1

		relay_chain::Balances,

4291

1

>()

4292

1

	.unwrap() as u8;

4293

4294

1

	encoded.push(index);

4295

4296

	// Then call bytes

4297

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4298

1

		// 100 to sovereign

4299

1

		dest: para_a_account(),

4300

1

		value: 100u32.into(),

4301

1

4302

1

	.encode();

4303

1

	encoded.append(&mut call_bytes);

4304

4305

1

	ParaA::execute_with(|| {

4306

1

		assert_ok!(XcmTransactor::transact_through_signed(

4307

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4308

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4309

1

			CurrencyPayment {

4310

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4311

1

					Location::parent()

4312

1

				))),

4313

1

				fee_amount: None

4314

1

},

4315

1

			encoded,

4316

			// 4000000000 for transfer + 4000 for XCM

4317

1

			TransactWeights {

4318

1

				transact_required_weight_at_most: 4000000000.into(),

4319

1

				overall_weight: None

4320

1

},

4321

			false

4322

));

4323

1

});

4324

4325

1

	Relay::execute_with(|| {

4326

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4327

4328

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4329

1

});

4330

1

4331

4332

#[test]

4333

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4334

1

	MockNet::reset();

4335

1

	let mut ancestry = Location::parent();

4336

4337

1

	ParaA::execute_with(|| {

4338

1

		ancestry = parachain::UniversalLocation::get().into();

4339

1

});

4340

4341

	// Let's construct the Junction that we will append with DescendOrigin

4342

1

	let signed_origin: Junctions = [AccountKey20 {

4343

1

		network: None,

4344

1

		key: PARAALICE,

4345

1

}]

4346

1

	.into();

4347

4348

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4349

1

	descend_origin_multilocation

4350

1

		.append_with(signed_origin)

4351

1

		.unwrap();

4352

4353

	// To convert it to what the relay will see instead of us

4354

1

	descend_origin_multilocation

4355

1

		.reanchor(&Location::parent(), &ancestry.interior)

4356

1

		.unwrap();

4357

4358

1

	let derived = xcm_builder::Account32Hash::<

4359

1

		relay_chain::KusamaNetwork,

4360

1

		relay_chain::AccountId,

4361

1

	>::convert_location(&descend_origin_multilocation)

4362

1

	.unwrap();

4363

4364

1

	Relay::execute_with(|| {

4365

		// free execution, full amount received

4366

1

		assert_ok!(RelayBalances::transfer_allow_death(

4367

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4368

1

			derived.clone(),

4369

			4000004100u128,

4370

));

4371

		// derived account has all funds

4372

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4373

		// sovereign account has 0 funds

4374

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4375

1

});

4376

4377

	// Encode the call. Balances transact to para_a_account

4378

	// First index

4379

1

	let mut encoded: Vec<u8> = Vec::new();

4380

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4381

1

		relay_chain::Balances,

4382

1

>()

4383

1

	.unwrap() as u8;

4384

4385

1

	encoded.push(index);

4386

4387

	// Then call bytes

4388

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4389

1

		// 100 to sovereign

4390

1

		dest: para_a_account(),

4391

1

		value: 100u32.into(),

4392

1

4393

1

	.encode();

4394

1

	encoded.append(&mut call_bytes);

4395

4396

1

	let total_weight = 4000004000u64;

4397

1

	ParaA::execute_with(|| {

4398

1

		assert_ok!(XcmTransactor::transact_through_signed(

4399

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4400

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4401

1

			CurrencyPayment {

4402

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4403

1

					Location::parent()

4404

1

				))),

4405

1

				fee_amount: Some(total_weight as u128)

4406

1

},

4407

1

			encoded,

4408

			// 4000000000 for transfer + 4000 for XCM

4409

1

			TransactWeights {

4410

1

				transact_required_weight_at_most: 4000000000.into(),

4411

1

				overall_weight: Some(Limited(total_weight.into()))

4412

1

},

4413

			false

4414

));

4415

1

});

4416

4417

1

	Relay::execute_with(|| {

4418

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4419

4420

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4421

1

});

4422

1

4423

4424

#[test]

4425

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4426

1

	MockNet::reset();

4427

1

	let mut ancestry = Location::parent();

4428

4429

1

	ParaA::execute_with(|| {

4430

1

		ancestry = parachain::UniversalLocation::get().into();

4431

1

});

4432

4433

	// Let's construct the Junction that we will append with DescendOrigin

4434

1

	let signed_origin: Junctions = [AccountKey20 {

4435

1

		network: None,

4436

1

		key: PARAALICE,

4437

1

}]

4438

1

	.into();

4439

4440

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4441

1

	descend_origin_multilocation

4442

1

		.append_with(signed_origin)

4443

1

		.unwrap();

4444

4445

	// To convert it to what the relay will see instead of us

4446

1

	descend_origin_multilocation

4447

1

		.reanchor(&Location::parent(), &ancestry.interior)

4448

1

		.unwrap();

4449

4450

1

	let derived = xcm_builder::Account32Hash::<

4451

1

		relay_chain::KusamaNetwork,

4452

1

		relay_chain::AccountId,

4453

1

	>::convert_location(&descend_origin_multilocation)

4454

1

	.unwrap();

4455

4456

1

	Relay::execute_with(|| {

4457

		// free execution, full amount received

4458

1

		assert_ok!(RelayBalances::transfer_allow_death(

4459

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4460

1

			derived.clone(),

4461

			4000009100u128,

4462

));

4463

		// derived account has all funds

4464

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4465

		// sovereign account has 0 funds

4466

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4467

1

});

4468

4469

	// Encode the call. Balances transact to para_a_account

4470

	// First index

4471

1

	let mut encoded: Vec<u8> = Vec::new();

4472

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4473

1

		relay_chain::Balances,

4474

1

>()

4475

1

	.unwrap() as u8;

4476

4477

1

	encoded.push(index);

4478

4479

	// Then call bytes

4480

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4481

1

		// 100 to sovereign

4482

1

		dest: para_a_account(),

4483

1

		value: 100u32.into(),

4484

1

4485

1

	.encode();

4486

1

	encoded.append(&mut call_bytes);

4487

4488

1

	let total_weight = 4000009000u64;

4489

1

	ParaA::execute_with(|| {

4490

1

		assert_ok!(XcmTransactor::transact_through_signed(

4491

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4492

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4493

1

			CurrencyPayment {

4494

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4495

1

					Location::parent()

4496

1

				))),

4497

1

				fee_amount: Some(total_weight as u128)

4498

1

},

4499

1

			encoded,

4500

			// 4000000000 for transfer + 9000 for XCM

4501

1

			TransactWeights {

4502

1

				transact_required_weight_at_most: 4000000000.into(),

4503

1

				overall_weight: Some(Limited(total_weight.into()))

4504

1

},

4505

			true

4506

));

4507

1

});

4508

4509

1

	Relay::execute_with(|| {

4510

		// 100 transferred

4511

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4512

4513

		// 4000009000 refunded

4514

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4515

1

});

4516

1

4517

4518

#[test]

4519

1

fn transact_through_signed_multilocation_para_to_para() {

4520

1

	MockNet::reset();

4521

1

	let mut ancestry = Location::parent();

4522

4523

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4524

4525

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4526

4527

1

	ParaA::execute_with(|| {

4528

		// Root can set transact info

4529

1

		assert_ok!(XcmTransactor::set_transact_info(

4530

1

			parachain::RuntimeOrigin::root(),

4531

			// ParaB

4532

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4533

			// Para charges 1000 for every instruction, and we have 3, so 3

4534

1

			3.into(),

4535

1

			20000000000.into(),

4536

			// 4 instructions in transact through signed

4537

1

			Some(4.into())

4538

));

4539

		// Root can set transact info

4540

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4541

1

		set_fee_per_second_for_location(

4542

1

			para_b_balances.clone(),

4543

1

			parachain::ParaTokensPerSecond::get(),

4544

4545

1

		.expect("must succeed");

4546

1

		ancestry = parachain::UniversalLocation::get().into();

4547

1

});

4548

4549

	// Let's construct the Junction that we will append with DescendOrigin

4550

1

	let signed_origin: Junctions = [AccountKey20 {

4551

1

		network: None,

4552

1

		key: PARAALICE,

4553

1

}]

4554

1

	.into();

4555

4556

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4557

1

	descend_origin_location.append_with(signed_origin).unwrap();

4558

4559

	// To convert it to what the paraB will see instead of us

4560

1

	descend_origin_location

4561

1

		.reanchor(&para_b_location, &ancestry.interior)

4562

1

		.unwrap();

4563

4564

1

	let derived = xcm_builder::HashedDescription::<

4565

1

		parachain::AccountId,

4566

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4567

1

	>::convert_location(&descend_origin_location)

4568

1

	.unwrap();

4569

4570

1

	ParaB::execute_with(|| {

4571

		// free execution, full amount received

4572

1

		assert_ok!(ParaBalances::transfer_allow_death(

4573

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4574

1

			derived.clone(),

4575

			4000000104u128,

4576

));

4577

		// derived account has all funds

4578

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4579

		// sovereign account has 0 funds

4580

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4581

1

});

4582

4583

	// Encode the call. Balances transact to para_a_account

4584

	// First index

4585

1

	let mut encoded: Vec<u8> = Vec::new();

4586

1

	let index =

4587

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4588

1

			.unwrap() as u8;

4589

4590

1

	encoded.push(index);

4591

4592

	// Then call bytes

4593

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4594

1

		// 100 to sovereign

4595

1

		dest: para_a_account_20(),

4596

1

		value: 100u32.into(),

4597

1

4598

1

	.encode();

4599

1

	encoded.append(&mut call_bytes);

4600

4601

1

	ParaA::execute_with(|| {

4602

1

		assert_ok!(XcmTransactor::transact_through_signed(

4603

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4604

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4605

1

			CurrencyPayment {

4606

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4607

1

					para_b_balances

4608

1

				))),

4609

1

				fee_amount: None

4610

1

},

4611

1

			encoded,

4612

			// 4000000000 for transfer + 4000 for XCM

4613

			// 1-1 to fee

4614

1

			TransactWeights {

4615

1

				transact_required_weight_at_most: 4000000000.into(),

4616

1

				overall_weight: None

4617

1

},

4618

			false

4619

));

4620

1

});

4621

4622

1

	ParaB::execute_with(|| {

4623

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4624

4625

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4626

1

});

4627

1

4628

4629

#[test]

4630

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4631

1

	MockNet::reset();

4632

1

	let mut ancestry = Location::parent();

4633

4634

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4635

4636

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4637

4638

1

	ParaA::execute_with(|| {

4639

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4640

1

		set_fee_per_second_for_location(

4641

1

			para_b_balances.clone(),

4642

1

			parachain::ParaTokensPerSecond::get(),

4643

4644

1

		.expect("must succeed");

4645

1

		ancestry = parachain::UniversalLocation::get().into();

4646

1

});

4647

4648

	// Let's construct the Junction that we will append with DescendOrigin

4649

1

	let signed_origin: Junctions = [AccountKey20 {

4650

1

		network: None,

4651

1

		key: PARAALICE,

4652

1

}]

4653

1

	.into();

4654

4655

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4656

1

	descend_origin_location.append_with(signed_origin).unwrap();

4657

4658

	// To convert it to what the paraB will see instead of us

4659

1

	descend_origin_location

4660

1

		.reanchor(&para_b_location, &ancestry.interior)

4661

1

		.unwrap();

4662

4663

1

	let derived = xcm_builder::HashedDescription::<

4664

1

		parachain::AccountId,

4665

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4666

1

	>::convert_location(&descend_origin_location)

4667

1

	.unwrap();

4668

4669

1

	ParaB::execute_with(|| {

4670

		// free execution, full amount received

4671

1

		assert_ok!(ParaBalances::transfer_allow_death(

4672

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4673

1

			derived.clone(),

4674

			4000009100u128,

4675

));

4676

		// derived account has all funds

4677

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4678

		// sovereign account has 0 funds

4679

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4680

1

});

4681

4682

	// Encode the call. Balances transact to para_a_account

4683

	// First index

4684

1

	let mut encoded: Vec<u8> = Vec::new();

4685

1

	let index =

4686

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4687

1

			.unwrap() as u8;

4688

4689

1

	encoded.push(index);

4690

4691

	// Then call bytes

4692

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4693

1

		// 100 to sovereign

4694

1

		dest: para_a_account_20(),

4695

1

		value: 100u32.into(),

4696

1

4697

1

	.encode();

4698

1

	encoded.append(&mut call_bytes);

4699

4700

1

	let overall_weight = 4000009000u64;

4701

1

	ParaA::execute_with(|| {

4702

1

		assert_ok!(XcmTransactor::transact_through_signed(

4703

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4704

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4705

1

			CurrencyPayment {

4706

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4707

1

					para_b_balances

4708

1

				))),

4709

1

				fee_amount: Some(overall_weight as u128)

4710

1

},

4711

1

			encoded,

4712

			// 4000000000 for transfer + 9000 for XCM

4713

1

			TransactWeights {

4714

1

				transact_required_weight_at_most: 4000000000.into(),

4715

1

				overall_weight: Some(Limited(overall_weight.into()))

4716

1

},

4717

			true

4718

));

4719

1

});

4720

4721

1

	ParaB::execute_with(|| {

4722

		// Check the derived account was refunded

4723

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4724

4725

		// Check the transfer was executed

4726

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4727

1

});

4728

1

4729

4730

#[test]

4731

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4732

1

	MockNet::reset();

4733

1

	let mut ancestry = Location::parent();

4734

4735

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4736

4737

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4738

4739

1

	ParaA::execute_with(|| {

4740

		// Root can set transact info

4741

1

		assert_ok!(XcmTransactor::set_transact_info(

4742

1

			parachain::RuntimeOrigin::root(),

4743

			// ParaB

4744

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4745

			// Para charges 1000 for every instruction, and we have 3, so 3

4746

1

			3.into(),

4747

1

			20000000000.into(),

4748

			// 4 instructions in transact through signed

4749

1

			Some(4.into())

4750

));

4751

		// Root can set transact info

4752

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4753

1

		set_fee_per_second_for_location(

4754

1

			para_b_balances.clone(),

4755

1

			parachain::ParaTokensPerSecond::get(),

4756

4757

1

		.expect("must succeed");

4758

1

		ancestry = parachain::UniversalLocation::get().into();

4759

1

});

4760

4761

	// 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

4768

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4769

1

	descend_origin_location.append_with(signed_origin).unwrap();

4770

4771

	// 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

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

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

			4000000104u128,

4788

));

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

4797

	// Encode the call. Balances transact to para_a_account

4798

	// 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

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

4821

	// 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

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

			// 4000000000 for transfer + 4000 for XCM

4840

			// 1-1 to fee

4841

1

			TransactWeights {

4842

1

				transact_required_weight_at_most: 4000000000.into(),

4843

1

				overall_weight: None

4844

1

},

4845

			false

4846

));

4847

1

});

4848

4849

1

	ParaB::execute_with(|| {

4850

		// 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

);

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

4863

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4864

4865

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4866

4867

1

	ParaA::execute_with(|| {

4868

		// Root can set transact info

4869

1

		assert_ok!(XcmTransactor::set_transact_info(

4870

1

			parachain::RuntimeOrigin::root(),

4871

			// ParaB

4872

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4873

			// Para charges 1000 for every instruction, and we have 3, so 3

4874

1

			3.into(),

4875

1

			20000000000.into(),

4876

			// 4 instructions in transact through signed

4877

1

			Some(4.into())

4878

));

4879

		// Root can set transact info

4880

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4881

1

		set_fee_per_second_for_location(

4882

1

			para_b_balances.clone(),

4883

1

			parachain::ParaTokensPerSecond::get(),

4884

4885

1

		.expect("must succeed");

4886

1

		ancestry = parachain::UniversalLocation::get().into();

4887

1

});

4888

4889

	// Let's construct the Junction that we will append with DescendOrigin

4890

1

	let signed_origin: Junctions = [AccountKey20 {

4891

1

		network: None,

4892

1

		key: PARAALICE,

4893

1

}]

4894

1

	.into();

4895

4896

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4897

1

	descend_origin_location.append_with(signed_origin).unwrap();

4898

4899

	// To convert it to what the paraB will see instead of us

4900

1

	descend_origin_location

4901

1

		.reanchor(&para_b_location, &ancestry.interior)

4902

1

		.unwrap();

4903

4904

1

	let derived = xcm_builder::HashedDescription::<

4905

1

		parachain::AccountId,

4906

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4907

1

	>::convert_location(&descend_origin_location)

4908

1

	.unwrap();

4909

4910

1

	let mut parachain_b_alice_balances_before = 0;

4911

1

	ParaB::execute_with(|| {

4912

1

		assert_ok!(ParaBalances::transfer_allow_death(

4913

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4914

1

			derived.clone(),

4915

			4000000104u128,

4916

));

4917

		// derived account has all funds

4918

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4919

		// sovereign account has 0 funds

4920

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4921

4922

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4923

1

});

4924

4925

	// Encode the call. Balances transact to para_a_account

4926

	// First index

4927

1

	let mut encoded: Vec<u8> = Vec::new();

4928

1

	let index =

4929

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4930

1

			.unwrap() as u8;

4931

4932

1

	encoded.push(index);

4933

4934

	use sp_core::U256;

4935

	// Let's do a EVM transfer

4936

1

	let eth_tx =

4937

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4938

1

			gas_limit: U256::from(21000),

4939

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4940

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4941

1

			value: U256::from(100),

4942

1

			input: BoundedVec::<

4943

1

u8,

4944

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4945

1

			>::try_from(vec![]).unwrap(),

4946

1

			access_list: None,

4947

1

});

4948

4949

	// Then call bytes

4950

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4951

1

		transact_as: PARAALICE.into(),

4952

1

		xcm_transaction: eth_tx,

4953

1

4954

1

	.encode();

4955

1

	encoded.append(&mut call_bytes);

4956

4957

1

	ParaA::execute_with(|| {

4958

1

		assert_ok!(XcmTransactor::transact_through_signed(

4959

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4960

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4961

1

			CurrencyPayment {

4962

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4963

1

					para_b_balances

4964

1

				))),

4965

1

				fee_amount: None

4966

1

},

4967

1

			encoded,

4968

1

			TransactWeights {

4969

1

				transact_required_weight_at_most: 4000000000.into(),

4970

1

				overall_weight: None

4971

1

},

4972

			false

4973

));

4974

1

});

4975

4976

1

	ParaB::execute_with(|| {

4977

		// Make sure the EVM transfer wasn't executed

4978

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4979

1

});

4980

1

4981

4982

#[test]

4983

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4984

1

	MockNet::reset();

4985

1

	let mut ancestry = Location::parent();

4986

4987

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4988

4989

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4990

4991

1

	ParaA::execute_with(|| {

4992

		// Root can set transact info

4993

1

		assert_ok!(XcmTransactor::set_transact_info(

4994

1

			parachain::RuntimeOrigin::root(),

4995

			// ParaB

4996

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4997

			// Para charges 1000 for every instruction, and we have 3, so 3

4998

1

			3.into(),

4999

1

			20000000000.into(),

5000

			// 4 instructions in transact through signed

5001

1

			Some(4.into())

5002

));

5003

		// Root can set transact info

5004

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5005

1

		set_fee_per_second_for_location(

5006

1

			para_b_balances.clone(),

5007

1

			parachain::ParaTokensPerSecond::get(),

5008

5009

1

		.expect("must succeed");

5010

1

		ancestry = parachain::UniversalLocation::get().into();

5011

1

});

5012

5013

	// Let's construct the Junction that we will append with DescendOrigin

5014

1

	let signed_origin: Junctions = [AccountKey20 {

5015

1

		network: None,

5016

1

		key: PARAALICE,

5017

1

}]

5018

1

	.into();

5019

5020

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5021

1

	descend_origin_location.append_with(signed_origin).unwrap();

5022

5023

	// To convert it to what the paraB will see instead of us

5024

1

	descend_origin_location

5025

1

		.reanchor(&para_b_location, &ancestry.interior)

5026

1

		.unwrap();

5027

5028

1

	let derived = xcm_builder::HashedDescription::<

5029

1

		parachain::AccountId,

5030

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5031

1

	>::convert_location(&descend_origin_location)

5032

1

	.unwrap();

5033

5034

1

	let transfer_recipient = evm_account();

5035

1

	let mut transfer_recipient_balance_before = 0;

5036

1

	ParaB::execute_with(|| {

5037

1

		assert_ok!(ParaBalances::transfer_allow_death(

5038

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5039

1

			derived.clone(),

5040

			4000000104u128,

5041

));

5042

		// derived account has all funds

5043

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5044

		// sovereign account has 0 funds

5045

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5046

5047

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5048

5049

		// Add proxy ALICE  -> derived

5050

1

		let _ = parachain::Proxy::add_proxy_delegate(

5051

1

			&PARAALICE.into(),

5052

1

			derived,

5053

1

			parachain::ProxyType::Any,

5054

1

0,

5055

1

);

5056

1

});

5057

5058

	// Encode the call. Balances transact to para_a_account

5059

	// First index

5060

1

	let mut encoded: Vec<u8> = Vec::new();

5061

1

	let index =

5062

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5063

1

			.unwrap() as u8;

5064

5065

1

	encoded.push(index);

5066

5067

	use sp_core::U256;

5068

	// Let's do a EVM transfer

5069

1

	let eth_tx =

5070

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5071

1

			gas_limit: U256::from(21000),

5072

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5073

1

			value: U256::from(100),

5074

1

			input: BoundedVec::<

5075

1

u8,

5076

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5077

1

			>::try_from(vec![]).unwrap(),

5078

1

			access_list: None,

5079

1

});

5080

5081

	// Then call bytes

5082

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5083

1

		transact_as: PARAALICE.into(),

5084

1

		xcm_transaction: eth_tx,

5085

1

5086

1

	.encode();

5087

1

	encoded.append(&mut call_bytes);

5088

5089

1

	ParaA::execute_with(|| {

5090

1

		assert_ok!(XcmTransactor::transact_through_signed(

5091

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5092

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5093

1

			CurrencyPayment {

5094

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5095

1

					para_b_balances

5096

1

				))),

5097

1

				fee_amount: None

5098

1

},

5099

1

			encoded,

5100

1

			TransactWeights {

5101

1

				transact_required_weight_at_most: 4000000000.into(),

5102

1

				overall_weight: None

5103

1

},

5104

			false

5105

));

5106

1

});

5107

5108

1

	ParaB::execute_with(|| {

5109

		// Make sure the EVM transfer was executed

5110

1

		assert!(

5111

1

			ParaBalances::free_balance(&transfer_recipient.into())

5112

1

				== transfer_recipient_balance_before + 100

5113

);

5114

1

});

5115

1

5116

5117

#[test]

5118

1

fn hrmp_init_accept_through_root() {

5119

1

	MockNet::reset();

5120

5121

1

	Relay::execute_with(|| {

5122

1

		assert_ok!(RelayBalances::transfer_allow_death(

5123

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5124

1

			para_a_account(),

5125

			1000u128

5126

));

5127

1

		assert_ok!(RelayBalances::transfer_allow_death(

5128

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5129

1

			para_b_account(),

5130

			1000u128

5131

));

5132

1

});

5133

5134

1

	ParaA::execute_with(|| {

5135

1

		let total_fee = 1_000u128;

5136

1

		let total_weight: u64 = 1_000_000_000;

5137

1

		let tx_weight: u64 = 500_000_000;

5138

		// Root can send hrmp init channel

5139

1

		assert_ok!(XcmTransactor::hrmp_manage(

5140

1

			parachain::RuntimeOrigin::root(),

5141

1

			HrmpOperation::InitOpen(HrmpInitParams {

5142

1

				para_id: 2u32.into(),

5143

1

				proposed_max_capacity: 1,

5144

1

				proposed_max_message_size: 1

5145

1

}),

5146

1

			CurrencyPayment {

5147

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5148

1

					Location::parent()

5149

1

				))),

5150

1

				fee_amount: Some(total_fee)

5151

1

},

5152

1

			TransactWeights {

5153

1

				transact_required_weight_at_most: tx_weight.into(),

5154

1

				overall_weight: Some(Limited(total_weight.into()))

5155

1

5156

));

5157

1

});

5158

1

	Relay::execute_with(|| {

5159

1

		let expected_event: relay_chain::RuntimeEvent =

5160

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5161

1

				sender: 1u32.into(),

5162

1

				recipient: 2u32.into(),

5163

1

				proposed_max_capacity: 1u32,

5164

1

				proposed_max_message_size: 1u32,

5165

1

5166

1

			.into();

5167

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5168

1

});

5169

1

	ParaB::execute_with(|| {

5170

1

		let total_fee = 1_000u128;

5171

1

		let total_weight: u64 = 1_000_000_000;

5172

1

		let tx_weight: u64 = 500_000_000;

5173

		// Root can send hrmp accept channel

5174

1

		assert_ok!(XcmTransactor::hrmp_manage(

5175

1

			parachain::RuntimeOrigin::root(),

5176

1

			HrmpOperation::Accept {

5177

1

				para_id: 1u32.into()

5178

1

},

5179

1

			CurrencyPayment {

5180

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5181

1

					Location::parent()

5182

1

				))),

5183

1

				fee_amount: Some(total_fee)

5184

1

},

5185

1

			TransactWeights {

5186

1

				transact_required_weight_at_most: tx_weight.into(),

5187

1

				overall_weight: Some(Limited(total_weight.into()))

5188

1

5189

));

5190

1

});

5191

5192

1

	Relay::execute_with(|| {

5193

1

		let expected_event: relay_chain::RuntimeEvent =

5194

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5195

1

				sender: 1u32.into(),

5196

1

				recipient: 2u32.into(),

5197

1

5198

1

			.into();

5199

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5200

1

});

5201

1

5202

5203

#[test]

5204

1

fn hrmp_close_works() {

5205

1

	MockNet::reset();

5206

5207

1

	Relay::execute_with(|| {

5208

1

		assert_ok!(RelayBalances::transfer_allow_death(

5209

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5210

1

			para_a_account(),

5211

			1000u128

5212

));

5213

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5214

1

			relay_chain::RuntimeOrigin::root(),

5215

1

			1u32.into(),

5216

1

			2u32.into(),

5217

			1u32,

5218

			1u32

5219

));

5220

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5221

1

			relay_chain::RuntimeOrigin::root(),

5222

			1u32

5223

));

5224

1

});

5225

5226

1

	ParaA::execute_with(|| {

5227

1

		let total_fee = 1_000u128;

5228

1

		let total_weight: u64 = 1_000_000_000;

5229

1

		let tx_weight: u64 = 500_000_000;

5230

		// Root can send hrmp close

5231

1

		assert_ok!(XcmTransactor::hrmp_manage(

5232

1

			parachain::RuntimeOrigin::root(),

5233

1

			HrmpOperation::Close(HrmpChannelId {

5234

1

				sender: 1u32.into(),

5235

1

				recipient: 2u32.into()

5236

1

}),

5237

1

			CurrencyPayment {

5238

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5239

1

					Location::parent()

5240

1

				))),

5241

1

				fee_amount: Some(total_fee)

5242

1

},

5243

1

			TransactWeights {

5244

1

				transact_required_weight_at_most: tx_weight.into(),

5245

1

				overall_weight: Some(Limited(total_weight.into()))

5246

1

5247

));

5248

1

});

5249

1

	Relay::execute_with(|| {

5250

1

		let expected_event: relay_chain::RuntimeEvent =

5251

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5252

1

				by_parachain: 1u32.into(),

5253

1

				channel_id: HrmpChannelId {

5254

1

					sender: 1u32.into(),

5255

1

					recipient: 2u32.into(),

5256

1

},

5257

1

5258

1

			.into();

5259

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5260

1

});

5261

1

5262

5263

use crate::xcm_mock::parachain::XcmWeightTrader;

5264

use parity_scale_codec::{Decode, Encode};

5265

use sp_io::hashing::blake2_256;

5266

5267

// Helper to derive accountIds

5268

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5269

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5270

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5271

7