Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonbase Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{ConstU32, PalletInfo, PalletInfoAccess},

23

	weights::constants::WEIGHT_REF_TIME_PER_SECOND,

24

	weights::Weight,

25

	BoundedVec,

26

};

27

use moonbase_runtime::xcm_config::AssetType;

28

use pallet_xcm_transactor::{

29

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

30

};

31

use sp_runtime::traits::Convert;

32

use sp_std::boxed::Box;

33

use xcm::{

34

	latest::prelude::{

35

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

36

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

37

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

38

		WeightLimit, Wild, WithdrawAsset, Xcm,

39

},

40

	VersionedAssetId, VersionedAssets, VersionedXcm,

41

};

42

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

43

use xcm_executor::traits::ConvertLocation;

44

use xcm_executor::traits::TransferType;

45

use xcm_mock::*;

46

use xcm_primitives::{

47

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

48

};

49

use xcm_simulator::TestExt;

50

mod common;

51

use cumulus_primitives_core::relay_chain::HrmpChannelId;

52

use parachain::PolkadotXcm;

53

54

28

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

55

28

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

56

28

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

57

28

		.into_version(xcm::latest::VERSION)

58

28

		.map_err(|_| ())?

59

	else {

60

		return Err(());

61

};

62

	use frame_support::weights::WeightToFee as _;

63

28

	let native_amount_per_second: u128 =

64

28

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

65

28

			&Weight::from_parts(

66

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

67

28

0,

68

28

),

69

70

28

		.try_into()

71

28

		.map_err(|_| ())?;

72

28

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

73

28

	let relative_price: u128 = if units_per_second > 0u128 {

74

10

		native_amount_per_second

75

10

			.saturating_mul(precision_factor)

76

10

			.saturating_div(units_per_second)

77

	} else {

78

18

		0u128

79

};

80

28

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

81

28

		location_v5,

82

28

		(true, relative_price),

83

);

84

28

	Ok(())

85

28

86

87

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

88

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

89

9

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

90

	use moonbeam_tests_primitives::MemoryFeeTrader;

91

	use xcm_primitives::XcmFeeTrader;

92

93

	// In tests, we configure fees for XcmTransactor via the in-memory fee trader

94

	// instead of pallet-xcm-weight-trader, so that generic XCM funding transfers

95

	// remain free (as on master) and only the transactor calls are charged.

96

9

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

97

9

98

99

25

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

100

25

	Asset {

101

25

		id: AssetId(

102

25

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

103

25

				currency_id,

104

25

105

25

			.unwrap(),

106

25

),

107

25

		fun: Fungibility::Fungible(amount),

108

25

109

25

110

111

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

112

#[test]

113

1

fn receive_relay_asset_from_relay() {

114

1

	MockNet::reset();

115

116

1

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

117

1

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

118

1

	let asset_metadata = parachain::AssetMetadata {

119

1

		name: b"RelayToken".to_vec(),

120

1

		symbol: b"Relay".to_vec(),

121

1

		decimals: 12,

122

1

};

123

	// register relay asset in parachain A

124

1

	ParaA::execute_with(|| {

125

1

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

126

1

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

127

1

			.try_into()

128

1

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

129

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

130

1

			source_id,

131

1

			source_location_latest,

132

1

			asset_metadata.decimals,

133

1

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

134

1

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

135

));

136

1

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

137

1

});

138

139

	// Actually send relay asset to parachain

140

1

	let dest: Location = AccountKey20 {

141

1

		network: None,

142

1

		key: PARAALICE,

143

1

144

1

	.into();

145

1

	Relay::execute_with(|| {

146

1

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

147

1

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

148

1

			assets: Wild(All),

149

1

			beneficiary: dest.clone(),

150

1

		}]);

151

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

152

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

153

1

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

154

1

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

155

1

			Box::new(TransferType::LocalReserve),

156

1

			Box::new(fees_id),

157

1

			Box::new(TransferType::LocalReserve),

158

1

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

159

1

			WeightLimit::Unlimited

160

));

161

1

});

162

163

	// Verify that parachain received the asset

164

1

	ParaA::execute_with(|| {

165

		// free execution, full amount received

166

1

		assert_eq!(

167

1

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

168

1

			Ok(U256::from(123))

169

);

170

1

});

171

1

172

173

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

174

#[test]

175

1

fn send_relay_asset_to_relay() {

176

1

	MockNet::reset();

177

178

1

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

179

1

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

180

181

1

	let asset_metadata = parachain::AssetMetadata {

182

1

		name: b"RelayToken".to_vec(),

183

1

		symbol: b"Relay".to_vec(),

184

1

		decimals: 12,

185

1

};

186

187

	// Register relay asset in paraA

188

1

	ParaA::execute_with(|| {

189

1

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

190

1

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

191

1

			.try_into()

192

1

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

193

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

194

1

			source_id,

195

1

			source_location_latest,

196

1

			asset_metadata.decimals,

197

1

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

198

1

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

199

));

200

		// Free execution

201

1

		assert_ok!(add_supported_asset(source_location, 0));

202

1

});

203

204

1

	let dest: Location = Junction::AccountKey20 {

205

1

		network: None,

206

1

		key: PARAALICE,

207

1

208

1

	.into();

209

210

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

211

1

	Relay::execute_with(|| {

212

1

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

213

1

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

214

1

			assets: Wild(All),

215

1

			beneficiary: dest.clone(),

216

1

		}]);

217

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

218

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

219

1

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

220

1

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

221

1

			Box::new(TransferType::LocalReserve),

222

1

			Box::new(fees_id),

223

1

			Box::new(TransferType::LocalReserve),

224

1

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

225

1

			WeightLimit::Unlimited

226

));

227

1

});

228

229

1

	ParaA::execute_with(|| {

230

		// Free execution, full amount received

231

1

		assert_eq!(

232

1

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

233

1

			Ok(U256::from(123))

234

);

235

1

});

236

237

	// Lets gather the balance before sending back money

238

1

	let mut balance_before_sending = 0;

239

1

	Relay::execute_with(|| {

240

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

241

1

});

242

243

	// We now send back some money to the relay

244

1

	let dest = Location {

245

1

		parents: 1,

246

1

		interior: [AccountId32 {

247

1

			network: None,

248

1

			id: RELAYALICE.into(),

249

1

}]

250

1

		.into(),

251

1

};

252

1

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

253

254

1

	ParaA::execute_with(|| {

255

1

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

256

		// free execution, full amount received

257

1

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

258

1

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

259

1

			assets: Wild(All),

260

1

			beneficiary,

261

1

		}]);

262

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

263

1

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

264

1

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

265

1

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

266

1

			Box::new(TransferType::DestinationReserve),

267

1

			Box::new(fees_id),

268

1

			Box::new(TransferType::DestinationReserve),

269

1

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

270

1

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

271

));

272

1

});

273

274

	// The balances in paraAlice should have been substracted

275

1

	ParaA::execute_with(|| {

276

1

		assert_eq!(

277

1

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

278

1

			Ok(U256::from(0))

279

);

280

1

});

281

282

	// Balances in the relay should have been received

283

1

	Relay::execute_with(|| {

284

		// Free execution,x	 full amount received

285

1

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

286

1

});

287

1

288

289

#[test]

290

1

fn send_relay_asset_to_para_b() {

291

1

	MockNet::reset();

292

293

1

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

294

1

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

295

296

1

	let asset_metadata = parachain::AssetMetadata {

297

1

		name: b"RelayToken".to_vec(),

298

1

		symbol: b"Relay".to_vec(),

299

1

		decimals: 12,

300

1

};

301

302

	// Register asset in paraA. Free execution

303

1

	ParaA::execute_with(|| {

304

1

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

305

1

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

306

1

			.try_into()

307

1

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

308

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

309

1

			source_id,

310

1

			source_location_latest,

311

1

			asset_metadata.decimals,

312

1

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

313

1

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

314

));

315

1

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

316

1

});

317

318

	// Register asset in paraB. Free execution

319

1

	ParaB::execute_with(|| {

320

1

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

321

1

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

322

1

			.try_into()

323

1

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

324

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

325

1

			source_id,

326

1

			source_location_latest,

327

1

			asset_metadata.decimals,

328

1

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

329

1

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

330

));

331

1

		assert_ok!(add_supported_asset(source_location, 0));

332

1

});

333

334

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

335

1

	let dest: Location = Junction::AccountKey20 {

336

1

		network: None,

337

1

		key: PARAALICE,

338

1

339

1

	.into();

340

1

	Relay::execute_with(|| {

341

1

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

342

1

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

343

1

			assets: Wild(All),

344

1

			beneficiary: dest.clone(),

345

1

		}]);

346

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

347

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

348

1

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

349

1

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

350

1

			Box::new(TransferType::LocalReserve),

351

1

			Box::new(fees_id),

352

1

			Box::new(TransferType::LocalReserve),

353

1

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

354

1

			WeightLimit::Unlimited

355

));

356

1

});

357

358

1

	ParaA::execute_with(|| {

359

		// Free execution, full amount received

360

1

		assert_eq!(

361

1

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

362

1

			Ok(U256::from(123))

363

);

364

1

});

365

366

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

367

1

	let dest = Location {

368

1

		parents: 1,

369

1

		interior: [

370

1

			Parachain(2),

371

1

			AccountKey20 {

372

1

				network: None,

373

1

				key: PARAALICE.into(),

374

1

},

375

1

376

1

		.into(),

377

1

};

378

1

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

379

380

1

	ParaA::execute_with(|| {

381

1

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

382

1

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

383

1

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

384

1

			assets: Wild(All),

385

1

			beneficiary,

386

1

		}]);

387

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

388

1

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

389

1

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

390

1

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

391

1

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

392

1

			Box::new(fees_id),

393

1

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

394

1

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

395

1

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

396

));

397

1

});

398

399

	// Para A balances should have been subtracted

400

1

	ParaA::execute_with(|| {

401

1

		assert_eq!(

402

1

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

403

1

			Ok(U256::from(23))

404

);

405

1

});

406

407

	// Para B balances should have been credited

408

1

	ParaB::execute_with(|| {

409

1

		assert_eq!(

410

1

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

411

1

			Ok(U256::from(100))

412

);

413

1

});

414

1

415

416

#[test]

417

1

fn send_para_a_asset_to_para_b() {

418

1

	MockNet::reset();

419

420

	// this represents the asset in paraA

421

1

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

422

1

	let source_location: AssetType = para_a_balances

423

1

		.try_into()

424

1

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

425

1

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

426

427

1

	let asset_metadata = parachain::AssetMetadata {

428

1

		name: b"ParaAToken".to_vec(),

429

1

		symbol: b"ParaA".to_vec(),

430

1

		decimals: 18,

431

1

};

432

433

	// Register asset in paraB. Free execution

434

1

	ParaB::execute_with(|| {

435

1

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

436

1

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

437

1

			.try_into()

438

1

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

439

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

440

1

			source_id,

441

1

			source_location_latest,

442

1

			asset_metadata.decimals,

443

1

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

444

1

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

445

));

446

1

		assert_ok!(add_supported_asset(source_location, 0));

447

1

});

448

449

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

450

1

	let dest = Location {

451

1

		parents: 1,

452

1

		interior: [

453

1

			Parachain(2),

454

1

			AccountKey20 {

455

1

				network: None,

456

1

				key: PARAALICE.into(),

457

1

},

458

1

459

1

		.into(),

460

1

};

461

462

1

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

463

464

1

	ParaA::execute_with(|| {

465

1

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

466

		// Free execution, full amount received

467

1

		assert_ok!(PolkadotXcm::transfer_assets(

468

1

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

469

1

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

470

1

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

471

1

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

472

0,

473

1

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

474

));

475

1

});

476

477

	// Native token is substracted in paraA

478

1

	ParaA::execute_with(|| {

479

1

		assert_eq!(

480

1

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

481

			INITIAL_BALANCE - 100

482

);

483

1

});

484

485

	// Asset is minted in paraB

486

1

	ParaB::execute_with(|| {

487

1

		assert_eq!(

488

1

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

489

1

			Ok(U256::from(100))

490

);

491

1

});

492

1

493

494

#[test]

495

1

fn send_para_a_asset_from_para_b_to_para_c() {

496

1

	MockNet::reset();

497

498

	// Represents para A asset

499

1

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

500

1

	let source_location: AssetType = para_a_balances

501

1

		.try_into()

502

1

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

503

1

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

504

505

1

	let asset_metadata = parachain::AssetMetadata {

506

1

		name: b"ParaAToken".to_vec(),

507

1

		symbol: b"ParaA".to_vec(),

508

1

		decimals: 18,

509

1

};

510

511

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

512

1

	ParaB::execute_with(|| {

513

1

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

514

1

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

515

1

			.try_into()

516

1

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

517

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

518

1

			source_id,

519

1

			source_location_latest,

520

1

			asset_metadata.decimals,

521

1

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

522

1

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

523

));

524

1

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

525

1

});

526

527

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

528

1

	ParaC::execute_with(|| {

529

1

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

530

1

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

531

1

			.try_into()

532

1

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

533

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

534

1

			source_id,

535

1

			source_location_latest,

536

1

			asset_metadata.decimals,

537

1

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

538

1

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

539

));

540

1

		assert_ok!(add_supported_asset(source_location, 0));

541

1

});

542

543

	// Send para A asset to para B

544

1

	let dest = Location {

545

1

		parents: 1,

546

1

		interior: [

547

1

			Parachain(2),

548

1

			AccountKey20 {

549

1

				network: None,

550

1

				key: PARAALICE.into(),

551

1

},

552

1

553

1

		.into(),

554

1

};

555

1

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

556

557

1

	ParaA::execute_with(|| {

558

1

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

559

		// free execution, full amount received

560

1

		assert_ok!(PolkadotXcm::transfer_assets(

561

1

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

562

1

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

563

1

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

564

1

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

565

0,

566

1

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

567

));

568

1

});

569

570

	// Para A balances have been substracted

571

1

	ParaA::execute_with(|| {

572

1

		assert_eq!(

573

1

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

574

			INITIAL_BALANCE - 100

575

);

576

1

});

577

578

	// Para B balances have been credited

579

1

	ParaB::execute_with(|| {

580

1

		assert_eq!(

581

1

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

582

1

			Ok(U256::from(100))

583

);

584

1

});

585

586

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

587

1

	let dest = Location {

588

1

		parents: 1,

589

1

		interior: [

590

1

			Parachain(3),

591

1

			AccountKey20 {

592

1

				network: None,

593

1

				key: PARAALICE.into(),

594

1

},

595

1

596

1

		.into(),

597

1

};

598

1

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

599

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(vec![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

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

614

1

	ParaC::execute_with(|| {

615

1

		assert_eq!(

616

1

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

617

1

			Ok(U256::from(95))

618

);

619

1

});

620

1

621

622

#[test]

623

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

624

1

	MockNet::reset();

625

626

	// Para A asset

627

1

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

628

1

	let source_location: AssetType = para_a_balances

629

1

		.try_into()

630

1

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

631

1

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

632

633

1

	let asset_metadata = parachain::AssetMetadata {

634

1

		name: b"ParaAToken".to_vec(),

635

1

		symbol: b"ParaA".to_vec(),

636

1

		decimals: 18,

637

1

};

638

639

	// Register para A asset in para B

640

1

	ParaB::execute_with(|| {

641

1

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

642

1

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

643

1

			.try_into()

644

1

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

645

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

646

1

			source_id,

647

1

			source_location_latest,

648

1

			asset_metadata.decimals,

649

1

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

650

1

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

651

));

652

1

		assert_ok!(add_supported_asset(source_location, 0));

653

1

});

654

655

	// Send para A asset to para B

656

1

	let dest = Location {

657

1

		parents: 1,

658

1

		interior: [

659

1

			Parachain(2),

660

1

			AccountKey20 {

661

1

				network: None,

662

1

				key: PARAALICE.into(),

663

1

},

664

1

665

1

		.into(),

666

1

};

667

1

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

668

669

1

	ParaA::execute_with(|| {

670

1

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

671

1

		assert_ok!(PolkadotXcm::transfer_assets(

672

1

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

673

1

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

674

1

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

675

1

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

676

0,

677

1

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

678

));

679

1

});

680

681

	// Balances have been subtracted

682

1

	ParaA::execute_with(|| {

683

1

		assert_eq!(

684

1

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

685

			INITIAL_BALANCE - 100

686

);

687

1

});

688

689

	// Para B balances have been credited

690

1

	ParaB::execute_with(|| {

691

1

		assert_eq!(

692

1

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

693

1

			Ok(U256::from(100))

694

);

695

1

});

696

697

	// Send back para A asset to para A

698

1

	let dest = Location {

699

1

		parents: 1,

700

1

		interior: [

701

1

			Parachain(1),

702

1

			AccountKey20 {

703

1

				network: None,

704

1

				key: PARAALICE.into(),

705

1

},

706

1

707

1

		.into(),

708

1

};

709

1

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

710

711

1

	ParaB::execute_with(|| {

712

1

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

713

1

		assert_ok!(PolkadotXcm::transfer_assets(

714

1

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

715

1

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

716

1

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

717

1

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

718

0,

719

1

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

720

));

721

1

});

722

723

1

	ParaA::execute_with(|| {

724

		// Weight used is 4

725

1

		assert_eq!(

726

1

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

727

			INITIAL_BALANCE - 4

728

);

729

1

});

730

1

731

732

#[test]

733

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

734

1

	MockNet::reset();

735

736

1

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

737

1

	let source_location: AssetType = para_a_balances

738

1

		.try_into()

739

1

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

740

1

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

741

742

1

	let asset_metadata = parachain::AssetMetadata {

743

1

		name: b"ParaAToken".to_vec(),

744

1

		symbol: b"ParaA".to_vec(),

745

1

		decimals: 18,

746

1

};

747

748

1

	ParaB::execute_with(|| {

749

1

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

750

1

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

751

1

			.try_into()

752

1

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

753

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

754

1

			source_id,

755

1

			source_location_latest,

756

1

			asset_metadata.decimals,

757

1

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

758

1

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

759

));

760

1

		assert_ok!(add_supported_asset(source_location, 0));

761

1

});

762

763

1

	let dest = Location {

764

1

		parents: 1,

765

1

		interior: [

766

1

			Parachain(2),

767

1

			AccountKey20 {

768

1

				network: None,

769

1

				key: PARAALICE.into(),

770

1

},

771

1

772

1

		.into(),

773

1

};

774

1

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

775

776

1

	ParaA::execute_with(|| {

777

1

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

778

1

		assert_ok!(PolkadotXcm::transfer_assets(

779

1

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

780

1

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

781

1

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

782

1

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

783

0,

784

1

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

785

));

786

1

});

787

788

	// Para A asset has been credited

789

1

	ParaA::execute_with(|| {

790

1

		assert_eq!(

791

1

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

792

			INITIAL_BALANCE - 100

793

);

794

1

});

795

796

1

	ParaB::execute_with(|| {

797

		// free execution, full amount received

798

1

		assert_eq!(

799

1

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

800

1

			Ok(U256::from(100))

801

);

802

1

});

803

804

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

805

	// Message through polkadotXCM pallet

806

807

1

	let dest = Location {

808

1

		parents: 1,

809

1

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

810

1

};

811

812

1

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

813

814

1

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

815

1

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

816

1

		ClearOrigin,

817

1

		BuyExecution {

818

1

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

819

1

			weight_limit: Limited(80.into()),

820

1

},

821

1

		DepositAsset {

822

1

			assets: All.into(),

823

1

			beneficiary: Location::new(

824

1

0,

825

1

				[AccountKey20 {

826

1

					network: None,

827

1

					key: PARAALICE,

828

1

}],

829

1

),

830

1

},

831

1

	]));

