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

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

94

9

	let native_amount_per_second =

95

9

		frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND as u128;

96

9

	let relative_price = native_amount_per_second

97

9

		.saturating_mul(precision_factor)

98

9

		.checked_div(fee_per_second)

99

9

		.ok_or(())?;

100

101

9

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

102

9

103

104

23

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

105

23

	Asset {

106

23

		id: AssetId(

107

23

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

108

23

				currency_id,

109

23

110

23

			.unwrap(),

111

23

),

112

23

		fun: Fungibility::Fungible(amount),

113

23

114

23

115

116

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

117

#[test]

118

1

fn receive_relay_asset_from_relay() {

119

1

	MockNet::reset();

120

121

1

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

122

1

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

123

1

	let asset_metadata = parachain::AssetMetadata {

124

1

		name: b"RelayToken".to_vec(),

125

1

		symbol: b"Relay".to_vec(),

126

1

		decimals: 12,

127

1

};

128

129

	// Register relay asset in paraA

130

1

	ParaA::execute_with(|| {

131

1

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

132

1

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

133

1

			.try_into()

134

1

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

135

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

136

1

			source_id,

137

1

			source_location_latest,

138

1

			asset_metadata.decimals,

139

1

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

140

1

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

141

));

142

1

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

143

1

});

144

145

	// Actually send relay asset to parachain

146

1

	let dest: Location = AccountKey20 {

147

1

		network: None,

148

1

		key: PARAALICE,

149

1

150

1

	.into();

151

152

	// First send relay chain asset to Parachain

153

1

	Relay::execute_with(|| {

154

1

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

155

1

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

156

1

			assets: Wild(All),

157

1

			beneficiary: dest.clone(),

158

1

		}]);

159

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

160

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

161

1

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

162

1

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

163

1

			Box::new(TransferType::LocalReserve),

164

1

			Box::new(fees_id),

165

1

			Box::new(TransferType::LocalReserve),

166

1

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

167

1

			WeightLimit::Unlimited

168

));

169

1

});

170

171

	// Verify that parachain received the asset

172

1

	ParaA::execute_with(|| {

173

		// free execution, full amount received

174

1

		assert_eq!(

175

1

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

176

1

			Ok(U256::from(123))

177

);

178

1

});

179

1

180

181

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

182

#[test]

183

1

fn send_relay_asset_to_relay() {

184

1

	MockNet::reset();

185

186

1

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

187

1

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

188

189

1

	let asset_metadata = parachain::AssetMetadata {

190

1

		name: b"RelayToken".to_vec(),

191

1

		symbol: b"Relay".to_vec(),

192

1

		decimals: 12,

193

1

};

194

195

	// Register relay asset in paraA

196

1

	ParaA::execute_with(|| {

197

1

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

198

1

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

199

1

			.try_into()

200

1

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

201

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

202

1

			source_id,

203

1

			source_location_latest,

204

1

			asset_metadata.decimals,

205

1

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

206

1

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

207

));

208

		// Free execution

209

1

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

210

1

});

211

212

1

	let dest: Location = Junction::AccountKey20 {

213

1

		network: None,

214

1

		key: PARAALICE,

215

1

216

1

	.into();

217

218

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

219

1

	Relay::execute_with(|| {

220

1

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

221

1

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

222

1

			assets: Wild(All),

223

1

			beneficiary: dest.clone(),

224

1

		}]);

225

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

226

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

227

1

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

228

1

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

229

1

			Box::new(TransferType::LocalReserve),

230

1

			Box::new(fees_id),

231

1

			Box::new(TransferType::LocalReserve),

232

1

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

233

1

			WeightLimit::Unlimited

234

));

235

1

});

236

237

1

	ParaA::execute_with(|| {

238

		// Free execution, full amount received

239

1

		assert_eq!(

240

1

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

241

1

			Ok(U256::from(123))

242

);

243

1

});

244

245

	// Lets gather the balance before sending back money

246

1

	let mut balance_before_sending = 0;

247

1

	Relay::execute_with(|| {

248

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

249

1

});

250

251

	// We now send back some money to the relay

252

1

	let dest = Location {

253

1

		parents: 1,

254

1

		interior: [AccountId32 {

255

1

			network: None,

256

1

			id: RELAYALICE.into(),

257

1

}]

258

1

		.into(),

259

1

};

260

1

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

261

1

	ParaA::execute_with(|| {

262

1

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

263

1

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

264

1

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

265

1

			assets: Wild(All),

266

1

			beneficiary: beneficiary.clone(),

267

1

		}]);

268

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

269

1

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

270

1

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

271

1

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

272

1

			Box::new(TransferType::DestinationReserve),

273

1

			Box::new(fees_id),

274

1

			Box::new(TransferType::DestinationReserve),

275

1

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

276

1

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

277

));

278

1

});

279

280

	// The balances in paraAlice should have been substracted

281

1

	ParaA::execute_with(|| {

282

1

		assert_eq!(

283

1

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

284

1

			Ok(U256::from(0))

285

);

286

1

});

287

288

	// Balances in the relay should have been received

289

1

	Relay::execute_with(|| {

290

		// free execution,x	 full amount received

291

1

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

292

1

});

293

1

294

295

#[test]

296

1

fn send_relay_asset_to_para_b() {

297

1

	MockNet::reset();

298

299

1

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

300

1

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

301

302

1

	let asset_metadata = parachain::AssetMetadata {

303

1

		name: b"RelayToken".to_vec(),

304

1

		symbol: b"Relay".to_vec(),

305

1

		decimals: 12,

306

1

};

307

308

	// Register asset in paraA. Free execution

309

1

	ParaA::execute_with(|| {

310

1

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

311

1

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

312

1

			.try_into()

313

1

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

314

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

315

1

			source_id,

316

1

			source_location_latest,

317

1

			asset_metadata.decimals,

318

1

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

319

1

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

320

));

321

1

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

322

1

});

323

324

	// Register asset in paraB. Free execution

325

1

	ParaB::execute_with(|| {

326

1

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

327

1

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

328

1

			.try_into()

329

1

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

330

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

331

1

			source_id,

332

1

			source_location_latest,

333

1

			asset_metadata.decimals,

334

1

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

335

1

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

336

));

337

1

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

338

1

});

339

340

1

	let dest: Location = Junction::AccountKey20 {

341

1

		network: None,

342

1

		key: PARAALICE,

343

1

344

1

	.into();

345

1

	Relay::execute_with(|| {

346

1

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

347

1

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

348

1

			assets: Wild(All),

349

1

			beneficiary: dest.clone(),

350

1

		}]);

351

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

352

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

353

1

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

354

1

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

355

1

			Box::new(TransferType::LocalReserve),

356

1

			Box::new(fees_id),

357

1

			Box::new(TransferType::LocalReserve),

358

1

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

359

1

			WeightLimit::Unlimited

360

));

361

1

});

362

363

1

	ParaA::execute_with(|| {

364

		// free execution, full amount received

365

1

		assert_eq!(

366

1

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

367

1

			Ok(U256::from(123))

368

);

369

1

});

370

371

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

372

1

	let dest = Location {

373

1

		parents: 1,

374

1

		interior: [

375

1

			Parachain(2),

376

1

			AccountKey20 {

377

1

				network: None,

378

1

				key: PARAALICE.into(),

379

1

},

380

1

381

1

		.into(),

382

1

};

383

1

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

384

1

	ParaA::execute_with(|| {

385

1

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

386

1

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

387

1

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

388

1

			assets: Wild(All),

389

1

			beneficiary: beneficiary.clone(),

390

1

		}]);

391

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

392

1

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

393

1

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

394

1

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

395

1

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

396

1

			Box::new(fees_id),

397

1

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

398

1

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

399

1

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

400

));

401

1

});

402

403

	// Para A balances should have been substracted

404

1

	ParaA::execute_with(|| {

405

1

		assert_eq!(

406

1

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

407

1

			Ok(U256::from(23))

408

);

409

1

});

410

411

	// Para B balances should have been credited

412

1

	ParaB::execute_with(|| {

413

1

		assert_eq!(

414

1

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

415

1

			Ok(U256::from(100))

416

);

417

1

});

418

1

419

420

#[test]

421

1

fn send_para_a_asset_to_para_b() {

422

1

	MockNet::reset();

423

424

	// This represents the asset in paraA

425

1

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

426

1

	let source_location: AssetType = para_a_balances

427

1

		.try_into()

428

1

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

429

1

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

430

431

1

	let asset_metadata = parachain::AssetMetadata {

432

1

		name: b"ParaAToken".to_vec(),

433

1

		symbol: b"ParaA".to_vec(),

434

1

		decimals: 18,

435

1

};

436

437

	// Register asset in paraB. Free execution

438

1

	ParaB::execute_with(|| {

439

1

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

440

1

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

441

1

			.try_into()

442

1

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

443

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

444

1

			source_id,

445

1

			source_location_latest,

446

1

			asset_metadata.decimals,

447

1

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

448

1

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

449

));

450

1

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

451

1

});

452

453

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

454

1

	let dest = Location {

455

1

		parents: 1,

456

1

		interior: [

457

1

			Parachain(2),

458

1

			AccountKey20 {

459

1

				network: None,

460

1

				key: PARAALICE.into(),

461

1

},

462

1

463

1

		.into(),

464

1

};

465

466

1

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

467

	// Native token is substracted in paraA

468

1

	ParaA::execute_with(|| {

469

1

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

470

		// Free execution, full amount received

471

1

		assert_ok!(PolkadotXcm::transfer_assets(

472

1

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

473

1

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

474

1

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

475

1

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

476

0,

477

1

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

478

));

479

1

});

480

481

1

	ParaA::execute_with(|| {

482

1

		assert_eq!(

483

1

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

484

			INITIAL_BALANCE - 100

485

);

486

1

});

487

488

	// Asset is minted in paraB

489

1

	ParaB::execute_with(|| {

490

		// Free execution, full amount received

491

1

		assert_eq!(

492

1

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

493

1

			Ok(U256::from(100))

494

);

495

1

});

496

1

497

498

#[test]

499

1

fn send_para_a_asset_from_para_b_to_para_c() {

500

1

	MockNet::reset();

501

502

	// Represents para A asset

503

1

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

504

1

	let source_location: AssetType = para_a_balances

505

1

		.try_into()

506

1

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

507

1

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

508

509

1

	let asset_metadata = parachain::AssetMetadata {

510

1

		name: b"ParaAToken".to_vec(),

511

1

		symbol: b"ParaA".to_vec(),

512

1

		decimals: 18,

513

1

};

514

515

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

516

1

	ParaB::execute_with(|| {

517

1

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

518

1

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

519

1

			.try_into()

520

1

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

521

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

522

1

			source_id,

523

1

			source_location_latest,

524

1

			asset_metadata.decimals,

525

1

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

526

1

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

527

));

528

1

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

529

1

});

530

531

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

532

1

	ParaC::execute_with(|| {

533

1

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

534

1

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

535

1

			.try_into()

536

1

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

537

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

538

1

			source_id,

539

1

			source_location_latest,

540

1

			asset_metadata.decimals,

541

1

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

542

1

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

543

));

544

1

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

545

1

});

546

547

1

	let dest = Location {

548

1

		parents: 1,

549

1

		interior: [

550

1

			Parachain(2),

551

1

			AccountKey20 {

552

1

				network: None,

553

1

				key: PARAALICE.into(),

554

1

},

555

1

556

1

		.into(),

557

1

};

558

1

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

559

1

	ParaA::execute_with(|| {

560

1

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

561

1

		assert_ok!(PolkadotXcm::transfer_assets(

562

1

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

563

1

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

564

1

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

565

1

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

566

0,

567

1

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

568

));

569

1

});

570

571

	// Para A balances have been substracted

572

1

	ParaA::execute_with(|| {

573

1

		assert_eq!(

574

1

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

575

			INITIAL_BALANCE - 100

576

);

577

1

});

578

579

	// Para B balances have been credited

580

1

	ParaB::execute_with(|| {

581

1

		assert_eq!(

582

1

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

583

1

			Ok(U256::from(100))

584

);

585

1

});

586

587

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

588

1

	let dest = Location {

589

1

		parents: 1,

590

1

		interior: [

591

1

			Parachain(3),

592

1

			AccountKey20 {

593

1

				network: None,

594

1

				key: PARAALICE.into(),

595

1

},

596

1

597

1

		.into(),

598

1

};

599

1

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

600

1

	ParaB::execute_with(|| {

601

1

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

602

1

		assert_ok!(PolkadotXcm::transfer_assets(

603

1

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

604

1

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

605

1

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

606

1

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

607

0,

608

1

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

609

));

610

1

});

611

612

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

613

1

	ParaC::execute_with(|| {

614

1

		assert_eq!(

615

1

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

616

1

			Ok(U256::from(95))

617

);

618

1

});

619

1

620

621

#[test]

622

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

623

1

	MockNet::reset();

624

625

	// para A asset

626

1

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

627

1

	let source_location: AssetType = para_a_balances

628

1

		.try_into()

629

1

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

630

1

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

631

632

1

	let asset_metadata = parachain::AssetMetadata {

633

1

		name: b"ParaAToken".to_vec(),

634

1

		symbol: b"ParaA".to_vec(),

635

1

		decimals: 18,

636

1

};

637

638

	// Register para A asset in para B

639

1

	ParaB::execute_with(|| {

640

1

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

641

1

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

642

1

			.try_into()

643

1

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

644

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

645

1

			source_id,

646

1

			source_location_latest,

647

1

			asset_metadata.decimals,

648

1

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

649

1

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

650

));

651

1

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

652

1

});

653

654

	// Send para A asset to para B

655

1

	let dest = Location {

656

1

		parents: 1,

657

1

		interior: [

658

1

			Parachain(2),

659

1

			AccountKey20 {

660

1

				network: None,

661

1

				key: PARAALICE.into(),

662

1

},

663

1

664

1

		.into(),

665

1

};

666

1

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

667

1

	ParaA::execute_with(|| {

668

1

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

669

1

		assert_ok!(PolkadotXcm::transfer_assets(

670

1

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

671

1

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

672

1

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

673

1

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

674

0,

675

1

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

676

));

677

1

});

678

679

	// Balances have been substracted

680

1

	ParaA::execute_with(|| {

681

1

		assert_eq!(

682

1

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

683

			INITIAL_BALANCE - 100

684

);

685

1

});

686

687

	// Para B balances have been credited

688

1

	ParaB::execute_with(|| {

689

1

		assert_eq!(

690

1

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

691

1

			Ok(U256::from(100))

692

);

693

1

});

694

695

	// Send back para A asset to para A

696

1

	let dest = Location {

697

1

		parents: 1,

698

1

		interior: [

699

1

			Parachain(1),

700

1

			AccountKey20 {

701

1

				network: None,

702

1

				key: PARAALICE.into(),

703

1

},

704

1

705

1

		.into(),

706

1

};

707

1

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

708

1

	ParaB::execute_with(|| {

709

1

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

710

1

		assert_ok!(PolkadotXcm::transfer_assets(

711

1

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

712

1

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

713

1

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

714

1

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

715

0,

716

1

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

717

));

718

1

});

719

720

1

	ParaA::execute_with(|| {

721

		// Weight used is 4

722

1

		assert_eq!(

723

1

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

724

			INITIAL_BALANCE - 4

725

);

726

1

});

727

1

728

729

#[test]

730

1

fn receive_relay_asset_with_trader() {

731

1

	MockNet::reset();

732

733

1

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

734

1

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

735

736

1

	let asset_metadata = parachain::AssetMetadata {

737

1

		name: b"RelayToken".to_vec(),

738

1

		symbol: b"Relay".to_vec(),

739

1

		decimals: 12,

740

1

};

741

742

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

743

	// we know later we will divide by 1e12

744

	// Lets put 1e6 as units per second

745

1

	ParaA::execute_with(|| {

746

1

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

747

1

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

748

1

			.try_into()

749

1

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

750

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

751

1

			source_id,

752

1

			source_location_latest,

753

1

			asset_metadata.decimals,

754

1

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

755

1

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

756

));

757

1

		assert_ok!(add_supported_asset(

758

1

			source_location.clone(),

759

			2500000000000u128

760

));

761

1

});

762

763

1

	let dest: Location = Junction::AccountKey20 {

764

1

		network: None,

765

1

		key: PARAALICE,

766

1

767

1

	.into();

768

	// We are sending 100 tokens from relay.

769

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

770

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

771

	// Units per second should be 2_500_000_000_000_000

772

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

773

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

774

1

	Relay::execute_with(|| {

775

1

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

776

1

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

777

1

			assets: Wild(All),

778

1

			beneficiary: dest.clone(),

779

1

		}]);

780

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

781

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

782

1

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

783

1

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

784

1

			Box::new(TransferType::LocalReserve),

785

1

			Box::new(fees_id),

786

1

			Box::new(TransferType::LocalReserve),

787

1

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

788

1

			WeightLimit::Unlimited

789

));

790

1

});

791

792

1

	ParaA::execute_with(|| {

793

		// non-free execution, not full amount received

794

1

		assert_eq!(

795

1

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

796

1

			Ok(U256::from(90))

797

);

798

		// Fee should have been received by treasury

799

1

		assert_eq!(

800

1

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

801

1

			Ok(U256::from(10))

802

);

803

1

});

804

1

805

806

#[test]

807

1