832

1

	ParaB::execute_with(|| {

833

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

834

		// and deposit asset

835

1

		assert_ok!(ParachainPalletXcm::send(

836

1

			parachain::RuntimeOrigin::root(),

837

1

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

838

1

			Box::new(message),

839

));

840

1

});

841

842

1

	ParaA::execute_with(|| {

843

		// Weight used is 4

844

1

		assert_eq!(

845

1

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

846

			INITIAL_BALANCE - 4

847

);

848

1

});

849

1

850

851

#[test]

852

1

fn receive_relay_asset_with_trader() {

853

1

	MockNet::reset();

854

855

1

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

856

1

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

857

858

1

	let asset_metadata = parachain::AssetMetadata {

859

1

		name: b"RelayToken".to_vec(),

860

1

		symbol: b"Relay".to_vec(),

861

1

		decimals: 12,

862

1

};

863

864

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

865

	// we know later we will divide by 1e12

866

	// Lets put 1e6 as units per second

867

1

	ParaA::execute_with(|| {

868

1

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

869

1

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

870

1

			.try_into()

871

1

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

872

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

873

1

			source_id,

874

1

			source_location_latest,

875

1

			asset_metadata.decimals,

876

1

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

877

1

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

878

));

879

1

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

880

1

});

881

882

1

	let dest: Location = Junction::AccountKey20 {

883

1

		network: None,

884

1

		key: PARAALICE,

885

1

886

1

	.into();

887

	// We are sending 100 tokens from relay.

888

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

889

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

890

	// Units per second should be 2_500_000_000_000_000

891

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

892

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

893

1

	Relay::execute_with(|| {

894

1

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

895

1

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

896

1

			assets: Wild(All),

897

1

			beneficiary: dest.clone(),

898

1

		}]);

899

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

900

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

901

1

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

902

1

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

903

1

			Box::new(TransferType::LocalReserve),

904

1

			Box::new(fees_id),

905

1

			Box::new(TransferType::LocalReserve),

906

1

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

907

1

			WeightLimit::Unlimited

908

));

909

1

});

910

911

1

	ParaA::execute_with(|| {

912

		// non-free execution, not full amount received

913

1

		assert_eq!(

914

1

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

915

1

			Ok(U256::from(90))

916

);

917

		// Fee should have been received by treasury

918

1

		assert_eq!(

919

1

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

920

1

			Ok(U256::from(10))

921

);

922

1

});

923

1

924

925

#[test]

926

1

fn send_para_a_asset_to_para_b_with_trader() {

927

1

	MockNet::reset();

928

929

1

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

930

1

	let source_location: AssetType = para_a_balances

931

1

		.try_into()

932

1

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

933

1

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

934

935

1

	let asset_metadata = parachain::AssetMetadata {

936

1

		name: b"ParaAToken".to_vec(),

937

1

		symbol: b"ParaA".to_vec(),

938

1

		decimals: 18,

939

1

};

940

941

1

	ParaB::execute_with(|| {

942

1

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

943

1

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

944

1

			.try_into()

945

1

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

946

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

947

1

			source_id,

948

1

			source_location_latest,

949

1

			asset_metadata.decimals,

950

1

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

951

1

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

952

));

953

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

954

1

});

955

956

1

	let dest = Location {

957

1

		parents: 1,

958

1

		interior: [

959

1

			Parachain(2),

960

1

			AccountKey20 {

961

1

				network: None,

962

1

				key: PARAALICE.into(),

963

1

},

964

1

965

1

		.into(),

966

1

};

967

1

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

968

969

	// In destination chain, we only need 4 weight

970

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

971

1

	ParaA::execute_with(|| {

972

1

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

973

1

		assert_ok!(PolkadotXcm::transfer_assets(

974

1

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

975

1

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

976

1

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

977

1

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

978

0,

979

1

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

980

));

981

1

});

982

1

	ParaA::execute_with(|| {

983

		// free execution, full amount received

984

1

		assert_eq!(

985

1

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

986

			INITIAL_BALANCE - 100

987

);

988

1

});

989

990

	// We are sending 100 tokens from para A.

991

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

992

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

993

	// Units per second should be 2_500_000_000_000_000

994

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

995

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

996

	// will be 4

997

1

	ParaB::execute_with(|| {

998

1

		assert_eq!(

999

1

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

1000

1

			Ok(U256::from(90))

1001

);

1002

		// Fee should have been received by treasury

1003

1

		assert_eq!(

1004

1

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

1005

1

			Ok(U256::from(10))

1006

);

1007

1

});

1008

1

1009

1010

#[test]

1011

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1012

1

	MockNet::reset();

1013

1014

1

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

1015

1

	let source_location: AssetType = para_a_balances

1016

1

		.try_into()

1017

1

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

1018

1

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

1019

1020

1

	let asset_metadata = parachain::AssetMetadata {

1021

1

		name: b"ParaAToken".to_vec(),

1022

1

		symbol: b"ParaA".to_vec(),

1023

1

		decimals: 18,

1024

1

};

1025

1026

1

	ParaB::execute_with(|| {

1027

1

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

1028

1

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

1029

1

			.try_into()

1030

1

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

1031

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1032

1

			source_id,

1033

1

			source_location_latest,

1034

1

			asset_metadata.decimals,

1035

1

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

1036

1

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

1037

));

1038

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

1039

1

		assert_ok!(add_supported_asset(source_location, 12500000));

1040

1

});

1041

1042

1

	let dest = Location {

1043

1

		parents: 1,

1044

1

		interior: [

1045

1

			Parachain(2),

1046

1

			AccountKey20 {

1047

1

				network: None,

1048

1

				key: PARAALICE.into(),

1049

1

},

1050

1

1051

1

		.into(),

1052

1

};

1053

1

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

1054

	// we use transfer_with_fee

1055

1

	ParaA::execute_with(|| {

1056

1

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

1057

1

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

1058

1

		assert_ok!(PolkadotXcm::transfer_assets(

1059

1

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

1060

1

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

1061

1

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

1062

1

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

1063

0,

1064

1

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

1065

));

1066

1

});

1067

1

	ParaA::execute_with(|| {

1068

		// 100 tokens transferred plus 1 taken from fees

1069

1

		assert_eq!(

1070

1

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

1071

			INITIAL_BALANCE - 100 - 1

1072

);

1073

1

});

1074

1075

1

	ParaB::execute_with(|| {

1076

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

1077

		// what it is specified

1078

1

		assert_eq!(

1079

1

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

1080

1

			Ok(U256::from(101))

1081

);

1082

1

});

1083

1

1084

1085

#[test]

1086

1

fn error_when_not_paying_enough() {

1087

1

	MockNet::reset();

1088

1089

1

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

1090

1

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

1091

1092

1

	let asset_metadata = parachain::AssetMetadata {

1093

1

		name: b"RelayToken".to_vec(),

1094

1

		symbol: b"Relay".to_vec(),

1095

1

		decimals: 12,

1096

1

};

1097

1098

1

	let dest: Location = Junction::AccountKey20 {

1099

1

		network: None,

1100

1

		key: PARAALICE,

1101

1

1102

1

	.into();

1103

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

1104

	// we know later we will divide by 1e12

1105

	// Lets put 1e6 as units per second

1106

1

	ParaA::execute_with(|| {

1107

1

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

1108

1

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

1109

1

			.try_into()

1110

1

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

1111

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1112

1

			source_id,

1113

1

			source_location_latest,

1114

1

			asset_metadata.decimals,

1115

1

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

1116

1

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

1117

));

1118

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

1119

1

});

1120

1121

1

	ParaA::execute_with(|| {

1122

		// amount not received as it is not paying enough

1123

1

		assert_eq!(

1124

1

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

1125

1

			Ok(U256::from(0))

1126

);

1127

1

});

1128

1129

	// We are sending 100 tokens from relay.

1130

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

1131

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

1132

1

	Relay::execute_with(|| {

1133

1

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

1134

1

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

1135

1

			assets: Wild(All),

1136

1

			beneficiary: dest.clone(),

1137

1

		}]);

1138

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1139

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1140

1

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

1141

1

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

1142

1

			Box::new(TransferType::LocalReserve),

1143

1

			Box::new(fees_id),

1144

1

			Box::new(TransferType::LocalReserve),

1145

1

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

1146

1

			WeightLimit::Unlimited

1147

));

1148

1

});

1149

1150

1

	ParaA::execute_with(|| {

1151

		// amount not received as it is not paying enough

1152

1

		assert_eq!(

1153

1

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

1154

1

			Ok(U256::from(0))

1155

);

1156

1

});

1157

1

1158

1159

#[test]

1160

1

fn transact_through_derivative_multilocation() {

1161

1

	MockNet::reset();

1162

1163

1

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

1164

1

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

1165

1166

1

	let asset_metadata = parachain::AssetMetadata {

1167

1

		name: b"RelayToken".to_vec(),

1168

1

		symbol: b"Relay".to_vec(),

1169

1

		decimals: 12,

1170

1

};

1171

1172

1

	ParaA::execute_with(|| {

1173

1

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

1174

1

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

1175

1

			.try_into()

1176

1

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

1177

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1178

1

			source_id,

1179

1

			source_location_latest,

1180

1

			asset_metadata.decimals,

1181

1

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

1182

1

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

1183

));

1184

1

		assert_ok!(add_supported_asset(source_location, 1));

1185

1186

		// Root can set transact info

1187

1

		assert_ok!(XcmTransactor::set_transact_info(

1188

1

			parachain::RuntimeOrigin::root(),

1189

1

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

1190

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

1191

1

			3000.into(),

1192

1

			20000000000.into(),

1193

1

			None

1194

));

1195

		// Root can set transact info

1196

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

1197

1

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

1198

1

			.expect("must succeed");

1199

1

});

1200

1201

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

1202

1203

1

	let dest: Location = AccountKey20 {

1204

1

		network: None,

1205

1

		key: PARAALICE,

1206

1

1207

1

	.into();

1208

1

	Relay::execute_with(|| {

1209

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

1210

1

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

1211

1

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

1212

1

			assets: Wild(All),

1213

1

			beneficiary: dest.clone(),

1214

1

		}]);

1215

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1216

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1217

1

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

1218

1

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

1219

1

			Box::new(TransferType::LocalReserve),

1220

1

			Box::new(fees_id),

1221

1

			Box::new(TransferType::LocalReserve),

1222

1

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

1223

1

			WeightLimit::Unlimited

1224

));

1225

1

});

1226

1227

1

	ParaA::execute_with(|| {

1228

		// free execution, full amount received

1229

1

		assert_eq!(

1230

1

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

1231

1

			Ok(U256::from(4000003100u128))

1232

);

1233

1

});

1234

1235

	// Register address

1236

1

	ParaA::execute_with(|| {

1237

1

		assert_ok!(XcmTransactor::register(

1238

1

			parachain::RuntimeOrigin::root(),

1239

1

			PARAALICE.into(),

1240

0,

1241

));

1242

1

});

1243

1244

	// Send to registered address

1245

1246

1

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

1247

1

	let dest = Location {

1248

1

		parents: 1,

1249

1

		interior: [AccountId32 {

1250

1

			network: None,

1251

1

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

1252

1

}]

1253

1

		.into(),

1254

1

};

1255

1

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

1256

1257

1

	ParaA::execute_with(|| {

1258

1

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

1259

1

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

1260

1

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

1261

1

			assets: Wild(All),

1262

1

			beneficiary: beneficiary.clone(),

1263

1

		}]);

1264

		// free execution, full amount received

1265

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1266

1

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

1267

1

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

1268

1

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

1269

1

			Box::new(TransferType::DestinationReserve),

1270

1

			Box::new(fees_id),

1271

1

			Box::new(TransferType::DestinationReserve),

1272

1

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

1273

1

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

1274

));

1275

1

});

1276

1277

1

	ParaA::execute_with(|| {

1278

		// free execution, full amount received

1279

1

		assert_eq!(

1280

1

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

1281

1

			Ok(U256::from(4000003000u128))

1282

);

1283

1

});

1284

1285

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

1286

	// again

1287

1

	Relay::execute_with(|| {

1288

		// free execution,x	 full amount received

1289

1

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

1290

1

});

1291

1292

	// Encode the call. Balances transact to para_a_account

1293

	// First index

1294

1

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

1295

1

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

1296

1

		relay_chain::Balances,

1297

1

>()

1298

1

	.unwrap() as u8;

1299

1300

1

	encoded.push(index);

1301

1302

	// Then call bytes

1303

1

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

1304

1

		dest: para_a_account(),

1305

1

		value: 100u32.into(),

1306

1

1307

1

	.encode();

1308

1

	encoded.append(&mut call_bytes);

1309

1310

1

	ParaA::execute_with(|| {

1311

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1312

1

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

1313

1

			MockTransactors::Relay,

1314

0,

1315

1

			CurrencyPayment {

1316

1

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

1317

1

					Location::parent()

1318

1

				))),

1319

1

				fee_amount: None

1320

1

},

1321

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

1322

1

			encoded,

1323

1

			TransactWeights {

1324

1

				transact_required_weight_at_most: 4000000000.into(),

1325

1

				overall_weight: None

1326

1

},

1327

			false

1328

));

1329

1

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

1330

1

			.iter()

1331

19

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

1332

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

1333

..

1334

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

1335

19

				_ => None,

1336

19

});

1337

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

1338

1

		assert!(event_found.is_none());

1339

1

});

1340

1341

1

	Relay::execute_with(|| {

1342

		// free execution,x	 full amount received

1343

1

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

1344

1345

1

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

1346

1

});

1347

1

1348

1349

#[test]

1350

1

fn transact_through_derivative_with_custom_fee_weight() {

1351

1

	MockNet::reset();

1352

1353

1

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

1354

1

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

1355

1356

1

	let asset_metadata = parachain::AssetMetadata {

1357

1

		name: b"RelayToken".to_vec(),

1358

1

		symbol: b"Relay".to_vec(),

1359

1

		decimals: 12,

1360

1

};

1361

1362

1

	ParaA::execute_with(|| {

1363

1

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

1364

1

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

1365

1

			.try_into()

1366

1

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

1367

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1368

1

			source_id,

1369

1

			source_location_latest,

1370

1

			asset_metadata.decimals,

1371

1

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

1372

1

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

1373

));

1374

1

		assert_ok!(add_supported_asset(source_location, 1));

1375

1

});

1376

1377

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

1378

1379

1

	let dest: Location = AccountKey20 {

1380

1

		network: None,

1381

1

		key: PARAALICE,

1382

1

1383

1

	.into();

1384

1

	Relay::execute_with(|| {

1385

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

1386

1

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

1387

1

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

1388

1

			assets: Wild(All),

1389

1

			beneficiary: dest.clone(),

1390

1

		}]);

1391

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1392

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1393

1

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

1394

1

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

1395

1

			Box::new(TransferType::LocalReserve),

1396

1

			Box::new(fees_id),

1397

1

			Box::new(TransferType::LocalReserve),

1398

1

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

1399

1

			WeightLimit::Unlimited

1400

));

1401

1

});

1402

1403

1

	ParaA::execute_with(|| {

1404

		// free execution, full amount received

1405

1

		assert_eq!(

1406

1

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

1407

1

			Ok(U256::from(4000003100u128))

1408

);

1409

1

});

1410

1411

	// Register address

1412

1

	ParaA::execute_with(|| {

1413

1

		assert_ok!(XcmTransactor::register(

1414

1

			parachain::RuntimeOrigin::root(),

1415

1

			PARAALICE.into(),

1416

0,

1417

));

1418

1

});

1419

1420

	// Send to registered address

1421

1422

1

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

1423

1

	let dest = Location {

1424

1

		parents: 1,

1425

1

		interior: [AccountId32 {

1426

1

			network: None,

1427

1

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

1428

1

}]

1429

1

		.into(),

1430

1

};

1431

1

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

1432

1433

1

	ParaA::execute_with(|| {

1434

1

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

1435

1

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

1436

1

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

1437

1

			assets: Wild(All),

1438

1

			beneficiary: beneficiary.clone(),

1439

1

		}]);

1440

		// free execution, full amount received

1441

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1442

1

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

1443

1

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

1444

1

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

1445

1

			Box::new(TransferType::DestinationReserve),

1446

1

			Box::new(fees_id),

1447

1

			Box::new(TransferType::DestinationReserve),

1448

1

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

1449

1

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

1450

));

1451

1

});

1452

1453

1

	ParaA::execute_with(|| {

1454

		// free execution, full amount received

1455

1

		assert_eq!(

1456

1

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

1457

1

			Ok(U256::from(4000003000u128))

1458

);

1459

1

});

1460

1461

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

1462

	// again

1463

1

	Relay::execute_with(|| {

1464

		// free execution,x	 full amount received

1465

1

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

1466

1

});

1467

1468

	// Encode the call. Balances transact to para_a_account

1469

	// First index

1470

1

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

1471

1

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

1472

1

		relay_chain::Balances,

1473

1

>()

1474

1

	.unwrap() as u8;

1475

1476

1

	encoded.push(index);

1477

1478

	// Then call bytes

1479

1

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

1480

1

		dest: para_a_account(),

1481

1

		value: 100u32.into(),

1482

1

1483

1

	.encode();

1484

1

	encoded.append(&mut call_bytes);

1485

1486

1

	let overall_weight = 4000003000u64;

1487

1

	ParaA::execute_with(|| {

1488

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1489

1

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

1490

1

			MockTransactors::Relay,

1491

0,

1492

1

			CurrencyPayment {

1493

1

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

1494

1

					Location::parent()

1495

1

				))),

1496

1

				// 1-1 fee weight mapping

1497

1

				fee_amount: Some(overall_weight as u128)

1498

1

},

1499

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

1500

1

			encoded,

1501

1

			TransactWeights {

1502

1

				transact_required_weight_at_most: 4000000000.into(),

1503

1

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

1504

1

},

1505

			false

1506

));

1507

1

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

1508

1

			.iter()

1509

18

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

1510

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

1511

..

1512

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

1513

18

				_ => None,

1514

18

});

1515

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

1516

1

		assert!(event_found.is_none());

1517

1

});

1518

1519

1

	Relay::execute_with(|| {

1520

		// free execution,x	 full amount received

1521

1

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

1522

1523

1

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

1524

1

});

1525

1

1526

1527

#[test]

1528

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1529

1

	MockNet::reset();

1530

1531

1

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

1532

1

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

1533

1534

1

	let asset_metadata = parachain::AssetMetadata {

1535

1

		name: b"RelayToken".to_vec(),

1536

1

		symbol: b"Relay".to_vec(),

1537

1

		decimals: 12,

1538

1

};

1539

1540

1

	ParaA::execute_with(|| {

1541

1

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

1542

1

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

1543

1

			.try_into()

1544

1

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

1545

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1546

1

			source_id,

1547

1

			source_location_latest,

1548

1

			asset_metadata.decimals,

1549

1

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

1550

1

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

1551

));

1552

1

		assert_ok!(add_supported_asset(source_location, 1));

1553

1

});

1554

1555

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

1556

1557

1

	let dest: Location = AccountKey20 {

1558

1

		network: None,

1559

1

		key: PARAALICE,

1560

1

1561

1

	.into();

1562

1

	Relay::execute_with(|| {

1563

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

1564

1

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

1565

1

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

1566

1

			assets: Wild(All),

1567

1

			beneficiary: dest.clone(),

1568

1

		}]);

1569

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1570

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1571

1

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

1572

1

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

1573

1

			Box::new(TransferType::LocalReserve),

1574

1

			Box::new(fees_id),

1575

1

			Box::new(TransferType::LocalReserve),

1576

1

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

1577

1

			WeightLimit::Unlimited

1578

));

1579

1

});

1580

1581

1

	ParaA::execute_with(|| {

1582

		// free execution, full amount received

1583

1

		assert_eq!(

1584

1

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

1585

1

			Ok(U256::from(4000009100u128))

1586

);

1587

1

});

1588

1589

	// Register address

1590

1

	ParaA::execute_with(|| {

1591

1

		assert_ok!(XcmTransactor::register(

1592

1

			parachain::RuntimeOrigin::root(),

1593

1

			PARAALICE.into(),

1594

0,

1595

));

1596

1

});

1597

1598

	// Send to registered address

1599

1600

1

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

1601

1

	let dest = Location {

1602

1

		parents: 1,

1603

1

		interior: [AccountId32 {

1604

1

			network: None,

1605

1

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

1606

1

}]

1607

1

		.into(),

1608

1

};

1609

1

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

1610

1611

1

	ParaA::execute_with(|| {

1612

1

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

1613

1

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

1614

1

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

1615

1

			assets: Wild(All),

1616

1

			beneficiary: beneficiary.clone(),

1617

1

		}]);

1618

		// free execution, full amount received

1619

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1620

1

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

1621

1

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

1622

1

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

1623

1

			Box::new(TransferType::DestinationReserve),

1624

1

			Box::new(fees_id),

1625

1

			Box::new(TransferType::DestinationReserve),

1626

1

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

1627

1

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

1628

));

1629

1

});

1630

1631

1

	ParaA::execute_with(|| {

1632

		// free execution, full amount received

1633

1

		assert_eq!(

1634

1

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

1635

1

			Ok(U256::from(4000009000u128))

1636

);

1637

1

});

1638

1639

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

1640

	// again

1641

1

	Relay::execute_with(|| {

1642

		// free execution,x	 full amount received

1643

1

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

1644

1

});

1645

1646

	// Encode the call. Balances transact to para_a_account

1647

	// First index

1648

1

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

1649

1

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

1650

1

		relay_chain::Balances,

1651

1

>()

1652

1

	.unwrap() as u8;

1653

1654

1

	encoded.push(index);

1655

1656

	// Then call bytes

1657

1

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

1658

1

		dest: para_a_account(),

1659

1

		value: 100u32.into(),

1660

1

1661

1

	.encode();

1662

1

	encoded.append(&mut call_bytes);

1663

1664

1

	let overall_weight = 4000009000u64;

1665

1

	ParaA::execute_with(|| {

1666

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1667

1

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

1668

1

			MockTransactors::Relay,

1669

0,

1670

1

			CurrencyPayment {

1671

1

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

1672

1

					Location::parent()

1673

1

				))),

1674

1

				// 1-1 fee weight mapping

1675

1

				fee_amount: Some(overall_weight as u128)

1676

1

},

1677

1

			encoded,

1678

1

			TransactWeights {

1679

1

				transact_required_weight_at_most: 4000000000.into(),

1680

1

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

1681

1

},

1682

			true

1683

));

1684

1

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

1685

1

			.iter()

1686

18

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

1687

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

1688

..

1689

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

1690

18

				_ => None,

1691

18

});

1692

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

1693

1

		assert!(event_found.is_none());

1694

1

});

1695

1696

1

	Relay::execute_with(|| {

1697

		// free execution, full amount received

1698

		// 4000009000 refunded + 100 transferred = 4000009100

1699

1

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

1700

1

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

1701

1

});

1702

1

1703

1704

#[test]

1705

1

fn transact_through_sovereign() {

1706

1

	MockNet::reset();

1707

1708

1

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

1709

1

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

1710

1711

1

	let asset_metadata = parachain::AssetMetadata {

1712

1

		name: b"RelayToken".to_vec(),

1713

1

		symbol: b"Relay".to_vec(),

1714

1

		decimals: 12,

1715

1

};

1716

1717

1

	ParaA::execute_with(|| {

1718

1

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

1719

1

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

1720

1

			.try_into()

1721

1

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

1722

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1723

1

			source_id,

1724

1

			source_location_latest,

1725

1

			asset_metadata.decimals,

1726

1

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

1727

1

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

1728

));

1729

1

		assert_ok!(add_supported_asset(source_location, 1));

1730

1731

		// Root can set transact info

1732

1

		assert_ok!(XcmTransactor::set_transact_info(

1733

1

			parachain::RuntimeOrigin::root(),

1734

1

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

1735

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

1736

1

			3000.into(),

1737

1

			20000000000.into(),

1738

1

			None

1739

));

1740

		// Root can set transact info

1741

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

1742

1

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

1743

1

			.expect("must succeed");

1744

1

});

1745

1746

1

	let dest: Location = AccountKey20 {

1747

1

		network: None,

1748

1

		key: PARAALICE,

1749

1

1750

1

	.into();

1751

1

	Relay::execute_with(|| {

1752

1

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

1753

1

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

1754

1

			assets: Wild(All),

1755

1

			beneficiary: dest.clone(),

1756

1

		}]);

1757

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1758

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1759

1

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

1760

1

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

1761

1

			Box::new(TransferType::LocalReserve),

1762

1

			Box::new(fees_id),

1763

1

			Box::new(TransferType::LocalReserve),

1764

1

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

1765

1

			WeightLimit::Unlimited

1766

));

1767

1

});

1768

1769

1

	ParaA::execute_with(|| {

1770

		// free execution, full amount received

1771

1

		assert_eq!(

1772

1

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

1773

1

			Ok(U256::from(4000003100u128))

1774

);

1775

1

});

1776

1777

	// Register address

1778

1

	ParaA::execute_with(|| {

1779

1

		assert_ok!(XcmTransactor::register(

1780

1

			parachain::RuntimeOrigin::root(),

1781

1

			PARAALICE.into(),

1782

0,

1783

));

1784

1

});

1785

1786

	// Send to registered address

1787

1

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

1788

1

	let dest = Location {

1789

1

		parents: 1,

1790

1

		interior: [AccountId32 {

1791

1

			network: None,

1792

1

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

1793

1

}]

1794

1

		.into(),

1795

1

};

1796

1

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

1797

1798

1

	ParaA::execute_with(|| {

1799

1

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

1800

1

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

1801

1

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

1802

1

			assets: Wild(All),

1803

1

			beneficiary: beneficiary.clone(),

1804

1

		}]);

1805

		// free execution, full amount received

1806

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1807

1

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

1808

1

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

1809

1

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

1810

1

			Box::new(TransferType::DestinationReserve),

1811

1

			Box::new(fees_id),

1812

1

			Box::new(TransferType::DestinationReserve),

1813

1

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

1814

1

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

1815

));

1816

1

});

1817

1818

1

	ParaA::execute_with(|| {

1819

		// free execution, full amount received

1820

1

		assert_eq!(

1821

1

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

1822

1

			Ok(U256::from(4000003000u128))

1823

);

1824

1

});

1825

1826

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

1827

	// again

1828

1

	Relay::execute_with(|| {

1829

		// free execution,x	 full amount received

1830

1

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

1831

1

1832

1

});

1833

1834

	// We send the xcm transact operation to parent

1835

1

	let dest = Location {

1836

1

		parents: 1,

1837

1

		interior: [].into(),

1838

1

};

1839

1840

	// Encode the call. Balances transact to para_a_account

1841

	// First index

1842

1

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

1843

1

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

1844

1

		relay_chain::Balances,

1845

1

>()

1846

1

	.unwrap() as u8;

1847

1848

1

	encoded.push(index);

1849

1850

	// Then call bytes

1851

1

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

1852

1

		dest: para_a_account(),

1853

1

		value: 100u32.into(),

1854

1

1855

1

	.encode();

1856

1

	encoded.append(&mut call_bytes);

1857

1858

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

1859

1

	ParaA::execute_with(|| {

1860

1

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

1861

1

			moonbase_runtime::xcm_config::Transactors::Relay,

1862

1

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

1863

);

1864

1865

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1866

1

			parachain::RuntimeOrigin::root(),

1867

1

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

1868

1

			Some(PARAALICE.into()),

1869

1

			CurrencyPayment {

1870

1

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

1871

1

					Location::parent()

1872

1

				))),

1873

1

				fee_amount: None

1874

1

},

1875

1

			utility_bytes,

1876

1

			OriginKind::SovereignAccount,

1877

1

			TransactWeights {

1878

1

				transact_required_weight_at_most: 4000000000.into(),

1879

1

				overall_weight: None

1880

1

},

1881

			false

1882

));

1883

1

});

1884

1885

1

	Relay::execute_with(|| {

1886

		// free execution,x	 full amount received

1887

1

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

1888

1889

1

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

1890

1

});

1891

1

1892

1893

#[test]

1894

1

fn transact_through_sovereign_fee_payer_none() {

1895

1

	MockNet::reset();

1896

1897

1

	ParaA::execute_with(|| {

1898

		// Root can set transact info

1899

1

		assert_ok!(XcmTransactor::set_transact_info(

1900

1

			parachain::RuntimeOrigin::root(),

1901

1

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

1902

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

1903

1

			3000.into(),

1904

1

			20000000000.into(),

1905

1

			None

1906

));

1907

		// Root can set transact info

1908

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

1909

1

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

1910

1

			.expect("must succeed");

1911

1

});

1912

1913

1

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

1914

1915

1

	Relay::execute_with(|| {

1916

		// Transfer 100 tokens to derivative_address on the relay

1917

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1918

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1919

1

			derivative_address.clone(),

1920

			100u128

1921

));

1922

1923

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

1924

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1925

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1926

1

			para_a_account(),

1927

			4000003000u128

1928

));

1929

1

});

1930

1931

	// Check balances before the transact call

1932

1

	Relay::execute_with(|| {

1933

1

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

1934

1

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

1935

1

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

1936

1

});

1937

1938

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

1939

1

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

1940

1

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

1941

1

		relay_chain::Balances,

1942

1

>()

1943

1

	.unwrap() as u8;

1944

1945

1

	encoded.push(index);

1946

1947

1

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

1948

1

		dest: RELAYBOB,

1949

1

		value: 100u32.into(),

1950

1

1951

1

	.encode();

1952

1

	encoded.append(&mut call_bytes);

1953

1954

	// We send the xcm transact operation to parent

1955

1

	let dest = Location {

1956

1

		parents: 1,

1957

1

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

1958

1

};

1959

1960

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

1961

1

	ParaA::execute_with(|| {

1962

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

1963

1

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

1964

1

			moonbase_runtime::xcm_config::Transactors::Relay,

1965

1

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

1966

);

1967

1968

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1969

1

			parachain::RuntimeOrigin::root(),

1970

1

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

1971

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

1972

1

			None,

1973

1

			CurrencyPayment {

1974

1

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

1975

1

					Location::parent()

1976

1

				))),

1977

1

				fee_amount: None

1978

1

},

1979

1

			utility_bytes,

1980

1

			OriginKind::SovereignAccount,

1981

1

			TransactWeights {

1982

1

				transact_required_weight_at_most: 4000000000.into(),

1983

1

				overall_weight: None

1984

1

},

1985

			false

1986

));

1987

1

});

1988

1989

	// Check balances after the transact call are correct

1990

1

	Relay::execute_with(|| {

1991

1

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

1992

1

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

1993

1

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

1994

1

});

1995

1

1996

1997

#[test]

1998

1

fn transact_through_sovereign_with_custom_fee_weight() {

1999

1

	MockNet::reset();

2000

2001

1

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

2002

1

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

2003

2004

1

	let asset_metadata = parachain::AssetMetadata {

2005

1

		name: b"RelayToken".to_vec(),

2006

1

		symbol: b"Relay".to_vec(),

2007

1

		decimals: 12,

2008

1

};

2009

2010

1

	ParaA::execute_with(|| {

2011

1

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

2012

1

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

2013

1

			.try_into()

2014

1

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

2015

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2016

1

			source_id,

2017

1

			source_location_latest,

2018

1

			asset_metadata.decimals,

2019

1

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

2020

1

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

2021

));

2022

1

		assert_ok!(add_supported_asset(source_location, 1));

2023

1

});

2024

2025

1

	let dest: Location = AccountKey20 {

2026

1

		network: None,

2027

1

		key: PARAALICE,

2028

1

2029

1

	.into();

2030

1

	Relay::execute_with(|| {

2031

1

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

2032

1

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

2033

1

			assets: Wild(All),

2034

1

			beneficiary: dest.clone(),

2035

1

		}]);

2036

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2037

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2038

1

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

2039

1

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

2040

1

			Box::new(TransferType::LocalReserve),

2041

1

			Box::new(fees_id),

2042

1

			Box::new(TransferType::LocalReserve),

2043

1

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

2044

1

			WeightLimit::Unlimited

2045

));

2046

1

});

2047

2048

1

	ParaA::execute_with(|| {

2049

		// free execution, full amount received

2050

1

		assert_eq!(

2051

1

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

2052

1

			Ok(U256::from(4000003100u128))

2053

);

2054

1

});

2055

2056

	// Register address

2057

1

	ParaA::execute_with(|| {

2058

1

		assert_ok!(XcmTransactor::register(

2059

1

			parachain::RuntimeOrigin::root(),

2060

1

			PARAALICE.into(),

2061

0,

2062

));

2063

1

});

2064

2065

	// Send to registered address

2066

1

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

2067

1

	let dest = Location {

2068

1

		parents: 1,

2069

1

		interior: [AccountId32 {

2070

1

			network: None,

2071

1

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

2072

1

}]

2073

1

		.into(),

2074

1

};

2075

1

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

2076

2077

1

	ParaA::execute_with(|| {

2078

1

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

2079

1

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

2080

1

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

2081

1

			assets: Wild(All),

2082

1

			beneficiary: beneficiary.clone(),

2083

1

		}]);

2084

		// free execution, full amount received

2085

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2086

1

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

2087

1

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

2088

1

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

2089

1

			Box::new(TransferType::DestinationReserve),

2090

1

			Box::new(fees_id),

2091

1

			Box::new(TransferType::DestinationReserve),

2092

1

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

2093

1

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

2094

));

2095

1

});

2096

2097

1

	ParaA::execute_with(|| {

2098

		// free execution, full amount received

2099

1

		assert_eq!(

2100

1

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

2101

1

			Ok(U256::from(4000003000u128))

2102

);

2103

1

});

2104

2105

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

2106

	// again

2107

1

	Relay::execute_with(|| {

2108

		// free execution,x	 full amount received

2109

1

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

2110

1

2111

1

});

2112

2113

	// We send the xcm transact operation to parent

2114

1

	let dest = Location {

2115

1

		parents: 1,

2116

1

		interior: [].into(),

2117

1

};

2118

2119

	// Encode the call. Balances transact to para_a_account

2120

	// First index

2121

1

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

2122

1

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

2123

1

		relay_chain::Balances,

2124

1

>()

2125

1

	.unwrap() as u8;

2126

2127

1

	encoded.push(index);

2128

2129

	// Then call bytes

2130

1

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

2131

1

		dest: para_a_account(),

2132

1

		value: 100u32.into(),

2133

1

2134

1

	.encode();

2135

1

	encoded.append(&mut call_bytes);

2136

2137

1

	let total_weight = 4000003000u64;

2138

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

2139

1

	ParaA::execute_with(|| {

2140

1

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

2141

1

			moonbase_runtime::xcm_config::Transactors::Relay,

2142

1

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

2143

);

2144

2145

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2146

1

			parachain::RuntimeOrigin::root(),

2147

1

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

2148

1

			Some(PARAALICE.into()),

2149

1

			CurrencyPayment {

2150

1

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

2151

1

					Location::parent()

2152

1

				))),

2153

1

				// 1-1 fee-weight mapping

2154

1

				fee_amount: Some(total_weight as u128)

2155

1

},

2156

1

			utility_bytes,

2157

1

			OriginKind::SovereignAccount,

2158

1

			TransactWeights {

2159

1

				transact_required_weight_at_most: 4000000000.into(),

2160

1

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

2161

1

},

2162

			false

2163

));

2164

1

});

2165

2166

1

	Relay::execute_with(|| {

2167

		// free execution,x	 full amount received

2168

1

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

2169

2170

1

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

2171

1

});

2172

1

2173

2174

#[test]

2175

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2176

1

	MockNet::reset();

2177

2178

1

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

2179

1

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

2180

2181

1

	let asset_metadata = parachain::AssetMetadata {

2182

1

		name: b"RelayToken".to_vec(),

2183

1

		symbol: b"Relay".to_vec(),

2184

1

		decimals: 12,

2185

1

};

2186

2187

1

	ParaA::execute_with(|| {

2188

1

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

2189

1

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

2190

1

			.try_into()

2191

1

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

2192

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2193

1

			source_id,

2194

1

			source_location_latest,

2195

1

			asset_metadata.decimals,

2196

1

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

2197

1

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

2198

));

2199

1

		assert_ok!(add_supported_asset(source_location, 1));

2200

1

});

2201

2202

1

	let dest: Location = AccountKey20 {

2203

1

		network: None,

2204

1

		key: PARAALICE,

2205

1

2206

1

	.into();

2207

1

	Relay::execute_with(|| {

2208

1

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

2209

1

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

2210

1

			assets: Wild(All),

2211

1

			beneficiary: dest.clone(),

2212

1

		}]);

2213

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2214

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2215

1

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

2216

1

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

2217

1

			Box::new(TransferType::LocalReserve),

2218

1

			Box::new(fees_id),

2219

1

			Box::new(TransferType::LocalReserve),

2220

1

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

2221

1

			WeightLimit::Unlimited

2222

));

2223

1

});

2224

2225