fn send_para_a_asset_to_para_b_with_trader() {

808

1

	MockNet::reset();

809

810

1

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

811

1

	let source_location: AssetType = para_a_balances

812

1

		.try_into()

813

1

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

814

1

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

815

816

1

	let asset_metadata = parachain::AssetMetadata {

817

1

		name: b"ParaAToken".to_vec(),

818

1

		symbol: b"ParaA".to_vec(),

819

1

		decimals: 18,

820

1

};

821

822

1

	ParaB::execute_with(|| {

823

1

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

824

1

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

825

1

			.try_into()

826

1

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

827

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

828

1

			source_id,

829

1

			source_location_latest,

830

1

			asset_metadata.decimals,

831

1

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

832

1

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

833

));

834

1

		assert_ok!(add_supported_asset(

835

1

			source_location.clone(),

836

			2500000000000u128

837

));

838

1

});

839

840

1

	let dest = Location {

841

1

		parents: 1,

842

1

		interior: [

843

1

			Parachain(2),

844

1

			AccountKey20 {

845

1

				network: None,

846

1

				key: PARAALICE.into(),

847

1

},

848

1

849

1

		.into(),

850

1

};

851

852

1

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

853

	// In destination chain, we only need 4 weight

854

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

855

1

	ParaA::execute_with(|| {

856

1

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

857

1

		assert_ok!(PolkadotXcm::transfer_assets(

858

1

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

859

1

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

860

1

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

861

1

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

862

0,

863

1

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

864

));

865

1

});

866

1

	ParaA::execute_with(|| {

867

		// free execution, full amount received

868

1

		assert_eq!(

869

1

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

870

			INITIAL_BALANCE - 100

871

);

872

1

});

873

874

	// We are sending 100 tokens from para A.

875

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

876

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

877

	// Units per second should be 2_500_000_000_000_000

878

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

879

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

880

	// will be 4

881

1

	ParaB::execute_with(|| {

882

1

		assert_eq!(

883

1

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

884

1

			Ok(U256::from(90))

885

);

886

		// Fee should have been received by treasury

887

1

		assert_eq!(

888

1

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

889

1

			Ok(U256::from(10))

890

);

891

1

});

892

1

893

894

#[test]

895

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

896

1

	MockNet::reset();

897

898

1

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

899

1

	let source_location: AssetType = para_a_balances

900

1

		.try_into()

901

1

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

902

1

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

903

904

1

	let asset_metadata = parachain::AssetMetadata {

905

1

		name: b"ParaAToken".to_vec(),

906

1

		symbol: b"ParaA".to_vec(),

907

1

		decimals: 18,

908

1

};

909

910

1

	ParaB::execute_with(|| {

911

1

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

912

1

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

913

1

			.try_into()

914

1

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

915

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

916

1

			source_id,

917

1

			source_location_latest,

918

1

			asset_metadata.decimals,

919

1

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

920

1

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

921

));

922

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

923

1

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

924

1

});

925

926

1

	let dest = Location {

927

1

		parents: 1,

928

1

		interior: [

929

1

			Parachain(2),

930

1

			AccountKey20 {

931

1

				network: None,

932

1

				key: PARAALICE.into(),

933

1

},

934

1

935

1

		.into(),

936

1

};

937

1

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

938

	// we use transfer_with_fee

939

1

	ParaA::execute_with(|| {

940

1

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

941

1

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

942

1

		assert_ok!(PolkadotXcm::transfer_assets(

943

1

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

944

1

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

945

1

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

946

1

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

947

0,

948

1

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

949

));

950

1

});

951

1

	ParaA::execute_with(|| {

952

		// 100 tokens transferred plus 1 taken from fees

953

1

		assert_eq!(

954

1

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

955

			INITIAL_BALANCE - 100 - 1

956

);

957

1

});

958

959

1

	ParaB::execute_with(|| {

960

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

961

		// what it is specified

962

1

		assert_eq!(

963

1

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

964

1

			Ok(U256::from(101))

965

);

966

1

});

967

1

968

969

#[test]

970

1

fn error_when_not_paying_enough() {

971

1

	MockNet::reset();

972

973

1

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

974

1

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

975

976

1

	let asset_metadata = parachain::AssetMetadata {

977

1

		name: b"RelayToken".to_vec(),

978

1

		symbol: b"Relay".to_vec(),

979

1

		decimals: 12,

980

1

};

981

982

1

	let dest: Location = Junction::AccountKey20 {

983

1

		network: None,

984

1

		key: PARAALICE,

985

1

986

1

	.into();

987

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

988

	// we know later we will divide by 1e12

989

	// Lets put 1e6 as units per second

990

1

	ParaA::execute_with(|| {

991

1

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

992

1

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

993

1

			.try_into()

994

1

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

995

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

996

1

			source_id,

997

1

			source_location_latest,

998

1

			asset_metadata.decimals,

999

1

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

1000

1

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

1001

));

1002

1

		assert_ok!(add_supported_asset(

1003

1

			source_location.clone(),

1004

			2500000000000u128

1005

));

1006

1

});

1007

1008

	// We are sending 100 tokens from relay.

1009

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

1010

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

1011

1

	Relay::execute_with(|| {

1012

1

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

1013

1

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

1014

1

			assets: Wild(All),

1015

1

			beneficiary: dest.clone(),

1016

1

		}]);

1017

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1018

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1019

1

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

1020

1

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

1021

1

			Box::new(TransferType::LocalReserve),

1022

1

			Box::new(fees_id),

1023

1

			Box::new(TransferType::LocalReserve),

1024

1

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

1025

1

			WeightLimit::Unlimited

1026

));

1027

1

});

1028

1029

1

	ParaA::execute_with(|| {

1030

		// amount not received as it is not paying enough

1031

1

		assert_eq!(

1032

1

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

1033

1

			Ok(U256::from(0))

1034

);

1035

1

});

1036

1

1037

1038

#[test]

1039

1

fn transact_through_derivative_multilocation() {

1040

1

	MockNet::reset();

1041

1042

1

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

1043

1

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

1044

1045

1

	let asset_metadata = parachain::AssetMetadata {

1046

1

		name: b"RelayToken".to_vec(),

1047

1

		symbol: b"Relay".to_vec(),

1048

1

		decimals: 12,

1049

1

};

1050

1051

1

	ParaA::execute_with(|| {

1052

1

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

1053

1

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

1054

1

			.try_into()

1055

1

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

1056

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1057

1

			source_id,

1058

1

			source_location_latest,

1059

1

			asset_metadata.decimals,

1060

1

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

1061

1

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

1062

));

1063

1

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

1064

1065

		// Root can set transact info

1066

1

		assert_ok!(XcmTransactor::set_transact_info(

1067

1

			parachain::RuntimeOrigin::root(),

1068

1

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

1069

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

1070

1

			3000.into(),

1071

1

			20000000000.into(),

1072

1

			None

1073

));

1074

		// Root can set transact info

1075

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

1076

1

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

1077

1

			.expect("must succeed");

1078

1

});

1079

1080

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

1081

1082

1

	let dest: Location = AccountKey20 {

1083

1

		network: None,

1084

1

		key: PARAALICE,

1085

1

1086

1

	.into();

1087

1

	Relay::execute_with(|| {

1088

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

1089

1

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

1090

1

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

1091

1

			assets: Wild(All),

1092

1

			beneficiary: dest.clone(),

1093

1

		}]);

1094

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1095

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1096

1

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

1097

1

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

1098

1

			Box::new(TransferType::LocalReserve),

1099

1

			Box::new(fees_id),

1100

1

			Box::new(TransferType::LocalReserve),

1101

1

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

1102

1

			WeightLimit::Unlimited

1103

));

1104

1

});

1105

1106

1

	ParaA::execute_with(|| {

1107

		// free execution, full amount received

1108

1

		assert_eq!(

1109

1

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

1110

1

			Ok(U256::from(4000003100u64))

1111

);

1112

1

});

1113

1114

	// Register address

1115

1

	ParaA::execute_with(|| {

1116

1

		assert_ok!(XcmTransactor::register(

1117

1

			parachain::RuntimeOrigin::root(),

1118

1

			PARAALICE.into(),

1119

0,

1120

));

1121

1

});

1122

1123

	// Send to registered address

1124

1125

1

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

1126

1

	let dest = Location {

1127

1

		parents: 1,

1128

1

		interior: [AccountId32 {

1129

1

			network: None,

1130

1

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

1131

1

}]

1132

1

		.into(),

1133

1

};

1134

1

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

1135

1136

1

	ParaA::execute_with(|| {

1137

1

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

1138

		// free execution, full amount received

1139

1

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

1140

1

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

1141

1

			assets: Wild(All),

1142

1

			beneficiary: beneficiary.clone(),

1143

1

		}]);

1144

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1145

1

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

1146

1

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

1147

1

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

1148

1

			Box::new(TransferType::DestinationReserve),

1149

1

			Box::new(fees_id),

1150

1

			Box::new(TransferType::DestinationReserve),

1151

1

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

1152

1

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

1153

));

1154

1

});

1155

1156

1

	ParaA::execute_with(|| {

1157

		// free execution, full amount received

1158

1

		assert_eq!(

1159

1

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

1160

1

			Ok(U256::from(4000003000u64))

1161

);

1162

1

});

1163

1164

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

1165

	// again

1166

1

	Relay::execute_with(|| {

1167

		// free execution,x	 full amount received

1168

1

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

1169

1

});

1170

1171

	// Encode the call. Balances transact to para_a_account

1172

	// First index

1173

1

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

1174

1

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

1175

1

		relay_chain::Balances,

1176

1

>()

1177

1

	.unwrap() as u8;

1178

1179

1

	encoded.push(index);

1180

1181

	// Then call bytes

1182

1

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

1183

1

		dest: para_a_account(),

1184

1

		value: 100u32.into(),

1185

1

1186

1

	.encode();

1187

1

	encoded.append(&mut call_bytes);

1188

1189

1

	ParaA::execute_with(|| {

1190

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1191

1

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

1192

1

			parachain::MockTransactors::Relay,

1193

0,

1194

1

			CurrencyPayment {

1195

1

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

1196

1

					Location::parent()

1197

1

				))),

1198

1

				fee_amount: None

1199

1

},

1200

1

			encoded,

1201

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

1202

1

			TransactWeights {

1203

1

				transact_required_weight_at_most: 4000000000.into(),

1204

1

				overall_weight: None

1205

1

},

1206

			false

1207

));

1208

1

});

1209

1210

1

	Relay::execute_with(|| {

1211

		// free execution,x	 full amount received

1212

1

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

1213

1214

1

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

1215

1

});

1216

1

1217

1218

#[test]

1219

1

fn transact_through_derivative_with_custom_fee_weight() {

1220

1

	MockNet::reset();

1221

1222

1

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

1223

1

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

1224

1225

1

	let asset_metadata = parachain::AssetMetadata {

1226

1

		name: b"RelayToken".to_vec(),

1227

1

		symbol: b"Relay".to_vec(),

1228

1

		decimals: 12,

1229

1

};

1230

1231

1

	ParaA::execute_with(|| {

1232

1

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

1233

1

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

1234

1

			.try_into()

1235

1

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

1236

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1237

1

			source_id,

1238

1

			source_location_latest,

1239

1

			asset_metadata.decimals,

1240

1

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

1241

1

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

1242

));

1243

1

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

1244

1

});

1245

1246

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

1247

1248

1

	let dest: Location = AccountKey20 {

1249

1

		network: None,

1250

1

		key: PARAALICE,

1251

1

1252

1

	.into();

1253

1

	Relay::execute_with(|| {

1254

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

1255

1

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

1256

1

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

1257

1

			assets: Wild(All),

1258

1

			beneficiary: dest.clone(),

1259

1

		}]);

1260

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1261

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1262

1

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

1263

1

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

1264

1

			Box::new(TransferType::LocalReserve),

1265

1

			Box::new(fees_id),

1266

1

			Box::new(TransferType::LocalReserve),

1267

1

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

1268

1

			WeightLimit::Unlimited

1269

));

1270

1

});

1271

1272

1

	ParaA::execute_with(|| {

1273

		// free execution, full amount received

1274

1

		assert_eq!(

1275

1

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

1276

1

			Ok(U256::from(4000003100u64))

1277

);

1278

1

});

1279

1280

	// Register address

1281

1

	ParaA::execute_with(|| {

1282

1

		assert_ok!(XcmTransactor::register(

1283

1

			parachain::RuntimeOrigin::root(),

1284

1

			PARAALICE.into(),

1285

0,

1286

));

1287

1

});

1288

1289

	// Send to registered address

1290

1291

1

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

1292

1

	let dest = Location {

1293

1

		parents: 1,

1294

1

		interior: [AccountId32 {

1295

1

			network: None,

1296

1

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

1297

1

}]

1298

1

		.into(),

1299

1

};

1300

1

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

1301

1302

1

	ParaA::execute_with(|| {

1303

1

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

1304

		// free execution, full amount received

1305

1

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

1306

1

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

1307

1

			assets: Wild(All),

1308

1

			beneficiary: beneficiary.clone(),

1309

1

		}]);

1310

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1311

1

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

1312

1

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

1313

1

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

1314

1

			Box::new(TransferType::DestinationReserve),

1315

1

			Box::new(fees_id),

1316

1

			Box::new(TransferType::DestinationReserve),

1317

1

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

1318

1

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

1319

));

1320

1

});

1321

1322

1

	ParaA::execute_with(|| {

1323

		// free execution, full amount received

1324

1

		assert_eq!(

1325

1

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

1326

1

			Ok(U256::from(4000003000u64))

1327

);

1328

1

});

1329

1330

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

1331

	// again

1332

1

	Relay::execute_with(|| {

1333

		// free execution,x	 full amount received

1334

1

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

1335

1

});

1336

1337

	// Encode the call. Balances transact to para_a_account

1338

	// First index

1339

1

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

1340

1

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

1341

1

		relay_chain::Balances,

1342

1

>()

1343

1

	.unwrap() as u8;

1344

1345

1

	encoded.push(index);

1346

1347

	// Then call bytes

1348

1

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

1349

1

		dest: para_a_account(),

1350

1

		value: 100u32.into(),

1351

1

1352

1

	.encode();

1353

1

	encoded.append(&mut call_bytes);

1354

1355

1

	let overall_weight = 4000003000u64;

1356

1

	ParaA::execute_with(|| {

1357

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1358

1

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

1359

1

			parachain::MockTransactors::Relay,

1360

0,

1361

1

			CurrencyPayment {

1362

1

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

1363

1

					Location::parent()

1364

1

				))),

1365

1

				// 1-1 fee weight mapping

1366

1

				fee_amount: Some(overall_weight as u128)

1367

1

},

1368

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

1369

1

			encoded,

1370

1

			TransactWeights {

1371

1

				transact_required_weight_at_most: 4000000000.into(),

1372

1

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

1373

1

},

1374

			false

1375

));

1376

1

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

1377

1

			.iter()

1378

18

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

1379

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

1380

..

1381

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

1382

18

				_ => None,

1383

18

});

1384

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

1385

1

		assert!(event_found.is_none());

1386

1

});

1387

1388

1

	Relay::execute_with(|| {

1389

		// free execution,x	 full amount received

1390

1

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

1391

1392

1

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

1393

1

});

1394

1

1395

1396

#[test]

1397

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1398

1

	MockNet::reset();

1399

1400

1

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

1401

1

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

1402

1403

1

	let asset_metadata = parachain::AssetMetadata {

1404

1

		name: b"RelayToken".to_vec(),

1405

1

		symbol: b"Relay".to_vec(),

1406

1

		decimals: 12,

1407

1

};

1408

1409

1

	ParaA::execute_with(|| {

1410

1

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

1411

1

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

1412

1

			.try_into()

1413

1

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

1414

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1415

1

			source_id,

1416

1

			source_location_latest,

1417

1

			asset_metadata.decimals,

1418

1

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

1419

1

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

1420

));

1421

1

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

1422

1

});

1423

1424

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

1425

1426

1

	let dest: Location = AccountKey20 {

1427

1

		network: None,

1428

1

		key: PARAALICE,

1429

1

1430

1

	.into();

1431

1

	Relay::execute_with(|| {

1432

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

1433

1

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

1434

1

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

1435

1

			assets: Wild(All),

1436

1

			beneficiary: dest.clone(),

1437

1

		}]);

1438

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1439

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1440

1

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

1441

1

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

1442

1

			Box::new(TransferType::LocalReserve),

1443

1

			Box::new(fees_id),

1444

1

			Box::new(TransferType::LocalReserve),

1445

1

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

1446

1

			WeightLimit::Unlimited

1447

));

1448

1

});

1449

1450

1

	ParaA::execute_with(|| {

1451

		// free execution, full amount received

1452

1

		assert_eq!(

1453

1

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

1454

1

			Ok(U256::from(4000009100u64))

1455

);

1456

1

});

1457

1458

	// Register address

1459

1

	ParaA::execute_with(|| {

1460

1

		assert_ok!(XcmTransactor::register(

1461

1

			parachain::RuntimeOrigin::root(),

1462

1

			PARAALICE.into(),

1463

0,

1464

));

1465

1

});

1466

1467

	// Send to registered address

1468

1469

1

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

1470

1

	let dest = Location {

1471

1

		parents: 1,

1472

1

		interior: [AccountId32 {

1473

1

			network: None,

1474

1

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

1475

1

}]

1476

1

		.into(),

1477

1

};

1478

1

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

1479

1480

1

	ParaA::execute_with(|| {

1481

1

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

1482

		// free execution, full amount received

1483

1

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

1484

1

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

1485

1

			assets: Wild(All),

1486

1

			beneficiary: beneficiary.clone(),

1487

1

		}]);

1488

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1489

1

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

1490

1

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

1491

1

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

1492

1

			Box::new(TransferType::DestinationReserve),

1493

1

			Box::new(fees_id),

1494

1

			Box::new(TransferType::DestinationReserve),

1495

1

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

1496

1

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

1497

));

1498

1

});

1499