1

	ParaA::execute_with(|| {

2226

		// free execution, full amount received

2227

1

		assert_eq!(

2228

1

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

2229

1

			Ok(U256::from(4000009100u128))

2230

);

2231

1

});

2232

2233

	// Register address

2234

1

	ParaA::execute_with(|| {

2235

1

		assert_ok!(XcmTransactor::register(

2236

1

			parachain::RuntimeOrigin::root(),

2237

1

			PARAALICE.into(),

2238

0,

2239

));

2240

1

});

2241

2242

	// Send to registered address

2243

1

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

2244

1

	let dest = Location {

2245

1

		parents: 1,

2246

1

		interior: [AccountId32 {

2247

1

			network: None,

2248

1

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

2249

1

}]

2250

1

		.into(),

2251

1

};

2252

1

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

2253

2254

1

	ParaA::execute_with(|| {

2255

1

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

2256

1

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

2257

1

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

2258

1

			assets: Wild(All),

2259

1

			beneficiary: beneficiary.clone(),

2260

1

		}]);

2261

		// free execution, full amount received

2262

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2263

1

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

2264

1

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

2265

1

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

2266

1

			Box::new(TransferType::DestinationReserve),

2267

1

			Box::new(fees_id),

2268

1

			Box::new(TransferType::DestinationReserve),

2269

1

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

2270

1

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

2271

));

2272

1

});

2273

2274

1

	ParaA::execute_with(|| {

2275

		// free execution, full amount received

2276

1

		assert_eq!(

2277

1

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

2278

1

			Ok(U256::from(4000009000u128))

2279

);

2280

1

});

2281

2282

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

2283

	// again

2284

1

	Relay::execute_with(|| {

2285

		// free execution,x	 full amount received

2286

1

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

2287

1

2288

1

});

2289

2290

	// We send the xcm transact operation to parent

2291

1

	let dest = Location {

2292

1

		parents: 1,

2293

1

		interior: [].into(),

2294

1

};

2295

2296

	// Encode the call. Balances transact to para_a_account

2297

	// First index

2298

1

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

2299

1

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

2300

1

		relay_chain::Balances,

2301

1

>()

2302

1

	.unwrap() as u8;

2303

2304

1

	encoded.push(index);

2305

2306

	// Then call bytes

2307

1

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

2308

1

		dest: para_a_account(),

2309

1

		value: 100u32.into(),

2310

1

2311

1

	.encode();

2312

1

	encoded.append(&mut call_bytes);

2313

2314

1

	let total_weight = 4000009000u64;

2315

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

2316

1

	ParaA::execute_with(|| {

2317

1

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

2318

1

			moonbase_runtime::xcm_config::Transactors::Relay,

2319

1

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

2320

);

2321

2322

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2323

1

			parachain::RuntimeOrigin::root(),

2324

1

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

2325

1

			Some(PARAALICE.into()),

2326

1

			CurrencyPayment {

2327

1

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

2328

1

					Location::parent()

2329

1

				))),

2330

1

				// 1-1 fee-weight mapping

2331

1

				fee_amount: Some(total_weight as u128)

2332

1

},

2333

1

			utility_bytes,

2334

1

			OriginKind::SovereignAccount,

2335

1

			TransactWeights {

2336

1

				transact_required_weight_at_most: 4000000000.into(),

2337

1

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

2338

1

},

2339

			true

2340

));

2341

1

});

2342

2343

1

	Relay::execute_with(|| {

2344

		// free execution, full amount received

2345

		// 4000009000 refunded + 100 transferred = 4000009100

2346

1

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

2347

2348

1

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

2349

1

});

2350

1

2351

2352

#[test]

2353

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2354

1

	MockNet::reset();

2355

2356

1

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

2357

1

	let asset_metadata = parachain::AssetMetadata {

2358

1

		name: b"RelayToken".to_vec(),

2359

1

		symbol: b"Relay".to_vec(),

2360

1

		decimals: 12,

2361

1

};

2362

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

2363

1

	ParaA::execute_with(|| {

2364

1

		parachain::XcmVersioner::set_version(1);

2365

1

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

2366

1

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

2367

1

			.try_into()

2368

1

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

2369

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2370

3,

2371

1

			source_location_latest,

2372

1

			asset_metadata.decimals,

2373

1

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

2374

1

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

2375

));

2376

1

		assert_ok!(add_supported_asset(source_location, 0));

2377

1

});

2378

2379

1

	let response = Response::Version(2);

2380

1

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

2381

2382

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

2383

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

2384

1

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

2385

1

		query_id: 0,

2386

1

		response,

2387

1

		max_weight: Weight::zero(),

2388

1

		querier: Some(querier),

2389

1

	}]);

2390

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

2391

	// it directly here

2392

	// Actually send relay asset to parachain

2393

1

	let dest: Location = AccountKey20 {

2394

1

		network: None,

2395

1

		key: PARAALICE,

2396

1

2397

1

	.into();

2398

2399

1

	Relay::execute_with(|| {

2400

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

2401

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2402

1

			relay_chain::RuntimeOrigin::root(),

2403

1

			Some(3)

2404

));

2405

2406

		// Wrap version, which sets VersionedStorage

2407

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

2408

		// this is not necessary in prod

2409

1

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

2410

1

			&Parachain(1).into(),

2411

1

			mock_message

2412

));

2413

2414

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

2415

1

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

2416

1

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

2417

1

			assets: Wild(All),

2418

1

			beneficiary: dest.clone(),

2419

1

		}]);

2420

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2421

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2422

1

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

2423

1

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

2424

1

			Box::new(TransferType::LocalReserve),

2425

1

			Box::new(fees_id),

2426

1

			Box::new(TransferType::LocalReserve),

2427

1

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

2428

1

			WeightLimit::Unlimited

2429

));

2430

2431

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

2432

1

		relay_chain::relay_roll_to(2);

2433

2434

		// queries should have been updated

2435

1

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

2436

1

});

2437

2438

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2439

1

		pallet_xcm::Event::SupportedVersionChanged {

2440

1

			location: Location {

2441

1

				parents: 0,

2442

1

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

2443

1

},

2444

1

			version: 1,

2445

1

2446

1

		.into();

2447

2448

1

	Relay::execute_with(|| {

2449

		// Assert that the events vector contains the version change

2450

1

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

2451

1

});

2452

2453

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

2454

	// of the new version change

2455

1

	ParaA::execute_with(|| {

2456

		// Set version

2457

1

		parachain::XcmVersioner::set_version(2);

2458

		// Do runtime upgrade

2459

1

		parachain::on_runtime_upgrade();

2460

		// Initialize block, to call on_initialize and notify targets

2461

1

		parachain::para_roll_to(2);

2462

		// Expect the event in the parachain

2463

1

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

2464

2

e,

2465

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

2466

				result: 2,

2467

..

2468

})

2469

		)));

2470

1

});

2471

2472

	// This event should have been seen in the relay

2473

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2474

1

		pallet_xcm::Event::SupportedVersionChanged {

2475

1

			location: Location {

2476

1

				parents: 0,

2477

1

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

2478

1

},

2479

1

			version: 2,

2480

1

2481

1

		.into();

2482

2483

1

	Relay::execute_with(|| {

2484

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

2485

1

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

2486

1

});

2487

1

2488

2489

#[test]

2490

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2491

1

	MockNet::reset();

2492

2493

1

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

2494

1

	let source_location: AssetType = para_a_balances

2495

1

		.try_into()

2496

1

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

2497

1

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

2498

2499

1

	let asset_metadata = parachain::AssetMetadata {

2500

1

		name: b"ParaAToken".to_vec(),

2501

1

		symbol: b"ParaA".to_vec(),

2502

1

		decimals: 18,

2503

1

};

2504

1

	let response = Response::Version(2);

2505

1

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

2506

2507

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

2508

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

2509

1

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

2510

1

		query_id: 0,

2511

1

		response,

2512

1

		max_weight: Weight::zero(),

2513

1

		querier: Some(querier),

2514

1

	}]);

2515

2516

1

	ParaA::execute_with(|| {

2517

		// advertised version

2518

1

		parachain::XcmVersioner::set_version(2);

2519

1

});

2520

2521

1

	ParaB::execute_with(|| {

2522

		// Let's try with v0

2523

1

		parachain::XcmVersioner::set_version(0);

2524

2525

1

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

2526

1

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

2527

1

			.try_into()

2528

1

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

2529

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2530

1

			source_id,

2531

1

			source_location_latest,

2532

1

			asset_metadata.decimals,

2533

1

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

2534

1

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

2535

));

2536

1

		assert_ok!(add_supported_asset(source_location, 0));

2537

1

});

2538

2539

1

	ParaA::execute_with(|| {

2540

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

2541

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2542

1

			parachain::RuntimeOrigin::root(),

2543

1

			Some(3)

2544

));

2545

		// Wrap version, which sets VersionedStorage

2546

1

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

2547

1

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

2548

1

			mock_message

2549

));

2550

2551

1

		parachain::para_roll_to(2);

2552

2553

		// queries should have been updated

2554

1

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

2555

1

});

2556

2557

1

	let expected_supported_version: parachain::RuntimeEvent =

2558

1

		pallet_xcm::Event::SupportedVersionChanged {

2559

1

			location: Location {

2560

1

				parents: 1,

2561

1

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

2562

1

},

2563

1

			version: 0,

2564

1

2565

1

		.into();

2566

2567

1

	ParaA::execute_with(|| {

2568

		// Assert that the events vector contains the version change

2569

1

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

2570

1

});

2571

2572

	// Let's ensure talking in v0 works

2573

1

	let dest = Location {

2574

1

		parents: 1,

2575

1

		interior: [

2576

1

			Parachain(2),

2577

1

			AccountKey20 {

2578

1

				network: None,

2579

1

				key: PARAALICE.into(),

2580

1

},

2581

1

2582

1

		.into(),

2583

1

2584

1

	.into();

2585

1

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

2586

1

	ParaA::execute_with(|| {

2587

1

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

2588

		// free execution, full amount received

2589

1

		assert_ok!(PolkadotXcm::transfer_assets(

2590

1

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

2591

1

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

2592

1

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

2593

1

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

2594

0,

2595

1

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

2596

));

2597

		// free execution, full amount received

2598

1

		assert_eq!(

2599

1

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

2600

			INITIAL_BALANCE - 100

2601

);

2602

1

});

2603

2604

1

	ParaB::execute_with(|| {

2605

		// free execution, full amount received

2606

1

		assert_eq!(

2607

1

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

2608

1

			Ok(U256::from(100))

2609

);

2610

1

});

2611

2612

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

2613

	// of the new version change

2614

1

	ParaB::execute_with(|| {

2615

		// Set version

2616

1

		parachain::XcmVersioner::set_version(2);

2617

		// Do runtime upgrade

2618

1

		parachain::on_runtime_upgrade();

2619

		// Initialize block, to call on_initialize and notify targets

2620

1

		parachain::para_roll_to(2);

2621

		// Expect the event in the parachain

2622

1

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

2623

2

e,

2624

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

2625

				result: 2,

2626

..

2627

})

2628

		)));

2629

1

});

2630

2631

	// This event should have been seen in para A

2632

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2633

1

		pallet_xcm::Event::SupportedVersionChanged {

2634

1

			location: Location {

2635

1

				parents: 1,

2636

1

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

2637

1

},

2638

1

			version: 2,

2639

1

2640

1

		.into();

2641

2642

	// Para A should have received the version change

2643

1

	ParaA::execute_with(|| {

2644

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

2645

1

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

2646

1

});

2647

1

2648

2649

#[test]

2650

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2651

1

	MockNet::reset();

2652

2653

1

	let fresh_account = PARABOB;

2654

1

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

2655

1

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

2656

1

	let asset_metadata = parachain::AssetMetadata {

2657

1

		name: b"RelayToken".to_vec(),

2658

1

		symbol: b"Relay".to_vec(),

2659

1

		decimals: 12,

2660

1

};

2661

	// register relay asset in parachain A

2662

1

	ParaA::execute_with(|| {

2663

1

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

2664

1

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

2665

1

			.try_into()

2666

1

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

2667

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2668

1

			source_id,

2669

1

			source_location_latest,

2670

1

			asset_metadata.decimals,

2671

1

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

2672

1

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

2673

));

2674

1

		assert_ok!(add_supported_asset(source_location, 0));

2675

1

});

2676

2677

	// Actually send relay asset to parachain

2678

1

	let dest: Location = AccountKey20 {

2679

1

		network: None,

2680

1

		key: fresh_account,

2681

1

2682

1

	.into();

2683

1

	Relay::execute_with(|| {

2684

1

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

2685

1

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

2686

1

			assets: Wild(All),

2687

1

			beneficiary: dest.clone(),

2688

1

		}]);

2689

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2690

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2691

1

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

2692

1

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

2693

1

			Box::new(TransferType::LocalReserve),

2694

1

			Box::new(fees_id),

2695

1

			Box::new(TransferType::LocalReserve),

2696

1

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

2697

1

			WeightLimit::Unlimited

2698

));

2699

1

});

2700

2701

	// parachain should not have received assets

2702

1

	ParaA::execute_with(|| {

2703

		// free execution, full amount received

2704

1

		assert_eq!(

2705

1

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

2706

1

			Ok(U256::from(123))

2707

);

2708

1

});

2709

1

2710

2711

#[test]

2712

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2713

1

	MockNet::reset();

2714

2715

1

	let fresh_account = [2u8; 20];

2716

1

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

2717

1

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

2718

1

	let asset_metadata = parachain::AssetMetadata {

2719

1

		name: b"RelayToken".to_vec(),

2720

1

		symbol: b"Relay".to_vec(),

2721

1

		decimals: 12,

2722

1

};

2723

	// register relay asset in parachain A

2724

1

	ParaA::execute_with(|| {

2725

1

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

2726

1

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

2727

1

			.try_into()

2728

1

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

2729

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2730

1

			source_id,

2731

1

			source_location_latest,

2732

1

			asset_metadata.decimals,

2733

1

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

2734

1

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

2735

));

2736

1

		assert_ok!(add_supported_asset(source_location, 0));

2737

1

});

2738

2739

	// Actually send relay asset to parachain

2740

1

	let dest: Location = AccountKey20 {

2741

1

		network: None,

2742

1

		key: fresh_account,

2743

1

2744

1

	.into();

2745

1

	Relay::execute_with(|| {

2746

1

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

2747

1

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

2748

1

			assets: Wild(All),

2749

1

			beneficiary: dest.clone(),

2750

1

		}]);

2751

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2752

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2753

1

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

2754

1

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

2755

1

			Box::new(TransferType::LocalReserve),

2756

1

			Box::new(fees_id),

2757

1

			Box::new(TransferType::LocalReserve),

2758

1

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

2759

1

			WeightLimit::Unlimited

2760

));

2761

1

});

2762

2763

	// parachain should have received assets

2764

1

	ParaA::execute_with(|| {

2765

		// free execution, full amount received

2766

1

		assert_eq!(

2767

1

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

2768

1

			Ok(U256::from(123))

2769

);

2770

1

});

2771

1

2772

2773

#[test]

2774

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2775

1

	MockNet::reset();

2776

2777

1

	let mut sufficient_account = [0u8; 20];

2778

1

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

2779

2780

1

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

2781

2782

	// Evm account is self sufficient

2783

1

	ParaA::execute_with(|| {

2784

1

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

2785

1

});

2786

2787

1

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

2788

1

	let asset_metadata = parachain::AssetMetadata {

2789

1

		name: b"RelayToken".to_vec(),

2790

1

		symbol: b"Relay".to_vec(),

2791

1

		decimals: 12,

2792

1

};

2793

	// register relay asset in parachain A

2794

1

	ParaA::execute_with(|| {

2795

1

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

2796

1

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

2797

1

			.try_into()

2798

1

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

2799

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2800

1,

2801

1

			source_location_latest,

2802

1

			asset_metadata.decimals,

2803

1

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

2804

1

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

2805

));

2806

1

		assert_ok!(add_supported_asset(source_location, 0));

2807

1

});

2808

2809

	// Actually send relay asset to parachain

2810

1

	let dest: Location = AccountKey20 {

2811

1

		network: None,

2812

1

		key: sufficient_account,

2813

1

2814

1

	.into();

2815

1

	Relay::execute_with(|| {

2816

1

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

2817

1

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

2818

1

			assets: Wild(All),

2819

1

			beneficiary: dest.clone(),

2820

1

		}]);

2821

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2822

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2823

1

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

2824

1

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

2825

1

			Box::new(TransferType::LocalReserve),

2826

1

			Box::new(fees_id),

2827

1

			Box::new(TransferType::LocalReserve),

2828

1

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

2829

1

			WeightLimit::Unlimited

2830

));

2831

1

});

2832

2833

	// Evm account sufficient ref count increased by 1.

2834

1

	ParaA::execute_with(|| {

2835

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

2836

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

2837

		// remove contract data

2838

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

2839

1

});

2840

2841

1

	ParaA::execute_with(|| {

2842

		// Remove the account from the evm context.

2843

1

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

2844

		// Evm account sufficient ref count decreased by 1.

2845

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

2846

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

2847

		// remove contract data

2848

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

2849

1

});

2850

1

2851

2852

#[test]

2853

1

fn empty_account_should_not_be_reset() {

2854

1

	MockNet::reset();

2855

2856

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

2857

1

	let sufficient_account = PARABOB;

2858

2859

1

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

2860

2861

1

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

2862

1

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

2863

1

	let asset_metadata = parachain::AssetMetadata {

2864

1

		name: b"RelayToken".to_vec(),

2865

1

		symbol: b"Relay".to_vec(),

2866

1

		decimals: 12,

2867

1

};

2868

	// register relay asset in parachain A

2869

1

	ParaA::execute_with(|| {

2870

1

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

2871

1

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

2872

1

			.try_into()

2873

1

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

2874

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2875

1

			source_id,

2876

1

			source_location_latest,

2877

1

			asset_metadata.decimals,

2878

1

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

2879

1

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

2880

));

2881

1

		assert_ok!(add_supported_asset(source_location, 0));

2882

1

});

2883

2884

	// Send native token to evm_account

2885

1

	ParaA::execute_with(|| {

2886

1

		assert_ok!(ParaBalances::transfer_allow_death(

2887

1

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

2888

1

			evm_account_id,

2889

2890

));

2891

1

});

2892

2893

	// Actually send relay asset to parachain

2894

1

	let dest: Location = AccountKey20 {

2895

1

		network: None,

2896

1

		key: sufficient_account,

2897

1

2898

1

	.into();

2899

1

	Relay::execute_with(|| {

2900

1

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

2901

1

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

2902

1

			assets: Wild(All),

2903

1

			beneficiary: dest.clone(),

2904

1

		}]);

2905

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2906

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2907

1

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

2908

1

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

2909

1

			Box::new(TransferType::LocalReserve),

2910

1

			Box::new(fees_id),

2911

1

			Box::new(TransferType::LocalReserve),

2912

1

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

2913

1

			WeightLimit::Unlimited

2914

));

2915

1

});

2916

2917

1

	ParaA::execute_with(|| {

2918

		// Empty the assets from the account.

2919

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

2920

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

2921

1

		assert_ok!(parachain::EvmForeignAssets::transfer(

2922

1

			source_id,

2923

1

			evm_account_id,

2924

1

			PARAALICE.into(),

2925

1

			U256::from(123)

2926

));

2927

		// Verify account asset balance is Zero.

2928

1

		assert_eq!(

2929

1

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

2930

1

			Ok(U256::from(0))

2931

);

2932

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

2933

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

2934

1

		assert_ok!(ParaBalances::force_set_balance(

2935

1

			parachain::RuntimeOrigin::root(),

2936

1

			evm_account_id,

2937

0,

2938

));

2939

		// Verify account native balance is Zero.

2940

1

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

2941

		// Remove the account from the evm context.

2942

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

2943

1

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

2944

		// Verify reference count.

2945

1

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

2946

1

		assert_eq!(account.sufficients, 0);

2947

1

		assert_eq!(account.consumers, 0);

2948

1

		assert_eq!(account.providers, 1);

2949

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

2950

1

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

2951

1

});

2952

1

2953

2954

#[test]

2955

1

fn test_statemint_like() {

2956

1

	MockNet::reset();

2957

2958

1

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

2959

2960

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2961

1

		polkadot_parachain::primitives::Sibling,

2962

1

		statemint_like::AccountId,

2963

1

	>::convert_location(&dest_para)

2964

1

	.unwrap();

2965

2966

1

	let statemint_asset_a_balances = Location::new(

2967

1,

2968

1

2969

1

			Parachain(1000),

2970

1

			PalletInstance(5),

2971

1

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

2972

1

],

2973

);

2974

1

	let source_location: AssetType = statemint_asset_a_balances

2975

1

		.try_into()

2976

1

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

2977

1

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

2978

2979

1

	let asset_metadata = parachain::AssetMetadata {

2980

1

		name: b"StatemintToken".to_vec(),

2981

1

		symbol: b"StatemintToken".to_vec(),

2982

1

		decimals: 12,

2983

1

};

2984

2985

1

	ParaA::execute_with(|| {

2986

1

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

2987

1

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

2988

1

			.try_into()

2989

1

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

2990

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2991

1

			source_id,

2992

1

			source_location_latest,

2993

1

			asset_metadata.decimals,

2994

1

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

2995

1

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

2996

));

2997

1

		assert_ok!(add_supported_asset(source_location, 0));

2998

1

});

2999

3000

1

	Statemint::execute_with(|| {

3001

		// Set new prefix

3002

1

		statemint_like::PrefixChanger::set_prefix(

3003

1

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

3004

);

3005

1

		assert_ok!(StatemintAssets::create(

3006

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3007

0,

3008

			RELAYALICE,

3009

3010

));

3011

3012

1

		assert_ok!(StatemintAssets::mint(

3013

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3014

0,

3015

			RELAYALICE,

3016

			300000000000000

3017

));

3018

3019

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

3020

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3021

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3022

1

			sov,

3023

			100000000000000

3024

));

3025

3026

		// Actually send relay asset to parachain

3027

1

		let dest: Location = AccountKey20 {

3028

1

			network: None,

3029

1

			key: PARAALICE,

3030

1

3031

1

		.into();

3032

3033

		// Send asset with previous prefix

3034

1

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

3035

1

0,

3036

1

3037

1

				xcm::latest::prelude::PalletInstance(

3038

1

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

3039

1

),

3040

1

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

3041

1

],

3042

1

))

3043

1

		.into();

3044

1

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

3045

1

			assets: Wild(All),

3046

1

			beneficiary: dest.clone(),

3047

1

		}]);

3048

1

		assert_ok!(

3049

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3050

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3051

1

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

3052

1

				Box::new(

3053

1

3054

1

3055

1

							xcm::latest::prelude::PalletInstance(

3056

1

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

3057

1

),

3058

1

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

3059

1

],

3060

1

3061

1

3062

1

						.into()

3063

),

3064

1

				Box::new(TransferType::LocalReserve),

3065

1

				Box::new(fees_id),

3066

1

				Box::new(TransferType::LocalReserve),

3067

1

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

3068

1

				WeightLimit::Unlimited

3069

3070

);

3071

1

});

3072

3073

1

	ParaA::execute_with(|| {

3074

1

		assert_eq!(

3075

1

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

3076

1

			Ok(U256::from(123))

3077

);

3078

1

});

3079

1

3080

3081

#[test]

3082

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

3083

1

	MockNet::reset();

3084

3085

	// Relay asset

3086

1

	let relay_location = Location::parent();

3087

1

	let relay_location_v3 =

3088

1

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

3089

1

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

3090

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

3091

};

3092

1

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

3093

1

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

3094

3095

1

	let relay_asset_metadata = parachain::AssetMetadata {

3096

1

		name: b"RelayToken".to_vec(),

3097

1

		symbol: b"Relay".to_vec(),

3098

1

		decimals: 12,

3099

1

};

3100

3101

	// Statemint asset

3102

1

	let statemint_asset = Location::new(

3103

1,

3104

1

3105

1

			Parachain(1000u32),

3106

1

			PalletInstance(5u8),

3107

1

			GeneralIndex(10u128),

3108

1

],

3109

);

3110

1

	let statemint_location_asset: AssetType = statemint_asset

3111

1

		.clone()

3112

1

		.try_into()

3113

1

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

3114

1

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

3115

3116

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3117

1

		name: b"USDC".to_vec(),

3118

1

		symbol: b"USDC".to_vec(),

3119

1

		decimals: 12,

3120

1

};

3121

3122

1

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

3123

3124

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3125

1

		polkadot_parachain::primitives::Sibling,

3126

1

		statemint_like::AccountId,

3127

1

	>::convert_location(&dest_para)

3128

1

	.unwrap();

3129

3130

1

	ParaA::execute_with(|| {

3131

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3132

1

			source_relay_id,

3133

1

			relay_location.clone(),

3134

1

			relay_asset_metadata.decimals,

3135

1

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

3136

1

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

3137

));

3138

1

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

3139

3140

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3141

1

			source_statemint_asset_id,

3142

1

			statemint_asset.clone(),

3143

1

			asset_metadata_statemint_asset.decimals,

3144

1

			asset_metadata_statemint_asset

3145

1

				.symbol

3146

1

				.try_into()

3147

1

				.expect("too long"),

3148

1

			asset_metadata_statemint_asset

3149

1

				.name

3150

1

				.try_into()

3151

1

				.expect("too long"),

3152

));

3153

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0));

3154

1

});

3155

3156

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3157

1

		network: None,

3158

1

		key: PARAALICE,

3159

1

3160

1

	.into();

3161

3162

	// Send relay chain asset to Alice in Parachain A

3163

1

	Relay::execute_with(|| {

3164

1

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

3165

1

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

3166

1

			assets: Wild(All),

3167

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

3168

1

		}]);

3169

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

3170

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3171

1

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

3172

1

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

3173

1

			Box::new(TransferType::LocalReserve),

3174

1

			Box::new(fees_id),

3175

1

			Box::new(TransferType::LocalReserve),

3176

1

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

3177

1

			WeightLimit::Unlimited

3178

));

3179

1

});

3180

3181

1

	Statemint::execute_with(|| {

3182

		// Set new prefix

3183

1

		statemint_like::PrefixChanger::set_prefix(

3184

1

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

3185

);

3186

3187

1

		assert_ok!(StatemintAssets::create(

3188

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3189

10,

3190

			RELAYALICE,

3191

3192

));

3193

3194

1

		assert_ok!(StatemintAssets::mint(

3195

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3196

10,

3197

			RELAYALICE,

3198

			300000000000000

3199

));

3200

3201

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

3202

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

3203

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3204

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3205

1

			sov,

3206

			100000000000000

3207

));

3208

3209

		// Send statemint USDC asset to Alice in Parachain A

3210

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

3211

1

			network: None,

3212

1

			key: PARAALICE,

3213

1

3214

1

		.into();

3215

3216

		// Send with new prefix

3217

1

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

3218

1

0,

3219

1

3220

1

				xcm::latest::prelude::PalletInstance(

3221

1

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

3222

1

),

3223

1

				GeneralIndex(10),

3224

1

],

3225

1

))

3226

1

		.into();

3227

1

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

3228

1

			assets: Wild(All),

3229

1

			beneficiary: parachain_beneficiary_from_statemint.clone(),

3230

1

		}]);

3231

1

		assert_ok!(

3232

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3233

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3234

1

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

3235

1

				Box::new(

3236

1

3237

1

3238

1

							xcm::latest::prelude::PalletInstance(

3239

1

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

3240

1

),

3241

1

							GeneralIndex(10),

3242

1

],

3243

1

3244

1

3245

1

						.into()

3246

),

3247

1

				Box::new(TransferType::LocalReserve),

3248

1

				Box::new(fees_id),

3249

1

				Box::new(TransferType::LocalReserve),

3250

1

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

3251

1

				WeightLimit::Unlimited

3252

3253

);

3254

1

});

3255

3256

1

	let statemint_beneficiary = Location {

3257

1

		parents: 1,

3258

1

		interior: [

3259

1

			Parachain(1000),

3260

1

			AccountId32 {

3261

1

				network: None,

3262

1

				id: RELAYBOB.into(),

3263

1

},

3264

1

3265

1

		.into(),

3266

1

};

3267

3268

1

	ParaA::execute_with(|| {

3269

		// Alice has received 125 USDC

3270

1

		assert_eq!(

3271

1

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

3272

1

			Ok(U256::from(125))

3273

);

3274

3275

		// Alice has received 200 Relay assets

3276

1

		assert_eq!(

3277

1

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

3278

1

			Ok(U256::from(200))

3279

);

3280

1

});

3281

3282

1

	Statemint::execute_with(|| {

3283

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

3284

1

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

3285

1

});

3286

3287

1

	let (chain_part, beneficiary) =

3288

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

3289

3290

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

3291

1

	ParaA::execute_with(|| {

3292

1

		let asset = currency_to_asset(

3293

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3294

			100,

3295

);

3296

1

		let asset_fee =

3297

1

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

3298

1

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

3299

1

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

3300

1

			assets: Wild(All),

3301

1

			beneficiary: beneficiary.clone(),

3302

1

		}]);

3303

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3304

1

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

3305

1

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

3306

1

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

3307

1

			Box::new(TransferType::DestinationReserve),

3308

1

			Box::new(fees_id),

3309

1

			Box::new(TransferType::DestinationReserve),

3310

1

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

3311

1

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

3312

));

3313

1

});

3314

3315

1

	ParaA::execute_with(|| {

3316

		// Alice has 100 USDC less

3317

1

		assert_eq!(

3318

1

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

3319

1

			Ok(U256::from(25))

3320

);

3321

3322

		// Alice has 100 relay asset less

3323

1

		assert_eq!(

3324

1

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

3325

1

			Ok(U256::from(100))

3326

);

3327

1

});

3328

3329

1

	Statemint::execute_with(|| {

3330

		// Check that BOB received 100 USDC on statemint

3331

1

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

3332

1

});

3333

1

3334

3335

#[test]

3336

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3337

1

	MockNet::reset();

3338

3339

	// Relay asset

3340

1

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

3341

1

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

3342

1

	let relay_location_v5 = Location::parent();

3343

1

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

3344

3345

1

	let relay_asset_metadata = parachain::AssetMetadata {

3346

1

		name: b"RelayToken".to_vec(),

3347

1

		symbol: b"Relay".to_vec(),

3348

1

		decimals: 12,

3349

1

};

3350

3351

1

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

3352

3353

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3354

1

		polkadot_parachain::primitives::Sibling,

3355

1

		statemint_like::AccountId,

3356

1

	>::convert_location(&dest_para)

3357

1

	.unwrap();

3358

3359

1

	ParaA::execute_with(|| {

3360

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3361

1

			source_relay_id,

3362

1

			relay_location_v5.clone(),

3363

1

			relay_asset_metadata.decimals,

3364

1

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

3365

1

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

3366

));

3367

1

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

3368

1

});

3369

3370

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3371

1

		network: None,

3372

1

		key: PARAALICE,

3373

1

3374

1

	.into();

3375

3376

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3377

1

		network: None,

3378

1

		id: RELAYALICE.into(),

3379

1

3380

1

	.into();

3381

3382

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

3383

1

	Relay::execute_with(|| {

3384

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3385

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3386

1

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

3387

1

			Box::new(

3388

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3389

1

					.clone()

3390

1

					.into()

3391

),

3392

1

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

3393

0,

3394

1

			WeightLimit::Unlimited

3395

));

3396

1

});

3397

3398

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3399

1

	Statemint::execute_with(|| {

3400

		// Check Alice received 200 tokens on AssetHub

3401

1

		assert_eq!(

3402

1

			StatemintBalances::free_balance(RELAYALICE),

3403

			INITIAL_BALANCE + 200

3404

);

3405

3406

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3407

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3408

1

			sov,

3409

			110000000000000

3410

));

3411

3412

		// Now send those tokens to ParaA

3413

1

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

3414

1

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

3415

1

			assets: Wild(All),

3416

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3417

1

		}]);

3418

1

		assert_ok!(

3419

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3420

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3421

1

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

3422

1

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

3423

1

				Box::new(TransferType::LocalReserve),

3424

1

				Box::new(fees_id),

3425

1

				Box::new(TransferType::LocalReserve),

3426

1

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

3427

1

				WeightLimit::Unlimited

3428

3429

);

3430

1

});

3431

3432

1

	ParaA::execute_with(|| {

3433

		// Alice should have received the DOTs

3434

1

		assert_eq!(

3435

1

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

3436

1

			Ok(U256::from(200))

3437

);

3438

1

});

3439

3440

1

	let dest = Location::new(

3441

1,

3442

1

3443

1

			Parachain(1000),

3444

1

			AccountId32 {

3445

1

				network: None,

3446

1

				id: RELAYBOB.into(),

3447

1

},

3448

1

],

3449

);

3450

1

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

3451

3452

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

3453

1

	ParaA::execute_with(|| {

3454

1

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

3455

1

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

3456

1

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

3457

1

			assets: Wild(All),

3458

1

			beneficiary: beneficiary.clone(),

3459

1

		}]);

3460

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3461

1

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

3462

1

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

3463

1

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

3464

1

			Box::new(TransferType::DestinationReserve),

3465

1

			Box::new(fees_id),

3466

1

			Box::new(TransferType::DestinationReserve),

3467

1

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

3468

1

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

3469

));

3470

3471

1

		assert_eq!(

3472

1

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

3473

1

			Ok(U256::from(100))

3474

);

3475

1

});

3476

3477

1

	Statemint::execute_with(|| {

3478

		// Check that Bob received the tokens back in AssetHub

3479

1

		assert_eq!(

3480

1

			StatemintBalances::free_balance(RELAYBOB),

3481

			INITIAL_BALANCE + 100

3482

);

3483

1

});

3484

3485

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

3486

1

	Statemint::execute_with(|| {

3487

		// Now send those tokens to ParaA

3488

1

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

3489

1

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

3490

1

			assets: Wild(All),

3491

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3492

1

		}]);

3493

1

		assert_ok!(

3494

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3495

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3496

1

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

3497

1

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

3498

1

				Box::new(TransferType::LocalReserve),

3499

1

				Box::new(fees_id),

3500

1

				Box::new(TransferType::LocalReserve),

3501

1

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

3502

1

				WeightLimit::Unlimited

3503

3504

);

3505

3506

		// 100 DOTs were deducted from Bob's account

3507

1

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

3508

1

});

3509

3510

1

	ParaA::execute_with(|| {

3511

		// Alice should have received 100 DOTs

3512

1

		assert_eq!(

3513

1

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

3514

1

			Ok(U256::from(200))

3515

);

3516

1

});

3517

1

3518

3519

#[test]

3520

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3521

1

	MockNet::reset();

3522

3523

	// Relay asset

3524

1

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

3525

1

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

3526

1

	let relay_location_v5 = Location::parent();

3527

1

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

3528

3529

1

	let relay_asset_metadata = parachain::AssetMetadata {

3530

1

		name: b"RelayToken".to_vec(),

3531

1

		symbol: b"Relay".to_vec(),

3532

1

		decimals: 12,

3533

1

};

3534

3535

1

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

3536

3537

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3538

1

		polkadot_parachain::primitives::Sibling,

3539

1

		statemint_like::AccountId,

3540

1

	>::convert_location(&dest_para)

3541

1

	.unwrap();

3542

3543

1

	ParaA::execute_with(|| {

3544

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3545

1

			source_relay_id,

3546

1

			relay_location_v5.clone(),

3547

1

			relay_asset_metadata.decimals,

3548

1

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

3549

1

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

3550

));

3551

1

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

3552

1

});

3553

3554

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3555

1

		network: None,

3556

1

		key: PARAALICE,

3557

1

3558

1

	.into();

3559

3560

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3561

1

		network: None,

3562

1

		id: RELAYALICE.into(),

3563

1

3564

1

	.into();

3565

3566

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

3567

1

	Relay::execute_with(|| {

3568

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3569

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3570

1

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

3571

1

			Box::new(

3572

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3573

1

					.clone()

3574

1

					.into()

3575

),

3576

1

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

3577

0,

3578

1

			WeightLimit::Unlimited

3579

));

3580

1

});

3581

3582

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3583

1

	Statemint::execute_with(|| {

3584

		// Check Alice received 200 tokens on AssetHub

3585

1

		assert_eq!(

3586

1

			StatemintBalances::free_balance(RELAYALICE),

3587

			INITIAL_BALANCE + 200

3588

);

3589

3590

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3591

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3592

1

			sov,

3593

			110000000000000

3594

));

3595

3596

		// Now send those tokens to ParaA

3597

1

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

3598

1

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

3599

1

			assets: Wild(All),

3600

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3601

1

		}]);

3602

1

		assert_ok!(

3603

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3604

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3605

1

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

3606

1

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

3607

1

				Box::new(TransferType::LocalReserve),

3608

1

				Box::new(fees_id),

3609

1

				Box::new(TransferType::LocalReserve),

3610

1

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

3611

1

				WeightLimit::Unlimited

3612

3613

);

3614

1

});

3615

3616

1

	ParaA::execute_with(|| {

3617

		// Alice should have received the DOTs

3618

1

		assert_eq!(

3619

1

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

3620

1

			Ok(U256::from(200))

3621

);

3622

1

});

3623

3624

1

	let dest = Location::new(

3625

1,

3626

1

3627

1

			Parachain(1000),

3628

1

			AccountId32 {

3629

1

				network: None,

3630

1

				id: RELAYBOB.into(),

3631

1

},

3632

1

],

3633

);

3634

1

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

3635

3636

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

3637

1

	ParaA::execute_with(|| {

3638

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3639

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3640

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3641

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3642

1

			assets: Wild(All),

3643

1

			beneficiary: beneficiary.clone(),

3644

1

		}]);