1500

1

	ParaA::execute_with(|| {

1501

		// free execution, full amount received

1502

1

		assert_eq!(

1503

1

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

1504

1

			Ok(U256::from(4000009000u64))

1505

);

1506

1

});

1507

1508

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

1509

	// again

1510

1

	Relay::execute_with(|| {

1511

		// free execution,x	 full amount received

1512

1

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

1513

1

});

1514

1515

	// Encode the call. Balances transact to para_a_account

1516

	// First index

1517

1

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

1518

1

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

1519

1

		relay_chain::Balances,

1520

1

>()

1521

1

	.unwrap() as u8;

1522

1523

1

	encoded.push(index);

1524

1525

	// Then call bytes

1526

1

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

1527

1

		dest: para_a_account(),

1528

1

		value: 100u32.into(),

1529

1

1530

1

	.encode();

1531

1

	encoded.append(&mut call_bytes);

1532

1533

1

	let overall_weight = 4000009000u64;

1534

1

	ParaA::execute_with(|| {

1535

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1536

1

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

1537

1

			parachain::MockTransactors::Relay,

1538

0,

1539

1

			CurrencyPayment {

1540

1

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

1541

1

					Location::parent()

1542

1

				))),

1543

1

				// 1-1 fee weight mapping

1544

1

				fee_amount: Some(overall_weight as u128)

1545

1

},

1546

1

			encoded,

1547

1

			TransactWeights {

1548

1

				transact_required_weight_at_most: 4000000000.into(),

1549

1

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

1550

1

},

1551

			true

1552

));

1553

1

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

1554

1

			.iter()

1555

18

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

1556

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

1557

..

1558

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

1559

18

				_ => None,

1560

18

});

1561

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

1562

1

		assert!(event_found.is_none());

1563

1

});

1564

1565

1

	Relay::execute_with(|| {

1566

		// free execution,x	 full amount received

1567

		// 4000009000 refunded + 100 transferred = 4000009100

1568

1

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

1569

1

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

1570

1

});

1571

1

1572

1573

#[test]

1574

1

fn transact_through_sovereign() {

1575

1

	MockNet::reset();

1576

1577

1

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

1578

1

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

1579

1580

1

	let asset_metadata = parachain::AssetMetadata {

1581

1

		name: b"RelayToken".to_vec(),

1582

1

		symbol: b"Relay".to_vec(),

1583

1

		decimals: 12,

1584

1

};

1585

1586

1

	ParaA::execute_with(|| {

1587

1

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

1588

1

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

1589

1

			.try_into()

1590

1

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

1591

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1592

1

			source_id,

1593

1

			source_location_latest,

1594

1

			asset_metadata.decimals,

1595

1

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

1596

1

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

1597

));

1598

1

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

1599

1600

		// Root can set transact info

1601

1

		assert_ok!(XcmTransactor::set_transact_info(

1602

1

			parachain::RuntimeOrigin::root(),

1603

1

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

1604

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

1605

1

			3000.into(),

1606

1

			20000000000.into(),

1607

1

			None

1608

));

1609

		// Root can set transact info

1610

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

1611

1

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

1612

1

			.expect("must succeed");

1613

1

});

1614

1615

1

	let dest: Location = AccountKey20 {

1616

1

		network: None,

1617

1

		key: PARAALICE,

1618

1

1619

1

	.into();

1620

1

	Relay::execute_with(|| {

1621

1

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

1622

1

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

1623

1

			assets: Wild(All),

1624

1

			beneficiary: dest.clone(),

1625

1

		}]);

1626

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1627

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1628

1

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

1629

1

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

1630

1

			Box::new(TransferType::LocalReserve),

1631

1

			Box::new(fees_id),

1632

1

			Box::new(TransferType::LocalReserve),

1633

1

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

1634

1

			WeightLimit::Unlimited

1635

));

1636

1

});

1637

1638

1

	ParaA::execute_with(|| {

1639

		// free execution, full amount received

1640

1

		assert_eq!(

1641

1

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

1642

1

			Ok(U256::from(4000003100u64))

1643

);

1644

1

});

1645

1646

	// Register address

1647

1

	ParaA::execute_with(|| {

1648

1

		assert_ok!(XcmTransactor::register(

1649

1

			parachain::RuntimeOrigin::root(),

1650

1

			PARAALICE.into(),

1651

0,

1652

));

1653

1

});

1654

1655

	// Send to registered address

1656

1

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

1657

1

	let dest = Location {

1658

1

		parents: 1,

1659

1

		interior: [AccountId32 {

1660

1

			network: None,

1661

1

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

1662

1

}]

1663

1

		.into(),

1664

1

};

1665

1

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

1666

1667

1

	ParaA::execute_with(|| {

1668

1

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

1669

		// free execution, full amount received

1670

1

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

1671

1

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

1672

1

			assets: Wild(All),

1673

1

			beneficiary: beneficiary.clone(),

1674

1

		}]);

1675

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1676

1

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

1677

1

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

1678

1

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

1679

1

			Box::new(TransferType::DestinationReserve),

1680

1

			Box::new(fees_id),

1681

1

			Box::new(TransferType::DestinationReserve),

1682

1

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

1683

1

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

1684

));

1685

1

});

1686

1687

1

	ParaA::execute_with(|| {

1688

		// free execution, full amount received

1689

1

		assert_eq!(

1690

1

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

1691

1

			Ok(U256::from(4000003000u64))

1692

);

1693

1

});

1694

1695

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

1696

	// again

1697

1

	Relay::execute_with(|| {

1698

		// free execution,x	 full amount received

1699

1

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

1700

1

1701

1

});

1702

1703

	// We send the xcm transact operation to parent

1704

1

	let dest = Location {

1705

1

		parents: 1,

1706

1

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

1707

1

};

1708

1709

	// Encode the call. Balances transact to para_a_account

1710

	// First index

1711

1

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

1712

1

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

1713

1

		relay_chain::Balances,

1714

1

>()

1715

1

	.unwrap() as u8;

1716

1717

1

	encoded.push(index);

1718

1719

	// Then call bytes

1720

1

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

1721

1

		dest: para_a_account(),

1722

1

		value: 100u32.into(),

1723

1

1724

1

	.encode();

1725

1

	encoded.append(&mut call_bytes);

1726

1727

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

1728

1

	ParaA::execute_with(|| {

1729

1

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

1730

1

			parachain::MockTransactors::Relay,

1731

1

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

1732

);

1733

1734

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1735

1

			parachain::RuntimeOrigin::root(),

1736

1

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

1737

1

			Some(PARAALICE.into()),

1738

1

			CurrencyPayment {

1739

1

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

1740

1

					Location::parent()

1741

1

				))),

1742

1

				fee_amount: None

1743

1

},

1744

1

			utility_bytes,

1745

1

			OriginKind::SovereignAccount,

1746

1

			TransactWeights {

1747

1

				transact_required_weight_at_most: 4000000000.into(),

1748

1

				overall_weight: None

1749

1

},

1750

			false

1751

));

1752

1

});

1753

1754

1

	Relay::execute_with(|| {

1755

		// free execution,x	 full amount received

1756

1

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

1757

1758

1

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

1759

1

});

1760

1

1761

1762

#[test]

1763

1

fn transact_through_sovereign_fee_payer_none() {

1764

1

	MockNet::reset();

1765

1766

1

	ParaA::execute_with(|| {

1767

		// Root can set transact info

1768

1

		assert_ok!(XcmTransactor::set_transact_info(

1769

1

			parachain::RuntimeOrigin::root(),

1770

1

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

1771

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

1772

1

			3000.into(),

1773

1

			20000000000.into(),

1774

1

			None

1775

));

1776

		// Root can set transact info

1777

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

1778

1

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

1779

1

			.expect("must succeed");

1780

1

});

1781

1782

1

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

1783

1784

1

	Relay::execute_with(|| {

1785

		// Transfer 100 tokens to derivative_address on the relay

1786

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1787

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1788

1

			derivative_address.clone(),

1789

			100u128

1790

));

1791

1792

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

1793

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1794

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1795

1

			para_a_account(),

1796

			4000003000u128

1797

));

1798

1

});

1799

1800

	// Check balances before the transact call

1801

1

	Relay::execute_with(|| {

1802

1

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

1803

1

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

1804

1

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

1805

1

});

1806

1807

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

1808

1

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

1809

1

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

1810

1

		relay_chain::Balances,

1811

1

>()

1812

1

	.unwrap() as u8;

1813

1814

1

	encoded.push(index);

1815

1816

1

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

1817

1

		dest: RELAYBOB,

1818

1

		value: 100u32.into(),

1819

1

1820

1

	.encode();

1821

1

	encoded.append(&mut call_bytes);

1822

1823

	// We send the xcm transact operation to parent

1824

1

	let dest = Location {

1825

1

		parents: 1,

1826

1

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

1827

1

};

1828

1829

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

1830

1

	ParaA::execute_with(|| {

1831

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

1832

1

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

1833

1

			parachain::MockTransactors::Relay,

1834

1

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

1835

);

1836

1837

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1838

1

			parachain::RuntimeOrigin::root(),

1839

1

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

1840

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

1841

1

			None,

1842

1

			CurrencyPayment {

1843

1

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

1844

1

					Location::parent()

1845

1

				))),

1846

1

				fee_amount: None

1847

1

},

1848

1

			utility_bytes,

1849

1

			OriginKind::SovereignAccount,

1850

1

			TransactWeights {

1851

1

				transact_required_weight_at_most: 4000000000.into(),

1852

1

				overall_weight: None

1853

1

},

1854

			false

1855

));

1856

1

});

1857

1858

	// Check balances after the transact call are correct

1859

1

	Relay::execute_with(|| {

1860

1

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

1861

1

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

1862

1

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

1863

1

});

1864

1

1865

1866

#[test]

1867

1

fn transact_through_sovereign_with_custom_fee_weight() {

1868

1

	MockNet::reset();

1869

1870

1

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

1871

1

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

1872

1873

1

	let asset_metadata = parachain::AssetMetadata {

1874

1

		name: b"RelayToken".to_vec(),

1875

1

		symbol: b"Relay".to_vec(),

1876

1

		decimals: 12,

1877

1

};

1878

1879

1

	ParaA::execute_with(|| {

1880

1

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

1881

1

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

1882

1

			.try_into()

1883

1

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

1884

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1885

1

			source_id,

1886

1

			source_location_latest,

1887

1

			asset_metadata.decimals,

1888

1

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

1889

1

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

1890

));

1891

1

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

1892

1

});

1893

1894

1

	let dest: Location = AccountKey20 {

1895

1

		network: None,

1896

1

		key: PARAALICE,

1897

1

1898

1

	.into();

1899

1

	Relay::execute_with(|| {

1900

1

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

1901

1

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

1902

1

			assets: Wild(All),

1903

1

			beneficiary: dest.clone(),

1904

1

		}]);

1905

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1906

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1907

1

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

1908

1

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

1909

1

			Box::new(TransferType::LocalReserve),

1910

1

			Box::new(fees_id),

1911

1

			Box::new(TransferType::LocalReserve),

1912

1

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

1913

1

			WeightLimit::Unlimited

1914

));

1915

1

});

1916

1917

1

	ParaA::execute_with(|| {

1918

		// free execution, full amount received

1919

1

		assert_eq!(

1920

1

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

1921

1

			Ok(U256::from(4000003100u64))

1922

);

1923

1

});

1924

1925

	// Register address

1926

1

	ParaA::execute_with(|| {

1927

1

		assert_ok!(XcmTransactor::register(

1928

1

			parachain::RuntimeOrigin::root(),

1929

1

			PARAALICE.into(),

1930

0,

1931

));

1932

1

});

1933

1934

	// Send to registered address

1935

1

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

1936

1

	let dest = Location {

1937

1

		parents: 1,

1938

1

		interior: [AccountId32 {

1939

1

			network: None,

1940

1

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

1941

1

}]

1942

1

		.into(),

1943

1

};

1944

1

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

1945

1946

1

	ParaA::execute_with(|| {

1947

1

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

1948

		// free execution, full amount received

1949

1

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

1950

1

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

1951

1

			assets: Wild(All),

1952

1

			beneficiary: beneficiary.clone(),

1953

1

		}]);

1954

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1955

1

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

1956

1

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

1957

1

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

1958

1

			Box::new(TransferType::DestinationReserve),

1959

1

			Box::new(fees_id),

1960

1

			Box::new(TransferType::DestinationReserve),

1961

1

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

1962

1

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

1963

));

1964

1

});

1965

1966

1

	ParaA::execute_with(|| {

1967

		// free execution, full amount received

1968

1

		assert_eq!(

1969

1

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

1970

1

			Ok(U256::from(4000003000u64))

1971

);

1972

1

});

1973

1974

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

1975

	// again

1976

1

	Relay::execute_with(|| {

1977

		// free execution,x	 full amount received

1978

1

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

1979

1

1980

1

});

1981

1982

	// We send the xcm transact operation to parent

1983

1

	let dest = Location {

1984

1

		parents: 1,

1985

1

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

1986

1

};

1987

1988

	// Encode the call. Balances transact to para_a_account

1989

	// First index

1990

1

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

1991

1

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

1992

1

		relay_chain::Balances,

1993

1

>()

1994

1

	.unwrap() as u8;

1995

1996

1

	encoded.push(index);

1997

1998

	// Then call bytes

1999

1

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

2000

1

		dest: para_a_account(),

2001

1

		value: 100u32.into(),

2002

1

2003

1

	.encode();

2004

1

	encoded.append(&mut call_bytes);

2005

2006

1

	let total_weight = 4000003000u64;

2007

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

2008

1

	ParaA::execute_with(|| {

2009

1

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

2010

1

			parachain::MockTransactors::Relay,

2011

1

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

2012

);

2013

2014

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2015

1

			parachain::RuntimeOrigin::root(),

2016

1

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

2017

1

			Some(PARAALICE.into()),

2018

1

			CurrencyPayment {

2019

1

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

2020

1

					Location::parent()

2021

1

				))),

2022

1

				// 1-1 fee-weight mapping

2023

1

				fee_amount: Some(total_weight as u128)

2024

1

},

2025

1

			utility_bytes,

2026

1

			OriginKind::SovereignAccount,

2027

1

			TransactWeights {

2028

1

				transact_required_weight_at_most: 4000000000.into(),

2029

1

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

2030

1

},

2031

			false

2032

));

2033

1

});

2034

2035

1

	Relay::execute_with(|| {

2036

		// free execution,x	 full amount received

2037

1

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

2038

2039

1

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

2040

1

});

2041

1

2042

2043

#[test]

2044

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2045

1

	MockNet::reset();

2046

2047

1

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

2048

1

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

2049

2050

1

	let asset_metadata = parachain::AssetMetadata {

2051

1

		name: b"RelayToken".to_vec(),

2052

1

		symbol: b"Relay".to_vec(),

2053

1

		decimals: 12,

2054

1

};

2055

2056

1

	ParaA::execute_with(|| {

2057

1

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

2058

1

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

2059

1

			.try_into()

2060

1

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

2061

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2062

1

			source_id,

2063

1

			source_location_latest,

2064

1

			asset_metadata.decimals,

2065

1

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

2066

1

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

2067

));

2068

1

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

2069

1

});

2070

2071

1

	let dest: Location = AccountKey20 {

2072

1

		network: None,

2073

1

		key: PARAALICE,

2074

1

2075

1

	.into();

2076

1

	Relay::execute_with(|| {

2077

1

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

2078

1

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

2079

1

			assets: Wild(All),

2080

1

			beneficiary: dest.clone(),

2081

1

		}]);

2082

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2083

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2084

1

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

2085

1

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

2086

1

			Box::new(TransferType::LocalReserve),

2087

1

			Box::new(fees_id),

2088

1

			Box::new(TransferType::LocalReserve),

2089

1

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

2090

1

			WeightLimit::Unlimited

2091

));

2092

1

});

2093

2094

1

	ParaA::execute_with(|| {

2095

		// free execution, full amount received

2096

1

		assert_eq!(

2097

1

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

2098

1

			Ok(U256::from(4000009100u64))

2099

);

2100

1

});

2101

2102

	// Register address

2103

1

	ParaA::execute_with(|| {

2104

1

		assert_ok!(XcmTransactor::register(

2105

1

			parachain::RuntimeOrigin::root(),

2106

1

			PARAALICE.into(),

2107

0,

2108

));

2109

1

});

2110

2111

	// Send to registered address

2112

1

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

2113

1

	let dest = Location {

2114

1

		parents: 1,

2115

1

		interior: [AccountId32 {

2116

1

			network: None,

2117

1

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

2118

1

}]

2119

1

		.into(),

2120

1

};

2121

1

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

2122

2123

1

	ParaA::execute_with(|| {

2124

1

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

2125

		// free execution, full amount received

2126

1

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

2127

1

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

2128

1

			assets: Wild(All),

2129

1

			beneficiary: beneficiary.clone(),

2130

1

		}]);

2131

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2132

1

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

2133

1

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

2134

1

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

2135

1

			Box::new(TransferType::DestinationReserve),

2136

1

			Box::new(fees_id),

2137

1

			Box::new(TransferType::DestinationReserve),

2138

1

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

2139

1

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

2140

));

2141

1

});

2142

2143

1

	ParaA::execute_with(|| {

2144

		// free execution, full amount received

2145

1

		assert_eq!(

2146

1

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

2147

1

			Ok(U256::from(4000009000u64))

2148

);

2149

1

});

2150

2151

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

2152

	// again

2153

1

	Relay::execute_with(|| {

2154

		// free execution,x	 full amount received

2155

1

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

2156

1

2157

1

});

2158

2159

	// We send the xcm transact operation to parent