3645

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3646

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3647

1

			Box::new(VersionedLocation::from(chain_part)),

3648

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

3649

1

			Box::new(TransferType::DestinationReserve),

3650

1

			Box::new(fees_id),

3651

1

			Box::new(TransferType::DestinationReserve),

3652

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3653

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3654

));

3655

3656

1

		assert_eq!(

3657

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3658

1

			Ok(U256::from(90))

3659

);

3660

1

});

3661

3662

1

	Statemint::execute_with(|| {

3663

		// Free execution: check that Bob received the tokens back in AssetHub

3664

1

		assert_eq!(

3665

1

			StatemintBalances::free_balance(RELAYBOB),

3666

			INITIAL_BALANCE + 110

3667

);

3668

1

});

3669

3670

	// Send back tokens from AH to ParaA from Bob's account

3671

1

	Statemint::execute_with(|| {

3672

		// Now send those tokens to ParaA

3673

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3674

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3675

1

			assets: Wild(All),

3676

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3677

1

		}]);

3678

1

		assert_ok!(

3679

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3680

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3681

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3682

1

				Box::new((Location::parent(), 100).into()),

3683

1

				Box::new(TransferType::LocalReserve),

3684

1

				Box::new(fees_id),

3685

1

				Box::new(TransferType::LocalReserve),

3686

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3687

1

				WeightLimit::Unlimited

3688

3689

);

3690

3691

		// 100 DOTs were deducted from Bob's account

3692

1

		assert_eq!(

3693

1

			StatemintBalances::free_balance(RELAYBOB),

3694

			INITIAL_BALANCE + 10

3695

);

3696

1

});

3697

3698

1

	ParaA::execute_with(|| {

3699

		// Alice should have received 100 DOTs

3700

1

		assert_eq!(

3701

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3702

1

			Ok(U256::from(190))

3703

);

3704

1

});

3705

1

3706

3707

#[test]

3708

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3709

1

	MockNet::reset();

3710

3711

	// Relay asset

3712

1

	let relay_location_v3 = xcm::v3::Location::parent();

3713

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3714

1

	let relay_location_v5 = Location::parent();

3715

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3716

3717

1

	let relay_asset_metadata = parachain::AssetMetadata {

3718

1

		name: b"RelayToken".to_vec(),

3719

1

		symbol: b"Relay".to_vec(),

3720

1

		decimals: 12,

3721

1

};

3722

3723

1

	let dest_para = Location::new(1, [Parachain(1)]);

3724

3725

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3726

1

		polkadot_parachain::primitives::Sibling,

3727

1

		statemint_like::AccountId,

3728

1

	>::convert_location(&dest_para)

3729

1

	.unwrap();

3730

3731

1

	ParaA::execute_with(|| {

3732

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3733

1

			source_relay_id,

3734

1

			relay_location_v5.clone(),

3735

1

			relay_asset_metadata.decimals,

3736

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3737

1

			relay_asset_metadata.name.try_into().expect("too long"),

3738

));

3739

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3740

1

});

3741

3742

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3743

1

		network: None,

3744

1

		key: PARAALICE,

3745

1

3746

1

	.into();

3747

3748

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3749

1

		network: None,

3750

1

		id: RELAYALICE.into(),

3751

1

3752

1

	.into();

3753

3754

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3755

1

	Relay::execute_with(|| {

3756

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3757

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3758

1

			Box::new(Parachain(1000).into()),

3759

1

			Box::new(

3760

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3761

1

					.clone()

3762

1

					.into()

3763

),

3764

1

			Box::new(([], 200).into()),

3765

0,

3766

1

			WeightLimit::Unlimited

3767

));

3768

1

});

3769

3770

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3771

1

	Statemint::execute_with(|| {

3772

		// Check Alice received 200 tokens on AssetHub

3773

1

		assert_eq!(

3774

1

			StatemintBalances::free_balance(RELAYALICE),

3775

			INITIAL_BALANCE + 200

3776

);

3777

3778

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3779

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3780

1

			sov,

3781

			110000000000000

3782

));

3783

3784

		// Now send those tokens to ParaA

3785

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3786

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3787

1

			assets: Wild(All),

3788

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3789

1

		}]);

3790

1

		assert_ok!(

3791

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3792

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3793

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3794

1

				Box::new((Location::parent(), 200).into()),

3795

1

				Box::new(TransferType::LocalReserve),

3796

1

				Box::new(fees_id),

3797

1

				Box::new(TransferType::LocalReserve),

3798

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3799

1

				WeightLimit::Unlimited

3800

3801

);

3802

1

});

3803

3804

1

	ParaA::execute_with(|| {

3805

		// Alice should have received the DOTs

3806

1

		assert_eq!(

3807

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3808

1

			Ok(U256::from(200))

3809

);

3810

1

});

3811

3812

1

	let dest = Location::new(

3813

1,

3814

1

3815

1

			Parachain(1000),

3816

1

			AccountId32 {

3817

1

				network: None,

3818

1

				id: RELAYBOB.into(),

3819

1

},

3820

1

],

3821

);

3822

3823

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3824

1

	let asset = Asset {

3825

1

		id: AssetId(Location::parent()),

3826

1

		fun: Fungibility::Fungible(100),

3827

1

};

3828

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3829

1

	ParaA::execute_with(|| {

3830

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3831

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3832

1

			assets: Wild(All),

3833

1

			beneficiary,

3834

1

		}]);

3835

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3836

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3837

1

			Box::new(VersionedLocation::from(chain_part)),

3838

1

			Box::new(VersionedAssets::from(asset)),

3839

1

			Box::new(TransferType::DestinationReserve),

3840

1

			Box::new(fees_id),

3841

1

			Box::new(TransferType::DestinationReserve),

3842

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3843

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3844

));

3845

3846

1

		assert_eq!(

3847

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3848

1

			Ok(U256::from(100))

3849

);

3850

1

});

3851

3852

1

	Statemint::execute_with(|| {

3853

		// Check that Bob received the tokens back in AssetHub

3854

1

		assert_eq!(

3855

1

			StatemintBalances::free_balance(RELAYBOB),

3856

			INITIAL_BALANCE + 100

3857

);

3858

1

});

3859

3860

	// Send back tokens from AH to ParaA from Bob's account

3861

1

	Statemint::execute_with(|| {

3862

		// Now send those tokens to ParaA

3863

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3864

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3865

1

			assets: Wild(All),

3866

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3867

1

		}]);

3868

1

		assert_ok!(

3869

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3870

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3871

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3872

1

				Box::new((Location::parent(), 100).into()),

3873

1

				Box::new(TransferType::LocalReserve),

3874

1

				Box::new(fees_id),

3875

1

				Box::new(TransferType::LocalReserve),

3876

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3877

1

				WeightLimit::Unlimited

3878

3879

);

3880

3881

		// 100 DOTs were deducted from Bob's account

3882

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3883

1

});

3884

3885

1

	ParaA::execute_with(|| {

3886

		// Alice should have received 100 DOTs

3887

1

		assert_eq!(

3888

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3889

1

			Ok(U256::from(200))

3890

);

3891

1

});

3892

1

3893

3894

#[test]

3895

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3896

1

	MockNet::reset();

3897

3898

	// Relay asset

3899

1

	let relay_location_v3 = xcm::v3::Location::parent();

3900

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3901

1

	let relay_location_v5 = Location::parent();

3902

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3903

3904

1

	let relay_asset_metadata = parachain::AssetMetadata {

3905

1

		name: b"RelayToken".to_vec(),

3906

1

		symbol: b"Relay".to_vec(),

3907

1

		decimals: 12,

3908

1

};

3909

3910

	// Statemint asset

3911

1

	let statemint_asset = Location::new(

3912

1,

3913

1

3914

1

			Parachain(1000u32),

3915

1

			PalletInstance(5u8),

3916

1

			GeneralIndex(10u128),

3917

1

],

3918

);

3919

1

	let statemint_location_asset: AssetType = statemint_asset

3920

1

		.clone()

3921

1

		.try_into()

3922

1

		.expect("Location convertion to AssetType should succeed");

3923

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3924

3925

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3926

1

		name: b"USDC".to_vec(),

3927

1

		symbol: b"USDC".to_vec(),

3928

1

		decimals: 12,

3929

1

};

3930

3931

1

	let dest_para = Location::new(1, [Parachain(1)]);

3932

3933

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3934

1

		polkadot_parachain::primitives::Sibling,

3935

1

		statemint_like::AccountId,

3936

1

	>::convert_location(&dest_para)

3937

1

	.unwrap();

3938

3939

1

	ParaA::execute_with(|| {

3940

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3941

1

			source_relay_id,

3942

1

			relay_location_v5.clone(),

3943

1

			relay_asset_metadata.decimals,

3944

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3945

1

			relay_asset_metadata.name.try_into().expect("too long"),

3946

));

3947

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3948

3949

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3950

1

			source_statemint_asset_id,

3951

1

			statemint_asset.clone(),

3952

1

			asset_metadata_statemint_asset.decimals,

3953

1

			asset_metadata_statemint_asset

3954

1

				.symbol

3955

1

				.try_into()

3956

1

				.expect("too long"),

3957

1

			asset_metadata_statemint_asset

3958

1

				.name

3959

1

				.try_into()

3960

1

				.expect("too long"),

3961

));

3962

1

		XcmWeightTrader::set_asset_price(statemint_asset, 0u128);

3963

1

});

3964

3965

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3966

1

		network: None,

3967

1

		key: PARAALICE,

3968

1

3969

1

	.into();

3970

3971

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3972

1

		network: None,

3973

1

		id: RELAYALICE.into(),

3974

1

3975

1

	.into();

3976

3977

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3978

1

	Relay::execute_with(|| {

3979

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3980

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3981

1

			Box::new(Parachain(1000).into()),

3982

1

			Box::new(

3983

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3984

1

					.clone()

3985

1

					.into()

3986

),

3987

1

			Box::new(([], 200).into()),

3988

0,

3989

1

			WeightLimit::Unlimited

3990

));

3991

1

});

3992

3993

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3994

1

	Statemint::execute_with(|| {

3995

		// Check Alice received 200 tokens on AssetHub

3996

1

		assert_eq!(

3997

1

			StatemintBalances::free_balance(RELAYALICE),

3998

			INITIAL_BALANCE + 200

3999

);

4000

4001

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4002

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4003

1

			sov,

4004

			110000000000000

4005

));

4006

4007

1

		statemint_like::PrefixChanger::set_prefix(

4008

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4009

);

4010

4011

1

		assert_ok!(StatemintAssets::create(

4012

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4013

10,

4014

			RELAYALICE,

4015

4016

));

4017

4018

1

		assert_ok!(StatemintAssets::mint(

4019

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4020

10,

4021

			RELAYALICE,

4022

			300000000000000

4023

));

4024

4025

		// Now send relay tokens to ParaA

4026

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4027

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4028

1

			assets: Wild(All),

4029

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4030

1

		}]);

4031

1

		assert_ok!(

4032

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4033

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4034

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4035

1

				Box::new((Location::parent(), 200).into()),

4036

1

				Box::new(TransferType::LocalReserve),

4037

1

				Box::new(fees_id),

4038

1

				Box::new(TransferType::LocalReserve),

4039

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4040

1

				WeightLimit::Unlimited

4041

4042

);

4043

4044

		// Send USDC

4045

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4046

1

0,

4047

1

4048

1

				xcm::latest::prelude::PalletInstance(

4049

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4050

1

),

4051

1

				GeneralIndex(10),

4052

1

],

4053

1

))

4054

1

		.into();

4055

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4056

1

			assets: Wild(All),

4057

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4058

1

		}]);

4059

1

		assert_ok!(

4060

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4061

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4062

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4063

1

				Box::new(

4064

1

4065

1

4066

1

							xcm::latest::prelude::PalletInstance(

4067

1

								<StatemintAssets as PalletInfoAccess>::index() as u8

4068

1

),

4069

1

							GeneralIndex(10),

4070

1

],

4071

1

4072

1

4073

1

						.into()

4074

),

4075

1

				Box::new(TransferType::LocalReserve),

4076

1

				Box::new(fees_id),

4077

1

				Box::new(TransferType::LocalReserve),

4078

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4079

1

				WeightLimit::Unlimited

4080

4081

);

4082

1

});

4083

4084

1

	ParaA::execute_with(|| {

4085

		// Alice should have received the DOTs

4086

1

		assert_eq!(

4087

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4088

1

			Ok(U256::from(200))

4089

);

4090

4091

		// Alice has received 125 USDC

4092

1

		assert_eq!(

4093

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4094

1

			Ok(U256::from(125))

4095

);

4096

1

});

4097

4098

1

	let dest = Location::new(

4099

1,

4100

1

4101

1

			Parachain(1000),

4102

1

			AccountId32 {

4103

1

				network: None,

4104

1

				id: RELAYBOB.into(),

4105

1

},

4106

1

],

4107

);

4108

4109

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4110

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4111

1

	ParaA::execute_with(|| {

4112

1

		let asset = currency_to_asset(

4113

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

4114

			100,

4115

);

4116

1

		let asset_fee =

4117

1

			currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

4118

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4119

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4120

1

			assets: Wild(All),

4121

1

			beneficiary: beneficiary.clone(),

4122

1

		}]);

4123

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4124

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4125

1

			Box::new(VersionedLocation::from(chain_part)),

4126

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

4127

1

			Box::new(TransferType::DestinationReserve),

4128

1

			Box::new(fees_id),

4129

1

			Box::new(TransferType::DestinationReserve),

4130

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4131

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4132

));

4133

4134

1

		assert_eq!(

4135

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4136

1

			Ok(U256::from(100))

4137

);

4138

1

});

4139

4140

1

	Statemint::execute_with(|| {

4141

		// Check that Bob received relay tokens back in AssetHub

4142

1

		assert_eq!(

4143

1

			StatemintBalances::free_balance(RELAYBOB),

4144

			INITIAL_BALANCE + 100

4145

);

4146

4147

		// Check that BOB received 100 USDC on AssetHub

4148

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4149

1

});

4150

4151

	// Send back tokens from AH to ParaA from Bob's account

4152

1

	Statemint::execute_with(|| {

4153

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4154

4155

		// Now send those tokens to ParaA

4156

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4157

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4158

1

			assets: Wild(All),

4159

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4160

1

		}]);

4161

1

		assert_ok!(

4162

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4163

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4164

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4165

1

				Box::new((Location::parent(), 100).into()),

4166

1

				Box::new(TransferType::LocalReserve),

4167

1

				Box::new(fees_id),

4168

1

				Box::new(TransferType::LocalReserve),

4169

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4170

1

				WeightLimit::Unlimited

4171

4172

);

4173

4174

		// 100 DOTs were deducted from Bob's account

4175

1

		assert_eq!(

4176

1

			StatemintBalances::free_balance(RELAYBOB),

4177

1

			bob_previous_balance - 100

4178

);

4179

1

});

4180

4181

1

	ParaA::execute_with(|| {

4182

		// Alice should have received 100 DOTs

4183

1

		assert_eq!(

4184

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4185

1

			Ok(U256::from(200))

4186

);

4187

1

});

4188

1

4189

4190

#[test]

4191

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

4192

1

	MockNet::reset();

4193

4194

	// Relay asset

4195

1

	let relay_location_v3 = xcm::v3::Location::parent();

4196

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

4197

1

	let relay_location_v5 = Location::parent();

4198

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

4199

4200

1

	let relay_asset_metadata = parachain::AssetMetadata {

4201

1

		name: b"RelayToken".to_vec(),

4202

1

		symbol: b"Relay".to_vec(),

4203

1

		decimals: 12,

4204

1

};

4205

4206

	// Statemint asset

4207

1

	let statemint_asset = Location::new(

4208

1,

4209

1

4210

1

			Parachain(1000u32),

4211

1

			PalletInstance(5u8),

4212

1

			GeneralIndex(10u128),

4213

1

],

4214

);

4215

1

	let statemint_location_asset: AssetType = statemint_asset

4216

1

		.clone()

4217

1

		.try_into()

4218

1

		.expect("Location convertion to AssetType should succeed");

4219

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

4220

4221

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

4222

1

		name: b"USDC".to_vec(),

4223

1

		symbol: b"USDC".to_vec(),

4224

1

		decimals: 12,

4225

1

};

4226

4227

1

	let dest_para = Location::new(1, [Parachain(1)]);

4228

4229

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

4230

1

		polkadot_parachain::primitives::Sibling,

4231

1

		statemint_like::AccountId,

4232

1

	>::convert_location(&dest_para)

4233

1

	.unwrap();

4234

4235

1

	ParaA::execute_with(|| {

4236

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4237

1

			source_relay_id,

4238

1

			relay_location_v5.clone(),

4239

1

			relay_asset_metadata.decimals,

4240

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

4241

1

			relay_asset_metadata.name.try_into().expect("too long"),

4242

));

4243

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4244

4245

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4246

1

			source_statemint_asset_id,

4247

1

			statemint_asset.clone(),

4248

1

			asset_metadata_statemint_asset.decimals,

4249

1

			asset_metadata_statemint_asset

4250

1

				.symbol

4251

1

				.try_into()

4252

1

				.expect("too long"),

4253

1

			asset_metadata_statemint_asset

4254

1

				.name

4255

1

				.try_into()

4256

1

				.expect("too long"),

4257

));

4258

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

4259

1

});

4260

4261

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4262

1

		network: None,

4263

1

		key: PARAALICE,

4264

1

4265

1

	.into();

4266

4267

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

4268

1

		network: None,

4269

1

		id: RELAYALICE.into(),

4270

1

4271

1

	.into();

4272

4273

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4274

1

	Relay::execute_with(|| {

4275

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4276

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4277

1

			Box::new(Parachain(1000).into()),

4278

1

			Box::new(

4279

1

				VersionedLocation::from(statemint_beneficiary_absolute)

4280

1

					.clone()

4281

1

					.into()

4282

),

4283

1

			Box::new(([], 200).into()),

4284

0,

4285

1

			WeightLimit::Unlimited

4286

));

4287

1

});

4288

4289

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4290

1

	Statemint::execute_with(|| {

4291

		// Check Alice received 200 tokens on AssetHub

4292

1

		assert_eq!(

4293

1

			StatemintBalances::free_balance(RELAYALICE),

4294

			INITIAL_BALANCE + 200

4295

);

4296

4297

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4298

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4299

1

			sov,

4300

			110000000000000

4301

));

4302

4303

1

		statemint_like::PrefixChanger::set_prefix(

4304

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4305

);

4306

4307

1

		assert_ok!(StatemintAssets::create(

4308

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4309

10,

4310

			RELAYALICE,

4311

4312

));

4313

4314

1

		assert_ok!(StatemintAssets::mint(

4315

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4316

10,

4317

			RELAYALICE,

4318

			300000000000000

4319

));

4320

4321

		// Now send relay tokens to ParaA

4322

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4323

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4324

1

			assets: Wild(All),

4325

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4326

1

		}]);

4327