2160

1

	let dest = Location {

2161

1

		parents: 1,

2162

1

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

2163

1

};

2164

2165

	// Encode the call. Balances transact to para_a_account

2166

	// First index

2167

1

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

2168

1

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

2169

1

		relay_chain::Balances,

2170

1

>()

2171

1

	.unwrap() as u8;

2172

2173

1

	encoded.push(index);

2174

2175

	// Then call bytes

2176

1

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

2177

1

		dest: para_a_account(),

2178

1

		value: 100u32.into(),

2179

1

2180

1

	.encode();

2181

1

	encoded.append(&mut call_bytes);

2182

2183

1

	let total_weight = 4000009000u64;

2184

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

2185

1

	ParaA::execute_with(|| {

2186

1

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

2187

1

			parachain::MockTransactors::Relay,

2188

1

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

2189

);

2190

2191

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2192

1

			parachain::RuntimeOrigin::root(),

2193

1

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

2194

1

			Some(PARAALICE.into()),

2195

1

			CurrencyPayment {

2196

1

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

2197

1

					Location::parent()

2198

1

				))),

2199

1

				// 1-1 fee-weight mapping

2200

1

				fee_amount: Some(total_weight as u128)

2201

1

},

2202

1

			utility_bytes,

2203

1

			OriginKind::SovereignAccount,

2204

1

			TransactWeights {

2205

1

				transact_required_weight_at_most: 4000000000.into(),

2206

1

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

2207

1

},

2208

			true

2209

));

2210

1

});

2211

2212

1

	Relay::execute_with(|| {

2213

		// free execution, full amount received

2214

		// 4000009000 refunded + 100 transferred = 4000009100

2215

1

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

2216

2217

1

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

2218

1

});

2219

1

2220

2221

#[test]

2222

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2223

1

	MockNet::reset();

2224

2225

1

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

2226

1

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

2227

1

	let asset_metadata = parachain::AssetMetadata {

2228

1

		name: b"RelayToken".to_vec(),

2229

1

		symbol: b"Relay".to_vec(),

2230

1

		decimals: 12,

2231

1

};

2232

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

2233

1

	ParaA::execute_with(|| {

2234

1

		parachain::XcmVersioner::set_version(1);

2235

1

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

2236

1

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

2237

1

			.try_into()

2238

1

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

2239

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2240

1

			source_id,

2241

1

			source_location_latest,

2242

1

			asset_metadata.decimals,

2243

1

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

2244

1

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

2245

));

2246

1

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

2247

1

});

2248

2249

1

	let response = Response::Version(2);

2250

1

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

2251

2252

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

2253

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

2254

1

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

2255

1

		query_id: 0,

2256

1

		response,

2257

1

		max_weight: Weight::zero(),

2258

1

		querier: Some(querier),

2259

1

	}]);

2260

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

2261

	// it directly here

2262

	// Actually send relay asset to parachain

2263

1

	let dest: Location = AccountKey20 {

2264

1

		network: None,

2265

1

		key: PARAALICE,

2266

1

2267

1

	.into();

2268

2269

1

	Relay::execute_with(|| {

2270

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

2271

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2272

1

			relay_chain::RuntimeOrigin::root(),

2273

1

			Some(3)

2274

));

2275

2276

		// Wrap version, which sets VersionedStorage

2277

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

2278

		// this is not necessary in prod

2279

1

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

2280

1

			&Parachain(1).into(),

2281

1

			mock_message

2282

));

2283

2284

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

2285

1

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

2286

1

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

2287

1

			assets: Wild(All),

2288

1

			beneficiary: dest.clone(),

2289

1

		}]);

2290

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2291

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2292

1

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

2293

1

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

2294

1

			Box::new(TransferType::LocalReserve),

2295

1

			Box::new(fees_id),

2296

1

			Box::new(TransferType::LocalReserve),

2297

1

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

2298

1

			WeightLimit::Unlimited

2299

));

2300

2301

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

2302

1

		relay_chain::relay_roll_to(2);

2303

2304

		// queries should have been updated

2305

1

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

2306

1

});

2307

2308

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2309

1

		pallet_xcm::Event::SupportedVersionChanged {

2310

1

			location: Location {

2311

1

				parents: 0,

2312

1

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

2313

1

},

2314

1

			version: 1,

2315

1

2316

1

		.into();

2317

2318

1

	Relay::execute_with(|| {

2319

		// Assert that the events vector contains the version change

2320

1

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

2321

1

});

2322

2323

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

2324

	// of the new version change

2325

1

	ParaA::execute_with(|| {

2326

		// Set version

2327

1

		parachain::XcmVersioner::set_version(2);

2328

		// Do runtime upgrade

2329

1

		parachain::on_runtime_upgrade();

2330

		// Initialize block, to call on_initialize and notify targets

2331

1

		parachain::para_roll_to(2);

2332

		// Expect the event in the parachain

2333

1

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

2334

2

e,

2335

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

2336

				result: 2,

2337

..

2338

})

2339

		)));

2340

1

});

2341

2342

	// This event should have been seen in the relay

2343

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2344

1

		pallet_xcm::Event::SupportedVersionChanged {

2345

1

			location: Location {

2346

1

				parents: 0,

2347

1

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

2348

1

},

2349

1

			version: 2,

2350

1

2351

1

		.into();

2352

2353

1

	Relay::execute_with(|| {

2354

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

2355

1

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

2356

1

});

2357

1

2358

2359

#[test]

2360

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2361

1

	MockNet::reset();

2362

2363

1

	let fresh_account = PARABOB;

2364

1

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

2365

1

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

2366

1

	let asset_metadata = parachain::AssetMetadata {

2367

1

		name: b"RelayToken".to_vec(),

2368

1

		symbol: b"Relay".to_vec(),

2369

1

		decimals: 12,

2370

1

};

2371

	// register relay asset in parachain A

2372

1

	ParaA::execute_with(|| {

2373

1

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

2374

1

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

2375

1

			.try_into()

2376

1

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

2377

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2378

1

			source_id,

2379

1

			source_location_latest,

2380

1

			asset_metadata.decimals,

2381

1

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

2382

1

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

2383

));

2384

1

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

2385

1

});

2386

2387

	// Actually send relay asset to parachain

2388

1

	let dest: Location = AccountKey20 {

2389

1

		network: None,

2390

1

		key: fresh_account,

2391

1

2392

1

	.into();

2393

1

	Relay::execute_with(|| {

2394

1

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

2395

1

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

2396

1

			assets: Wild(All),

2397

1

			beneficiary: dest.clone(),

2398

1

		}]);

2399

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2400

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2401

1

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

2402

1

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

2403

1

			Box::new(TransferType::LocalReserve),

2404

1

			Box::new(fees_id),

2405

1

			Box::new(TransferType::LocalReserve),

2406

1

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

2407

1

			WeightLimit::Unlimited

2408

));

2409

1

});

2410

2411

	// parachain should have received assets

2412

1

	ParaA::execute_with(|| {

2413

		// free execution, full amount received

2414

1

		assert_eq!(

2415

1

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

2416

1

			Ok(U256::from(123))

2417

);

2418

1

});

2419

1

2420

2421

#[test]

2422

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2423

1

	MockNet::reset();

2424

2425

1

	let fresh_account = [2u8; 20];

2426

1

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

2427

1

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

2428

1

	let asset_metadata = parachain::AssetMetadata {

2429

1

		name: b"RelayToken".to_vec(),

2430

1

		symbol: b"Relay".to_vec(),

2431

1

		decimals: 12,

2432

1

};

2433

	// register relay asset in parachain A

2434

1

	ParaA::execute_with(|| {

2435

1

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

2436

1

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

2437

1

			.try_into()

2438

1

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

2439

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2440

1

			source_id,

2441

1

			source_location_latest,

2442

1

			asset_metadata.decimals,

2443

1

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

2444

1

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

2445

));

2446

1

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

2447

1

});

2448

2449

	// Actually send relay asset to parachain

2450

1

	let dest: Location = AccountKey20 {

2451

1

		network: None,

2452

1

		key: fresh_account,

2453

1

2454

1

	.into();

2455

1

	Relay::execute_with(|| {

2456

1

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

2457

1

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

2458

1

			assets: Wild(All),

2459

1

			beneficiary: dest.clone(),

2460

1

		}]);

2461

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2462

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2463

1

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

2464

1

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

2465

1

			Box::new(TransferType::LocalReserve),

2466

1

			Box::new(fees_id),

2467

1

			Box::new(TransferType::LocalReserve),

2468

1

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

2469

1

			WeightLimit::Unlimited

2470

));

2471

1

});

2472

2473

	// parachain should have received assets

2474

1

	ParaA::execute_with(|| {

2475

		// free execution, full amount received

2476

1

		assert_eq!(

2477

1

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

2478

1

			Ok(U256::from(123))

2479

);

2480

1

});

2481

1

2482

2483

#[test]

2484

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2485

1

	MockNet::reset();

2486

2487

1

	let mut sufficient_account = [0u8; 20];

2488

1

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

2489

2490

1

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

2491

2492

	// Evm account is self sufficient

2493

1

	ParaA::execute_with(|| {

2494

1

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

2495

1

});

2496

2497

1

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

2498

1

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

2499

1

	let asset_metadata = parachain::AssetMetadata {

2500

1

		name: b"RelayToken".to_vec(),

2501

1

		symbol: b"Relay".to_vec(),

2502

1

		decimals: 12,

2503

1

};

2504

	// register relay asset in parachain A

2505

1

	ParaA::execute_with(|| {

2506

1

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

2507

1

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

2508

1

			.try_into()

2509

1

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

2510

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2511

1

			source_id,

2512

1

			source_location_latest,

2513

1

			asset_metadata.decimals,

2514

1

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

2515

1

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

2516

));

2517

1

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

2518

1

});

2519

2520

	// Actually send relay asset to parachain

2521

1

	let dest: Location = AccountKey20 {

2522

1

		network: None,

2523

1

		key: sufficient_account,

2524

1

2525

1

	.into();

2526

1

	Relay::execute_with(|| {

2527

1

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

2528

1

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

2529

1

			assets: Wild(All),

2530

1

			beneficiary: dest.clone(),

2531

1

		}]);

2532

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2533

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2534

1

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

2535

1

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

2536

1

			Box::new(TransferType::LocalReserve),

2537

1

			Box::new(fees_id),

2538

1

			Box::new(TransferType::LocalReserve),

2539

1

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

2540

1

			WeightLimit::Unlimited

2541

));

2542

1

});

2543

2544

	// Evm account sufficient ref count increased by 1.

2545

1

	ParaA::execute_with(|| {

2546

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

2547

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

2548

		// will be implemented in a future release

2549

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

2550

1

});

2551

2552

1

	ParaA::execute_with(|| {

2553

		// Remove the account from the evm context.

2554

1

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

2555

		// Evm account sufficient ref count decreased by 1.

2556

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

2557

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

2558

		// will be implemented in a future release

2559

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

2560

1

});

2561

1

2562

2563

#[test]

2564

1

fn empty_account_should_not_be_reset() {

2565

1

	MockNet::reset();

2566

2567

	// Test account has nonce 1 on genesis.

2568

1

	let sufficient_account = PARABOB;

2569

2570

1

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

2571

2572

1

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

2573

1

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

2574

1

	let asset_metadata = parachain::AssetMetadata {

2575

1

		name: b"RelayToken".to_vec(),

2576

1

		symbol: b"Relay".to_vec(),

2577

1

		decimals: 12,

2578

1

};

2579

	// register relay asset in parachain A

2580

1

	ParaA::execute_with(|| {

2581

1

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

2582

1

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

2583

1

			.try_into()

2584

1

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

2585

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2586

1

			source_id,

2587

1

			source_location_latest,

2588

1

			asset_metadata.decimals,

2589

1

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

2590

1

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

2591

));

2592

1

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

2593

1

});

2594

2595

	// Send native token to evm_account

2596

1

	ParaA::execute_with(|| {

2597

1

		assert_ok!(ParaBalances::transfer_allow_death(

2598

1

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

2599

1

			evm_account_id,

2600

2601

));

2602

1

});

2603

2604

	// Actually send relay asset to parachain

2605

1

	let dest: Location = AccountKey20 {

2606

1

		network: None,

2607

1

		key: sufficient_account,

2608

1

2609

1

	.into();

2610

1

	Relay::execute_with(|| {

2611

1

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

2612

1

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

2613

1

			assets: Wild(All),

2614

1

			beneficiary: dest.clone(),

2615

1

		}]);

2616

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2617

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2618

1

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

2619

1

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

2620

1

			Box::new(TransferType::LocalReserve),

2621

1

			Box::new(fees_id),

2622

1

			Box::new(TransferType::LocalReserve),

2623

1

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

2624

1

			WeightLimit::Unlimited

2625

));

2626

1

});

2627

2628

1

	ParaA::execute_with(|| {

2629

		// Empty the assets from the account.

2630

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

2631

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

2632

		// Transfer using EvmForeignAssets

2633

1

		assert_ok!(EvmForeignAssets::transfer(

2634

1

			source_id,

2635

1

			evm_account_id,

2636

1

			PARAALICE.into(),

2637

1

			U256::from(123)

2638

));

2639

		// Verify account asset balance is Zero.

2640

1

		assert_eq!(

2641

1

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

2642

1

			Ok(U256::from(0))

2643

);

2644

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

2645

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

2646

1

		assert_ok!(ParaBalances::force_set_balance(

2647

1

			parachain::RuntimeOrigin::root(),

2648

1

			evm_account_id,

2649

0,

2650

));

2651

		// Verify account native balance is Zero.

2652

1

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

2653

		// Remove the account from the evm context.

2654

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

2655

1

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

2656

		// Verify reference count.

2657

1

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

2658

1

		assert_eq!(account.sufficients, 0);

2659

1

		assert_eq!(account.consumers, 0);

2660

1

		assert_eq!(account.providers, 1);

2661

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

2662

1

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

2663

1

});

2664

1

2665

2666

#[test]

2667

1

fn test_statemint_like() {

2668

1

	MockNet::reset();

2669

2670

1

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

2671

2672

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2673

1

		polkadot_parachain::primitives::Sibling,

2674

1

		statemint_like::AccountId,

2675

1

	>::convert_location(&dest_para)

2676

1

	.unwrap();

2677

2678

1

	let statemint_asset_a_balances = Location::new(

2679

1,

2680

1

2681

1

			Parachain(1000),

2682

1

			PalletInstance(5),

2683

1

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

2684

1

],

2685

);

2686

1

	let source_location: AssetType = statemint_asset_a_balances

2687

1

		.try_into()

2688

1

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

2689

1

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

2690

2691

1

	let asset_metadata = parachain::AssetMetadata {

2692

1

		name: b"StatemintToken".to_vec(),

2693

1

		symbol: b"StatemintToken".to_vec(),

2694

1

		decimals: 12,

2695

1

};

2696

2697

1

	ParaA::execute_with(|| {

2698

1

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

2699

1

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

2700

1

			.try_into()

2701

1

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

2702

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2703

1

			source_id,

2704

1

			source_location_latest,

2705

1

			asset_metadata.decimals,

2706

1

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

2707

1

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

2708

));

2709

1

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

2710

1

});

2711

2712

1

	Statemint::execute_with(|| {

2713

		// Set new prefix

2714

1

		statemint_like::PrefixChanger::set_prefix(

2715

1

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

2716

);

2717

2718

1

		assert_ok!(StatemintAssets::create(

2719

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2720

0,

2721

			RELAYALICE,

2722

2723

));

2724

2725

1

		assert_ok!(StatemintAssets::mint(

2726

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2727

0,

2728

			RELAYALICE,

2729

			300000000000000

2730

));

2731

2732

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

2733

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2734

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2735

1

			sov,

2736

			100000000000000

2737

));

2738

2739

		// Actually send relay asset to parachain

2740

1

		let dest: Location = AccountKey20 {

2741

1

			network: None,

2742

1

			key: PARAALICE,

2743

1

2744

1

		.into();

2745

2746

		// Send with new prefix

2747

1

		let assets: VersionedAssets = (

2748

1

2749

1

				xcm::latest::prelude::PalletInstance(

2750

1

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

2751

1

),

2752

1

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

2753

1

],

2754

1

			123,

2755

1

2756

1

			.into();

2757

1

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

2758

1

0,

2759

1

2760

1

				xcm::latest::prelude::PalletInstance(

2761

1

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

2762

1

),

2763

1

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

2764

1

],

2765

1

))

2766

1

		.into();

2767

1

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

2768

1

			assets: Wild(All),

2769

1

			beneficiary: dest.clone(),

2770

1

		}]);

2771

1

		assert_ok!(

2772

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

2773

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

2774

1

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

2775

1

				Box::new(assets),

2776

1

				Box::new(TransferType::LocalReserve),

2777

1

				Box::new(fees_id),

2778

1

				Box::new(TransferType::LocalReserve),

2779

1

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

2780

1

				WeightLimit::Unlimited

2781

2782

);

2783

1

});

2784

2785

1

	ParaA::execute_with(|| {

2786

1

		assert_eq!(

2787

1

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

2788

1

			Ok(U256::from(123))

2789

);

2790

1

});

2791

1

2792

2793

#[test]

2794

2795

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2796

1

	MockNet::reset();

2797

2798

	// Relay asset

2799

1

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

2800

1

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

2801

2802

1

	let relay_asset_metadata = parachain::AssetMetadata {

2803

1

		name: b"RelayToken".to_vec(),

2804

1

		symbol: b"Relay".to_vec(),

2805

1

		decimals: 12,

2806

1

};

2807

2808

	// Statemint asset

2809

1

	let statemint_asset = Location::new(

2810

1,

2811

1

2812

1

			Parachain(1000u32),

2813

1

			PalletInstance(5u8),

2814

1

			GeneralIndex(10u128),

2815

1

],

2816

);

2817

1

	let statemint_location_asset: AssetType = statemint_asset

2818

1

		.clone()

2819

1

		.try_into()

2820

1

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

2821

1

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

2822

2823

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2824

1

		name: b"USDC".to_vec(),

2825

1

		symbol: b"USDC".to_vec(),

2826

1

		decimals: 12,

2827

1

};

2828

2829

1

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

2830

2831

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2832

1

		polkadot_parachain::primitives::Sibling,

2833

1

		statemint_like::AccountId,

2834

1

	>::convert_location(&dest_para)

2835

1

	.unwrap();

2836

2837

1

	ParaA::execute_with(|| {

2838

1

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

2839

1

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

2840

1

			.try_into()

2841

1

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

2842

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2843

1

			source_relay_id,

2844

1

			source_location_latest,

2845

1

			relay_asset_metadata.decimals,

2846

1

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

2847

1

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

2848

));

2849

1

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

2850

2851

1

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

2852

1

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

2853

1

			.try_into()

2854

1

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

2855

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2856

1

			source_statemint_asset_id,

2857

1

			source_location_latest,

2858

1

			asset_metadata_statemint_asset.decimals,

2859

1

			asset_metadata_statemint_asset

2860

1

				.symbol

2861

1

				.try_into()

2862

1

				.expect("too long"),

2863

1

			asset_metadata_statemint_asset

2864

1

				.name

2865

1

				.try_into()

2866

1

				.expect("too long"),

2867

));

2868

1

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

2869

1

});

2870

2871

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2872

1

		network: None,

2873

1

		key: PARAALICE,

2874

1

2875

1

	.into();

2876

2877

	// Send relay chain asset to Alice in Parachain A

2878

1

	Relay::execute_with(|| {

2879

1

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

2880

1

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

2881

1

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

2882

1

			assets: Wild(All),

2883

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

2884

1

		}]);

2885

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2886

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2887

1

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

2888

1

			Box::new(assets),

2889

1

			Box::new(TransferType::LocalReserve),

2890

1

			Box::new(fees_id),

2891

1

			Box::new(TransferType::LocalReserve),

2892

1

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

2893

1

			WeightLimit::Unlimited

2894

));

2895

1

});

2896

2897

1

	Statemint::execute_with(|| {

2898

		// Set new prefix

2899

1

		statemint_like::PrefixChanger::set_prefix(

2900

1

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

2901

);

2902

2903

1

		assert_ok!(StatemintAssets::create(

2904

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2905

10,

2906

			RELAYALICE,

2907

2908

));

2909

2910

1

		assert_ok!(StatemintAssets::mint(

2911

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2912

10,

2913

			RELAYALICE,

2914

			300000000000000

2915

));

2916

2917

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

2918

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

2919

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2920

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2921

1

			sov,

2922

			100000000000000

2923

));

2924

2925

		// Send statemint USDC asset to Alice in Parachain A

2926

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2927

1

			network: None,

2928

1

			key: PARAALICE,

2929

1

2930

1

		.into();

2931

2932

		// Send with new prefix

2933

1

		let assets: VersionedAssets = (

2934

1

2935

1

				xcm::latest::prelude::PalletInstance(

2936

1

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

2937

1

),

2938

1

				GeneralIndex(10),

2939

1

],

2940

1

			125,

2941

1

2942

1

			.into();

2943

1

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

2944

1

0,

2945

1

2946

1

				xcm::latest::prelude::PalletInstance(

2947

1

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

2948

1

),

2949

1

				GeneralIndex(10),

2950

1

],

2951

1

))

2952

1

		.into();

2953

1

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

2954

1

			assets: Wild(All),

2955

1

			beneficiary: parachain_beneficiary_from_statemint.clone(),

2956

1

		}]);

2957

1

		assert_ok!(

2958

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

2959

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

2960

1

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

2961

1

				Box::new(assets),

2962

1

				Box::new(TransferType::LocalReserve),

2963

1

				Box::new(fees_id),

2964

1

				Box::new(TransferType::LocalReserve),

2965

1

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

2966

1

				WeightLimit::Unlimited

2967

2968

);

2969

1

});

2970

2971

1

	let statemint_beneficiary = Location {

2972

1

		parents: 1,

2973

1

		interior: [

2974

1

			Parachain(1000),

2975

1

			AccountId32 {

2976

1

				network: None,

2977

1

				id: RELAYBOB.into(),

2978

1

},

2979

1

2980

1

		.into(),

2981

1

};

2982

2983

1

	ParaA::execute_with(|| {

2984

		// Alice has received 125 USDC

2985

1

		assert_eq!(

2986

1

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

2987

1

			Ok(U256::from(125))

2988

);

2989

2990

		// Alice has received 200 Relay assets

2991

1

		assert_eq!(

2992

1

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

2993

1

			Ok(U256::from(200))

2994

);

2995

1

});

2996

2997

1

	Statemint::execute_with(|| {

2998

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

2999

1

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

3000

1

});

3001

1

	let (chain_part, beneficiary) =

3002

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

3003

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

3004

1

	ParaA::execute_with(|| {

3005

1

		let asset = currency_to_asset(

3006

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3007

			100,

3008

);

3009

1

		let asset_fee =

3010

1

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

3011

1

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

3012

1

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

3013

3014

1

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

3015

1

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

3016

1

			assets: Wild(All),

3017

1

			beneficiary: beneficiary.clone(),

3018

1

		}]);

3019

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3020

1

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

3021

1

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

3022

1

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

3023

1

			Box::new(TransferType::DestinationReserve),

3024

1

			Box::new(fees_id),

3025

1

			Box::new(TransferType::DestinationReserve),

3026

1

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

3027

1

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

3028

));

3029

1

});

3030

3031

1

	ParaA::execute_with(|| {

3032

		// Alice has 100 USDC less

3033

1

		assert_eq!(

3034

1

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

3035

1

			Ok(U256::from(25))

3036

);

3037

3038

		// Alice has 100 relay asset less

3039

1

		assert_eq!(

3040

1

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

3041

1

			Ok(U256::from(100))

3042

);

3043

1

});

3044

3045

1

	Statemint::execute_with(|| {

3046

1

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

3047

		// Check that BOB received 100 USDC on statemint

3048

1

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

3049

1

});

3050

1

3051

3052

#[test]

3053

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3054

1

	MockNet::reset();

3055

3056

	// Relay asset

3057

1

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

3058

1

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

3059

3060

1

	let relay_asset_metadata = parachain::AssetMetadata {

3061

1

		name: b"RelayToken".to_vec(),

3062

1

		symbol: b"Relay".to_vec(),

3063

1

		decimals: 12,

3064

1

};

3065

3066

1

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

3067

3068

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3069

1

		polkadot_parachain::primitives::Sibling,

3070

1

		statemint_like::AccountId,

3071

1

	>::convert_location(&dest_para)

3072

1

	.unwrap();

3073

3074

1

	ParaA::execute_with(|| {

3075

1

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

3076

1

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

3077

1

			.try_into()

3078

1

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

3079

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3080

1

			source_relay_id,

3081

1

			source_location_latest,

3082

1

			relay_asset_metadata.decimals,

3083

1

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

3084

1

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

3085

));

3086

1

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

3087

1

});

3088

3089

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3090

1

		network: None,

3091

1

		key: PARAALICE,

3092

1

3093

1

	.into();

3094

3095

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3096

1

		network: None,

3097

1

		id: RELAYALICE.into(),

3098

1

3099

1

	.into();

3100

3101

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

3102

1

	Relay::execute_with(|| {

3103

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3104

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3105

1

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

3106

1

			Box::new(

3107

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3108

1

					.clone()

3109

1

					.into()

3110

),

3111

1

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

3112

0,

3113

1

			WeightLimit::Unlimited

3114

));

3115

1

});

3116

3117

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3118

1

	Statemint::execute_with(|| {

3119

		// Check Alice received 200 tokens on AssetHub

3120

1

		assert_eq!(

3121

1

			StatemintBalances::free_balance(RELAYALICE),

3122

			INITIAL_BALANCE + 200

3123

);

3124

3125

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3126

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3127

1

			sov,

3128

			110000000000000

3129

));

3130

3131

		// Now send those tokens to ParaA

3132

1

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

3133

1

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

3134

1

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

3135

1

			assets: Wild(All),

3136

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3137

1

		}]);

3138

1

		assert_ok!(

3139

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3140

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3141

1

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

3142

1

				Box::new(assets),

3143

1

				Box::new(TransferType::LocalReserve),

3144

1

				Box::new(fees_id),

3145

1

				Box::new(TransferType::LocalReserve),

3146

1

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

3147

1

				WeightLimit::Unlimited

3148

3149

);

3150

1

});

3151

3152

1

	ParaA::execute_with(|| {

3153

		// Alice should have received the DOTs

3154

1

		assert_eq!(

3155

1

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

3156

1

			Ok(U256::from(200))

3157

);

3158

1

});

3159

3160

1

	let dest = Location::new(

3161

1,

3162

1

3163

1

			Parachain(1000),

3164

1

			AccountId32 {

3165

1

				network: None,

3166

1

				id: RELAYBOB.into(),

3167

1

},

3168

1

],

3169

);

3170

1

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

3171

3172

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

3173

1

	ParaA::execute_with(|| {

3174

1

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

3175

1

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

3176

1

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

3177

1

			assets: Wild(All),

3178

1

			beneficiary: beneficiary.clone(),

3179

1

		}]);

3180

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3181

1

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

3182

1

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

3183

1

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

3184

1

			Box::new(TransferType::DestinationReserve),

3185

1

			Box::new(fees_id),

3186

1

			Box::new(TransferType::DestinationReserve),

3187

1

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

3188

1

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

3189

));

3190

3191

1

		assert_eq!(

3192

1

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

3193

1

			Ok(U256::from(100))

3194

);

3195

1

});

3196

3197

1

	Statemint::execute_with(|| {

3198

		// Check that Bob received the tokens back in AssetHub

3199

1

		assert_eq!(

3200

1

			StatemintBalances::free_balance(RELAYBOB),

3201

			INITIAL_BALANCE + 100

3202

);

3203

1

});

3204

3205

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

3206

1

	Statemint::execute_with(|| {

3207

		// Now send those tokens to ParaA

3208

1

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

3209

1

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

3210

1

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

3211

1

			assets: Wild(All),

3212

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3213

1

		}]);

3214

1

		assert_ok!(

3215

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3216

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3217

1

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

3218

1

				Box::new(assets),

3219

1

				Box::new(TransferType::LocalReserve),

3220

1

				Box::new(fees_id),

3221

1

				Box::new(TransferType::LocalReserve),

3222

1

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

3223

1

				WeightLimit::Unlimited

3224

3225

);

3226

3227

		// 100 DOTs were deducted from Bob's account

3228

1

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

3229

1

});

3230

3231

1

	ParaA::execute_with(|| {

3232

		// Alice should have received 100 DOTs

3233

1

		assert_eq!(

3234

1

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

3235

1

			Ok(U256::from(200))

3236

);

3237

1

});

3238

1

3239

3240

#[test]

3241

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3242

1

	MockNet::reset();

3243

3244

	// Relay asset

3245

1

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

3246

1

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

3247

3248

1

	let relay_asset_metadata = parachain::AssetMetadata {

3249

1

		name: b"RelayToken".to_vec(),

3250

1

		symbol: b"Relay".to_vec(),

3251

1

		decimals: 12,

3252

1

};

3253

3254

1

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

3255

3256

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3257

1

		polkadot_parachain::primitives::Sibling,

3258

1

		statemint_like::AccountId,

3259

1

	>::convert_location(&dest_para)

3260

1

	.unwrap();

3261

3262

1

	ParaA::execute_with(|| {

3263

1

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

3264

1

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

3265

1

			.try_into()

3266

1

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

3267

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3268

1

			source_relay_id,

3269

1

			source_location_latest,

3270

1

			relay_asset_metadata.decimals,

3271

1

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

3272

1

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

3273

));

3274

1

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

3275

1

});

3276

3277

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3278

1

		network: None,

3279

1

		key: PARAALICE,

3280

1

3281

1

	.into();

3282

3283

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3284

1

		network: None,

3285

1

		id: RELAYALICE.into(),

3286

1

3287

1

	.into();

3288

3289

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

3290

1

	Relay::execute_with(|| {

3291

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3292

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3293

1

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

3294

1

			Box::new(

3295

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3296

1

					.clone()

3297

1

					.into()

3298

),

3299

1

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

3300

0,

3301

1

			WeightLimit::Unlimited

3302

));

3303

1

});

3304

3305

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3306

1

	Statemint::execute_with(|| {

3307

		// Check Alice received 200 tokens on AssetHub

3308

1

		assert_eq!(

3309

1

			StatemintBalances::free_balance(RELAYALICE),

3310

			INITIAL_BALANCE + 200

3311

);

3312

3313

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3314

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3315

1

			sov,

3316

			110000000000000

3317

));

3318

3319

		// Now send those tokens to ParaA

3320

1

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

3321

1

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

3322

1

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

3323

1

			assets: Wild(All),

3324

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3325

1

		}]);

3326

1

		assert_ok!(

3327

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3328

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3329

1

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

3330

1

				Box::new(assets),

3331

1

				Box::new(TransferType::LocalReserve),

3332

1

				Box::new(fees_id),

3333

1

				Box::new(TransferType::LocalReserve),

3334

1

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

3335

1

				WeightLimit::Unlimited

3336

3337

);

3338

1

});

3339

3340

1

	ParaA::execute_with(|| {

3341

		// Alice should have received the DOTs

3342

1

		assert_eq!(

3343

1

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

3344

1

			Ok(U256::from(200))

3345

);

3346

1

});

3347

3348

1

	let dest = Location::new(

3349

1,

3350

1

3351

1

			Parachain(1000),

3352

1

			AccountId32 {

3353

1

				network: None,

3354

1

				id: RELAYBOB.into(),

3355

1

},

3356

1

],

3357

);

3358

1

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

3359

3360

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

3361

1

	ParaA::execute_with(|| {

3362

1

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

3363

1

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

3364

1

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

3365

1

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

3366

1

			assets: Wild(All),

3367

1

			beneficiary: beneficiary.clone(),

3368

1

		}]);

3369

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3370

1

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

3371

1

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

3372

1

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

3373

1

			Box::new(TransferType::DestinationReserve),

3374

1

			Box::new(fees_id),

3375

1

			Box::new(TransferType::DestinationReserve),

3376

1

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

3377

1

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

3378

));

3379

3380

1

		assert_eq!(

3381

1

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

3382

1

			Ok(U256::from(90))

3383

);

3384

1

});

3385

3386

1

	Statemint::execute_with(|| {

3387

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

3388

1

		assert_eq!(

3389

1

			StatemintBalances::free_balance(RELAYBOB),

3390

			INITIAL_BALANCE + 110

3391

);

3392

1

});

3393

3394

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

3395

1

	Statemint::execute_with(|| {

3396

		// Now send those tokens to ParaA

3397

1

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

3398

1

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

3399

1

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

3400

1

			assets: Wild(All),

3401

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3402

1

		}]);

3403

1

		assert_ok!(

3404

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3405

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3406

1

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

3407

1

				Box::new(assets),

3408

1

				Box::new(TransferType::LocalReserve),

3409

1

				Box::new(fees_id),

3410

1

				Box::new(TransferType::LocalReserve),

3411

1

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

3412

1

				WeightLimit::Unlimited

3413

3414

);

3415

3416

		// 100 DOTs were deducted from Bob's account

3417

1

		assert_eq!(

3418

1

			StatemintBalances::free_balance(RELAYBOB),

3419

			INITIAL_BALANCE + 10

3420

);

3421

1

});

3422

3423

1

	ParaA::execute_with(|| {

3424

		// Alice should have received 100 DOTs

3425

1

		assert_eq!(

3426

1

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

3427

1

			Ok(U256::from(190))

3428

);

3429

1

});

3430

1

3431

3432

#[test]

3433

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3434

1

	MockNet::reset();

3435

3436

	// Relay asset

3437

1

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

3438

1

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

3439

3440

1

	let relay_asset_metadata = parachain::AssetMetadata {

3441

1

		name: b"RelayToken".to_vec(),

3442

1

		symbol: b"Relay".to_vec(),

3443

1

		decimals: 12,

3444

1

};

3445

3446

1

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

3447

3448

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3449

1

		polkadot_parachain::primitives::Sibling,

3450

1

		statemint_like::AccountId,

3451

1

	>::convert_location(&dest_para)

3452

1

	.unwrap();

3453

3454

1

	ParaA::execute_with(|| {

3455

1

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

3456

1

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

3457

1

			.try_into()

3458

1

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

3459

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3460

1

			source_relay_id,

3461

1

			source_location_latest,

3462

1

			relay_asset_metadata.decimals,

3463

1

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

3464

1

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

3465

));

3466

1

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

3467

1

});

3468

3469

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3470

1

		network: None,

3471

1

		key: PARAALICE,

3472

1

3473

1

	.into();

3474

3475

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3476

1

		network: None,

3477

1

		id: RELAYALICE.into(),

3478

1

3479

1

	.into();

3480

3481

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

3482

1

	Relay::execute_with(|| {

3483

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3484

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3485

1

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

3486

1

			Box::new(

3487

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3488

1

					.clone()

3489

1

					.into()

3490

),

3491

1

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

3492

0,

3493

1

			WeightLimit::Unlimited

3494

));

3495

1

});

3496

3497

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3498