1

		assert_ok!(

4328

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4329

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4330

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4331

1

				Box::new((Location::parent(), 200).into()),

4332

1

				Box::new(TransferType::LocalReserve),

4333

1

				Box::new(fees_id),

4334

1

				Box::new(TransferType::LocalReserve),

4335

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4336

1

				WeightLimit::Unlimited

4337

4338

);

4339

4340

		// Send USDC

4341

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4342

1

0,

4343

1

4344

1

				xcm::latest::prelude::PalletInstance(

4345

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4346

1

),

4347

1

				GeneralIndex(10),

4348

1

],

4349

1

))

4350

1

		.into();

4351

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4352

1

			assets: Wild(All),

4353

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4354

1

		}]);

4355

1

		assert_ok!(

4356

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4357

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4358

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4359

1

				Box::new(

4360

1

4361

1

4362

1

							xcm::latest::prelude::PalletInstance(

4363

1

								<StatemintAssets as PalletInfoAccess>::index() as u8

4364

1

),

4365

1

							GeneralIndex(10),

4366

1

],

4367

1

4368

1

4369

1

						.into()

4370

),

4371

1

				Box::new(TransferType::LocalReserve),

4372

1

				Box::new(fees_id),

4373

1

				Box::new(TransferType::LocalReserve),

4374

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4375

1

				WeightLimit::Unlimited

4376

4377

);

4378

1

});

4379

4380

1

	ParaA::execute_with(|| {

4381

		// Alice should have received the DOTs

4382

1

		assert_eq!(

4383

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4384

1

			Ok(U256::from(200))

4385

);

4386

4387

		// Alice has received 125 USDC

4388

1

		assert_eq!(

4389

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4390

1

			Ok(U256::from(125))

4391

);

4392

1

});

4393

4394

1

	let dest = Location::new(

4395

1,

4396

1

4397

1

			Parachain(1000),

4398

1

			AccountId32 {

4399

1

				network: None,

4400

1

				id: RELAYBOB.into(),

4401

1

},

4402

1

],

4403

);

4404

4405

1

	let statemint_asset_to_send = Asset {

4406

1

		id: AssetId(statemint_asset),

4407

1

		fun: Fungibility::Fungible(100),

4408

1

};

4409

4410

1

	let relay_asset_to_send = Asset {

4411

1

		id: AssetId(Location::parent()),

4412

1

		fun: Fungibility::Fungible(100),

4413

1

};

4414

4415

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4416

1

	let assets_to_send: XcmAssets =

4417

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

4418

4419

	// For some reason the order of the assets is inverted when creating the array above.

4420

	// We need to use relay asset for fees, so we pick index 0.

4421

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4422

4423

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4424

1

	ParaA::execute_with(|| {

4425

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4426

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4427

1

			assets: Wild(All),

4428

1

			beneficiary,

4429

1

		}]);

4430

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4431

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4432

1

			Box::new(VersionedLocation::from(chain_part)),

4433

1

			Box::new(VersionedAssets::from(assets_to_send)),

4434

1

			Box::new(TransferType::DestinationReserve),

4435

1

			Box::new(fees_id),

4436

1

			Box::new(TransferType::DestinationReserve),

4437

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4438

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4439

));

4440

4441

1

		assert_eq!(

4442

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4443

1

			Ok(U256::from(100))

4444

);

4445

1

});

4446

4447

1

	Statemint::execute_with(|| {

4448

		// Check that Bob received relay tokens back in AssetHub

4449

1

		assert_eq!(

4450

1

			StatemintBalances::free_balance(RELAYBOB),

4451

			INITIAL_BALANCE + 100

4452

);

4453

4454

		// Check that BOB received 100 USDC on AssetHub

4455

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4456

1

});

4457

4458

	// Send back tokens from AH to ParaA from Bob's account

4459

1

	Statemint::execute_with(|| {

4460

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4461

4462

		// Now send those tokens to ParaA

4463

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4464

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4465

1

			assets: Wild(All),

4466

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4467

1

		}]);

4468

1

		assert_ok!(

4469

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4470

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4471

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4472

1

				Box::new((Location::parent(), 100).into()),

4473

1

				Box::new(TransferType::LocalReserve),

4474

1

				Box::new(fees_id),

4475

1

				Box::new(TransferType::LocalReserve),

4476

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4477

1

				WeightLimit::Unlimited

4478

4479

);

4480

4481

		// 100 DOTs were deducted from Bob's account

4482

1

		assert_eq!(

4483

1

			StatemintBalances::free_balance(RELAYBOB),

4484

1

			bob_previous_balance - 100

4485

);

4486

1

});

4487

4488

1

	ParaA::execute_with(|| {

4489

		// Alice should have received 100 DOTs

4490

1

		assert_eq!(

4491

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4492

1

			Ok(U256::from(200))

4493

);

4494

1

});

4495

1

4496

4497

#[test]

4498

1

fn transact_through_signed_multilocation() {

4499

1

	MockNet::reset();

4500

1

	let mut ancestry = Location::parent();

4501

4502

1

	ParaA::execute_with(|| {

4503

		// Root can set transact info

4504

1

		assert_ok!(XcmTransactor::set_transact_info(

4505

1

			parachain::RuntimeOrigin::root(),

4506

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4507

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4508

1

			3000.into(),

4509

1

			20000000000.into(),

4510

			// 4 instructions in transact through signed

4511

1

			Some(4000.into())

4512

));

4513

		// Root can set transact info

4514

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4515

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

4516

1

			.expect("must succeed");

4517

1

		ancestry = parachain::UniversalLocation::get().into();

4518

1

});

4519

4520

	// Let's construct the Junction that we will append with DescendOrigin

4521

1

	let signed_origin: Junctions = [AccountKey20 {

4522

1

		network: None,

4523

1

		key: PARAALICE,

4524

1

}]

4525

1

	.into();

4526

4527

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4528

1

	descend_origin_multilocation

4529

1

		.append_with(signed_origin)

4530

1

		.unwrap();

4531

4532

	// To convert it to what the relay will see instead of us

4533

1

	descend_origin_multilocation

4534

1

		.reanchor(&Location::parent(), &ancestry.interior)

4535

1

		.unwrap();

4536

4537

1

	let derived = xcm_builder::Account32Hash::<

4538

1

		relay_chain::KusamaNetwork,

4539

1

		relay_chain::AccountId,

4540

1

	>::convert_location(&descend_origin_multilocation)

4541

1

	.unwrap();

4542

4543

1

	Relay::execute_with(|| {

4544

		// free execution, full amount received

4545

1

		assert_ok!(RelayBalances::transfer_allow_death(

4546

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4547

1

			derived.clone(),

4548

			4000004100u128,

4549

));

4550

		// derived account has all funds

4551

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4552

		// sovereign account has 0 funds

4553

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4554

1

});

4555

4556

	// Encode the call. Balances transact to para_a_account

4557

	// First index

4558

1

	let mut encoded: Vec<u8> = Vec::new();

4559

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4560

1

		relay_chain::Balances,

4561

1

>()

4562

1

	.unwrap() as u8;

4563

4564

1

	encoded.push(index);

4565

4566

	// Then call bytes

4567

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4568

1

		// 100 to sovereign

4569

1

		dest: para_a_account(),

4570

1

		value: 100u32.into(),

4571

1

4572

1

	.encode();

4573

1

	encoded.append(&mut call_bytes);

4574

4575

1

	ParaA::execute_with(|| {

4576

1

		assert_ok!(XcmTransactor::transact_through_signed(

4577

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4578

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4579

1

			CurrencyPayment {

4580

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4581

1

					Location::parent()

4582

1

				))),

4583

1

				fee_amount: None

4584

1

},

4585

1

			encoded,

4586

			// 4000000000 for transfer + 4000 for XCM

4587

1

			TransactWeights {

4588

1

				transact_required_weight_at_most: 4000000000.into(),

4589

1

				overall_weight: None

4590

1

},

4591

			false

4592

));

4593

1

});

4594

4595

1

	Relay::execute_with(|| {

4596

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4597

4598

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4599

1

});

4600

1

4601

4602

#[test]

4603

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4604

1

	MockNet::reset();

4605

1

	let mut ancestry = Location::parent();

4606

4607

1

	ParaA::execute_with(|| {

4608

1

		ancestry = parachain::UniversalLocation::get().into();

4609

1

});

4610

4611

	// Let's construct the Junction that we will append with DescendOrigin

4612

1

	let signed_origin: Junctions = [AccountKey20 {

4613

1

		network: None,

4614

1

		key: PARAALICE,

4615

1

}]

4616

1

	.into();

4617

4618

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4619

1

	descend_origin_multilocation

4620

1

		.append_with(signed_origin)

4621

1

		.unwrap();

4622

4623

	// To convert it to what the relay will see instead of us

4624

1

	descend_origin_multilocation

4625

1

		.reanchor(&Location::parent(), &ancestry.interior)

4626

1

		.unwrap();

4627

4628

1

	let derived = xcm_builder::Account32Hash::<

4629

1

		relay_chain::KusamaNetwork,

4630

1

		relay_chain::AccountId,

4631

1

	>::convert_location(&descend_origin_multilocation)

4632

1

	.unwrap();

4633

4634

1

	Relay::execute_with(|| {

4635

		// free execution, full amount received

4636

1

		assert_ok!(RelayBalances::transfer_allow_death(

4637

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4638

1

			derived.clone(),

4639

			4000004100u128,

4640

));

4641

		// derived account has all funds

4642

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4643

		// sovereign account has 0 funds

4644

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4645

1

});

4646

4647

	// Encode the call. Balances transact to para_a_account

4648

	// First index

4649

1

	let mut encoded: Vec<u8> = Vec::new();

4650

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4651

1

		relay_chain::Balances,

4652

1

>()

4653

1

	.unwrap() as u8;

4654

4655

1

	encoded.push(index);

4656

4657

	// Then call bytes

4658

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4659

1

		// 100 to sovereign

4660

1

		dest: para_a_account(),

4661

1

		value: 100u32.into(),

4662

1

4663

1

	.encode();

4664

1

	encoded.append(&mut call_bytes);

4665

4666

1

	let total_weight = 4000004000u64;

4667

1

	ParaA::execute_with(|| {

4668

1

		assert_ok!(XcmTransactor::transact_through_signed(

4669

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4670

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4671

1

			CurrencyPayment {

4672

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4673

1

					Location::parent()

4674

1

				))),

4675

1

				fee_amount: Some(total_weight as u128)

4676

1

},

4677

1

			encoded,

4678

			// 4000000000 for transfer + 4000 for XCM

4679

1

			TransactWeights {

4680

1

				transact_required_weight_at_most: 4000000000.into(),

4681

1

				overall_weight: Some(Limited(total_weight.into()))

4682

1

},

4683

			false

4684

));

4685

1

});

4686

4687

1

	Relay::execute_with(|| {

4688

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4689

4690

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4691

1

});

4692

1

4693

4694

#[test]

4695

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4696

1

	MockNet::reset();

4697

1

	let mut ancestry = Location::parent();

4698

4699

1

	ParaA::execute_with(|| {

4700

1

		ancestry = parachain::UniversalLocation::get().into();

4701

1

});

4702

4703

	// Let's construct the Junction that we will append with DescendOrigin

4704

1

	let signed_origin: Junctions = [AccountKey20 {

4705

1

		network: None,

4706

1

		key: PARAALICE,

4707

1

}]

4708

1

	.into();

4709

4710

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4711

1

	descend_origin_multilocation

4712

1

		.append_with(signed_origin)

4713

1

		.unwrap();

4714

4715

	// To convert it to what the relay will see instead of us

4716

1

	descend_origin_multilocation

4717

1

		.reanchor(&Location::parent(), &ancestry.interior)

4718

1

		.unwrap();

4719

4720

1

	let derived = xcm_builder::Account32Hash::<

4721

1

		relay_chain::KusamaNetwork,

4722

1

		relay_chain::AccountId,

4723

1

	>::convert_location(&descend_origin_multilocation)

4724

1

	.unwrap();

4725

4726

1

	Relay::execute_with(|| {

4727

		// free execution, full amount received

4728

1

		assert_ok!(RelayBalances::transfer_allow_death(

4729

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4730

1

			derived.clone(),

4731

			4000009100u128,

4732

));

4733

		// derived account has all funds

4734

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4735

		// sovereign account has 0 funds

4736

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4737

1

});

4738

4739

	// Encode the call. Balances transact to para_a_account

4740

	// First index

4741

1

	let mut encoded: Vec<u8> = Vec::new();

4742

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4743

1

		relay_chain::Balances,

4744

1

>()

4745

1

	.unwrap() as u8;

4746

4747

1

	encoded.push(index);

4748

4749

	// Then call bytes

4750

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4751

1

		// 100 to sovereign

4752

1

		dest: para_a_account(),

4753

1

		value: 100u32.into(),

4754

1

4755

1

	.encode();

4756

1

	encoded.append(&mut call_bytes);

4757

4758

1

	let total_weight = 4000009000u64;

4759

1

	ParaA::execute_with(|| {

4760

1

		assert_ok!(XcmTransactor::transact_through_signed(

4761

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4762

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4763

1

			CurrencyPayment {

4764

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4765

1

					Location::parent()

4766

1

				))),

4767

1

				fee_amount: Some(total_weight as u128)

4768

1

},

4769

1

			encoded,

4770

			// 4000000000 for transfer + 9000 for XCM

4771

1

			TransactWeights {

4772

1

				transact_required_weight_at_most: 4000000000.into(),

4773

1

				overall_weight: Some(Limited(total_weight.into()))

4774

1

},

4775

			true

4776

));

4777

1

});

4778

4779

1

	Relay::execute_with(|| {

4780

		// 100 transferred

4781

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4782

4783

		// 4000009000 refunded

4784

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4785

1

});

4786

1

4787

4788

#[test]

4789

1

fn transact_through_signed_multilocation_para_to_para() {

4790

1

	frame_support::__private::sp_tracing::init_for_tests();

4791

1

	MockNet::reset();

4792

1

	let mut ancestry = Location::parent();

4793

4794

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4795

4796

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4797

4798

1

	ParaA::execute_with(|| {

4799

		// Root can set transact info

4800

1

		assert_ok!(XcmTransactor::set_transact_info(

4801

1

			parachain::RuntimeOrigin::root(),

4802

			// ParaB

4803

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4804

			// Para charges 1000 for every instruction, and we have 3, so 3

4805

1

			3.into(),

4806

1

			20000000000.into(),

4807

			// 4 instructions in transact through signed

4808

1

			Some(4.into())

4809

));

4810

		// Root can set transact info

4811

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4812

1

		set_fee_per_second_for_location(

4813

1

			para_b_balances.clone(),

4814

1

			parachain::ParaTokensPerSecond::get(),

4815

4816

1

		.expect("must succeed");

4817

1

		ancestry = parachain::UniversalLocation::get().into();

4818

1

});

4819

4820

	// Let's construct the Junction that we will append with DescendOrigin

4821

1

	let signed_origin: Junctions = [AccountKey20 {

4822

1

		network: None,

4823

1

		key: PARAALICE,

4824

1

}]

4825

1

	.into();

4826

4827

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4828

1

	descend_origin_multilocation

4829

1

		.append_with(signed_origin)

4830

1

		.unwrap();

4831

4832

	// To convert it to what the paraB will see instead of us

4833

1

	descend_origin_multilocation

4834

1

		.reanchor(&para_b_location, &ancestry.interior)

4835

1

		.unwrap();

4836

4837

1

	let derived = xcm_builder::HashedDescription::<

4838

1

		parachain::AccountId,

4839

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4840

1

	>::convert_location(&descend_origin_multilocation)

4841

1

	.unwrap();

4842

4843

1

	ParaB::execute_with(|| {

4844

		// free execution, full amount received

4845

1

		assert_ok!(ParaBalances::transfer_allow_death(

4846

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4847

1

			derived.clone(),

4848

			4000000104u128,

4849

));

4850

		// derived account has all funds

4851

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4852

		// sovereign account has 0 funds

4853

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4854

1

});

4855

4856

	// Encode the call. Balances transact to para_a_account

4857

	// First index

4858

1

	let mut encoded: Vec<u8> = Vec::new();

4859

1

	let index =

4860

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4861

1

			.unwrap() as u8;

4862

4863

1

	encoded.push(index);

4864

4865

	// Then call bytes

4866

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4867

1

		// 100 to sovereign

4868

1

		dest: para_a_account_20(),

4869

1

		value: 100u32.into(),

4870

1

4871

1

	.encode();

4872

1

	encoded.append(&mut call_bytes);

4873

4874

1

	ParaA::execute_with(|| {

4875

1

		assert_ok!(XcmTransactor::transact_through_signed(

4876

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4877

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4878

1

			CurrencyPayment {

4879

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4880

1

					para_b_balances

4881

1

				))),

4882

1

				fee_amount: None

4883

1

},

4884

1

			encoded,

4885

			// 4000000000 for transfer + 4000 for XCM

4886

			// 1-1 to fee

4887

1

			TransactWeights {

4888

1

				transact_required_weight_at_most: 4000000000.into(),

4889

1

				overall_weight: None

4890

1

},

4891

			false

4892

));

4893

1

});

4894

4895

1

	ParaB::execute_with(|| {

4896

1

		assert_eq!(ParaBalances::free_balance(&derived), 0);

4897

4898

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4899

1

});

4900

1

4901

4902

#[test]

4903

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4904

1

	MockNet::reset();

4905

1

	let mut ancestry = Location::parent();

4906

4907

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4908

4909

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4910

4911

1

	ParaA::execute_with(|| {

4912

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4913

1

		set_fee_per_second_for_location(

4914

1

			para_b_balances.clone(),

4915

1

			parachain::ParaTokensPerSecond::get(),

4916

4917

1

		.expect("must succeed");

4918

1

		ancestry = parachain::UniversalLocation::get().into();

4919

1

});

4920

4921

	// Let's construct the Junction that we will append with DescendOrigin

4922

1

	let signed_origin: Junctions = [AccountKey20 {

4923

1

		network: None,

4924

1

		key: PARAALICE,

4925

1

}]

4926

1

	.into();

4927

4928

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4929

1

	descend_origin_multilocation

4930

1

		.append_with(signed_origin)

4931

1

		.unwrap();

4932

4933

	// To convert it to what the paraB will see instead of us

4934

1

	descend_origin_multilocation

4935

1

		.reanchor(&para_b_location, &ancestry.interior)

4936

1

		.unwrap();

4937

4938

1

	let derived = xcm_builder::HashedDescription::<

4939

1

		parachain::AccountId,

4940

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4941

1

	>::convert_location(&descend_origin_multilocation)

4942

1

	.unwrap();

4943

4944

1

	ParaB::execute_with(|| {

4945

		// free execution, full amount received

4946

1

		assert_ok!(ParaBalances::transfer_allow_death(

4947

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4948

1

			derived.clone(),

4949

			4000009100u128,

4950

));

4951

		// derived account has all funds

4952

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4953

		// sovereign account has 0 funds

4954

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4955

1

});

4956

4957

	// Encode the call. Balances transact to para_a_account

4958

	// First index

4959

1

	let mut encoded: Vec<u8> = Vec::new();

4960

1

	let index =

4961

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4962

1

			.unwrap() as u8;

4963

4964

1

	encoded.push(index);

4965

4966

	// Then call bytes

4967

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4968

1

		// 100 to sovereign

4969

1

		dest: para_a_account_20(),

4970

1

		value: 100u32.into(),

4971

1

4972

1

	.encode();

4973

1

	encoded.append(&mut call_bytes);

4974

4975

1

	let overall_weight = 4000009000u64;

4976

1

	ParaA::execute_with(|| {

4977

1

		assert_ok!(XcmTransactor::transact_through_signed(

4978

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4979

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4980

1

			CurrencyPayment {

4981

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4982

1

					para_b_balances

4983

1

				))),

4984

1

				fee_amount: Some(overall_weight as u128)

4985

1

},

4986

1

			encoded,

4987

			// 4000000000 for transfer + 9000 for XCM

4988

1

			TransactWeights {

4989

1

				transact_required_weight_at_most: 4000000000.into(),

4990

1

				overall_weight: Some(Limited(overall_weight.into()))

4991

1

},

4992

			true

4993

));