1

	Statemint::execute_with(|| {

3499

		// Check Alice received 200 tokens on AssetHub

3500

1

		assert_eq!(

3501

1

			StatemintBalances::free_balance(RELAYALICE),

3502

			INITIAL_BALANCE + 200

3503

);

3504

3505

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3506

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3507

1

			sov,

3508

			110000000000000

3509

));

3510

3511

		// Now send those tokens to ParaA

3512

1

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

3513

1

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

3514

1

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

3515

1

			assets: Wild(All),

3516

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3517

1

		}]);

3518

1

		assert_ok!(

3519

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3520

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3521

1

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

3522

1

				Box::new(assets),

3523

1

				Box::new(TransferType::LocalReserve),

3524

1

				Box::new(fees_id),

3525

1

				Box::new(TransferType::LocalReserve),

3526

1

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

3527

1

				WeightLimit::Unlimited

3528

3529

);

3530

1

});

3531

3532

1

	ParaA::execute_with(|| {

3533

		// Alice should have received the DOTs

3534

1

		assert_eq!(

3535

1

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

3536

1

			Ok(U256::from(200))

3537

);

3538

1

});

3539

3540

1

	let dest = Location::new(

3541

1,

3542

1

3543

1

			Parachain(1000),

3544

1

			AccountId32 {

3545

1

				network: None,

3546

1

				id: RELAYBOB.into(),

3547

1

},

3548

1

],

3549

);

3550

1

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

3551

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

3552

1

	ParaA::execute_with(|| {

3553

1

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

3554

1

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

3555

1

			assets: Wild(All),

3556

1

			beneficiary: beneficiary.clone(),

3557

1

		}]);

3558

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3559

1

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

3560

1

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

3561

1

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

3562

1

			Box::new(TransferType::DestinationReserve),

3563

1

			Box::new(fees_id),

3564

1

			Box::new(TransferType::DestinationReserve),

3565

1

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

3566

1

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

3567

));

3568

3569

1

		assert_eq!(

3570

1

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

3571

1

			Ok(U256::from(100))

3572

);

3573

1

});

3574

3575

1

	Statemint::execute_with(|| {

3576

		// Check that Bob received the tokens back in AssetHub

3577

1

		assert_eq!(

3578

1

			StatemintBalances::free_balance(RELAYBOB),

3579

			INITIAL_BALANCE + 100

3580

);

3581

1

});

3582

3583

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

3584

1

	Statemint::execute_with(|| {

3585

		// Now send those tokens to ParaA

3586

1

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

3587

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3588

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3589

1

			assets: Wild(All),

3590

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3591

1

		}]);

3592

1

		assert_ok!(

3593

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3594

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3595

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3596

1

				Box::new(assets),

3597

1

				Box::new(TransferType::LocalReserve),

3598

1

				Box::new(fees_id),

3599

1

				Box::new(TransferType::LocalReserve),

3600

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3601

1

				WeightLimit::Unlimited

3602

3603

);

3604

3605

		// 100 DOTs were deducted from Bob's account

3606

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3607

1

});

3608

3609

1

	ParaA::execute_with(|| {

3610

		// Alice should have received 100 DOTs

3611

1

		assert_eq!(

3612

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3613

1

			Ok(U256::from(200))

3614

);

3615

1

});

3616

1

3617

3618

#[test]

3619

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3620

1

	MockNet::reset();

3621

3622

	// Relay asset

3623

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3624

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3625

3626

1

	let relay_asset_metadata = parachain::AssetMetadata {

3627

1

		name: b"RelayToken".to_vec(),

3628

1

		symbol: b"Relay".to_vec(),

3629

1

		decimals: 12,

3630

1

};

3631

3632

	// Statemint asset

3633

1

	let statemint_asset = Location::new(

3634

1,

3635

1

3636

1

			Parachain(1000u32),

3637

1

			PalletInstance(5u8),

3638

1

			GeneralIndex(10u128),

3639

1

],

3640

);

3641

1

	let statemint_location_asset: AssetType = statemint_asset

3642

1

		.clone()

3643

1

		.try_into()

3644

1

		.expect("Location convertion to AssetType should succeed");

3645

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3646

3647

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3648

1

		name: b"USDC".to_vec(),

3649

1

		symbol: b"USDC".to_vec(),

3650

1

		decimals: 12,

3651

1

};

3652

3653

1

	let dest_para = Location::new(1, [Parachain(1)]);

3654

3655

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3656

1

		polkadot_parachain::primitives::Sibling,

3657

1

		statemint_like::AccountId,

3658

1

	>::convert_location(&dest_para)

3659

1

	.unwrap();

3660

3661

1

	ParaA::execute_with(|| {

3662

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3663

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3664

1

			.try_into()

3665

1

			.expect("v3 to latest location conversion failed");

3666

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3667

1

			source_relay_id,

3668

1

			source_location_latest,

3669

1

			relay_asset_metadata.decimals,

3670

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3671

1

			relay_asset_metadata.name.try_into().expect("too long"),

3672

));

3673

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3674

3675

1

		let parachain::AssetType::Xcm(source_location_v3) = statemint_location_asset.clone();

3676

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3677

1

			.try_into()

3678

1

			.expect("v3 to latest location conversion failed");

3679

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3680

1

			source_statemint_asset_id,

3681

1

			source_location_latest,

3682

1

			asset_metadata_statemint_asset.decimals,

3683

1

			asset_metadata_statemint_asset

3684

1

				.symbol

3685

1

				.try_into()

3686

1

				.expect("too long"),

3687

1

			asset_metadata_statemint_asset

3688

1

				.name

3689

1

				.try_into()

3690

1

				.expect("too long"),

3691

));

3692

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

3693

1

});

3694

3695

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3696

1

		network: None,

3697

1

		key: PARAALICE,

3698

1

3699

1

	.into();

3700

3701

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3702

1

		network: None,

3703

1

		id: RELAYALICE.into(),

3704

1

3705

1

	.into();

3706

3707

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3708

1

	Relay::execute_with(|| {

3709

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3710

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3711

1

			Box::new(Parachain(1000).into()),

3712

1

			Box::new(

3713

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3714

1

					.clone()

3715

1

					.into()

3716

),

3717

1

			Box::new(([], 200).into()),

3718

0,

3719

1

			WeightLimit::Unlimited

3720

));

3721

1

});

3722

3723

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3724

1

	Statemint::execute_with(|| {

3725

		// Check Alice received 200 tokens on AssetHub

3726

1

		assert_eq!(

3727

1

			StatemintBalances::free_balance(RELAYALICE),

3728

			INITIAL_BALANCE + 200

3729

);

3730

3731

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3732

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3733

1

			sov,

3734

			110000000000000

3735

));

3736

3737

1

		statemint_like::PrefixChanger::set_prefix(

3738

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

3739

);

3740

3741

1

		assert_ok!(StatemintAssets::create(

3742

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3743

10,

3744

			RELAYALICE,

3745

3746

));

3747

3748

1

		assert_ok!(StatemintAssets::mint(

3749

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3750

10,

3751

			RELAYALICE,

3752

			300000000000000

3753

));

3754

3755

		// Now send relay tokens to ParaA

3756

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

3757

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3758

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3759

1

			assets: Wild(All),

3760

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3761

1

		}]);

3762

1

		assert_ok!(

3763

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3764

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3765

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3766

1

				Box::new(assets),

3767

1

				Box::new(TransferType::LocalReserve),

3768

1

				Box::new(fees_id),

3769

1

				Box::new(TransferType::LocalReserve),

3770

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3771

1

				WeightLimit::Unlimited

3772

3773

);

3774

3775

		// Send USDC

3776

1

		let assets: VersionedAssets = (

3777

1

3778

1

				xcm::latest::prelude::PalletInstance(

3779

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

3780

1

),

3781

1

				GeneralIndex(10),

3782

1

],

3783

1

			125,

3784

1

3785

1

			.into();

3786

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

3787

1

0,

3788

1

3789

1

				xcm::latest::prelude::PalletInstance(

3790

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

3791

1

),

3792

1

				GeneralIndex(10),

3793

1

],

3794

1

))

3795

1

		.into();

3796

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3797

1

			assets: Wild(All),

3798

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3799

1

		}]);

3800

1

		assert_ok!(

3801

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3802

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3803

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3804

1

				Box::new(assets),

3805

1

				Box::new(TransferType::LocalReserve),

3806

1

				Box::new(fees_id),

3807

1

				Box::new(TransferType::LocalReserve),

3808

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3809

1

				WeightLimit::Unlimited

3810

3811

);

3812

1

});

3813

3814

1

	ParaA::execute_with(|| {

3815

		// Alice should have received the DOTs

3816

1

		assert_eq!(

3817

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3818

1

			Ok(U256::from(200))

3819

);

3820

3821

		// Alice has received 125 USDC

3822

1

		assert_eq!(

3823

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

3824

1

			Ok(U256::from(125))

3825

);

3826

1

});

3827

3828

1

	let dest = Location::new(

3829

1,

3830

1

3831

1

			Parachain(1000),

3832

1

			AccountId32 {

3833

1

				network: None,

3834

1

				id: RELAYBOB.into(),

3835

1

},

3836

1

],

3837

);

3838

3839

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3840

3841

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3842

1

	ParaA::execute_with(|| {

3843

1

		let asset_1 = currency_to_asset(

3844

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3845

			100,

3846

);

3847

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3848

1

		let assets_to_send = vec![asset_1, asset_2];

3849

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3850

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3851

1

			assets: Wild(All),

3852

1

			beneficiary: beneficiary.clone(),

3853

1

		}]);

3854

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3855

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3856

1

			Box::new(VersionedLocation::from(chain_part)),

3857

1

			Box::new(VersionedAssets::from(assets_to_send)),

3858

1

			Box::new(TransferType::DestinationReserve),

3859

1

			Box::new(fees_id),

3860

1

			Box::new(TransferType::DestinationReserve),

3861

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3862

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

3863

));

3864

3865

1

		assert_eq!(

3866

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3867

1

			Ok(U256::from(100))

3868

);

3869

1

});

3870

3871

1

	Statemint::execute_with(|| {

3872

		// Check that Bob received relay tokens back in AssetHub

3873

1

		assert_eq!(

3874

1

			StatemintBalances::free_balance(RELAYBOB),

3875

			INITIAL_BALANCE + 100

3876

);

3877

3878

		// Check that BOB received 100 USDC on AssetHub

3879

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

3880

1

});

3881

3882

	// Send back tokens from AH to ParaA from Bob's account

3883

1

	Statemint::execute_with(|| {

3884

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3885

3886

		// Now send those tokens to ParaA

3887

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

3888

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3889

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3890

1

			assets: Wild(All),

3891

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3892

1

		}]);

3893

1

		assert_ok!(

3894

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3895

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3896

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3897

1

				Box::new(assets),

3898

1

				Box::new(TransferType::LocalReserve),

3899

1

				Box::new(fees_id),

3900

1

				Box::new(TransferType::LocalReserve),

3901

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3902

1

				WeightLimit::Unlimited

3903

3904

);

3905

3906

		// 100 DOTs were deducted from Bob's account

3907

1

		assert_eq!(

3908

1

			StatemintBalances::free_balance(RELAYBOB),

3909

1

			bob_previous_balance - 100

3910

);

3911

1

});

3912

3913

1

	ParaA::execute_with(|| {

3914

		// Alice should have received 100 DOTs

3915

1

		assert_eq!(

3916

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3917

1

			Ok(U256::from(200))

3918

);

3919

1

});

3920

1

3921

3922

#[test]

3923

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3924

1

	MockNet::reset();

3925

3926

	// Relay asset

3927

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3928

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3929

3930

1

	let relay_asset_metadata = parachain::AssetMetadata {

3931

1

		name: b"RelayToken".to_vec(),

3932

1

		symbol: b"Relay".to_vec(),

3933

1

		decimals: 12,

3934

1

};

3935

3936

	// Statemint asset

3937

1

	let statemint_asset = Location::new(

3938

1,

3939

1

3940

1

			Parachain(1000u32),

3941

1

			PalletInstance(5u8),

3942

1

			GeneralIndex(10u128),

3943

1

],

3944

);

3945

1

	let statemint_location_asset: AssetType = statemint_asset

3946

1

		.clone()

3947

1

		.try_into()

3948

1

		.expect("Location convertion to AssetType should succeed");

3949

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3950

3951

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3952

1

		name: b"USDC".to_vec(),

3953

1

		symbol: b"USDC".to_vec(),

3954

1

		decimals: 12,

3955

1

};

3956

3957

1

	let dest_para = Location::new(1, [Parachain(1)]);

3958

3959

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3960

1

		polkadot_parachain::primitives::Sibling,

3961

1

		statemint_like::AccountId,

3962

1

	>::convert_location(&dest_para)

3963

1

	.unwrap();

3964

3965

1

	ParaA::execute_with(|| {

3966

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3967

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3968

1

			.try_into()

3969

1

			.expect("v3 to latest location conversion failed");

3970

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3971

1

			source_relay_id,

3972

1

			source_location_latest,

3973

1

			relay_asset_metadata.decimals,

3974

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3975

1

			relay_asset_metadata.name.try_into().expect("too long"),

3976

));

3977

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3978

3979

1

		let parachain::AssetType::Xcm(source_location_v3) = statemint_location_asset.clone();

3980

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3981

1

			.try_into()

3982

1

			.expect("v3 to latest location conversion failed");

3983

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3984

1

			source_statemint_asset_id,

3985

1

			source_location_latest,

3986

1

			asset_metadata_statemint_asset.decimals,

3987

1

			asset_metadata_statemint_asset

3988

1

				.symbol

3989

1

				.try_into()

3990

1

				.expect("too long"),

3991

1

			asset_metadata_statemint_asset

3992

1

				.name

3993

1

				.try_into()

3994

1

				.expect("too long"),

3995

));

3996

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

3997

1

});

3998

3999

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4000

1

		network: None,

4001

1

		key: PARAALICE,

4002

1

4003

1

	.into();

4004

4005

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

4006

1

		network: None,

4007

1

		id: RELAYALICE.into(),

4008

1

4009

1

	.into();

4010

4011

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4012

1

	Relay::execute_with(|| {

4013

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4014

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4015

1

			Box::new(Parachain(1000).into()),

4016

1

			Box::new(

4017

1

				VersionedLocation::from(statemint_beneficiary_absolute)

4018

1

					.clone()

4019

1

					.into()

4020

),

4021

1

			Box::new(([], 200).into()),

4022

0,

4023

1

			WeightLimit::Unlimited

4024

));

4025

1

});

4026

4027

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4028

1

	Statemint::execute_with(|| {

4029

		// Check Alice received 200 tokens on AssetHub

4030

1

		assert_eq!(

4031

1

			StatemintBalances::free_balance(RELAYALICE),

4032

			INITIAL_BALANCE + 200

4033

);

4034

4035

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4036

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4037

1

			sov,

4038

			110000000000000

4039

));

4040

4041

1

		statemint_like::PrefixChanger::set_prefix(

4042

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4043

);

4044

4045

1

		assert_ok!(StatemintAssets::create(

4046

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4047

10,

4048

			RELAYALICE,

4049

4050

));

4051

4052

1

		assert_ok!(StatemintAssets::mint(

4053

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4054

10,

4055

			RELAYALICE,

4056

			300000000000000

4057

));

4058

4059

		// Now send relay tokens to ParaA

4060

1

		let assets: VersionedAssets = (Location::parent(), 200).into();

4061

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4062

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4063

1

			assets: Wild(All),

4064

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4065

1

		}]);

4066

1

		assert_ok!(

4067

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4068

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4069

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4070

1

				Box::new(assets),

4071

1

				Box::new(TransferType::LocalReserve),

4072

1

				Box::new(fees_id),

4073

1

				Box::new(TransferType::LocalReserve),

4074

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4075

1

				WeightLimit::Unlimited

4076

4077

);

4078

4079

		// Send USDC

4080

1

		let assets: VersionedAssets = (

4081

1

4082

1

				xcm::latest::prelude::PalletInstance(

4083

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4084

1

),

4085

1

				GeneralIndex(10),

4086

1

],

4087

1

			125,

4088

1

4089

1

			.into();

4090

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4091

1

0,

4092

1

4093

1

				xcm::latest::prelude::PalletInstance(

4094

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4095

1

),

4096

1

				GeneralIndex(10),

4097

1

],

4098

1

))

4099

1

		.into();

4100

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4101

1

			assets: Wild(All),

4102

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4103

1

		}]);

4104

1

		assert_ok!(

4105

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4106

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4107

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4108

1

				Box::new(assets),

4109

1

				Box::new(TransferType::LocalReserve),

4110

1

				Box::new(fees_id),

4111

1

				Box::new(TransferType::LocalReserve),

4112

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4113

1

				WeightLimit::Unlimited

4114

4115

);

4116

1

});

4117

4118

1

	ParaA::execute_with(|| {

4119

		// Alice should have received the DOTs

4120

1

		assert_eq!(

4121

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4122

1

			Ok(U256::from(200))

4123

);

4124

4125

		// Alice has received 125 USDC

4126

1

		assert_eq!(

4127

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4128

1

			Ok(U256::from(125))

4129

);

4130

1

});

4131

4132

1

	let dest = Location::new(

4133

1,

4134

1

4135

1

			Parachain(1000),

4136

1

			AccountId32 {

4137

1

				network: None,

4138

1

				id: RELAYBOB.into(),

4139

1

},

4140

1

],

4141

);

4142

4143

1

	let statemint_asset_to_send = Asset {

4144

1

		id: AssetId(statemint_asset),

4145

1

		fun: Fungible(100),

4146

1

};

4147

4148

1

	let relay_asset_to_send = Asset {

4149

1

		id: AssetId(Location::parent()),

4150

1

		fun: Fungible(100),

4151

1

};

4152

4153

1

	let assets_to_send: XcmAssets =

4154

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

4155

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4156

	// For some reason the order of the assets is inverted when creating the array above.

4157

	// We need to use relay asset for fees, so we pick index 0.

4158

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4159

4160

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4161

1

	ParaA::execute_with(|| {

4162

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4163

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4164

1

			assets: Wild(All),

4165

1

			beneficiary: beneficiary.clone(),

4166

1

		}]);

4167

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4168

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4169

1

			Box::new(VersionedLocation::from(chain_part)),

4170

1

			Box::new(VersionedAssets::from(assets_to_send)),

4171

1

			Box::new(TransferType::DestinationReserve),

4172

1

			Box::new(fees_id),

4173

1

			Box::new(TransferType::DestinationReserve),

4174

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4175

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4176

));

4177

4178

1

		assert_eq!(

4179

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4180

1

			Ok(U256::from(100))

4181

);

4182

1

});

4183

4184

1

	Statemint::execute_with(|| {

4185

		// Check that Bob received relay tokens back in AssetHub

4186

1

		assert_eq!(

4187

1

			StatemintBalances::free_balance(RELAYBOB),

4188

			INITIAL_BALANCE + 100

4189

);

4190

4191

		// Check that BOB received 100 USDC on AssetHub

4192

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4193

1

});

4194

4195

	// Send back tokens from AH to ParaA from Bob's account

4196

1

	Statemint::execute_with(|| {

4197

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4198

4199

		// Now send those tokens to ParaA

4200

1

		let assets: VersionedAssets = (Location::parent(), 100).into();

4201

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4202

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4203

1

			assets: Wild(All),

4204

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4205

1

		}]);

4206

1

		assert_ok!(

4207

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4208

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4209

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4210

1

				Box::new(assets),

4211

1

				Box::new(TransferType::LocalReserve),

4212

1

				Box::new(fees_id),

4213

1

				Box::new(TransferType::LocalReserve),

4214

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4215

1

				WeightLimit::Unlimited

4216

4217

);

4218

4219

		// 100 DOTs were deducted from Bob's account

4220

1

		assert_eq!(

4221

1

			StatemintBalances::free_balance(RELAYBOB),

4222

1

			bob_previous_balance - 100

4223

);

4224

1

});

4225

4226

1

	ParaA::execute_with(|| {

4227

		// Alice should have received 100 DOTs

4228

1

		assert_eq!(

4229

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4230

1

			Ok(U256::from(200))

4231

);

4232

1

});

4233

1

4234

4235

#[test]

4236

1

fn transact_through_signed_multilocation() {

4237

1

	MockNet::reset();

4238

1

	let mut ancestry = Location::parent();

4239

4240

1

	ParaA::execute_with(|| {

4241

		// Root can set transact info

4242

1

		assert_ok!(XcmTransactor::set_transact_info(

4243

1

			parachain::RuntimeOrigin::root(),

4244

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4245

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4246

1

			3000.into(),

4247

1

			20000000000.into(),

4248

			// 4 instructions in transact through signed

4249

1

			Some(4000.into())

4250

));

4251

		// Root can set transact info

4252

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4253

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

4254

1

			.expect("must succeed");

4255

1

		ancestry = parachain::UniversalLocation::get().into();

4256

1

});

4257

4258

	// Let's construct the Junction that we will append with DescendOrigin

4259

1

	let signed_origin: Junctions = [AccountKey20 {

4260

1

		network: None,

4261

1

		key: PARAALICE,

4262

1

}]

4263

1

	.into();

4264

4265

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4266

1

	descend_origin_multilocation

4267

1

		.append_with(signed_origin)

4268

1

		.unwrap();

4269

4270

	// To convert it to what the relay will see instead of us

4271

1

	descend_origin_multilocation

4272

1

		.reanchor(&Location::parent(), &ancestry.interior)

4273

1

		.unwrap();

4274

4275

1

	let derived = xcm_builder::Account32Hash::<

4276

1

		relay_chain::KusamaNetwork,

4277

1

		relay_chain::AccountId,

4278

1

	>::convert_location(&descend_origin_multilocation)

4279

1

	.unwrap();

4280

4281

1

	Relay::execute_with(|| {

4282

		// free execution, full amount received

4283

1

		assert_ok!(RelayBalances::transfer_allow_death(

4284

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4285

1

			derived.clone(),

4286

			4000004100u128,

4287

));

4288

		// derived account has all funds

4289

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4290

		// sovereign account has 0 funds

4291

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4292

1

});

4293

4294

	// Encode the call. Balances transact to para_a_account

4295

	// First index

4296

1

	let mut encoded: Vec<u8> = Vec::new();

4297

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4298

1

		relay_chain::Balances,

4299

1

>()

4300

1

	.unwrap() as u8;

4301

4302

1

	encoded.push(index);

4303

4304

	// Then call bytes

4305

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4306

1

		// 100 to sovereign

4307

1

		dest: para_a_account(),

4308

1

		value: 100u32.into(),

4309

1

4310

1

	.encode();

4311

1

	encoded.append(&mut call_bytes);

4312

4313

1

	ParaA::execute_with(|| {

4314

1

		assert_ok!(XcmTransactor::transact_through_signed(

4315

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4316

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4317

1

			CurrencyPayment {

4318

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4319

1

					Location::parent()

4320

1

				))),

4321

1

				fee_amount: None

4322

1

},

4323

1

			encoded,

4324

			// 4000000000 for transfer + 4000 for XCM

4325

1

			TransactWeights {

4326

1

				transact_required_weight_at_most: 4000000000.into(),

4327

1

				overall_weight: None

4328

1

},

4329

			false

4330

));

4331

1

});

4332

4333

1

	Relay::execute_with(|| {

4334

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4335

4336

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4337

1

});

4338

1

4339

4340

#[test]

4341

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4342

1

	MockNet::reset();

4343

1

	let mut ancestry = Location::parent();

4344

4345

1

	ParaA::execute_with(|| {

4346

1

		ancestry = parachain::UniversalLocation::get().into();

4347

1

});

4348

4349

	// Let's construct the Junction that we will append with DescendOrigin

4350

1

	let signed_origin: Junctions = [AccountKey20 {

4351

1

		network: None,

4352

1

		key: PARAALICE,

4353

1

}]

4354

1

	.into();

4355

4356

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4357

1

	descend_origin_multilocation

4358

1

		.append_with(signed_origin)

4359

1

		.unwrap();

4360

4361

	// To convert it to what the relay will see instead of us

4362

1

	descend_origin_multilocation

4363

1

		.reanchor(&Location::parent(), &ancestry.interior)

4364

1

		.unwrap();

4365

4366

1

	let derived = xcm_builder::Account32Hash::<

4367

1

		relay_chain::KusamaNetwork,

4368

1

		relay_chain::AccountId,

4369

1

	>::convert_location(&descend_origin_multilocation)

4370

1

	.unwrap();

4371

4372

1

	Relay::execute_with(|| {

4373

		// free execution, full amount received

4374

1

		assert_ok!(RelayBalances::transfer_allow_death(

4375

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4376

1

			derived.clone(),

4377

			4000004100u128,

4378

));

4379

		// derived account has all funds

4380

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4381

		// sovereign account has 0 funds

4382

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4383

1

});

4384

4385

	// Encode the call. Balances transact to para_a_account

4386

	// First index

4387

1

	let mut encoded: Vec<u8> = Vec::new();

4388

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4389

1

		relay_chain::Balances,

4390

1

>()

4391

1

	.unwrap() as u8;

4392

4393

1

	encoded.push(index);

4394

4395

	// Then call bytes

4396

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4397

1

		// 100 to sovereign

4398

1

		dest: para_a_account(),

4399

1

		value: 100u32.into(),

4400

1

4401

1

	.encode();

4402

1

	encoded.append(&mut call_bytes);

4403

4404

1

	let total_weight = 4000004000u64;

4405

1

	ParaA::execute_with(|| {

4406

1

		assert_ok!(XcmTransactor::transact_through_signed(

4407

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4408

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4409

1

			CurrencyPayment {

4410

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4411

1

					Location::parent()

4412

1

				))),

4413

1

				fee_amount: Some(total_weight as u128)

4414

1

},

4415

1

			encoded,

4416

			// 4000000000 for transfer + 4000 for XCM

4417

1

			TransactWeights {

4418

1

				transact_required_weight_at_most: 4000000000.into(),

4419

1

				overall_weight: Some(Limited(total_weight.into()))

4420

1

},

4421

			false

4422

));

4423

1

});

4424

4425

1

	Relay::execute_with(|| {

4426

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4427

4428

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4429

1

});

4430

1

4431

4432

#[test]

4433

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4434

1

	MockNet::reset();

4435

1

	let mut ancestry = Location::parent();

4436

4437

1

	ParaA::execute_with(|| {

4438

1

		ancestry = parachain::UniversalLocation::get().into();

4439

1

});

4440

4441

	// Let's construct the Junction that we will append with DescendOrigin

4442

1

	let signed_origin: Junctions = [AccountKey20 {

4443

1

		network: None,

4444

1

		key: PARAALICE,

4445

1

}]

4446

1

	.into();

4447

4448

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4449

1

	descend_origin_multilocation

4450

1

		.append_with(signed_origin)

4451

1

		.unwrap();

4452

4453

	// To convert it to what the relay will see instead of us

4454

1

	descend_origin_multilocation

4455

1

		.reanchor(&Location::parent(), &ancestry.interior)

4456

1

		.unwrap();

4457

4458

1

	let derived = xcm_builder::Account32Hash::<

4459

1

		relay_chain::KusamaNetwork,

4460

1

		relay_chain::AccountId,

4461

1

	>::convert_location(&descend_origin_multilocation)

4462

1

	.unwrap();

4463

4464

1

	Relay::execute_with(|| {

4465

		// free execution, full amount received

4466

1

		assert_ok!(RelayBalances::transfer_allow_death(

4467

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4468

1

			derived.clone(),

4469

			4000009100u128,

4470

));

4471

		// derived account has all funds

4472

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4473

		// sovereign account has 0 funds

4474

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4475

1

});

4476

4477

	// Encode the call. Balances transact to para_a_account

4478

	// First index

4479

1

	let mut encoded: Vec<u8> = Vec::new();

4480

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4481

1

		relay_chain::Balances,

4482

1

>()

4483

1

	.unwrap() as u8;

4484

4485

1

	encoded.push(index);

4486

4487

	// Then call bytes

4488

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4489

1

		// 100 to sovereign

4490

1

		dest: para_a_account(),

4491

1

		value: 100u32.into(),

4492

1

4493

1

	.encode();

4494

1

	encoded.append(&mut call_bytes);

4495

4496

1

	let total_weight = 4000009000u64;

4497

1

	ParaA::execute_with(|| {

4498

1

		assert_ok!(XcmTransactor::transact_through_signed(

4499

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4500

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4501

1

			CurrencyPayment {

4502

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4503

1

					Location::parent()

4504

1

				))),

4505

1

				fee_amount: Some(total_weight as u128)

4506

1

},

4507

1

			encoded,

4508

			// 4000000000 for transfer + 9000 for XCM

4509

1

			TransactWeights {

4510

1

				transact_required_weight_at_most: 4000000000.into(),

4511

1

				overall_weight: Some(Limited(total_weight.into()))

4512

1

},

4513

			true

4514

));

4515

1

});

4516

4517

1

	Relay::execute_with(|| {

4518

		// 100 transferred

4519

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4520

4521

		// 4000009000 refunded

4522

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4523

1

});

4524

1

4525

4526

#[test]

4527

1

fn transact_through_signed_multilocation_para_to_para() {

4528

1

	MockNet::reset();

4529

1

	let mut ancestry = Location::parent();

4530

4531

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4532

4533

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4534

4535

1

	ParaA::execute_with(|| {

4536

		// Root can set transact info

4537

1

		assert_ok!(XcmTransactor::set_transact_info(

4538

1

			parachain::RuntimeOrigin::root(),

4539

			// ParaB

4540

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4541

			// Para charges 1000 for every instruction, and we have 3, so 3

4542

1

			3.into(),

4543

1

			20000000000.into(),

4544

			// 4 instructions in transact through signed

4545

1

			Some(4.into())

4546

));

4547

		// Root can set transact info

4548

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4549

1

		set_fee_per_second_for_location(

4550

1

			para_b_balances.clone(),

4551

1

			parachain::ParaTokensPerSecond::get(),

4552

4553

1

		.expect("must succeed");

4554

1

		ancestry = parachain::UniversalLocation::get().into();

4555

1

});

4556

4557

	// Let's construct the Junction that we will append with DescendOrigin

4558

1

	let signed_origin: Junctions = [AccountKey20 {

4559

1

		network: None,

4560

1

		key: PARAALICE,

4561

1

}]

4562

1

	.into();

4563

4564

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4565

1

	descend_origin_location.append_with(signed_origin).unwrap();

4566

4567

	// To convert it to what the paraB will see instead of us

4568

1

	descend_origin_location

4569

1

		.reanchor(&para_b_location, &ancestry.interior)

4570

1

		.unwrap();

4571

4572

1

	let derived = xcm_builder::HashedDescription::<

4573

1

		parachain::AccountId,

4574

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4575

1

	>::convert_location(&descend_origin_location)

4576

1

	.unwrap();

4577

4578

1

	ParaB::execute_with(|| {

4579

		// free execution, full amount received

4580

1

		assert_ok!(ParaBalances::transfer_allow_death(

4581

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4582

1

			derived.clone(),

4583

			4000000104u128,

4584

));

4585

		// derived account has all funds

4586

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4587

		// sovereign account has 0 funds

4588

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4589

1

});

4590

4591

	// Encode the call. Balances transact to para_a_account

4592

	// First index

4593

1

	let mut encoded: Vec<u8> = Vec::new();

4594

1

	let index =

4595

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4596

1

			.unwrap() as u8;

4597

4598

1

	encoded.push(index);

4599

4600

	// Then call bytes

4601

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4602

1

		// 100 to sovereign

4603

1

		dest: para_a_account_20(),

4604

1

		value: 100u32.into(),

4605

1

4606

1

	.encode();

4607

1

	encoded.append(&mut call_bytes);

4608

4609

1

	ParaA::execute_with(|| {

4610

1

		assert_ok!(XcmTransactor::transact_through_signed(

4611

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4612

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4613

1

			CurrencyPayment {

4614

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4615

1

					para_b_balances

4616

1

				))),

4617

1

				fee_amount: None

4618

1

},

4619

1

			encoded,

4620

			// 4000000000 for transfer + 4000 for XCM

4621

			// 1-1 to fee

4622

1

			TransactWeights {

4623

1

				transact_required_weight_at_most: 4000000000.into(),

4624

1

				overall_weight: None

4625

1

},

4626

			false

4627

));

4628

1

});

4629

4630

1

	ParaB::execute_with(|| {

4631

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4632

4633

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4634

1

});

4635

1

4636

4637

#[test]

4638

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4639

1

	MockNet::reset();

4640

1

	let mut ancestry = Location::parent();

4641

4642

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4643

4644

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4645

4646

1

	ParaA::execute_with(|| {

4647

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4648

1

		set_fee_per_second_for_location(

4649

1

			para_b_balances.clone(),

4650

1

			parachain::ParaTokensPerSecond::get(),

4651

4652

1

		.expect("must succeed");

4653

1

		ancestry = parachain::UniversalLocation::get().into();

4654

1

});

4655

4656

	// Let's construct the Junction that we will append with DescendOrigin

4657

1

	let signed_origin: Junctions = [AccountKey20 {

4658

1

		network: None,

4659

1

		key: PARAALICE,

4660

1

}]

4661

1

	.into();

4662

4663

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4664

1

	descend_origin_location.append_with(signed_origin).unwrap();

4665

4666

	// To convert it to what the paraB will see instead of us

4667

1

	descend_origin_location

4668

1

		.reanchor(&para_b_location, &ancestry.interior)

4669

1

		.unwrap();

4670

4671

1

	let derived = xcm_builder::HashedDescription::<

4672

1

		parachain::AccountId,

4673

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4674

1

	>::convert_location(&descend_origin_location)

4675

1

	.unwrap();

4676

4677

1

	ParaB::execute_with(|| {

4678

		// free execution, full amount received

4679

1

		assert_ok!(ParaBalances::transfer_allow_death(

4680

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4681

1

			derived.clone(),

4682

			4000009100u128,

4683

));

4684

		// derived account has all funds

4685

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4686

		// sovereign account has 0 funds

4687

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4688

1

});

4689

4690

	// Encode the call. Balances transact to para_a_account

4691

	// First index

4692

1

	let mut encoded: Vec<u8> = Vec::new();

4693

1

	let index =

4694

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4695

1

			.unwrap() as u8;

4696

4697

1

	encoded.push(index);

4698

4699

	// Then call bytes

4700

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4701

1

		// 100 to sovereign

4702

1

		dest: para_a_account_20(),

4703

1

		value: 100u32.into(),

4704

1

4705

1

	.encode();

4706

1

	encoded.append(&mut call_bytes);

4707

4708

1

	let overall_weight = 4000009000u64;

4709

1

	ParaA::execute_with(|| {

4710

1

		assert_ok!(XcmTransactor::transact_through_signed(

4711

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4712

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4713

1

			CurrencyPayment {

4714

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4715

1

					para_b_balances

4716

1

				))),

4717

1

				fee_amount: Some(overall_weight as u128)

4718

1

},

4719

1

			encoded,

4720

			// 4000000000 for transfer + 9000 for XCM

4721

1

			TransactWeights {

4722

1

				transact_required_weight_at_most: 4000000000.into(),

4723

1

				overall_weight: Some(Limited(overall_weight.into()))

4724

1

},

4725

			true

4726

));