4994

1

});

4995

4996

1

	ParaB::execute_with(|| {

4997

		// Check the derived account was refunded

4998

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4999

5000

		// Check the transfer was executed

5001

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

5002

1

});

5003

1

5004

5005

#[test]

5006

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

5007

1

	MockNet::reset();

5008

1

	let mut ancestry = Location::parent();

5009

5010

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5011

5012

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5013

5014

1

	ParaA::execute_with(|| {

5015

		// Root can set transact info

5016

1

		assert_ok!(XcmTransactor::set_transact_info(

5017

1

			parachain::RuntimeOrigin::root(),

5018

			// ParaB

5019

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5020

			// Para charges 1000 for every instruction, and we have 3, so 3

5021

1

			3.into(),

5022

1

			20000000000.into(),

5023

			// 4 instructions in transact through signed

5024

1

			Some(4.into())

5025

));

5026

		// Root can set transact info

5027

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5028

1

		set_fee_per_second_for_location(

5029

1

			para_b_balances.clone(),

5030

1

			parachain::ParaTokensPerSecond::get(),

5031

5032

1

		.expect("must succeed");

5033

1

		ancestry = parachain::UniversalLocation::get().into();

5034

1

});

5035

5036

	// Let's construct the Junction that we will append with DescendOrigin

5037

1

	let signed_origin: Junctions = [AccountKey20 {

5038

1

		network: None,

5039

1

		key: PARAALICE,

5040

1

}]

5041

1

	.into();

5042

5043

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5044

1

	descend_origin_multilocation

5045

1

		.append_with(signed_origin)

5046

1

		.unwrap();

5047

5048

	// To convert it to what the paraB will see instead of us

5049

1

	descend_origin_multilocation

5050

1

		.reanchor(&para_b_location, &ancestry.interior)

5051

1

		.unwrap();

5052

5053

1

	let derived = xcm_builder::HashedDescription::<

5054

1

		parachain::AccountId,

5055

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5056

1

	>::convert_location(&descend_origin_multilocation)

5057

1

	.unwrap();

5058

5059

1

	let mut parachain_b_alice_balances_before = 0;

5060

1

	ParaB::execute_with(|| {

5061

1

		assert_ok!(ParaBalances::transfer_allow_death(

5062

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5063

1

			derived.clone(),

5064

			4000000104u128,

5065

));

5066

		// derived account has all funds

5067

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5068

		// sovereign account has 0 funds

5069

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5070

5071

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5072

1

});

5073

5074

	// Encode the call. Balances transact to para_a_account

5075

	// First index

5076

1

	let mut encoded: Vec<u8> = Vec::new();

5077

1

	let index =

5078

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5079

1

			.unwrap() as u8;

5080

5081

1

	encoded.push(index);

5082

5083

	use sp_core::U256;

5084

	// Let's do a EVM transfer

5085

1

	let eth_tx =

5086

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5087

1

			gas_limit: U256::from(21000),

5088

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5089

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5090

1

			value: U256::from(100),

5091

1

			input: BoundedVec::<

5092

1

u8,

5093

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5094

1

			>::try_from(vec![]).unwrap(),

5095

1

			access_list: None,

5096

1

});

5097

5098

	// Then call bytes

5099

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

5100

1

		xcm_transaction: eth_tx,

5101

1

5102

1

	.encode();

5103

1

	encoded.append(&mut call_bytes);

5104

5105

1

	ParaA::execute_with(|| {

5106

1

		assert_ok!(XcmTransactor::transact_through_signed(

5107

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5108

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5109

1

			CurrencyPayment {

5110

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5111

1

					para_b_balances

5112

1

				))),

5113

1

				fee_amount: None

5114

1

},

5115

1

			encoded,

5116

			// 4000000000 for transfer + 4000 for XCM

5117

			// 1-1 to fee

5118

1

			TransactWeights {

5119

1

				transact_required_weight_at_most: 4000000000.into(),

5120

1

				overall_weight: None

5121

1

},

5122

			false

5123

));

5124

1

});

5125

5126

1

	ParaB::execute_with(|| {

5127

		// Make sure the EVM transfer went through

5128

1

		assert!(

5129

1

			ParaBalances::free_balance(&PARAALICE.into())

5130

1

				== parachain_b_alice_balances_before + 100

5131

);

5132

1

});

5133

1

5134

5135

#[test]

5136

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

5137

1

	MockNet::reset();

5138

1

	let mut ancestry = Location::parent();

5139

5140

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5141

5142

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5143

5144

1

	ParaA::execute_with(|| {

5145

		// Root can set transact info

5146

1

		assert_ok!(XcmTransactor::set_transact_info(

5147

1

			parachain::RuntimeOrigin::root(),

5148

			// ParaB

5149

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5150

			// Para charges 1000 for every instruction, and we have 3, so 3

5151

1

			3.into(),

5152

1

			20000000000.into(),

5153

			// 4 instructions in transact through signed

5154

1

			Some(4.into())

5155

));

5156

		// Root can set transact info

5157

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5158

1

		set_fee_per_second_for_location(

5159

1

			para_b_balances.clone(),

5160

1

			parachain::ParaTokensPerSecond::get(),

5161

5162

1

		.expect("must succeed");

5163

1

		ancestry = parachain::UniversalLocation::get().into();

5164

1

});

5165

5166

	// Let's construct the Junction that we will append with DescendOrigin

5167

1

	let signed_origin: Junctions = [AccountKey20 {

5168

1

		network: None,

5169

1

		key: PARAALICE,

5170

1

}]

5171

1

	.into();

5172

5173

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5174

1

	descend_origin_multilocation

5175

1

		.append_with(signed_origin)

5176

1

		.unwrap();

5177

5178

	// To convert it to what the paraB will see instead of us

5179

1

	descend_origin_multilocation

5180

1

		.reanchor(&para_b_location, &ancestry.interior)

5181

1

		.unwrap();

5182

5183

1

	let derived = xcm_builder::HashedDescription::<

5184

1

		parachain::AccountId,

5185

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5186

1

	>::convert_location(&descend_origin_multilocation)

5187

1

	.unwrap();

5188

5189

1

	let mut parachain_b_alice_balances_before = 0;

5190

1

	ParaB::execute_with(|| {

5191

1

		assert_ok!(ParaBalances::transfer_allow_death(

5192

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5193

1

			derived.clone(),

5194

			4000000104u128,

5195

));

5196

		// derived account has all funds

5197

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5198

		// sovereign account has 0 funds

5199

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5200

5201

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5202

1

});

5203

5204

	// Encode the call. Balances transact to para_a_account

5205

	// First index

5206

1

	let mut encoded: Vec<u8> = Vec::new();

5207

1

	let index =

5208

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5209

1

			.unwrap() as u8;

5210

5211

1

	encoded.push(index);

5212

5213

	use sp_core::U256;

5214

	// Let's do a EVM transfer

5215

1

	let eth_tx =

5216

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5217

1

			gas_limit: U256::from(21000),

5218

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5219

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5220

1

			value: U256::from(100),

5221

1

			input: BoundedVec::<

5222

1

u8,

5223

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5224

1

			>::try_from(vec![]).unwrap(),

5225

1

			access_list: None,

5226

1

});

5227

5228

	// Then call bytes

5229

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5230

1

		transact_as: PARAALICE.into(),

5231

1

		xcm_transaction: eth_tx,

5232

1

5233

1

	.encode();

5234

1

	encoded.append(&mut call_bytes);

5235

5236

1

	ParaA::execute_with(|| {

5237

1

		assert_ok!(XcmTransactor::transact_through_signed(

5238

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5239

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5240

1

			CurrencyPayment {

5241

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5242

1

					para_b_balances

5243

1

				))),

5244

1

				fee_amount: None

5245

1

},

5246

1

			encoded,

5247

1

			TransactWeights {

5248

1

				transact_required_weight_at_most: 4000000000.into(),

5249

1

				overall_weight: None

5250

1

},

5251

			false

5252

));

5253

1

});

5254

5255

1

	ParaB::execute_with(|| {

5256

		// Make sure the EVM transfer wasn't executed

5257

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

5258

1

});

5259

1

5260

5261

#[test]

5262

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

5263

1

	MockNet::reset();

5264

1

	let mut ancestry = Location::parent();

5265

5266

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5267

5268

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5269

5270

1

	ParaA::execute_with(|| {

5271

		// Root can set transact info

5272

1

		assert_ok!(XcmTransactor::set_transact_info(

5273

1

			parachain::RuntimeOrigin::root(),

5274

			// ParaB

5275

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5276

			// Para charges 1000 for every instruction, and we have 3, so 3

5277

1

			3.into(),

5278

1

			20000000000.into(),

5279

			// 4 instructions in transact through signed

5280

1

			Some(4.into())

5281

));

5282

		// Root can set transact info

5283

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5284

1

		set_fee_per_second_for_location(

5285

1

			para_b_balances.clone(),

5286

1

			parachain::ParaTokensPerSecond::get(),

5287

5288

1

		.expect("must succeed");

5289

1

		ancestry = parachain::UniversalLocation::get().into();

5290

1

});

5291

5292

	// Let's construct the Junction that we will append with DescendOrigin

5293

1

	let signed_origin: Junctions = [AccountKey20 {

5294

1

		network: None,

5295

1

		key: PARAALICE,

5296

1

}]

5297

1

	.into();

5298

5299

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5300

1

	descend_origin_multilocation

5301

1

		.append_with(signed_origin)

5302

1

		.unwrap();

5303

5304

	// To convert it to what the paraB will see instead of us

5305

1

	descend_origin_multilocation

5306

1

		.reanchor(&para_b_location, &ancestry.interior)

5307

1

		.unwrap();

5308

5309

1

	let derived = xcm_builder::HashedDescription::<

5310

1

		parachain::AccountId,

5311

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5312

1

	>::convert_location(&descend_origin_multilocation)

5313

1

	.unwrap();

5314

5315

1

	let transfer_recipient = evm_account();

5316

1

	let mut transfer_recipient_balance_before = 0;

5317

1

	ParaB::execute_with(|| {

5318

1

		assert_ok!(ParaBalances::transfer_allow_death(

5319

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5320

1

			derived.clone(),

5321

			4000000104u128,

5322

));

5323

		// derived account has all funds

5324

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5325

		// sovereign account has 0 funds

5326

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5327

5328

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5329

5330

		// Add proxy ALICE  -> derived

5331

1

		let _ = parachain::Proxy::add_proxy_delegate(

5332

1

			&PARAALICE.into(),

5333

1

			derived,

5334

1

			parachain::ProxyType::Any,

5335

1

0,

5336

1

);

5337

1

});

5338

5339

	// Encode the call. Balances transact to para_a_account

5340

	// First index

5341

1

	let mut encoded: Vec<u8> = Vec::new();

5342

1

	let index =

5343

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5344

1

			.unwrap() as u8;

5345

5346

1

	encoded.push(index);

5347

5348

	use sp_core::U256;

5349

	// Let's do a EVM transfer

5350

1

	let eth_tx =

5351

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5352

1

			gas_limit: U256::from(21000),

5353

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5354

1

			value: U256::from(100),

5355

1

			input: BoundedVec::<

5356

1

u8,

5357

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5358

1

			>::try_from(vec![]).unwrap(),

5359

1

			access_list: None,

5360

1

});

5361

5362

	// Then call bytes

5363

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5364

1

		transact_as: PARAALICE.into(),

5365

1

		xcm_transaction: eth_tx,

5366

1

5367

1

	.encode();

5368

1

	encoded.append(&mut call_bytes);

5369

5370

1

	ParaA::execute_with(|| {

5371

1

		assert_ok!(XcmTransactor::transact_through_signed(

5372

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5373

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5374

1

			CurrencyPayment {

5375

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5376

1

					para_b_balances

5377

1

				))),

5378

1

				fee_amount: None

5379

1

},

5380

1

			encoded,

5381

1

			TransactWeights {

5382

1

				transact_required_weight_at_most: 4000000000.into(),

5383

1

				overall_weight: None

5384

1

},

5385

			false

5386

));

5387

1

});

5388

5389

1

	ParaB::execute_with(|| {

5390

		// Make sure the EVM transfer was executed

5391

1

		assert!(

5392

1

			ParaBalances::free_balance(&transfer_recipient.into())

5393

1

				== transfer_recipient_balance_before + 100

5394

);

5395

1

});

5396

1

5397

5398

#[test]

5399

1

fn hrmp_init_accept_through_root() {

5400

1

	MockNet::reset();

5401

5402

1

	Relay::execute_with(|| {

5403

1

		assert_ok!(RelayBalances::transfer_allow_death(

5404

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5405

1

			para_a_account(),

5406

			1000u128

5407

));

5408

1

		assert_ok!(RelayBalances::transfer_allow_death(

5409

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5410

1

			para_b_account(),

5411

			1000u128

5412

));

5413

1

});

5414

5415

1

	ParaA::execute_with(|| {

5416

1

		let total_fee = 1_000u128;

5417

1

		let total_weight: u64 = 1_000_000_000;

5418

1

		let tx_weight: u64 = 500_000_000;

5419

		// Root can send hrmp init channel

5420

1

		assert_ok!(XcmTransactor::hrmp_manage(

5421

1

			parachain::RuntimeOrigin::root(),

5422

1

			HrmpOperation::InitOpen(HrmpInitParams {

5423

1

				para_id: 2u32.into(),

5424

1

				proposed_max_capacity: 1,

5425

1

				proposed_max_message_size: 1

5426

1

}),

5427

1

			CurrencyPayment {

5428

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5429

1

					Location::parent()

5430

1

				))),

5431

1

				fee_amount: Some(total_fee)

5432

1

},

5433

1

			TransactWeights {

5434

1

				transact_required_weight_at_most: tx_weight.into(),

5435

1

				overall_weight: Some(Limited(total_weight.into()))

5436

1

5437

));

5438

1

});

5439

1

	Relay::execute_with(|| {

5440

1

		let expected_event: relay_chain::RuntimeEvent =

5441

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5442

1

				sender: 1u32.into(),

5443

1

				recipient: 2u32.into(),

5444

1

				proposed_max_capacity: 1u32,

5445

1

				proposed_max_message_size: 1u32,

5446

1

5447

1

			.into();

5448

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5449

1

});

5450

1

	ParaB::execute_with(|| {

5451

1

		let total_fee = 1_000u128;

5452

1

		let total_weight: u64 = 1_000_000_000;

5453

1

		let tx_weight: u64 = 500_000_000;

5454

		// Root can send hrmp accept channel

5455

1

		assert_ok!(XcmTransactor::hrmp_manage(

5456

1

			parachain::RuntimeOrigin::root(),

5457

1

			HrmpOperation::Accept {

5458

1

				para_id: 1u32.into()

5459

1

},

5460

1

			CurrencyPayment {

5461

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5462

1

					Location::parent()

5463

1

				))),

5464

1

				fee_amount: Some(total_fee)

5465

1

},

5466

1

			TransactWeights {

5467

1

				transact_required_weight_at_most: tx_weight.into(),

5468

1

				overall_weight: Some(Limited(total_weight.into()))

5469

1

5470

));

5471

1

});

5472

5473

1

	Relay::execute_with(|| {

5474

1

		let expected_event: relay_chain::RuntimeEvent =

5475

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5476

1

				sender: 1u32.into(),

5477

1

				recipient: 2u32.into(),

5478

1

5479

1

			.into();

5480

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5481

1

});

5482

1

5483

5484

#[test]

5485

1

fn hrmp_close_works() {

5486

1

	MockNet::reset();

5487

5488

1

	Relay::execute_with(|| {

5489

1

		assert_ok!(RelayBalances::transfer_allow_death(

5490

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5491

1

			para_a_account(),

5492

			1000u128

5493

));

5494

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5495

1

			relay_chain::RuntimeOrigin::root(),

5496

1

			1u32.into(),

5497

1

			2u32.into(),

5498

			1u32,

5499

			1u32

5500

));

5501

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5502

1

			relay_chain::RuntimeOrigin::root(),

5503

			1u32

5504

));

5505

1

});

5506

5507

1

	ParaA::execute_with(|| {

5508

1

		let total_fee = 1_000u128;

5509

1

		let total_weight: u64 = 1_000_000_000;

5510

1

		let tx_weight: u64 = 500_000_000;

5511

1

		assert_ok!(XcmTransactor::hrmp_manage(

5512

1

			parachain::RuntimeOrigin::root(),

5513

1

			HrmpOperation::Close(HrmpChannelId {

5514

1

				sender: 1u32.into(),

5515

1

				recipient: 2u32.into()

5516

1

}),

5517

1

			CurrencyPayment {

5518

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5519

1

					Location::parent()

5520

1

				))),

5521

1

				fee_amount: Some(total_fee)

5522

1

},

5523

1

			TransactWeights {

5524

1

				transact_required_weight_at_most: tx_weight.into(),

5525

1

				overall_weight: Some(Limited(total_weight.into()))

5526

1

5527

));

5528

1

});

5529

1

	Relay::execute_with(|| {

5530

1

		let expected_event: relay_chain::RuntimeEvent =

5531

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5532

1

				by_parachain: 1u32.into(),

5533

1

				channel_id: HrmpChannelId {

5534

1

					sender: 1u32.into(),

5535

1

					recipient: 2u32.into(),

5536

1

},

5537

1

5538

1

			.into();

5539

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5540

1

});

5541

1

5542

5543

use crate::xcm_mock::parachain::{EvmForeignAssets, MockTransactors, Treasury, XcmWeightTrader};

5544

use parity_scale_codec::{Decode, Encode};

5545

use sp_core::U256;

5546

use sp_io::hashing::blake2_256;

5547

5548

// Helper to derive accountIds

5549

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5550

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5551

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5552

7