4727

1

});

4728

4729

1

	ParaB::execute_with(|| {

4730

		// Check the derived account was refunded

4731

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4732

4733

		// Check the transfer was executed

4734

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4735

1

});

4736

1

4737

4738

#[test]

4739

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4740

1

	MockNet::reset();

4741

1

	let mut ancestry = Location::parent();

4742

4743

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4744

4745

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4746

4747

1

	ParaA::execute_with(|| {

4748

		// Root can set transact info

4749

1

		assert_ok!(XcmTransactor::set_transact_info(

4750

1

			parachain::RuntimeOrigin::root(),

4751

			// ParaB

4752

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4753

			// Para charges 1000 for every instruction, and we have 3, so 3

4754

1

			3.into(),

4755

1

			20000000000.into(),

4756

			// 4 instructions in transact through signed

4757

1

			Some(4.into())

4758

));

4759

		// Root can set transact info

4760

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4761

1

		set_fee_per_second_for_location(

4762

1

			para_b_balances.clone(),

4763

1

			parachain::ParaTokensPerSecond::get(),

4764

4765

1

		.expect("must succeed");

4766

1

		ancestry = parachain::UniversalLocation::get().into();

4767

1

});

4768

4769

	// Let's construct the Junction that we will append with DescendOrigin

4770

1

	let signed_origin: Junctions = [AccountKey20 {

4771

1

		network: None,

4772

1

		key: PARAALICE,

4773

1

}]

4774

1

	.into();

4775

4776

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4777

1

	descend_origin_location.append_with(signed_origin).unwrap();

4778

4779

	// To convert it to what the paraB will see instead of us

4780

1

	descend_origin_location

4781

1

		.reanchor(&para_b_location, &ancestry.interior)

4782

1

		.unwrap();

4783

4784

1

	let derived = xcm_builder::HashedDescription::<

4785

1

		parachain::AccountId,

4786

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4787

1

	>::convert_location(&descend_origin_location)

4788

1

	.unwrap();

4789

4790

1

	let mut parachain_b_alice_balances_before = 0;

4791

1

	ParaB::execute_with(|| {

4792

1

		assert_ok!(ParaBalances::transfer_allow_death(

4793

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4794

1

			derived.clone(),

4795

			4000000104u128,

4796

));

4797

		// derived account has all funds

4798

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4799

		// sovereign account has 0 funds

4800

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4801

4802

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4803

1

});

4804

4805

	// Encode the call. Balances transact to para_a_account

4806

	// First index

4807

1

	let mut encoded: Vec<u8> = Vec::new();

4808

1

	let index =

4809

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4810

1

			.unwrap() as u8;

4811

4812

1

	encoded.push(index);

4813

4814

	use sp_core::U256;

4815

	// Let's do a EVM transfer

4816

1

	let eth_tx =

4817

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4818

1

			gas_limit: U256::from(21000),

4819

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4820

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4821

1

			value: U256::from(100),

4822

1

			input: BoundedVec::<

4823

1

u8,

4824

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4825

1

			>::try_from(vec![]).unwrap(),

4826

1

			access_list: None,

4827

1

});

4828

4829

	// Then call bytes

4830

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4831

1

		xcm_transaction: eth_tx,

4832

1

4833

1

	.encode();

4834

1

	encoded.append(&mut call_bytes);

4835

4836

1

	ParaA::execute_with(|| {

4837

1

		assert_ok!(XcmTransactor::transact_through_signed(

4838

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4839

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4840

1

			CurrencyPayment {

4841

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4842

1

					para_b_balances

4843

1

				))),

4844

1

				fee_amount: None

4845

1

},

4846

1

			encoded,

4847

			// 4000000000 for transfer + 4000 for XCM

4848

			// 1-1 to fee

4849

1

			TransactWeights {

4850

1

				transact_required_weight_at_most: 4000000000.into(),

4851

1

				overall_weight: None

4852

1

},

4853

			false

4854

));

4855

1

});

4856

4857

1

	ParaB::execute_with(|| {

4858

		// Make sure the EVM transfer went through

4859

1

		assert!(

4860

1

			ParaBalances::free_balance(&PARAALICE.into())

4861

1

				== parachain_b_alice_balances_before + 100

4862

);

4863

1

});

4864

1

4865

4866

#[test]

4867

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4868

1

	MockNet::reset();

4869

1

	let mut ancestry = Location::parent();

4870

4871

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4872

4873

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4874

4875

1

	ParaA::execute_with(|| {

4876

		// Root can set transact info

4877

1

		assert_ok!(XcmTransactor::set_transact_info(

4878

1

			parachain::RuntimeOrigin::root(),

4879

			// ParaB

4880

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4881

			// Para charges 1000 for every instruction, and we have 3, so 3

4882

1

			3.into(),

4883

1

			20000000000.into(),

4884

			// 4 instructions in transact through signed

4885

1

			Some(4.into())

4886

));

4887

		// Root can set transact info

4888

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4889

1

		set_fee_per_second_for_location(

4890

1

			para_b_balances.clone(),

4891

1

			parachain::ParaTokensPerSecond::get(),

4892

4893

1

		.expect("must succeed");

4894

1

		ancestry = parachain::UniversalLocation::get().into();

4895

1

});

4896

4897

	// Let's construct the Junction that we will append with DescendOrigin

4898

1

	let signed_origin: Junctions = [AccountKey20 {

4899

1

		network: None,

4900

1

		key: PARAALICE,

4901

1

}]

4902

1

	.into();

4903

4904

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4905

1

	descend_origin_location.append_with(signed_origin).unwrap();

4906

4907

	// To convert it to what the paraB will see instead of us

4908

1

	descend_origin_location

4909

1

		.reanchor(&para_b_location, &ancestry.interior)

4910

1

		.unwrap();

4911

4912

1

	let derived = xcm_builder::HashedDescription::<

4913

1

		parachain::AccountId,

4914

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4915

1

	>::convert_location(&descend_origin_location)

4916

1

	.unwrap();

4917

4918

1

	let mut parachain_b_alice_balances_before = 0;

4919

1

	ParaB::execute_with(|| {

4920

1

		assert_ok!(ParaBalances::transfer_allow_death(

4921

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4922

1

			derived.clone(),

4923

			4000000104u128,

4924

));

4925

		// derived account has all funds

4926

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4927

		// sovereign account has 0 funds

4928

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4929

4930

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4931

1

});

4932

4933

	// Encode the call. Balances transact to para_a_account

4934

	// First index

4935

1

	let mut encoded: Vec<u8> = Vec::new();

4936

1

	let index =

4937

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4938

1

			.unwrap() as u8;

4939

4940

1

	encoded.push(index);

4941

4942

	use sp_core::U256;

4943

	// Let's do a EVM transfer

4944

1

	let eth_tx =

4945

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4946

1

			gas_limit: U256::from(21000),

4947

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4948

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4949

1

			value: U256::from(100),

4950

1

			input: BoundedVec::<

4951

1

u8,

4952

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4953

1

			>::try_from(vec![]).unwrap(),

4954

1

			access_list: None,

4955

1

});

4956

4957

	// Then call bytes

4958

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4959

1

		transact_as: PARAALICE.into(),

4960

1

		xcm_transaction: eth_tx,

4961

1

4962

1

	.encode();

4963

1

	encoded.append(&mut call_bytes);

4964

4965

1

	ParaA::execute_with(|| {

4966

1

		assert_ok!(XcmTransactor::transact_through_signed(

4967

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4968

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4969

1

			CurrencyPayment {

4970

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4971

1

					para_b_balances

4972

1

				))),

4973

1

				fee_amount: None

4974

1

},

4975

1

			encoded,

4976

1

			TransactWeights {

4977

1

				transact_required_weight_at_most: 4000000000.into(),

4978

1

				overall_weight: None

4979

1

},

4980

			false

4981

));

4982

1

});

4983

4984

1

	ParaB::execute_with(|| {

4985

		// Make sure the EVM transfer wasn't executed

4986

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4987

1

});

4988

1

4989

4990

#[test]

4991

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4992

1

	MockNet::reset();

4993

1

	let mut ancestry = Location::parent();

4994

4995

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4996

4997

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4998

4999

1

	ParaA::execute_with(|| {

5000

		// Root can set transact info

5001

1

		assert_ok!(XcmTransactor::set_transact_info(

5002

1

			parachain::RuntimeOrigin::root(),

5003

			// ParaB

5004

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5005

			// Para charges 1000 for every instruction, and we have 3, so 3

5006

1

			3.into(),

5007

1

			20000000000.into(),

5008

			// 4 instructions in transact through signed

5009

1

			Some(4.into())

5010

));

5011

		// Root can set transact info

5012

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5013

1

		set_fee_per_second_for_location(

5014

1

			para_b_balances.clone(),

5015

1

			parachain::ParaTokensPerSecond::get(),

5016

5017

1

		.expect("must succeed");

5018

1

		ancestry = parachain::UniversalLocation::get().into();

5019

1

});

5020

5021

	// Let's construct the Junction that we will append with DescendOrigin

5022

1

	let signed_origin: Junctions = [AccountKey20 {

5023

1

		network: None,

5024

1

		key: PARAALICE,

5025

1

}]

5026

1

	.into();

5027

5028

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5029

1

	descend_origin_location.append_with(signed_origin).unwrap();

5030

5031

	// To convert it to what the paraB will see instead of us

5032

1

	descend_origin_location

5033

1

		.reanchor(&para_b_location, &ancestry.interior)

5034

1

		.unwrap();

5035

5036

1

	let derived = xcm_builder::HashedDescription::<

5037

1

		parachain::AccountId,

5038

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5039

1

	>::convert_location(&descend_origin_location)

5040

1

	.unwrap();

5041

5042

1

	let transfer_recipient = evm_account();

5043

1

	let mut transfer_recipient_balance_before = 0;

5044

1

	ParaB::execute_with(|| {

5045

1

		assert_ok!(ParaBalances::transfer_allow_death(

5046

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5047

1

			derived.clone(),

5048

			4000000104u128,

5049

));

5050

		// derived account has all funds

5051

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5052

		// sovereign account has 0 funds

5053

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5054

5055

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5056

5057

		// Add proxy ALICE  -> derived

5058

1

		let _ = parachain::Proxy::add_proxy_delegate(

5059

1

			&PARAALICE.into(),

5060

1

			derived,

5061

1

			parachain::ProxyType::Any,

5062

1

0,

5063

1

);

5064

1

});

5065

5066

	// Encode the call. Balances transact to para_a_account

5067

	// First index

5068

1

	let mut encoded: Vec<u8> = Vec::new();

5069

1

	let index =

5070

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5071

1

			.unwrap() as u8;

5072

5073

1

	encoded.push(index);

5074

5075

	use sp_core::U256;

5076

	// Let's do a EVM transfer

5077

1

	let eth_tx =

5078

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5079

1

			gas_limit: U256::from(21000),

5080

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5081

1

			value: U256::from(100),

5082

1

			input: BoundedVec::<

5083

1

u8,

5084

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5085

1

			>::try_from(vec![]).unwrap(),

5086

1

			access_list: None,

5087

1

});

5088

5089

	// Then call bytes

5090

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5091

1

		transact_as: PARAALICE.into(),

5092

1

		xcm_transaction: eth_tx,

5093

1

5094

1

	.encode();

5095

1

	encoded.append(&mut call_bytes);

5096

5097

1

	ParaA::execute_with(|| {

5098

1

		assert_ok!(XcmTransactor::transact_through_signed(

5099

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5100

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5101

1

			CurrencyPayment {

5102

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5103

1

					para_b_balances

5104

1

				))),

5105

1

				fee_amount: None

5106

1

},

5107

1

			encoded,

5108

1

			TransactWeights {

5109

1

				transact_required_weight_at_most: 4000000000.into(),

5110

1

				overall_weight: None

5111

1

},

5112

			false

5113

));

5114

1

});

5115

5116

1

	ParaB::execute_with(|| {

5117

		// Make sure the EVM transfer was executed

5118

1

		assert!(

5119

1

			ParaBalances::free_balance(&transfer_recipient.into())

5120

1

				== transfer_recipient_balance_before + 100

5121

);

5122

1

});

5123

1

5124

5125

#[test]

5126

1

fn hrmp_init_accept_through_root() {

5127

1

	MockNet::reset();

5128

5129

1

	Relay::execute_with(|| {

5130

1

		assert_ok!(RelayBalances::transfer_allow_death(

5131

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5132

1

			para_a_account(),

5133

			1000u128

5134

));

5135

1

		assert_ok!(RelayBalances::transfer_allow_death(

5136

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5137

1

			para_b_account(),

5138

			1000u128

5139

));

5140

1

});

5141

5142

1

	ParaA::execute_with(|| {

5143

1

		let total_fee = 1_000u128;

5144

1

		let total_weight: u64 = 1_000_000_000;

5145

1

		let tx_weight: u64 = 500_000_000;

5146

		// Root can send hrmp init channel

5147

1

		assert_ok!(XcmTransactor::hrmp_manage(

5148

1

			parachain::RuntimeOrigin::root(),

5149

1

			HrmpOperation::InitOpen(HrmpInitParams {

5150

1

				para_id: 2u32.into(),

5151

1

				proposed_max_capacity: 1,

5152

1

				proposed_max_message_size: 1

5153

1

}),

5154

1

			CurrencyPayment {

5155

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5156

1

					Location::parent()

5157

1

				))),

5158

1

				fee_amount: Some(total_fee)

5159

1

},

5160

1

			TransactWeights {

5161

1

				transact_required_weight_at_most: tx_weight.into(),

5162

1

				overall_weight: Some(Limited(total_weight.into()))

5163

1

5164

));

5165

1

});

5166

1

	Relay::execute_with(|| {

5167

1

		let expected_event: relay_chain::RuntimeEvent =

5168

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5169

1

				sender: 1u32.into(),

5170

1

				recipient: 2u32.into(),

5171

1

				proposed_max_capacity: 1u32,

5172

1

				proposed_max_message_size: 1u32,

5173

1

5174

1

			.into();

5175

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5176

1

});

5177

1

	ParaB::execute_with(|| {

5178

1

		let total_fee = 1_000u128;

5179

1

		let total_weight: u64 = 1_000_000_000;

5180

1

		let tx_weight: u64 = 500_000_000;

5181

		// Root can send hrmp accept channel

5182

1

		assert_ok!(XcmTransactor::hrmp_manage(

5183

1

			parachain::RuntimeOrigin::root(),

5184

1

			HrmpOperation::Accept {

5185

1

				para_id: 1u32.into()

5186

1

},

5187

1

			CurrencyPayment {

5188

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5189

1

					Location::parent()

5190

1

				))),

5191

1

				fee_amount: Some(total_fee)

5192

1

},

5193

1

			TransactWeights {

5194

1

				transact_required_weight_at_most: tx_weight.into(),

5195

1

				overall_weight: Some(Limited(total_weight.into()))

5196

1

5197

));

5198

1

});

5199

5200

1

	Relay::execute_with(|| {

5201

1

		let expected_event: relay_chain::RuntimeEvent =

5202

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5203

1

				sender: 1u32.into(),

5204

1

				recipient: 2u32.into(),

5205

1

5206

1

			.into();

5207

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5208

1

});

5209

1

5210

5211

#[test]

5212

1

fn hrmp_close_works() {

5213

1

	MockNet::reset();

5214

5215

1

	Relay::execute_with(|| {

5216

1

		assert_ok!(RelayBalances::transfer_allow_death(

5217

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5218

1

			para_a_account(),

5219

			1000u128

5220

));

5221

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5222

1

			relay_chain::RuntimeOrigin::root(),

5223

1

			1u32.into(),

5224

1

			2u32.into(),

5225

			1u32,

5226

			1u32

5227

));

5228

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5229

1

			relay_chain::RuntimeOrigin::root(),

5230

			1u32

5231

));

5232

1

});

5233

5234

1

	ParaA::execute_with(|| {

5235

1

		let total_fee = 1_000u128;

5236

1

		let total_weight: u64 = 1_000_000_000;

5237

1

		let tx_weight: u64 = 500_000_000;

5238

		// Root can send hrmp close

5239

1

		assert_ok!(XcmTransactor::hrmp_manage(

5240

1

			parachain::RuntimeOrigin::root(),

5241

1

			HrmpOperation::Close(HrmpChannelId {

5242

1

				sender: 1u32.into(),

5243

1

				recipient: 2u32.into()

5244

1

}),

5245

1

			CurrencyPayment {

5246

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5247

1

					Location::parent()

5248

1

				))),

5249

1

				fee_amount: Some(total_fee)

5250

1

},

5251

1

			TransactWeights {

5252

1

				transact_required_weight_at_most: tx_weight.into(),

5253

1

				overall_weight: Some(Limited(total_weight.into()))

5254

1

5255

));

5256

1

});

5257

1

	Relay::execute_with(|| {

5258

1

		let expected_event: relay_chain::RuntimeEvent =

5259

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5260

1

				by_parachain: 1u32.into(),

5261

1

				channel_id: HrmpChannelId {

5262

1

					sender: 1u32.into(),

5263

1

					recipient: 2u32.into(),

5264

1

},

5265

1

5266

1

			.into();

5267

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5268

1

});

5269

1

5270

5271

use crate::xcm_mock::parachain::XcmWeightTrader;

5272

use parity_scale_codec::{Decode, Encode};

5273

use sp_io::hashing::blake2_256;

5274

5275

// Helper to derive accountIds

5276

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5277

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5278

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5279

7