Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonriver Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{PalletInfo, PalletInfoAccess},

23

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

24

	BoundedVec,

25

};

26

use moonriver_runtime::xcm_config::AssetType;

27

use sp_core::ConstU32;

28

use sp_core::U256;

29

use sp_runtime::traits::Convert;

30

use xcm::{

31

	latest::prelude::{

32

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

33

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

34

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

35

		WeightLimit, Wild, WithdrawAsset, Xcm,

36

},

37

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

38

};

39

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

40

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

41

use xcm_mock::relay_chain;

42

use xcm_mock::*;

43

use xcm_simulator::TestExt;

44

mod common;

45

use cumulus_primitives_core::relay_chain::HrmpChannelId;

46

use pallet_xcm_transactor::{

47

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

48

};

49

use xcm_primitives::{

50

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

51

};

52

53

28

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

54

28

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

55

28

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

56

28

		.into_version(xcm::latest::VERSION)

57

28

		.map_err(|_| ())?

58

	else {

59

		return Err(());

60

};

61

	use frame_support::weights::WeightToFee as _;

62

28

	let native_amount_per_second: u128 =

63

28

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

64

28

			&Weight::from_parts(

65

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

66

28

0,

67

28

),

68

69

28

		.try_into()

70

28

		.map_err(|_| ())?;

71

28

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

72

28

	let relative_price: u128 = if units_per_second > 0u128 {

73

10

		native_amount_per_second

74

10

			.saturating_mul(precision_factor)

75

10

			.saturating_div(units_per_second)

76

	} else {

77

18

		0u128

78

};

79

28

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

80

28

		location_v5,

81

28

		(true, relative_price),

82

);

83

28

	Ok(())

84

28

85

86

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

87

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

88

9

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

89

	use moonbeam_tests_primitives::MemoryFeeTrader;

90

	use xcm_primitives::XcmFeeTrader;

91

92

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

93

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

94

9

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

95

9

	let native_amount_per_second =

96

9

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

97

9

	let relative_price = native_amount_per_second

98

9

		.saturating_mul(precision_factor)

99

9

		.checked_div(fee_per_second)

100

9

		.ok_or(())?;

101

102

9

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

103

9

104

105

25

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

106

25

	Asset {

107

25

		id: AssetId(

108

25

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

109

25

				currency_id,

110

25

111

25

			.unwrap(),

112

25

),

113

25

		fun: Fungibility::Fungible(amount),

114

25

115

25

116

117

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

118

#[test]

119

1

fn receive_relay_asset_from_relay() {

120

1

	MockNet::reset();

121

122

1

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

123

1

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

124

1

	let asset_metadata = parachain::AssetMetadata {

125

1

		name: b"RelayToken".to_vec(),

126

1

		symbol: b"Relay".to_vec(),

127

1

		decimals: 12,

128

1

};

129

	// Register relay asset in parachain A

130

1

	ParaA::execute_with(|| {

131

1

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

132

1

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

133

1

			.try_into()

134

1

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

135

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

136

1

			source_id,

137

1

			source_location_latest,

138

1

			asset_metadata.decimals,

139

1

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

140

1

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

141

));

142

1

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

143

1

});

144

145

	// Actually send relay asset to parachain

146

1

	let dest: Location = AccountKey20 {

147

1

		network: None,

148

1

		key: PARAALICE,

149

1

150

1

	.into();

151

1

	Relay::execute_with(|| {

152

1

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

153

1

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

154

1

			assets: Wild(All),

155

1

			beneficiary: dest.clone(),

156

1

		}]);

157

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

158

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

159

1

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

160

1

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

161

1

			Box::new(TransferType::LocalReserve),

162

1

			Box::new(fees_id),

163

1

			Box::new(TransferType::LocalReserve),

164

1

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

165

1

			WeightLimit::Unlimited

166

));

167

1

});

168

169

	// Verify that parachain received the asset

170

1

	ParaA::execute_with(|| {

171

		// free execution, full amount received

172

1

		assert_eq!(

173

1

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

174

1

			Ok(U256::from(123))

175

);

176

1

});

177

1

178

179

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

180

#[test]

181

1

fn send_relay_asset_to_relay() {

182

1

	MockNet::reset();

183

184

1

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

185

1

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

186

187

1

	let asset_metadata = parachain::AssetMetadata {

188

1

		name: b"RelayToken".to_vec(),

189

1

		symbol: b"Relay".to_vec(),

190

1

		decimals: 12,

191

1

};

192

193

	// Register relay asset in paraA

194

1

	ParaA::execute_with(|| {

195

1

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

196

1

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

197

1

			.try_into()

198

1

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

199

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

200

1

			source_id,

201

1

			source_location_latest,

202

1

			asset_metadata.decimals,

203

1

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

204

1

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

205

));

206

		// free execution

207

1

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

208

1

});

209

210

1

	let dest: Location = Junction::AccountKey20 {

211

1

		network: None,

212

1

		key: PARAALICE,

213

1

214

1

	.into();

215

216

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

217

1

	Relay::execute_with(|| {

218

1

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

219

1

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

220

1

			assets: Wild(All),

221

1

			beneficiary: dest.clone(),

222

1

		}]);

223

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

224

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

225

1

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

226

1

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

227

1

			Box::new(TransferType::LocalReserve),

228

1

			Box::new(fees_id),

229

1

			Box::new(TransferType::LocalReserve),

230

1

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

231

1

			WeightLimit::Unlimited

232

));

233

1

});

234

235

1

	ParaA::execute_with(|| {

236

		// Free execution, full amount received

237

1

		assert_eq!(

238

1

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

239

1

			Ok(U256::from(123))

240

);

241

1

});

242

243

	// Lets gather the balance before sending back money

244

1

	let mut balance_before_sending = 0;

245

1

	Relay::execute_with(|| {

246

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

247

1

});

248

249

	// We now send back some money to the relay

250

1

	let dest_chain = Location::parent();

251

1

	let beneficiary = Location {

252

1

		parents: 0,

253

1

		interior: [AccountId32 {

254

1

			network: None,

255

1

			id: RELAYALICE.into(),

256

1

}]

257

1

		.into(),

258

1

};

259

260

1

	ParaA::execute_with(|| {

261

1

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

262

1

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

263

1

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

264

1

			assets: Wild(All),

265

1

			beneficiary: beneficiary.clone(),

266

1

		}]);

267

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

268

1

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

269

1

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

270

1

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

271

1

			Box::new(TransferType::DestinationReserve),

272

1

			Box::new(fees_id),

273

1

			Box::new(TransferType::DestinationReserve),

274

1

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

275

1

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

276

));

277

1

});

278

279

	// The balances in paraAlice should have been substracted

280

1

	ParaA::execute_with(|| {

281

1

		assert_eq!(

282

1

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

283

1

			Ok(U256::from(0))

284

);

285

1

});

286

287

	// Balances in the relay should have been received

288

1

	Relay::execute_with(|| {

289

1

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

290

1

});

291

1

292

293

#[test]

294

1

fn send_relay_asset_to_para_b() {

295

1

	MockNet::reset();

296

297

1

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

298

1

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

299

300

1

	let asset_metadata = parachain::AssetMetadata {

301

1

		name: b"RelayToken".to_vec(),

302

1

		symbol: b"Relay".to_vec(),

303

1

		decimals: 12,

304

1

};

305

306

	// Register asset in paraA. Free execution

307

1

	ParaA::execute_with(|| {

308

1

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

309

1

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

310

1

			.try_into()

311

1

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

312

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

313

1

			source_id,

314

1

			source_location_latest,

315

1

			asset_metadata.decimals,

316

1

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

317

1

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

318

));

319

1

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

320

1

});

321

322

	// Register asset in paraB. Free execution

323

1

	ParaB::execute_with(|| {

324

1

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

325

1

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

326

1

			.try_into()

327

1

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

328

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

329

1

			source_id,

330

1

			source_location_latest,

331

1

			asset_metadata.decimals,

332

1

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

333

1

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

334

));

335

1

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

336

1

});

337

338

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

339

1

	let dest: Location = Junction::AccountKey20 {

340

1

		network: None,

341

1

		key: PARAALICE,

342

1

343

1

	.into();

344

1

	Relay::execute_with(|| {

345

1

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

346

1

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

347

1

			assets: Wild(All),

348

1

			beneficiary: dest.clone(),

349

1

		}]);

350

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

351

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

352

1

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

353

1

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

354

1

			Box::new(TransferType::LocalReserve),

355

1

			Box::new(fees_id),

356

1

			Box::new(TransferType::LocalReserve),

357

1

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

358

1

			WeightLimit::Unlimited

359

));

360

1

});

361

362

1

	ParaA::execute_with(|| {

363

1

		assert_eq!(

364

1

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

365

1

			Ok(U256::from(123))

366

);

367

1

});

368

369

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

370

1

	let dest = Location {

371

1

		parents: 1,

372

1

		interior: [

373

1

			Parachain(2),

374

1

			AccountKey20 {

375

1

				network: None,

376

1

				key: PARAALICE.into(),

377

1

},

378

1

379

1

		.into(),

380

1

};

381

1

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

382

383

1

	ParaA::execute_with(|| {

384

1

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

385

1

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

386

1

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

387

1

			assets: Wild(All),

388

1

			beneficiary: beneficiary.clone(),

389

1

		}]);

390

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

391

1

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

392

1

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

393

1

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

394

1

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

395

1

			Box::new(fees_id),

396

1

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

397

1

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

398

1

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

399

));

400

1

});

401

402

	// Para A balances should have been substracted

403

1

	ParaA::execute_with(|| {

404

1

		assert_eq!(

405

1

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

406

1

			Ok(U256::from(23))

407

);

408

1

});

409

410

	// Para B balances should have been credited

411

1

	ParaB::execute_with(|| {

412

1

		assert_eq!(

413

1

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

414

1

			Ok(U256::from(100))

415

);

416

1

});

417

1

418

419

#[test]

420

1

fn send_para_a_asset_to_para_b() {

421

1

	MockNet::reset();

422

423

	// This represents the asset in paraA

424

1

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

425

1

	let source_location: AssetType = para_a_balances

426

1

		.try_into()

427

1

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

428

1

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

429

430

1

	let asset_metadata = parachain::AssetMetadata {

431

1

		name: b"ParaAToken".to_vec(),

432

1

		symbol: b"ParaA".to_vec(),

433

1

		decimals: 18,

434

1

};

435

436

	// Register asset in paraB. Free execution

437

1

	ParaB::execute_with(|| {

438

1

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

439

1

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

440

1

			.try_into()

441

1

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

442

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

443

1

			source_id,

444

1

			source_location_latest,

445

1

			asset_metadata.decimals,

446

1

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

447

1

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

448

));

449

1

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

450

1

});

451

452

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

453

1

	let dest = Location {

454

1

		parents: 1,

455

1

		interior: [

456

1

			Parachain(2),

457

1

			AccountKey20 {

458

1

				network: None,

459

1

				key: PARAALICE.into(),

460

1

},

461

1

462

1

		.into(),

463

1

};

464

1

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

465

466

1

	ParaA::execute_with(|| {

467

1

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

468

1

		assert_ok!(PolkadotXcm::transfer_assets(

469

1

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

470

1

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

471

1

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

472

1

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

473

0,

474

1

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

475

));

476

1

});

477

478

	// Native token is substracted in paraA

479

1

	ParaA::execute_with(|| {

480

		// free execution, full amount received

481

1

		assert_eq!(

482

1

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

483

			INITIAL_BALANCE - 100

484

);

485

1

});

486

487

	// Asset is minted in paraB

488

1

	ParaB::execute_with(|| {

489

		// free execution, full amount received

490

1

		assert_eq!(

491

1

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

492

1

			Ok(U256::from(100))

493

);

494

1

});

495

1

496

497

#[test]

498

1

fn send_para_a_asset_from_para_b_to_para_c() {

499

1

	MockNet::reset();

500

501

	// Represents para A asset

502

1

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

503

1

	let source_location: AssetType = para_a_balances

504

1

		.try_into()

505

1

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

506

1

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

507

508

1

	let asset_metadata = parachain::AssetMetadata {

509

1

		name: b"ParaAToken".to_vec(),

510

1

		symbol: b"ParaA".to_vec(),

511

1

		decimals: 18,

512

1

};

513

514

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

515

1

	ParaB::execute_with(|| {

516

1

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

517

1

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

518

1

			.try_into()

519

1

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

520

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

521

1

			source_id,

522

1

			source_location_latest,

523

1

			asset_metadata.decimals,

524

1

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

525

1

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

526

));

527

1

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

528

1

});

529

530

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

531

1

	ParaC::execute_with(|| {

532

1

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

533

1

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

534

1

			.try_into()

535

1

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

536

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

537

1

			source_id,

538

1

			source_location_latest,

539

1

			asset_metadata.decimals,

540

1

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

541

1

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

542

));

543

1

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

544

1

});

545

546

	// Send para A asset to para B

547

1

	let dest = Location {

548

1

		parents: 1,

549

1

		interior: [

550

1

			Parachain(2),

551

1

			AccountKey20 {

552

1

				network: None,

553

1

				key: PARAALICE.into(),

554

1

},

555

1

556

1

		.into(),

557

1

};

558

1

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

559

560

1

	ParaA::execute_with(|| {

561

1

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

562

1

		assert_ok!(PolkadotXcm::transfer_assets(

563

1

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

564

1

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

565

1

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

566

1

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

567

0,

568

1

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

569

));

570

1

});

571

572

	// Para A balances have been substracted

573

1

	ParaA::execute_with(|| {

574

1

		assert_eq!(

575

1

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

576

			INITIAL_BALANCE - 100

577

);

578

1

});

579

580

	// Para B balances have been credited

581

1

	ParaB::execute_with(|| {

582

1

		assert_eq!(

583

1

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

584

1

			Ok(U256::from(100))

585

);

586

1

});

587

588

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

589

1

	let dest = Location {

590

1

		parents: 1,

591

1

		interior: [

592

1

			Parachain(3),

593

1

			AccountKey20 {

594

1

				network: None,

595

1

				key: PARAALICE.into(),

596

1

},

597

1

598

1

		.into(),

599

1

};

600

1

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

601

602

1

	ParaB::execute_with(|| {

603

1

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

604

1

		assert_ok!(PolkadotXcm::transfer_assets(

605

1

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

606

1

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

607

1

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

608

1

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

609

0,

610

1

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

611

));

612

1

});

613

614

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

615

1

	ParaC::execute_with(|| {

616

		// free execution, full amount received

617

1

		assert_eq!(

618

1

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

619

1

			Ok(U256::from(95))

620

);

621

1

});

622

1

623

624

#[test]

625

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

626

1

	MockNet::reset();

627

628

	// Para A asset

629

1

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

630

1

	let source_location: AssetType = para_a_balances

631

1

		.try_into()

632

1

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

633

1

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

634

635

1

	let asset_metadata = parachain::AssetMetadata {

636

1

		name: b"ParaAToken".to_vec(),

637

1

		symbol: b"ParaA".to_vec(),

638

1

		decimals: 18,

639

1

};

640

641

	// Register para A asset in para B

642

1

	ParaB::execute_with(|| {

643

1

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

644

1

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

645

1

			.try_into()

646

1

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

647

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

648

1

			source_id,

649

1

			source_location_latest,

650

1

			asset_metadata.decimals,

651

1

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

652

1

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

653

));

654

1

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

655

1

});

656

657

	// Send para A asset to para B

658

1

	let dest = Location {

659

1

		parents: 1,

660

1

		interior: [

661

1

			Parachain(2),

662

1

			AccountKey20 {

663

1

				network: None,

664

1

				key: PARAALICE.into(),

665

1

},

666

1

667

1

		.into(),

668

1

};

669

1

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

670

671

1

	ParaA::execute_with(|| {

672

1

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

673

1

		assert_ok!(PolkadotXcm::transfer_assets(

674

1

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

675

1

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

676

1

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

677

1

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

678

0,

679

1

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

680

));

681

1

});

682

683

	// Balances have been subtracted

684

1

	ParaA::execute_with(|| {

685

1

		assert_eq!(

686

1

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

687

			INITIAL_BALANCE - 100

688

);

689

1

});

690

691

	// Para B balances have been credited

692

1

	ParaB::execute_with(|| {

693

1

		assert_eq!(

694

1

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

695

1

			Ok(U256::from(100))

696

);

697

1

});

698

699

	// Send back para A asset to para A

700

1

	let dest = Location {

701

1

		parents: 1,

702

1

		interior: [

703

1

			Parachain(1),

704

1

			AccountKey20 {

705

1

				network: None,

706

1

				key: PARAALICE.into(),

707

1

},

708

1

709

1

		.into(),

710

1

};

711

1

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

712

713

1

	ParaB::execute_with(|| {

714

1

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

715

1

		assert_ok!(PolkadotXcm::transfer_assets(

716

1

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

717

1

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

718

1

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

719

1

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

720

0,

721

1

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

722

));

723

1

});

724

725

	// Para A asset has been credited

726

1

	ParaA::execute_with(|| {

727

		// Weight used is 4

728

1

		assert_eq!(

729

1

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

730

			INITIAL_BALANCE - 4

731

);

732

1

});

733

1

734

735

#[test]

736

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

737

1

	MockNet::reset();

738

739

1

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

740

1

	let source_location: AssetType = para_a_balances

741

1

		.try_into()

742

1

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

743

1

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

744

745

1

	let asset_metadata = parachain::AssetMetadata {

746

1

		name: b"ParaAToken".to_vec(),

747

1

		symbol: b"ParaA".to_vec(),

748

1

		decimals: 18,

749

1

};

750

751

1

	ParaB::execute_with(|| {

752

1

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

753

1

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

754

1

			.try_into()

755

1

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

756

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

757

1

			source_id,

758

1

			source_location_latest,

759

1

			asset_metadata.decimals,

760

1

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

761

1

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

762

));

763

1

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

764

1

});

765

766

1

	let dest = Location {

767

1

		parents: 1,

768

1

		interior: [

769

1

			Parachain(2),

770

1

			AccountKey20 {

771

1

				network: None,

772

1

				key: PARAALICE.into(),

773

1

},

774

1

775

1

		.into(),

776

1

};

777

1

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

778

779

1

	ParaA::execute_with(|| {

780

1

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

781

1

		assert_ok!(PolkadotXcm::transfer_assets(

782

1

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

783

1

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

784

1

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

785

1

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

786

0,

787

1

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

788

));

789

1

});

790

791

1

	ParaA::execute_with(|| {

792

		// Free execution, full amount received

793

1

		assert_eq!(

794

1

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

795

			INITIAL_BALANCE - 100

796

);

797

1

});

798

799

1

	ParaB::execute_with(|| {

800

		// Free execution, full amount received

801

1

		assert_eq!(

802

1

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

803

1

			Ok(U256::from(100))

804

);

805

1

});

806

807

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

808

	// Message through polkadotXCM pallet

809

810

1

	let dest = Location {

811

1

		parents: 1,

812

1

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

813

1

};

814

815

1

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

816

817

1

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

818

1

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

819

1

		ClearOrigin,

820

1

		BuyExecution {

821

1

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

822

1

			weight_limit: Limited(80.into()),

823

1

},

824

1

		DepositAsset {

825

1

			assets: All.into(),

826

1

			beneficiary: Location::new(

827

1

0,

828

1

				[AccountKey20 {

829

1

					network: None,

830

1

					key: PARAALICE,

831

1

}],

832

1

),

833

1

},

834

1

	]));

835

1

	ParaB::execute_with(|| {

836

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

837

		// and deposit asset

838

1

		assert_ok!(ParachainPalletXcm::send(

839

1

			parachain::RuntimeOrigin::root(),

840

1

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

841

1

			Box::new(message),

842

));

843

1

});

844

845

1

	ParaB::execute_with(|| {

846

		// free execution, full amount received

847

1

		assert_eq!(

848

1

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

849

1

			Ok(U256::from(100))

850

);

851

1

});

852

853

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

854

	// Message through polkadotXCM pallet

855

856

1

	let dest = Location {

857

1

		parents: 1,

858

1

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

859

1

};

860

861

1

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

862

863

1

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

864

1

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

865

1

		ClearOrigin,

866

1

		BuyExecution {

867

1

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

868

1

			weight_limit: Limited(80.into()),

869

1

},

870

1

		DepositAsset {

871

1

			assets: All.into(),

872

1

			beneficiary: Location::new(

873

1

0,

874

1

				[AccountKey20 {

875

1

					network: None,

876

1

					key: PARAALICE,

877

1

}],

878

1

),

879

1

},

880

1

	]));

881

1

	ParaB::execute_with(|| {

882

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

883

		// and deposit asset

884

1

		assert_ok!(ParachainPalletXcm::send(

885

1

			parachain::RuntimeOrigin::root(),

886

1

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

887

1

			Box::new(message),

888

));

889

1

});

890

891

1

	ParaA::execute_with(|| {

892

		// Weight used is 4

893

1

		assert_eq!(

894

1

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

895

			INITIAL_BALANCE - 4

896

);

897

1

});

898

1

899

900

#[test]

901

1

fn receive_relay_asset_with_trader() {

902

1

	MockNet::reset();

903

904

1

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

905

1

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

906

907

1

	let asset_metadata = parachain::AssetMetadata {

908

1

		name: b"RelayToken".to_vec(),

909

1

		symbol: b"Relay".to_vec(),

910

1

		decimals: 12,

911

1

};

912

913

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

914

	// we know later we will divide by 1e12

915

	// Lets put 1e6 as units per second

916

1

	ParaA::execute_with(|| {

917

1

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

918

1

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

919

1

			.try_into()

920

1

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

921

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

922

1

			source_id,

923

1

			source_location_latest,

924

1

			asset_metadata.decimals,

925

1

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

926

1

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

927

));

928

1

		assert_ok!(add_supported_asset(

929

1

			source_location.clone(),

930

			2500000000000u128

931

));

932

1

});

933

934

1

	let dest: Location = Junction::AccountKey20 {

935

1

		network: None,

936

1

		key: PARAALICE,

937

1

938

1

	.into();

939

	// We are sending 100 tokens from relay.

940

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

941

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

942

	// Units per second should be 2_500_000_000_000_000

943

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

944

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

945

1

	Relay::execute_with(|| {

946

1

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

947

1

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

948

1

			assets: Wild(All),

949

1

			beneficiary: dest.clone(),

950

1

		}]);

951

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

952

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

953

1

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

954

1

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

955

1

			Box::new(TransferType::LocalReserve),

956

1

			Box::new(fees_id),

957

1

			Box::new(TransferType::LocalReserve),

958

1

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

959

1

			WeightLimit::Unlimited

960

));

961

1

});

962

963

1

	ParaA::execute_with(|| {

964

		// non-free execution, not full amount received

965

1

		assert_eq!(

966

1

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

967

1

			Ok(U256::from(90))

968

);

969

		// Fee should have been received by treasury

970

1

		assert_eq!(

971

1

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

972

1

			Ok(U256::from(10))

973

);

974

1

});

975

1

976

977

#[test]

978

1

fn send_para_a_asset_to_para_b_with_trader() {

979

1

	MockNet::reset();

980

981

1

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

982

1

	let source_location: AssetType = para_a_balances

983

1

		.try_into()

984

1

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

985

1

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

986

987

1

	let asset_metadata = parachain::AssetMetadata {

988

1

		name: b"ParaAToken".to_vec(),

989

1

		symbol: b"ParaA".to_vec(),

990

1

		decimals: 18,

991

1

};

992

993

1

	ParaB::execute_with(|| {

994

1

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

995

1

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

996

1

			.try_into()

997

1

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

998

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

999

1

			source_id,

1000

1

			source_location_latest,

1001

1

			asset_metadata.decimals,

1002

1

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

1003

1

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

1004

));

1005

1

		assert_ok!(add_supported_asset(

1006

1

			source_location.clone(),

1007

			2500000000000u128

1008

));

1009

1

});

1010

1011

1

	let dest = Location {

1012

1

		parents: 1,

1013

1

		interior: [

1014

1

			Parachain(2),

1015

1

			AccountKey20 {

1016

1

				network: None,

1017

1

				key: PARAALICE.into(),

1018

1

},

1019

1

1020

1

		.into(),

1021

1

};

1022

1

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

1023

1024

	// In destination chain, we only need 4 weight

1025

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

1026

1

	ParaA::execute_with(|| {

1027

1

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

1028

1

		assert_ok!(PolkadotXcm::transfer_assets(

1029

1

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

1030

1

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

1031

1

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

1032

1

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

1033

0,

1034

1

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

1035

));

1036

1

});

1037

1

	ParaA::execute_with(|| {

1038

		// free execution, full amount received

1039

1

		assert_eq!(

1040

1

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

1041

			INITIAL_BALANCE - 100

1042

);

1043

1

});

1044

1045

	// We are sending 100 tokens from para A.

1046

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

1047

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

1048

	// Units per second should be 2_500_000_000_000_000

1049

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

1050

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

1051

	// will be 4

1052

1

	ParaB::execute_with(|| {

1053

1

		assert_eq!(

1054

1

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

1055

1

			Ok(U256::from(90))

1056

);

1057

		// Fee should have been received by treasury

1058

1

		assert_eq!(

1059

1

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

1060

1

			Ok(U256::from(10))

1061

);

1062

1

});

1063

1

1064

1065

#[test]

1066

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1067

1

	MockNet::reset();

1068

1069

1

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

1070

1

	let source_location: AssetType = para_a_balances

1071

1

		.try_into()

1072

1

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

1073

1

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

1074

1075

1

	let asset_metadata = parachain::AssetMetadata {

1076

1

		name: b"ParaAToken".to_vec(),

1077

1

		symbol: b"ParaA".to_vec(),

1078

1

		decimals: 18,

1079

1

};

1080

1081

1

	ParaB::execute_with(|| {

1082

1

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

1083

1

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

1084

1

			.try_into()

1085

1

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

1086

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1087

1

			source_id,

1088

1

			source_location_latest,

1089

1

			asset_metadata.decimals,

1090

1

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

1091

1

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

1092

));

1093

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

1094

1

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

1095

1

});

1096

1097

1

	let dest = Location {

1098

1

		parents: 1,

1099

1

		interior: [

1100

1

			Parachain(2),

1101

1

			AccountKey20 {

1102

1

				network: None,

1103

1

				key: PARAALICE.into(),

1104

1

},

1105

1

1106

1

		.into(),

1107

1

};

1108

1

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

1109

1110

	// we use transfer_with_fee

1111

1

	ParaA::execute_with(|| {

1112

1

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

1113

1

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

1114

1

		assert_ok!(PolkadotXcm::transfer_assets(

1115

1

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

1116

1

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

1117

1

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

1118

1

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

1119

0,

1120

1

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

1121

));

1122

1

});

1123

1

	ParaA::execute_with(|| {

1124

		// 100 tokens transferred plus 1 taken from fees

1125

1

		assert_eq!(

1126

1

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

1127

			INITIAL_BALANCE - 100 - 1

1128

);

1129

1

});

1130

1131

1

	ParaB::execute_with(|| {

1132

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

1133

		// what it is specified

1134

1

		assert_eq!(

1135

1

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

1136

1

			Ok(U256::from(101))

1137

);

1138

1

});

1139

1

1140

1141

#[test]

1142

1

fn error_when_not_paying_enough() {

1143

1

	MockNet::reset();

1144

1145

1

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

1146

1

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

1147

1148

1

	let asset_metadata = parachain::AssetMetadata {

1149

1

		name: b"RelayToken".to_vec(),

1150

1

		symbol: b"Relay".to_vec(),

1151

1

		decimals: 12,

1152

1

};

1153

1154

1

	let dest: Location = Junction::AccountKey20 {

1155

1

		network: None,

1156

1

		key: PARAALICE,

1157

1

1158

1

	.into();

1159

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

1160

	// we know later we will divide by 1e12

1161

	// Lets put 1e6 as units per second

1162

1

	ParaA::execute_with(|| {

1163

1

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

1164

1

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

1165

1

			.try_into()

1166

1

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

1167

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1168

1

			source_id,

1169

1

			source_location_latest,

1170

1

			asset_metadata.decimals,

1171

1

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

1172

1

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

1173

));

1174

1

		assert_ok!(add_supported_asset(

1175

1

			source_location.clone(),

1176

			2500000000000u128

1177

));

1178

1

});

1179

1180

	// We are sending 100 tokens from relay.

1181

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

1182

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

1183

1

	Relay::execute_with(|| {

1184

1

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

1185

1

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

1186

1

			assets: Wild(All),

1187

1

			beneficiary: dest.clone(),

1188

1

		}]);

1189

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1190

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1191

1

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

1192

1

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

1193

1

			Box::new(TransferType::LocalReserve),

1194

1

			Box::new(fees_id),

1195

1

			Box::new(TransferType::LocalReserve),

1196

1

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

1197

1

			WeightLimit::Unlimited

1198

));

1199

1

});

1200

1201

1

	ParaA::execute_with(|| {

1202

		// amount not received as it is not paying enough

1203

1

		assert_eq!(

1204

1

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

1205

1

			Ok(U256::from(0))

1206

);

1207

1

});

1208

1

1209

1210

#[test]

1211

1

fn transact_through_derivative_multilocation() {

1212

1

	MockNet::reset();

1213

1214

1

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

1215

1

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

1216

1217

1

	let asset_metadata = parachain::AssetMetadata {

1218

1

		name: b"RelayToken".to_vec(),

1219

1

		symbol: b"Relay".to_vec(),

1220

1

		decimals: 12,

1221

1

};

1222

1223

1

	ParaA::execute_with(|| {

1224

1

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

1225

1

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

1226

1

			.try_into()

1227

1

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

1228

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1229

1

			source_id,

1230

1

			source_location_latest,

1231

1

			asset_metadata.decimals,

1232

1

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

1233

1

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

1234

));

1235

1

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

1236

1237

		// Root can set transact info

1238

1

		assert_ok!(XcmTransactor::set_transact_info(

1239

1

			parachain::RuntimeOrigin::root(),

1240

1

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

1241

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

1242

1

			3000.into(),

1243

1

			20000000000.into(),

1244

1

			None

1245

));

1246

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

1247

1

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

1248

1

			.expect("must succeed");

1249

1

});

1250

1251

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

1252

1253

1

	let dest: Location = AccountKey20 {

1254

1

		network: None,

1255

1

		key: PARAALICE,

1256

1

1257

1

	.into();

1258

1

	Relay::execute_with(|| {

1259

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

1260

1

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

1261

1

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

1262

1

			assets: Wild(All),

1263

1

			beneficiary: dest.clone(),

1264

1

		}]);

1265

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1266

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1267

1

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

1268

1

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

1269

1

			Box::new(TransferType::LocalReserve),

1270

1

			Box::new(fees_id),

1271

1

			Box::new(TransferType::LocalReserve),

1272

1

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

1273

1

			WeightLimit::Unlimited

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(4000003100u64))

1282

);

1283

1

});

1284

1285

	// Register address

1286

1

	ParaA::execute_with(|| {

1287

1

		assert_ok!(XcmTransactor::register(

1288

1

			parachain::RuntimeOrigin::root(),

1289

1

			PARAALICE.into(),

1290

0,

1291

));

1292

1

});

1293

1294

	// Send to registered address

1295

1296

1

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

1297

1

	let dest = Location {

1298

1

		parents: 1,

1299

1

		interior: [AccountId32 {

1300

1

			network: None,

1301

1

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

1302

1

}]

1303

1

		.into(),

1304

1

};

1305

1

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

1306

1307

1

	ParaA::execute_with(|| {

1308

1

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

1309

		// free execution, full amount received

1310

1

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

1311

1

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

1312

1

			assets: Wild(All),

1313

1

			beneficiary: beneficiary.clone(),

1314

1

		}]);

1315

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1316

1

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

1317

1

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

1318

1

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

1319

1

			Box::new(TransferType::DestinationReserve),

1320

1

			Box::new(fees_id),

1321

1

			Box::new(TransferType::DestinationReserve),

1322

1

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

1323

1

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

1324

));

1325

1

});

1326

1327

1

	ParaA::execute_with(|| {

1328

		// free execution, full amount received

1329

1

		assert_eq!(

1330

1

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

1331

1

			Ok(U256::from(4000003000u64))

1332

);

1333

1

});

1334

1335

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

1336

	// again

1337

1

	Relay::execute_with(|| {

1338

		// free execution,x	 full amount received

1339

1

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

1340

1

});

1341

1342

	// Encode the call. Balances transact to para_a_account

1343

	// First index

1344

1

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

1345

1

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

1346

1

		relay_chain::Balances,

1347

1

>()

1348

1

	.unwrap() as u8;

1349

1350

1

	encoded.push(index);

1351

1352

	// Then call bytes

1353

1

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

1354

1

		dest: para_a_account(),

1355

1

		value: 100u32.into(),

1356

1

1357

1

	.encode();

1358

1

	encoded.append(&mut call_bytes);

1359

1360

1

	ParaA::execute_with(|| {

1361

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1362

1

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

1363

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1364

0,

1365

1

			CurrencyPayment {

1366

1

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

1367

1

					Location::parent()

1368

1

				))),

1369

1

				fee_amount: None

1370

1

},

1371

1

			encoded,

1372

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

1373

1

			TransactWeights {

1374

1

				transact_required_weight_at_most: 4000000000.into(),

1375

1

				overall_weight: None

1376

1

},

1377

			false

1378

));

1379

1

});

1380

1381

1

	Relay::execute_with(|| {

1382

		// free execution,x	 full amount received

1383

1

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

1384

1385

1

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

1386

1

});

1387

1

1388

1389

#[test]

1390

1

fn transact_through_derivative_with_custom_fee_weight() {

1391

1

	MockNet::reset();

1392

1393

1

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

1394

1

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

1395

1396

1

	let asset_metadata = parachain::AssetMetadata {

1397

1

		name: b"RelayToken".to_vec(),

1398

1

		symbol: b"Relay".to_vec(),

1399

1

		decimals: 12,

1400

1

};

1401

1402

1

	ParaA::execute_with(|| {

1403

1

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

1404

1

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

1405

1

			.try_into()

1406

1

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

1407

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1408

1

			source_id,

1409

1

			source_location_latest,

1410

1

			asset_metadata.decimals,

1411

1

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

1412

1

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

1413

));

1414

1

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

1415

1

});

1416

1417

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

1418

1419

1

	let dest: Location = AccountKey20 {

1420

1

		network: None,

1421

1

		key: PARAALICE,

1422

1

1423

1

	.into();

1424

1

	Relay::execute_with(|| {

1425

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

1426

1

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

1427

1

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

1428

1

			assets: Wild(All),

1429

1

			beneficiary: dest.clone(),

1430

1

		}]);

1431

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1432

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1433

1

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

1434

1

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

1435

1

			Box::new(TransferType::LocalReserve),

1436

1

			Box::new(fees_id),

1437

1

			Box::new(TransferType::LocalReserve),

1438

1

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

1439

1

			WeightLimit::Unlimited

1440

));

1441

1

});

1442

1443

1

	ParaA::execute_with(|| {

1444

		// free execution, full amount received

1445

1

		assert_eq!(

1446

1

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

1447

1

			Ok(U256::from(4000003100u64))

1448

);

1449

1

});

1450

1451

	// Register address

1452

1

	ParaA::execute_with(|| {

1453

1

		assert_ok!(XcmTransactor::register(

1454

1

			parachain::RuntimeOrigin::root(),

1455

1

			PARAALICE.into(),

1456

0,

1457

));

1458

1

});

1459

1460

	// Send to registered address

1461

1462

1

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

1463

1

	let dest = Location {

1464

1

		parents: 1,

1465

1

		interior: [AccountId32 {

1466

1

			network: None,

1467

1

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

1468

1

}]

1469

1

		.into(),

1470

1

};

1471

1

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

1472

1473

1

	ParaA::execute_with(|| {

1474

1

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

1475

		// free execution, full amount received

1476

1

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

1477

1

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

1478

1

			assets: Wild(All),

1479

1

			beneficiary: beneficiary.clone(),

1480

1

		}]);

1481

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1482

1

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

1483

1

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

1484

1

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

1485

1

			Box::new(TransferType::DestinationReserve),

1486

1

			Box::new(fees_id),

1487

1

			Box::new(TransferType::DestinationReserve),

1488

1

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

1489

1

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

1490

));

1491

1

});

1492

1493

1

	ParaA::execute_with(|| {

1494

		// free execution, full amount received

1495

1

		assert_eq!(

1496

1

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

1497

1

			Ok(U256::from(4000003000u64))

1498

);

1499

1

});

1500

1501

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

1502

	// again

1503

1

	Relay::execute_with(|| {

1504

		// free execution,x	 full amount received

1505

1

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

1506

1

});

1507

1508

	// Encode the call. Balances transact to para_a_account

1509

	// First index

1510

1

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

1511

1

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

1512

1

		relay_chain::Balances,

1513

1

>()

1514

1

	.unwrap() as u8;

1515

1516

1

	encoded.push(index);

1517

1518

	// Then call bytes

1519

1

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

1520

1

		dest: para_a_account(),

1521

1

		value: 100u32.into(),

1522

1

1523

1

	.encode();

1524

1

	encoded.append(&mut call_bytes);

1525

1526

1

	let overall_weight = 4000003000u64;

1527

1

	ParaA::execute_with(|| {

1528

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1529

1

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

1530

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1531

0,

1532

1

			CurrencyPayment {

1533

1

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

1534

1

					Location::parent()

1535

1

				))),

1536

1

				// 1-1 fee weight mapping

1537

1

				fee_amount: Some(overall_weight as u128)

1538

1

},

1539

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

1540

1

			encoded,

1541

1

			TransactWeights {

1542

1

				transact_required_weight_at_most: 4000000000.into(),

1543

1

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

1544

1

},

1545

			false

1546

));

1547

1

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

1548

1

			.iter()

1549

18

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

1550

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

1551

..

1552

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

1553

18

				_ => None,

1554

18

});

1555

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

1556

1

		assert!(event_found.is_none());

1557

1

});

1558

1559

1

	Relay::execute_with(|| {

1560

		// free execution,x	 full amount received

1561

1

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

1562

1563

1

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

1564

1

});

1565

1

1566

1567

#[test]

1568

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1569

1

	MockNet::reset();

1570

1571

1

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

1572

1

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

1573

1574

1

	let asset_metadata = parachain::AssetMetadata {

1575

1

		name: b"RelayToken".to_vec(),

1576

1

		symbol: b"Relay".to_vec(),

1577

1

		decimals: 12,

1578

1

};

1579

1580

1

	ParaA::execute_with(|| {

1581

1

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

1582

1

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

1583

1

			.try_into()

1584

1

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

1585

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1586

1

			source_id,

1587

1

			source_location_latest,

1588

1

			asset_metadata.decimals,

1589

1

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

1590

1

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

1591

));

1592

1

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

1593

1

});

1594

1595

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

1596

1597

1

	let dest: Location = AccountKey20 {

1598

1

		network: None,

1599

1

		key: PARAALICE,

1600

1

1601

1

	.into();

1602

1

	Relay::execute_with(|| {

1603

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

1604

1

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

1605

1

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

1606

1

			assets: Wild(All),

1607

1

			beneficiary: dest.clone(),

1608

1

		}]);

1609

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1610

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1611

1

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

1612

1

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

1613

1

			Box::new(TransferType::LocalReserve),

1614

1

			Box::new(fees_id),

1615

1

			Box::new(TransferType::LocalReserve),

1616

1

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

1617

1

			WeightLimit::Unlimited

1618

));

1619

1

});

1620

1621

1

	ParaA::execute_with(|| {

1622

		// free execution, full amount received

1623

1

		assert_eq!(

1624

1

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

1625

1

			Ok(U256::from(4000009100u64))

1626

);

1627

1

});

1628

1629

	// Register address

1630

1

	ParaA::execute_with(|| {

1631

1

		assert_ok!(XcmTransactor::register(

1632

1

			parachain::RuntimeOrigin::root(),

1633

1

			PARAALICE.into(),

1634

0,

1635

));

1636

1

});

1637

1638

	// Send to registered address

1639

1640

1

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

1641

1

	let dest = Location {

1642

1

		parents: 1,

1643

1

		interior: [AccountId32 {

1644

1

			network: None,

1645

1

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

1646

1

}]

1647

1

		.into(),

1648

1

};

1649

1

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

1650

1651

1

	ParaA::execute_with(|| {

1652

1

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

1653

		// free execution, full amount received

1654

1

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

1655

1

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

1656

1

			assets: Wild(All),

1657

1

			beneficiary: beneficiary.clone(),

1658

1

		}]);

1659

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1660

1

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

1661

1

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

1662

1

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

1663

1

			Box::new(TransferType::DestinationReserve),

1664

1

			Box::new(fees_id),

1665

1

			Box::new(TransferType::DestinationReserve),

1666

1

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

1667

1

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

1668

));

1669

1

});

1670

1671

1

	ParaA::execute_with(|| {

1672

		// free execution, full amount received

1673

1

		assert_eq!(

1674

1

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

1675

1

			Ok(U256::from(4000009000u64))

1676

);

1677

1

});

1678

1679

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

1680

	// again

1681

1

	Relay::execute_with(|| {

1682

		// free execution,x	 full amount received

1683

1

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

1684

1

});

1685

1686

	// Encode the call. Balances transact to para_a_account

1687

	// First index

1688

1

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

1689

1

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

1690

1

		relay_chain::Balances,

1691

1

>()

1692

1

	.unwrap() as u8;

1693

1694

1

	encoded.push(index);

1695

1696

	// Then call bytes

1697

1

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

1698

1

		dest: para_a_account(),

1699

1

		value: 100u32.into(),

1700

1

1701

1

	.encode();

1702

1

	encoded.append(&mut call_bytes);

1703

1704

1

	let overall_weight = 4000009000u64;

1705

1

	ParaA::execute_with(|| {

1706

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1707

1

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

1708

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1709

0,

1710

1

			CurrencyPayment {

1711

1

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

1712

1

					Location::parent()

1713

1

				))),

1714

1

				// 1-1 fee weight mapping

1715

1

				fee_amount: Some(overall_weight as u128)

1716

1

},

1717

1

			encoded,

1718

1

			TransactWeights {

1719

1

				transact_required_weight_at_most: 4000000000.into(),

1720

1

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

1721

1

},

1722

			true

1723

));

1724

1

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

1725

1

			.iter()

1726

18

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

1727

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

1728

..

1729

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

1730

18

				_ => None,

1731

18

});

1732

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

1733

1

		assert!(event_found.is_none());

1734

1

});

1735

1736

1

	Relay::execute_with(|| {

1737

		// free execution,x	 full amount received

1738

		// 4000009000 refunded + 100 transferred = 4000009100

1739

1

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

1740

1

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

1741

1

});

1742

1

1743

1744

#[test]

1745

1

fn transact_through_sovereign() {

1746

1

	MockNet::reset();

1747

1748

1

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

1749

1

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

1750

1751

1

	let asset_metadata = parachain::AssetMetadata {

1752

1

		name: b"RelayToken".to_vec(),

1753

1

		symbol: b"Relay".to_vec(),

1754

1

		decimals: 12,

1755

1

};

1756

1757

1

	ParaA::execute_with(|| {

1758

1

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

1759

1

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

1760

1

			.try_into()

1761

1

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

1762

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1763

1

			source_id,

1764

1

			source_location_latest,

1765

1

			asset_metadata.decimals,

1766

1

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

1767

1

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

1768

));

1769

1

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

1770

1771

		// Root can set transact info

1772

1

		assert_ok!(XcmTransactor::set_transact_info(

1773

1

			parachain::RuntimeOrigin::root(),

1774

1

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

1775

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

1776

1

			3000.into(),

1777

1

			20000000000.into(),

1778

1

			None

1779

));

1780

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

1781

1

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

1782

1

			.expect("must succeed");

1783

1

});

1784

1785

1

	let dest: Location = AccountKey20 {

1786

1

		network: None,

1787

1

		key: PARAALICE,

1788

1

1789

1

	.into();

1790

1

	Relay::execute_with(|| {

1791

1

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

1792

1

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

1793

1

			assets: Wild(All),

1794

1

			beneficiary: dest.clone(),

1795

1

		}]);

1796

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1797

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1798

1

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

1799

1

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

1800

1

			Box::new(TransferType::LocalReserve),

1801

1

			Box::new(fees_id),

1802

1

			Box::new(TransferType::LocalReserve),

1803

1

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

1804

1

			WeightLimit::Unlimited

1805

));

1806

1

});

1807

1808

1

	ParaA::execute_with(|| {

1809

		// free execution, full amount received

1810

1

		assert_eq!(

1811

1

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

1812

1

			Ok(U256::from(4000003100u64))

1813

);

1814

1

});

1815

1816

	// Register address

1817

1

	ParaA::execute_with(|| {

1818

1

		assert_ok!(XcmTransactor::register(

1819

1

			parachain::RuntimeOrigin::root(),

1820

1

			PARAALICE.into(),

1821

0,

1822

));

1823

1

});

1824

1825

	// Send to registered address

1826

1

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

1827

1

	let dest = Location {

1828

1

		parents: 1,

1829

1

		interior: [AccountId32 {

1830

1

			network: None,

1831

1

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

1832

1

}]

1833

1

		.into(),

1834

1

};

1835

1

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

1836

1837

1

	ParaA::execute_with(|| {

1838

1

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

1839

		// free execution, full amount received

1840

1

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

1841

1

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

1842

1

			assets: Wild(All),

1843

1

			beneficiary: beneficiary.clone(),

1844

1

		}]);

1845

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1846

1

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

1847

1

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

1848

1

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

1849

1

			Box::new(TransferType::DestinationReserve),

1850

1

			Box::new(fees_id),

1851

1

			Box::new(TransferType::DestinationReserve),

1852

1

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

1853

1

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

1854

));

1855

1

});

1856

1857

1

	ParaA::execute_with(|| {

1858

		// free execution, full amount received

1859

1

		assert_eq!(

1860

1

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

1861

1

			Ok(U256::from(4000003000u64))

1862

);

1863

1

});

1864

1865

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

1866

	// again

1867

1

	Relay::execute_with(|| {

1868

		// free execution,x	 full amount received

1869

1

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

1870

1

1871

1

});

1872

1873

	// We send the xcm transact operation to parent

1874

1

	let dest = Location {

1875

1

		parents: 1,

1876

1

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

1877

1

};

1878

1879

	// Encode the call. Balances transact to para_a_account

1880

	// First index

1881

1

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

1882

1

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

1883

1

		relay_chain::Balances,

1884

1

>()

1885

1

	.unwrap() as u8;

1886

1887

1

	encoded.push(index);

1888

1889

	// Then call bytes

1890

1

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

1891

1

		dest: para_a_account(),

1892

1

		value: 100u32.into(),

1893

1

1894

1

	.encode();

1895

1

	encoded.append(&mut call_bytes);

1896

1897

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

1898

1

	ParaA::execute_with(|| {

1899

1

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

1900

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1901

1

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

1902

);

1903

1904

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1905

1

			parachain::RuntimeOrigin::root(),

1906

1

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

1907

1

			Some(PARAALICE.into()),

1908

1

			CurrencyPayment {

1909

1

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

1910

1

					Location::parent()

1911

1

				))),

1912

1

				fee_amount: None

1913

1

},

1914

1

			utility_bytes,

1915

1

			OriginKind::SovereignAccount,

1916

1

			TransactWeights {

1917

1

				transact_required_weight_at_most: 4000000000.into(),

1918

1

				overall_weight: None

1919

1

},

1920

			false

1921

));

1922

1

});

1923

1924

1

	Relay::execute_with(|| {

1925

		// free execution,x	 full amount received

1926

1

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

1927

1928

1

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

1929

1

});

1930

1

1931

1932

#[test]

1933

1

fn transact_through_sovereign_fee_payer_none() {

1934

1

	MockNet::reset();

1935

1936

1

	ParaA::execute_with(|| {

1937

		// Root can set transact info

1938

1

		assert_ok!(XcmTransactor::set_transact_info(

1939

1

			parachain::RuntimeOrigin::root(),

1940

1

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

1941

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

1942

1

			3000.into(),

1943

1

			20000000000.into(),

1944

1

			None

1945

));

1946

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

1947

1

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

1948

1

			.expect("must succeed");

1949

1

});

1950

1951

1

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

1952

1953

1

	Relay::execute_with(|| {

1954

		// Transfer 100 tokens to derivative_address on the relay

1955

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1956

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1957

1

			derivative_address.clone(),

1958

			100u128

1959

));

1960

1961

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

1962

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1963

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1964

1

			para_a_account(),

1965

			4000003000u128

1966

));

1967

1

});

1968

1969

	// Check balances before the transact call

1970

1

	Relay::execute_with(|| {

1971

1

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

1972

1

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

1973

1

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

1974

1

});

1975

1976

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

1977

1

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

1978

1

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

1979

1

		relay_chain::Balances,

1980

1

>()

1981

1

	.unwrap() as u8;

1982

1983

1

	encoded.push(index);

1984

1985

1

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

1986

1

		dest: RELAYBOB,

1987

1

		value: 100u32.into(),

1988

1

1989

1

	.encode();

1990

1

	encoded.append(&mut call_bytes);

1991

1992

	// We send the xcm transact operation to parent

1993

1

	let dest = Location {

1994

1

		parents: 1,

1995

1

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

1996

1

};

1997

1998

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

1999

1

	ParaA::execute_with(|| {

2000

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

2001

1

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

2002

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2003

1

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

2004

);

2005

2006

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2007

1

			parachain::RuntimeOrigin::root(),

2008

1

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

2009

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

2010

1

			None,

2011

1

			CurrencyPayment {

2012

1

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

2013

1

					Location::parent()

2014

1

				))),

2015

1

				fee_amount: None

2016

1

},

2017

1

			utility_bytes,

2018

1

			OriginKind::SovereignAccount,

2019

1

			TransactWeights {

2020

1

				transact_required_weight_at_most: 4000000000.into(),

2021

1

				overall_weight: None

2022

1

},

2023

			false

2024

));

2025

1

});

2026

2027

	// Check balances after the transact call are correct

2028

1

	Relay::execute_with(|| {

2029

1

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

2030

1

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

2031

1

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

2032

1

});

2033

1

2034

2035

#[test]

2036

1

fn transact_through_sovereign_with_custom_fee_weight() {

2037

1

	MockNet::reset();

2038

2039

1

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

2040

1

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

2041

2042

1

	let asset_metadata = parachain::AssetMetadata {

2043

1

		name: b"RelayToken".to_vec(),

2044

1

		symbol: b"Relay".to_vec(),

2045

1

		decimals: 12,

2046

1

};

2047

2048

1

	ParaA::execute_with(|| {

2049

1

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

2050

1

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

2051

1

			.try_into()

2052

1

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

2053

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2054

1

			source_id,

2055

1

			source_location_latest,

2056

1

			asset_metadata.decimals,

2057

1

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

2058

1

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

2059

));

2060

1

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

2061

1

});

2062

2063

1

	let dest: Location = AccountKey20 {

2064

1

		network: None,

2065

1

		key: PARAALICE,

2066

1

2067

1

	.into();

2068

1

	Relay::execute_with(|| {

2069

1

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

2070

1

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

2071

1

			assets: Wild(All),

2072

1

			beneficiary: dest.clone(),

2073

1

		}]);

2074

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2075

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2076

1

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

2077

1

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

2078

1

			Box::new(TransferType::LocalReserve),

2079

1

			Box::new(fees_id),

2080

1

			Box::new(TransferType::LocalReserve),

2081

1

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

2082

1

			WeightLimit::Unlimited

2083

));

2084

1

});

2085

2086

1

	ParaA::execute_with(|| {

2087

		// free execution, full amount received

2088

1

		assert_eq!(

2089

1

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

2090

1

			Ok(U256::from(4000003100u64))

2091

);

2092

1

});

2093

2094

	// Register address

2095

1

	ParaA::execute_with(|| {

2096

1

		assert_ok!(XcmTransactor::register(

2097

1

			parachain::RuntimeOrigin::root(),

2098

1

			PARAALICE.into(),

2099

0,

2100

));

2101

1

});

2102

2103

	// Send to registered address

2104

1

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

2105

1

	let dest = Location {

2106

1

		parents: 1,

2107

1

		interior: [AccountId32 {

2108

1

			network: None,

2109

1

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

2110

1

}]

2111

1

		.into(),

2112

1

};

2113

1

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

2114

2115

1

	ParaA::execute_with(|| {

2116

1

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

2117

		// free execution, full amount received

2118

1

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

2119

1

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

2120

1

			assets: Wild(All),

2121

1

			beneficiary: beneficiary.clone(),

2122

1

		}]);

2123

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2124

1

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

2125

1

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

2126

1

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

2127

1

			Box::new(TransferType::DestinationReserve),

2128

1

			Box::new(fees_id),

2129

1

			Box::new(TransferType::DestinationReserve),

2130

1

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

2131

1

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

2132

));

2133

1

});

2134

2135

1

	ParaA::execute_with(|| {

2136

		// free execution, full amount received

2137

1

		assert_eq!(

2138

1

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

2139

1

			Ok(U256::from(4000003000u64))

2140

);

2141

1

});

2142

2143

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

2144

	// again

2145

1

	Relay::execute_with(|| {

2146

		// free execution,x	 full amount received

2147

1

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

2148

1

2149

1

});

2150

2151

	// We send the xcm transact operation to parent

2152

1

	let dest = Location {

2153

1

		parents: 1,

2154

1

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

2155

1

};

2156

2157

	// Encode the call. Balances transact to para_a_account

2158

	// First index

2159

1

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

2160

1

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

2161

1

		relay_chain::Balances,

2162

1

>()

2163

1

	.unwrap() as u8;

2164

2165

1

	encoded.push(index);

2166

2167

	// Then call bytes

2168

1

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

2169

1

		dest: para_a_account(),

2170

1

		value: 100u32.into(),

2171

1

2172

1

	.encode();

2173

1

	encoded.append(&mut call_bytes);

2174

2175

1

	let total_weight = 4000003000u64;

2176

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

2177

1

	ParaA::execute_with(|| {

2178

1

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

2179

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2180

1

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

2181

);

2182

2183

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2184

1

			parachain::RuntimeOrigin::root(),

2185

1

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

2186

1

			Some(PARAALICE.into()),

2187

1

			CurrencyPayment {

2188

1

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

2189

1

					Location::parent()

2190

1

				))),

2191

1

				// 1-1 fee-weight mapping

2192

1

				fee_amount: Some(total_weight as u128)

2193

1

},

2194

1

			utility_bytes,

2195

1

			OriginKind::SovereignAccount,

2196

1

			TransactWeights {

2197

1

				transact_required_weight_at_most: 4000000000.into(),

2198

1

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

2199

1

},

2200

			false

2201

));

2202

1

});

2203

2204

1

	Relay::execute_with(|| {

2205

		// free execution,x	 full amount received

2206

1

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

2207

2208

1

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

2209

1

});

2210

1

2211

2212

#[test]

2213

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2214

1

	MockNet::reset();

2215

2216

1

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

2217

1

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

2218

2219

1

	let asset_metadata = parachain::AssetMetadata {

2220

1

		name: b"RelayToken".to_vec(),

2221

1

		symbol: b"Relay".to_vec(),

2222

1

		decimals: 12,

2223

1

};

2224

2225

1

	ParaA::execute_with(|| {

2226

1

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

2227

1

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

2228

1

			.try_into()

2229

1

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

2230

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2231

1

			source_id,

2232

1

			source_location_latest,

2233

1

			asset_metadata.decimals,

2234

1

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

2235

1

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

2236

));

2237

1

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

2238

1

});

2239

2240

1

	let dest: Location = AccountKey20 {

2241

1

		network: None,

2242

1

		key: PARAALICE,

2243

1

2244

1

	.into();

2245

1

	Relay::execute_with(|| {

2246

1

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

2247

1

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

2248

1

			assets: Wild(All),

2249

1

			beneficiary: dest.clone(),

2250

1

		}]);

2251

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2252

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2253

1

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

2254

1

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

2255

1

			Box::new(TransferType::LocalReserve),

2256

1

			Box::new(fees_id),

2257

1

			Box::new(TransferType::LocalReserve),

2258

1

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

2259

1

			WeightLimit::Unlimited

2260

));

2261

1

});

2262

2263

1

	ParaA::execute_with(|| {

2264

		// free execution, full amount received

2265

1

		assert_eq!(

2266

1

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

2267

1

			Ok(U256::from(4000009100u64))

2268

);

2269

1

});

2270

2271

	// Register address

2272

1

	ParaA::execute_with(|| {

2273

1

		assert_ok!(XcmTransactor::register(

2274

1

			parachain::RuntimeOrigin::root(),

2275

1

			PARAALICE.into(),

2276

0,

2277

));

2278

1

});

2279

2280

	// Send to registered address

2281

1

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

2282

1

	let dest = Location {

2283

1

		parents: 1,

2284

1

		interior: [AccountId32 {

2285

1

			network: None,

2286

1

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

2287

1

}]

2288

1

		.into(),

2289

1

};

2290

1

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

2291

2292

1

	ParaA::execute_with(|| {

2293

1

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

2294

		// free execution, full amount received

2295

1

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

2296

1

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

2297

1

			assets: Wild(All),

2298

1

			beneficiary: beneficiary.clone(),

2299

1

		}]);

2300

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2301

1

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

2302

1

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

2303

1

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

2304

1

			Box::new(TransferType::DestinationReserve),

2305

1

			Box::new(fees_id),

2306

1

			Box::new(TransferType::DestinationReserve),

2307

1

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

2308

1

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

2309

));

2310

1

});

2311

2312

1

	ParaA::execute_with(|| {

2313

		// free execution, full amount received

2314

1

		assert_eq!(

2315

1

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

2316

1

			Ok(U256::from(4000009000u64))

2317

);

2318

1

});

2319

2320

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

2321

	// again

2322

1

	Relay::execute_with(|| {

2323

		// free execution,x	 full amount received

2324

1

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

2325

1

2326

1

});

2327

2328

	// We send the xcm transact operation to parent

2329

1

	let dest = Location {

2330

1

		parents: 1,

2331

1

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

2332

1

};

2333

2334

	// Encode the call. Balances transact to para_a_account

2335

	// First index

2336

1

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

2337

1

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

2338

1

		relay_chain::Balances,

2339

1

>()

2340

1

	.unwrap() as u8;

2341

2342

1

	encoded.push(index);

2343

2344

	// Then call bytes

2345

1

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

2346

1

		dest: para_a_account(),

2347

1

		value: 100u32.into(),

2348

1

2349

1

	.encode();

2350

1

	encoded.append(&mut call_bytes);

2351

2352

1

	let total_weight = 4000009000u64;

2353

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

2354

1

	ParaA::execute_with(|| {

2355

1

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

2356

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2357

1

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

2358

);

2359

2360

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2361

1

			parachain::RuntimeOrigin::root(),

2362

1

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

2363

1

			Some(PARAALICE.into()),

2364

1

			CurrencyPayment {

2365

1

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

2366

1

					Location::parent()

2367

1

				))),

2368

1

				// 1-1 fee-weight mapping

2369

1

				fee_amount: Some(total_weight as u128)

2370

1

},

2371

1

			utility_bytes,

2372

1

			OriginKind::SovereignAccount,

2373

1

			TransactWeights {

2374

1

				transact_required_weight_at_most: 4000000000.into(),

2375

1

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

2376

1

},

2377

			true

2378

));

2379

1

});

2380

2381

1

	Relay::execute_with(|| {

2382

		// free execution, full amount received

2383

		// 4000009000 refunded + 100 transferred = 4000009100

2384

1

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

2385

2386

1

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

2387

1

});

2388

1

2389

2390

#[test]

2391

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2392

1

	MockNet::reset();

2393

2394

1

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

2395

1

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

2396

1

	let asset_metadata = parachain::AssetMetadata {

2397

1

		name: b"RelayToken".to_vec(),

2398

1

		symbol: b"Relay".to_vec(),

2399

1

		decimals: 12,

2400

1

};

2401

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

2402

1

	ParaA::execute_with(|| {

2403

1

		parachain::XcmVersioner::set_version(1);

2404

1

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

2405

1

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

2406

1

			.try_into()

2407

1

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

2408

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2409

1

			source_id,

2410

1

			source_location_latest,

2411

1

			asset_metadata.decimals,

2412

1

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

2413

1

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

2414

));

2415

1

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

2416

1

});

2417

2418

1

	let response = Response::Version(2);

2419

1

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

2420

2421

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

2422

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

2423

1

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

2424

1

		query_id: 0,

2425

1

		response,

2426

1

		max_weight: Weight::zero(),

2427

1

		querier: Some(querier),

2428

1

	}]);

2429

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

2430

	// it directly here

2431

	// Actually send relay asset to parachain

2432

1

	let dest: Location = AccountKey20 {

2433

1

		network: None,

2434

1

		key: PARAALICE,

2435

1

2436

1

	.into();

2437

2438

1

	Relay::execute_with(|| {

2439

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

2440

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2441

1

			relay_chain::RuntimeOrigin::root(),

2442

1

			Some(3)

2443

));

2444

2445

		// Wrap version, which sets VersionedStorage

2446

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

2447

		// this is not necessary in prod

2448

1

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

2449

1

			&Parachain(1).into(),

2450

1

			mock_message

2451

));

2452

2453

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

2454

1

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

2455

1

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

2456

1

			assets: Wild(All),

2457

1

			beneficiary: dest.clone(),

2458

1

		}]);

2459

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2460

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2461

1

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

2462

1

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

2463

1

			Box::new(TransferType::LocalReserve),

2464

1

			Box::new(fees_id),

2465

1

			Box::new(TransferType::LocalReserve),

2466

1

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

2467

1

			WeightLimit::Unlimited

2468

));

2469

2470

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

2471

1

		relay_chain::relay_roll_to(2);

2472

2473

		// queries should have been updated

2474

1

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

2475

1

});

2476

2477

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2478

1

		pallet_xcm::Event::SupportedVersionChanged {

2479

1

			location: Location {

2480

1

				parents: 0,

2481

1

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

2482

1

},

2483

1

			version: 1,

2484

1

2485

1

		.into();

2486

2487

1

	Relay::execute_with(|| {

2488

		// Assert that the events vector contains the version change

2489

1

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

2490

1

});

2491

2492

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

2493

	// of the new version change

2494

1

	ParaA::execute_with(|| {

2495

		// Set version

2496

1

		parachain::XcmVersioner::set_version(2);

2497

		// Do runtime upgrade

2498

1

		parachain::on_runtime_upgrade();

2499

		// Initialize block, to call on_initialize and notify targets

2500

1

		parachain::para_roll_to(2);

2501

		// Expect the event in the parachain

2502

1

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

2503

2

e,

2504

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

2505

				result: 2,

2506

..

2507

})

2508

		)));

2509

1

});

2510

2511

	// This event should have been seen in the relay

2512

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2513

1

		pallet_xcm::Event::SupportedVersionChanged {

2514

1

			location: Location {

2515

1

				parents: 0,

2516

1

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

2517

1

},

2518

1

			version: 2,

2519

1

2520

1

		.into();

2521

2522

1

	Relay::execute_with(|| {

2523

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

2524

1

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

2525

1

});

2526

1

2527

2528

#[test]

2529

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2530

1

	MockNet::reset();

2531

2532

1

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

2533

1

	let source_location: AssetType = para_a_balances

2534

1

		.try_into()

2535

1

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

2536

1

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

2537

2538

1

	let asset_metadata = parachain::AssetMetadata {

2539

1

		name: b"ParaAToken".to_vec(),

2540

1

		symbol: b"ParaA".to_vec(),

2541

1

		decimals: 18,

2542

1

};

2543

1

	let response = Response::Version(2);

2544

1

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

2545

1

		.into();

2546

2547

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

2548

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

2549

1

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

2550

1

		query_id: 0,

2551

1

		response,

2552

1

		max_weight: Weight::zero(),

2553

1

		querier: Some(querier),

2554

1

	}]);

2555

2556

1

	ParaA::execute_with(|| {

2557

		// advertised version

2558

1

		parachain::XcmVersioner::set_version(2);

2559

1

});

2560

2561

1

	ParaB::execute_with(|| {

2562

		// Let's try with v0

2563

1

		parachain::XcmVersioner::set_version(0);

2564

2565

1

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

2566

1

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

2567

1

			.try_into()

2568

1

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

2569

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2570

1

			source_id,

2571

1

			source_location_latest,

2572

1

			asset_metadata.decimals,

2573

1

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

2574

1

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

2575

));

2576

1

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

2577

1

});

2578

2579

1

	ParaA::execute_with(|| {

2580

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

2581

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2582

1

			parachain::RuntimeOrigin::root(),

2583

1

			Some(3)

2584

));

2585

		// Wrap version, which sets VersionedStorage

2586

1

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

2587

1

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

2588

1

			mock_message

2589

));

2590

2591

1

		parachain::para_roll_to(2);

2592

2593

		// queries should have been updated

2594

1

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

2595

1

});

2596

2597

1

	let expected_supported_version: parachain::RuntimeEvent =

2598

1

		pallet_xcm::Event::SupportedVersionChanged {

2599

1

			location: Location {

2600

1

				parents: 1,

2601

1

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

2602

1

},

2603

1

			version: 0,

2604

1

2605

1

		.into();

2606

2607

1

	ParaA::execute_with(|| {

2608

		// Assert that the events vector contains the version change

2609

1

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

2610

1

});

2611

2612

	// Let's ensure talking in v0 works

2613

1

	let dest = Location {

2614

1

		parents: 1,

2615

1

		interior: [

2616

1

			Parachain(2),

2617

1

			AccountKey20 {

2618

1

				network: None,

2619

1

				key: PARAALICE.into(),

2620

1

},

2621

1

2622

1

		.into(),

2623

1

};

2624

1

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

2625

1

	ParaA::execute_with(|| {

2626

1

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

2627

		// free execution, full amount received

2628

1

		assert_ok!(PolkadotXcm::transfer_assets(

2629

1

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

2630

1

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

2631

1

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

2632

1

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

2633

0,

2634

1

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

2635

));

2636

		// free execution, full amount received

2637

1

		assert_eq!(

2638

1

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

2639

			INITIAL_BALANCE - 100

2640

);

2641

1

});

2642

2643

1

	ParaB::execute_with(|| {

2644

		// free execution, full amount received

2645

1

		assert_eq!(

2646

1

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

2647

1

			Ok(U256::from(100))

2648

);

2649

1

});

2650

2651

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

2652

	// of the new version change

2653

1

	ParaB::execute_with(|| {

2654

		// Set version

2655

1

		parachain::XcmVersioner::set_version(2);

2656

		// Do runtime upgrade

2657

1

		parachain::on_runtime_upgrade();

2658

		// Initialize block, to call on_initialize and notify targets

2659

1

		parachain::para_roll_to(2);

2660

		// Expect the event in the parachain

2661

1

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

2662

2

e,

2663

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

2664

				result: 2,

2665

..

2666

})

2667

		)));

2668

1

});

2669

2670

	// This event should have been seen in para A

2671

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2672

1

		pallet_xcm::Event::SupportedVersionChanged {

2673

1

			location: Location {

2674

1

				parents: 1,

2675

1

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

2676

1

},

2677

1

			version: 2,

2678

1

2679

1

		.into();

2680

2681

	// Para A should have received the version change

2682

1

	ParaA::execute_with(|| {

2683

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

2684

1

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

2685

1

});

2686

1

2687

2688

#[test]

2689

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2690

1

	MockNet::reset();

2691

2692

1

	let fresh_account = PARABOB;

2693

1

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

2694

1

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

2695

1

	let asset_metadata = parachain::AssetMetadata {

2696

1

		name: b"RelayToken".to_vec(),

2697

1

		symbol: b"Relay".to_vec(),

2698

1

		decimals: 12,

2699

1

};

2700

	// register relay asset in parachain A

2701

1

	ParaA::execute_with(|| {

2702

1

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

2703

1

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

2704

1

			.try_into()

2705

1

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

2706

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2707

1

			source_id,

2708

1

			source_location_latest,

2709

1

			asset_metadata.decimals,

2710

1

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

2711

1

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

2712

));

2713

1

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

2714

1

});

2715

2716

	// Actually send relay asset to parachain

2717

1

	let dest: Location = AccountKey20 {

2718

1

		network: None,

2719

1

		key: fresh_account,

2720

1

2721

1

	.into();

2722

1

	Relay::execute_with(|| {

2723

1

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

2724

1

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

2725

1

			assets: Wild(All),

2726

1

			beneficiary: dest.clone(),

2727

1

		}]);

2728

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2729

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2730

1

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

2731

1

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

2732

1

			Box::new(TransferType::LocalReserve),

2733

1

			Box::new(fees_id),

2734

1

			Box::new(TransferType::LocalReserve),

2735

1

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

2736

1

			WeightLimit::Unlimited

2737

));

2738

1

});

2739

2740

	// parachain should have received assets

2741

1

	ParaA::execute_with(|| {

2742

		// free execution, full amount received

2743

1

		assert_eq!(

2744

1

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

2745

1

			Ok(U256::from(123))

2746

);

2747

1

});

2748

1

2749

2750

#[test]

2751

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2752

1

	MockNet::reset();

2753

2754

1

	let fresh_account = [2u8; 20];

2755

1

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

2756

1

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

2757

1

	let asset_metadata = parachain::AssetMetadata {

2758

1

		name: b"RelayToken".to_vec(),

2759

1

		symbol: b"Relay".to_vec(),

2760

1

		decimals: 12,

2761

1

};

2762

	// register relay asset in parachain A

2763

1

	ParaA::execute_with(|| {

2764

1

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

2765

1

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

2766

1

			.try_into()

2767

1

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

2768

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2769

1

			source_id,

2770

1

			source_location_latest,

2771

1

			asset_metadata.decimals,

2772

1

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

2773

1

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

2774

));

2775

1

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

2776

1

});

2777

2778

	// Actually send relay asset to parachain

2779

1

	let dest: Location = AccountKey20 {

2780

1

		network: None,

2781

1

		key: fresh_account,

2782

1

2783

1

	.into();

2784

1

	Relay::execute_with(|| {

2785

1

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

2786

1

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

2787

1

			assets: Wild(All),

2788

1

			beneficiary: dest.clone(),

2789

1

		}]);

2790

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2791

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2792

1

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

2793

1

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

2794

1

			Box::new(TransferType::LocalReserve),

2795

1

			Box::new(fees_id),

2796

1

			Box::new(TransferType::LocalReserve),

2797

1

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

2798

1

			WeightLimit::Unlimited

2799

));

2800

1

});

2801

2802

	// parachain should have received assets

2803

1

	ParaA::execute_with(|| {

2804

		// free execution, full amount received

2805

1

		assert_eq!(

2806

1

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

2807

1

			Ok(U256::from(123))

2808

);

2809

1

});

2810

1

2811

2812

#[test]

2813

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2814

1

	MockNet::reset();

2815

2816

1

	let mut sufficient_account = [0u8; 20];

2817

1

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

2818

2819

1

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

2820

2821

	// Evm account is self sufficient

2822

1

	ParaA::execute_with(|| {

2823

1

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

2824

1

});

2825

2826

1

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

2827

1

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

2828

1

	let asset_metadata = parachain::AssetMetadata {

2829

1

		name: b"RelayToken".to_vec(),

2830

1

		symbol: b"Relay".to_vec(),

2831

1

		decimals: 12,

2832

1

};

2833

	// register relay asset in parachain A

2834

1

	ParaA::execute_with(|| {

2835

1

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

2836

1

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

2837

1

			.try_into()

2838

1

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

2839

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2840

1

			source_id,

2841

1

			source_location_latest,

2842

1

			asset_metadata.decimals,

2843

1

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

2844

1

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

2845

));

2846

1

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

2847

1

});

2848

2849

	// Actually send relay asset to parachain

2850

1

	let dest: Location = AccountKey20 {

2851

1

		network: None,

2852

1

		key: sufficient_account,

2853

1

2854

1

	.into();

2855

1

	Relay::execute_with(|| {

2856

1

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

2857

1

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

2858

1

			assets: Wild(All),

2859

1

			beneficiary: dest.clone(),

2860

1

		}]);

2861

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2862

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2863

1

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

2864

1

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

2865

1

			Box::new(TransferType::LocalReserve),

2866

1

			Box::new(fees_id),

2867

1

			Box::new(TransferType::LocalReserve),

2868

1

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

2869

1

			WeightLimit::Unlimited

2870

));

2871

1

});

2872

2873

	// Evm account sufficient ref count increased by 1.

2874

1

	ParaA::execute_with(|| {

2875

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

2876

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

2877

		// will be implemented in a future release

2878

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

2879

1

});

2880

2881

1

	ParaA::execute_with(|| {

2882

		// Remove the account from the evm context.

2883

1

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

2884

		// Evm account sufficient ref count decreased by 1.

2885

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

2886

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

2887

		// will be implemented in a future release

2888

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

2889

1

});

2890

1

2891

2892

#[test]

2893

1

fn empty_account_should_not_be_reset() {

2894

1

	MockNet::reset();

2895

2896

	// Test account has nonce 1 on genesis.

2897

1

	let sufficient_account = PARABOB;

2898

2899

1

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

2900

2901

1

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

2902

1

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

2903

1

	let asset_metadata = parachain::AssetMetadata {

2904

1

		name: b"RelayToken".to_vec(),

2905

1

		symbol: b"Relay".to_vec(),

2906

1

		decimals: 12,

2907

1

};

2908

	// register relay asset in parachain A

2909

1

	ParaA::execute_with(|| {

2910

1

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

2911

1

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

2912

1

			.try_into()

2913

1

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

2914

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2915

1

			source_id,

2916

1

			source_location_latest,

2917

1

			asset_metadata.decimals,

2918

1

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

2919

1

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

2920

));

2921

1

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

2922

1

});

2923

2924

	// Send native token to evm_account

2925

1

	ParaA::execute_with(|| {

2926

1

		assert_ok!(ParaBalances::transfer_allow_death(

2927

1

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

2928

1

			evm_account_id,

2929

2930

));

2931

1

});

2932

2933

	// Actually send relay asset to parachain

2934

1

	let dest: Location = AccountKey20 {

2935

1

		network: None,

2936

1

		key: sufficient_account,

2937

1

2938

1

	.into();

2939

1

	Relay::execute_with(|| {

2940

1

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

2941

1

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

2942

1

			assets: Wild(All),

2943

1

			beneficiary: dest.clone(),

2944

1

		}]);

2945

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2946

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2947

1

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

2948

1

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

2949

1

			Box::new(TransferType::LocalReserve),

2950

1

			Box::new(fees_id),

2951

1

			Box::new(TransferType::LocalReserve),

2952

1

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

2953

1

			WeightLimit::Unlimited

2954

));

2955

1

});

2956

2957

1

	ParaA::execute_with(|| {

2958

		// Empty the assets from the account.

2959

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

2960

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

2961

		// Transfer the assets from evm_account to PARAALICE

2962

1

		assert_ok!(EvmForeignAssets::transfer(

2963

1

			source_id,

2964

1

			evm_account_id,

2965

1

			PARAALICE.into(),

2966

1

			U256::from(123)

2967

));

2968

		// Verify account asset balance is Zero.

2969

1

		assert_eq!(

2970

1

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

2971

1

			Ok(U256::from(0))

2972

);

2973

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

2974

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

2975

1

		assert_ok!(ParaBalances::force_set_balance(

2976

1

			parachain::RuntimeOrigin::root(),

2977

1

			evm_account_id,

2978

0,

2979

));

2980

		// Verify account native balance is Zero.

2981

1

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

2982

		// Remove the account from the evm context.

2983

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

2984

1

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

2985

		// Verify reference count.

2986

1

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

2987

1

		assert_eq!(account.sufficients, 0);

2988

1

		assert_eq!(account.consumers, 0);

2989

1

		assert_eq!(account.providers, 1);

2990

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

2991

1

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

2992

1

});

2993

1

2994

2995

#[test]

2996

1

fn test_statemine_like() {

2997

1

	MockNet::reset();

2998

2999

1

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

3000

3001

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3002

1

		polkadot_parachain::primitives::Sibling,

3003

1

		statemine_like::AccountId,

3004

1

	>::convert_location(&dest_para)

3005

1

	.unwrap();

3006

3007

1

	let statemine_asset_a_balances = Location::new(

3008

1,

3009

1

3010

1

			Parachain(1000),

3011

1

			PalletInstance(5),

3012

1

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

3013

1

],

3014

);

3015

1

	let source_location: AssetType = statemine_asset_a_balances

3016

1

		.try_into()

3017

1

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

3018

1

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

3019

3020

1

	let asset_metadata = parachain::AssetMetadata {

3021

1

		name: b"StatemineToken".to_vec(),

3022

1

		symbol: b"StatemineToken".to_vec(),

3023

1

		decimals: 12,

3024

1

};

3025

3026

1

	ParaA::execute_with(|| {

3027

1

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

3028

1

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

3029

1

			.try_into()

3030

1

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

3031

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3032

1

			source_id,

3033

1

			source_location_latest,

3034

1

			asset_metadata.decimals,

3035

1

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

3036

1

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

3037

));

3038

1

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

3039

1

});

3040

3041

1

	Statemine::execute_with(|| {

3042

		// Set new prefix

3043

1

		statemine_like::PrefixChanger::set_prefix(

3044

1

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

3045

);

3046

1

		assert_ok!(StatemineAssets::create(

3047

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3048

0,

3049

			RELAYALICE,

3050

3051

));

3052

3053

1

		assert_ok!(StatemineAssets::mint(

3054

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3055

0,

3056

			RELAYALICE,

3057

			300000000000000

3058

));

3059

3060

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

3061

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3062

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3063

1

			sov,

3064

			100000000000000

3065

));

3066

3067

		// Actually send relay asset to parachain

3068

1

		let dest: Location = AccountKey20 {

3069

1

			network: None,

3070

1

			key: PARAALICE,

3071

1

3072

1

		.into();

3073

3074

		// Send with new prefix

3075

1

		let asset_location = Location::new(

3076

0,

3077

1

3078

1

				xcm::latest::prelude::PalletInstance(

3079

1

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

3080

1

),

3081

1

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

3082

1

],

3083

);

3084

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

3085

1

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

3086

1

			assets: Wild(All),

3087

1

			beneficiary: dest.clone(),

3088

1

		}]);

3089

1

		assert_ok!(

3090

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3091

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3092

1

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

3093

1

				Box::new((asset_location, 123).into()),

3094

1

				Box::new(TransferType::LocalReserve),

3095

1

				Box::new(fees_id),

3096

1

				Box::new(TransferType::LocalReserve),

3097

1

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

3098

1

				WeightLimit::Unlimited

3099

3100

);

3101

1

});

3102

3103

1

	ParaA::execute_with(|| {

3104

1

		assert_eq!(

3105

1

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

3106

1

			Ok(U256::from(123))

3107

);

3108

1

});

3109

1

3110

3111

#[test]

3112

1

fn send_statemine_asset_from_para_a_to_statemine_with_relay_fee() {

3113

1

	MockNet::reset();

3114

3115

	// Relay asset

3116

1

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

3117

1

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

3118

3119

1

	let relay_asset_metadata = parachain::AssetMetadata {

3120

1

		name: b"RelayToken".to_vec(),

3121

1

		symbol: b"Relay".to_vec(),

3122

1

		decimals: 12,

3123

1

};

3124

3125

	// Statemine asset

3126

1

	let statemine_asset = Location::new(

3127

1,

3128

1

3129

1

			Parachain(1000u32),

3130

1

			PalletInstance(5u8),

3131

1

			GeneralIndex(10u128),

3132

1

],

3133

);

3134

1

	let statemine_location_asset: AssetType = statemine_asset

3135

1

		.clone()

3136

1

		.try_into()

3137

1

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

3138

1

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

3139

3140

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3141

1

		name: b"USDC".to_vec(),

3142

1

		symbol: b"USDC".to_vec(),

3143

1

		decimals: 12,

3144

1

};

3145

3146

1

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

3147

3148

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3149

1

		polkadot_parachain::primitives::Sibling,

3150

1

		statemine_like::AccountId,

3151

1

	>::convert_location(&dest_para)

3152

1

	.unwrap();

3153

3154

1

	ParaA::execute_with(|| {

3155

1

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

3156

1

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

3157

1

			.try_into()

3158

1

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

3159

1

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

3160

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3161

1

			relay_id,

3162

1

			relay_location_latest,

3163

1

			relay_asset_metadata.decimals,

3164

1

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

3165

1

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

3166

));

3167

1

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

3168

3169

1

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

3170

1

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

3171

1

			.try_into()

3172

1

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

3173

1

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

3174

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3175

1

			statemine_id,

3176

1

			statemine_location_latest,

3177

1

			asset_metadata_statemine_asset.decimals,

3178

1

			asset_metadata_statemine_asset

3179

1

				.symbol

3180

1

				.try_into()

3181

1

				.expect("too long"),

3182

1

			asset_metadata_statemine_asset

3183

1

				.name

3184

1

				.try_into()

3185

1

				.expect("too long"),

3186

));

3187

1

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

3188

1

});

3189

3190

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3191

1

		network: None,

3192

1

		key: PARAALICE,

3193

1

3194

1

	.into();

3195

3196

	// Send relay chain asset to Alice in Parachain A

3197

1

	Relay::execute_with(|| {

3198

1

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

3199

1

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

3200

1

			assets: Wild(All),

3201

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

3202

1

		}]);

3203

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

3204

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3205

1

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

3206

1

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

3207

1

			Box::new(TransferType::LocalReserve),

3208

1

			Box::new(fees_id),

3209

1

			Box::new(TransferType::LocalReserve),

3210

1

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

3211

1

			WeightLimit::Unlimited

3212

));

3213

1

});

3214

3215

1

	Statemine::execute_with(|| {

3216

		// Set new prefix

3217

1

		statemine_like::PrefixChanger::set_prefix(

3218

1

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

3219

);

3220

3221

1

		assert_ok!(StatemineAssets::create(

3222

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3223

10,

3224

			RELAYALICE,

3225

3226

));

3227

3228

1

		assert_ok!(StatemineAssets::mint(

3229

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3230

10,

3231

			RELAYALICE,

3232

			300000000000000

3233

));

3234

3235

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

3236

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

3237

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3238

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3239

1

			sov,

3240

			100000000000000

3241

));

3242

3243

		// Send statemine USDC asset to Alice in Parachain A

3244

1

		let parachain_beneficiary_from_statemine: Location = AccountKey20 {

3245

1

			network: None,

3246

1

			key: PARAALICE,

3247

1

3248

1

		.into();

3249

3250

		// Send with new prefix

3251

1

		let asset_location = Location::new(

3252

0,

3253

1

3254

1

				xcm::latest::prelude::PalletInstance(

3255

1

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

3256

1

),

3257

1

				GeneralIndex(10),

3258

1

],

3259

);

3260

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

3261

1

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

3262

1

			assets: Wild(All),

3263

1

			beneficiary: parachain_beneficiary_from_statemine.clone(),

3264

1

		}]);

3265

1

		assert_ok!(

3266

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3267

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3268

1

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

3269

1

				Box::new((asset_location, 125).into()),

3270

1

				Box::new(TransferType::LocalReserve),

3271

1

				Box::new(fees_id),

3272

1

				Box::new(TransferType::LocalReserve),

3273

1

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

3274

1

				WeightLimit::Unlimited

3275

3276

);

3277

1

});

3278

3279

1

	let statemine_beneficiary = Location {

3280

1

		parents: 1,

3281

1

		interior: [

3282

1

			Parachain(1000),

3283

1

			AccountId32 {

3284

1

				network: None,

3285

1

				id: RELAYBOB.into(),

3286

1

},

3287

1

3288

1

		.into(),

3289

1

};

3290

3291

1

	ParaA::execute_with(|| {

3292

		// Alice has received 125 USDC

3293

1

		assert_eq!(

3294

1

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

3295

1

			Ok(U256::from(125))

3296

);

3297

3298

		// Alice has received 200 Relay assets

3299

1

		assert_eq!(

3300

1

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

3301

1

			Ok(U256::from(200))

3302

);

3303

1

});

3304

3305

1

	Statemine::execute_with(|| {

3306

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

3307

1

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

3308

1

});

3309

1

	let (chain_part, beneficiary) =

3310

1

		split_location_into_chain_part_and_beneficiary(statemine_beneficiary).unwrap();

3311

3312

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

3313

1

	ParaA::execute_with(|| {

3314

1

		let asset_1 = currency_to_asset(

3315

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3316

			100,

3317

);

3318

1

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

3319

1

		let fees_id: VersionedAssetId = asset_2.id.clone().into();

3320

1

		let assets_to_send = vec![asset_1, asset_2];

3321

1

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

3322

1

			assets: Wild(All),

3323

1

			beneficiary: beneficiary.clone(),

3324

1

		}]);

3325

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3326

1

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

3327

1

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

3328

1

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

3329

1

			Box::new(TransferType::DestinationReserve),

3330

1

			Box::new(fees_id),

3331

1

			Box::new(TransferType::DestinationReserve),

3332

1

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

3333

1

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

3334

));

3335

1

});

3336

3337

1

	ParaA::execute_with(|| {

3338

		// Alice has 100 USDC less

3339

1

		assert_eq!(

3340

1

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

3341

1

			Ok(U256::from(25))

3342

);

3343

3344

		// Alice has 100 relay asset less

3345

1

		assert_eq!(

3346

1

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

3347

1

			Ok(U256::from(100))

3348

);

3349

1

});

3350

3351

1

	Statemine::execute_with(|| {

3352

		// Check that BOB received 100 USDC on statemine

3353

1

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

3354

1

});

3355

1

3356

3357

#[test]

3358

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer() {

3359

1

	MockNet::reset();

3360

3361

	// Relay asset

3362

1

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

3363

1

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

3364

3365

1

	let relay_asset_metadata = parachain::AssetMetadata {

3366

1

		name: b"RelayToken".to_vec(),

3367

1

		symbol: b"Relay".to_vec(),

3368

1

		decimals: 12,

3369

1

};

3370

3371

1

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

3372

3373

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3374

1

		polkadot_parachain::primitives::Sibling,

3375

1

		statemine_like::AccountId,

3376

1

	>::convert_location(&dest_para)

3377

1

	.unwrap();

3378

3379

1

	ParaA::execute_with(|| {

3380

1

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

3381

1

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

3382

1

			.try_into()

3383

1

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

3384

1

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

3385

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3386

1

			source_id,

3387

1

			source_location_latest,

3388

1

			relay_asset_metadata.decimals,

3389

1

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

3390

1

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

3391

));

3392

1

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

3393

1

});

3394

3395

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3396

1

		network: None,

3397

1

		key: PARAALICE,

3398

1

3399

1

	.into();

3400

3401

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3402

1

		network: None,

3403

1

		id: RELAYALICE.into(),

3404

1

3405

1

	.into();

3406

3407

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

3408

1

	Relay::execute_with(|| {

3409

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3410

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3411

1

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

3412

1

			Box::new(

3413

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3414

1

					.clone()

3415

1

					.into()

3416

),

3417

1

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

3418

0,

3419

1

			WeightLimit::Unlimited

3420

));

3421

1

});

3422

3423

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3424

1

	Statemine::execute_with(|| {

3425

		// Check Alice received 200 tokens on AssetHub

3426

1

		assert_eq!(

3427

1

			StatemineBalances::free_balance(RELAYALICE),

3428

			INITIAL_BALANCE + 200

3429

);

3430

3431

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3432

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3433

1

			sov,

3434

			110000000000000

3435

));

3436

3437

		// Now send those tokens to ParaA

3438

1

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

3439

1

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

3440

1

			assets: Wild(All),

3441

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3442

1

		}]);

3443

1

		assert_ok!(

3444

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3445

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3446

1

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

3447

1

				Box::new((Location::parent(), 200).into()),

3448

1

				Box::new(TransferType::LocalReserve),

3449

1

				Box::new(fees_id),

3450

1

				Box::new(TransferType::LocalReserve),

3451

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3452

1

				WeightLimit::Unlimited

3453

3454

);

3455

1

});

3456

3457

1

	ParaA::execute_with(|| {

3458

		// Alice should have received the DOTs

3459

1

		assert_eq!(

3460

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3461

1

			Ok(U256::from(200))

3462

);

3463

1

});

3464

3465

1

	let dest = Location::new(

3466

1,

3467

1

3468

1

			Parachain(1000),

3469

1

			AccountId32 {

3470

1

				network: None,

3471

1

				id: RELAYBOB.into(),

3472

1

},

3473

1

],

3474

);

3475

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3476

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3477

1

	ParaA::execute_with(|| {

3478

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3479

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3480

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3481

1

			assets: Wild(All),

3482

1

			beneficiary: beneficiary.clone(),

3483

1

		}]);

3484

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3485

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3486

1

			Box::new(VersionedLocation::from(chain_part)),

3487

1

			Box::new(VersionedAssets::from(vec![asset])),

3488

1

			Box::new(TransferType::DestinationReserve),

3489

1

			Box::new(fees_id),

3490

1

			Box::new(TransferType::DestinationReserve),

3491

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3492

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3493

));

3494

3495

1

		assert_eq!(

3496

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3497

1

			Ok(U256::from(100))

3498

);

3499

1

});

3500

3501

1

	Statemine::execute_with(|| {

3502

		// Check that Bob received the tokens back in AssetHub

3503

1

		assert_eq!(

3504

1

			StatemineBalances::free_balance(RELAYBOB),

3505

			INITIAL_BALANCE + 100

3506

);

3507

1

});

3508

3509

	// Send back tokens from AH to ParaA from Bob's account

3510

1

	Statemine::execute_with(|| {

3511

		// Now send those tokens to ParaA

3512

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3513

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3514

1

			assets: Wild(All),

3515

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3516

1

		}]);

3517

1

		assert_ok!(

3518

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3519

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3520

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3521

1

				Box::new((Location::parent(), 100).into()),

3522

1

				Box::new(TransferType::LocalReserve),

3523

1

				Box::new(fees_id),

3524

1

				Box::new(TransferType::LocalReserve),

3525

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3526

1

				WeightLimit::Unlimited

3527

3528

);

3529

3530

		// 100 DOTs were deducted from Bob's account

3531

1

		assert_eq!(StatemineBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3532

1

});

3533

3534

1

	ParaA::execute_with(|| {

3535

		// Alice should have received 100 DOTs

3536

1

		assert_eq!(

3537

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3538

1

			Ok(U256::from(200))

3539

);

3540

1

});

3541

1

3542

3543

#[test]

3544

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_with_fee() {

3545

1

	MockNet::reset();

3546

3547

	// Relay asset

3548

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3549

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3550

3551

1

	let relay_asset_metadata = parachain::AssetMetadata {

3552

1

		name: b"RelayToken".to_vec(),

3553

1

		symbol: b"Relay".to_vec(),

3554

1

		decimals: 12,

3555

1

};

3556

3557

1

	let dest_para = Location::new(1, [Parachain(1)]);

3558

3559

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3560

1

		polkadot_parachain::primitives::Sibling,

3561

1

		statemine_like::AccountId,

3562

1

	>::convert_location(&dest_para)

3563

1

	.unwrap();

3564

3565

1

	ParaA::execute_with(|| {

3566

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3567

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3568

1

			.try_into()

3569

1

			.expect("v3 to latest location conversion failed");

3570

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3571

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3572

1

			source_id,

3573

1

			source_location_latest,

3574

1

			relay_asset_metadata.decimals,

3575

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3576

1

			relay_asset_metadata.name.try_into().expect("too long"),

3577

));

3578

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3579

1

});

3580

3581

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3582

1

		network: None,

3583

1

		key: PARAALICE,

3584

1

3585

1

	.into();

3586

3587

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3588

1

		network: None,

3589

1

		id: RELAYALICE.into(),

3590

1

3591

1

	.into();

3592

3593

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3594

1

	Relay::execute_with(|| {

3595

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3596

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3597

1

			Box::new(Parachain(1000).into()),

3598

1

			Box::new(

3599

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3600

1

					.clone()

3601

1

					.into()

3602

),

3603

1

			Box::new(([], 200).into()),

3604

0,

3605

1

			WeightLimit::Unlimited

3606

));

3607

1

});

3608

3609

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3610

1

	Statemine::execute_with(|| {

3611

		// Check Alice received 200 tokens on AssetHub

3612

1

		assert_eq!(

3613

1

			StatemineBalances::free_balance(RELAYALICE),

3614

			INITIAL_BALANCE + 200

3615

);

3616

3617

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3618

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3619

1

			sov,

3620

			110000000000000

3621

));

3622

3623

		// Now send those tokens to ParaA

3624

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3625

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3626

1

			assets: Wild(All),

3627

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3628

1

		}]);

3629

1

		assert_ok!(

3630

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3631

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3632

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3633

1

				Box::new((Location::parent(), 200).into()),

3634

1

				Box::new(TransferType::LocalReserve),

3635

1

				Box::new(fees_id),

3636

1

				Box::new(TransferType::LocalReserve),

3637

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3638

1

				WeightLimit::Unlimited

3639

3640

);

3641

1

});

3642

3643

1

	ParaA::execute_with(|| {

3644

		// Alice should have received the DOTs

3645

1

		assert_eq!(

3646

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3647

1

			Ok(U256::from(200))

3648

);

3649

1

});

3650

3651

1

	let dest = Location::new(

3652

1,

3653

1

3654

1

			Parachain(1000),

3655

1

			AccountId32 {

3656

1

				network: None,

3657

1

				id: RELAYBOB.into(),

3658

1

},

3659

1

],

3660

);

3661

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3662

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3663

1

	ParaA::execute_with(|| {

3664

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3665

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3666

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3667

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3668

1

			assets: Wild(All),

3669

1

			beneficiary: beneficiary.clone(),

3670

1

		}]);

3671

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3672

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3673

1

			Box::new(VersionedLocation::from(chain_part)),

3674

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

3675

1

			Box::new(TransferType::DestinationReserve),

3676

1

			Box::new(fees_id),

3677

1

			Box::new(TransferType::DestinationReserve),

3678

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3679

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3680

));

3681

3682

1

		assert_eq!(

3683

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3684

1

			Ok(U256::from(90))

3685

);

3686

1

});

3687

3688

1

	Statemine::execute_with(|| {

3689

		// Free execution: check that Bob received the tokens back in AssetHub

3690

1

		assert_eq!(

3691

1

			StatemineBalances::free_balance(RELAYBOB),

3692

			INITIAL_BALANCE + 110

3693

);

3694

1

});

3695

3696

	// Send back tokens from AH to ParaA from Bob's account

3697

1

	Statemine::execute_with(|| {

3698

		// Now send those tokens to ParaA

3699

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3700

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3701

1

			assets: Wild(All),

3702

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3703

1

		}]);

3704

1

		assert_ok!(

3705

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3706

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3707

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3708

1

				Box::new((Location::parent(), 100).into()),

3709

1

				Box::new(TransferType::LocalReserve),

3710

1

				Box::new(fees_id),

3711

1

				Box::new(TransferType::LocalReserve),

3712

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3713

1

				WeightLimit::Unlimited

3714

3715

);

3716

3717

		// 100 DOTs were deducted from Bob's account

3718

1

		assert_eq!(

3719

1

			StatemineBalances::free_balance(RELAYBOB),

3720

			INITIAL_BALANCE + 10

3721

);

3722

1

});

3723

3724

1

	ParaA::execute_with(|| {

3725

		// Alice should have received 100 DOTs

3726

1

		assert_eq!(

3727

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3728

1

			Ok(U256::from(190))

3729

);

3730

1

});

3731

1

3732

3733

#[test]

3734

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiasset() {

3735

1

	MockNet::reset();

3736

3737

	// Relay asset

3738

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3739

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3740

3741

1

	let relay_asset_metadata = parachain::AssetMetadata {

3742

1

		name: b"RelayToken".to_vec(),

3743

1

		symbol: b"Relay".to_vec(),

3744

1

		decimals: 12,

3745

1

};

3746

3747

1

	let dest_para = Location::new(1, [Parachain(1)]);

3748

3749

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3750

1

		polkadot_parachain::primitives::Sibling,

3751

1

		statemine_like::AccountId,

3752

1

	>::convert_location(&dest_para)

3753

1

	.unwrap();

3754

3755

1

	ParaA::execute_with(|| {

3756

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3757

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3758

1

			.try_into()

3759

1

			.expect("v3 to latest location conversion failed");

3760

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3761

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3762

1

			source_id,

3763

1

			source_location_latest,

3764

1

			relay_asset_metadata.decimals,

3765

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3766

1

			relay_asset_metadata.name.try_into().expect("too long"),

3767

));

3768

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3769

1

});

3770

3771

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3772

1

		network: None,

3773

1

		key: PARAALICE,

3774

1

3775

1

	.into();

3776

3777

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3778

1

		network: None,

3779

1

		id: RELAYALICE.into(),

3780

1

3781

1

	.into();

3782

3783

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3784

1

	Relay::execute_with(|| {

3785

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3786

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3787

1

			Box::new(Parachain(1000).into()),

3788

1

			Box::new(

3789

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3790

1

					.clone()

3791

1

					.into()

3792

),

3793

1

			Box::new(([], 200).into()),

3794

0,

3795

1

			WeightLimit::Unlimited

3796

));

3797

1

});

3798

3799

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3800

1

	Statemine::execute_with(|| {

3801

		// Check Alice received 200 tokens on AssetHub

3802

1

		assert_eq!(

3803

1

			StatemineBalances::free_balance(RELAYALICE),

3804

			INITIAL_BALANCE + 200

3805

);

3806

3807

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3808

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3809

1

			sov,

3810

			110000000000000

3811

));

3812

3813

		// Now send those tokens to ParaA

3814

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3815

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3816

1

			assets: Wild(All),

3817

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3818

1

		}]);

3819

1

		assert_ok!(

3820

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3821

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3822

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3823

1

				Box::new((Location::parent(), 200).into()),

3824

1

				Box::new(TransferType::LocalReserve),

3825

1

				Box::new(fees_id),

3826

1

				Box::new(TransferType::LocalReserve),

3827

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3828

1

				WeightLimit::Unlimited

3829

3830

);

3831

1

});

3832

3833

1

	ParaA::execute_with(|| {

3834

		// Alice should have received the DOTs

3835

1

		assert_eq!(

3836

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3837

1

			Ok(U256::from(200))

3838

);

3839

1

});

3840

3841

1

	let dest = Location::new(

3842

1,

3843

1

3844

1

			Parachain(1000),

3845

1

			AccountId32 {

3846

1

				network: None,

3847

1

				id: RELAYBOB.into(),

3848

1

},

3849

1

],

3850

);

3851

3852

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3853

3854

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3855

1

	ParaA::execute_with(|| {

3856

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3857

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3858

1

			assets: Wild(All),

3859

1

			beneficiary: beneficiary.clone(),

3860

1

		}]);

3861

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3862

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3863

1

			Box::new(VersionedLocation::from(chain_part)),

3864

1

			Box::new(VersionedAssets::from(

3865

1

				vec![(Location::parent(), 100).into()]

3866

)),

3867

1

			Box::new(TransferType::DestinationReserve),

3868

1

			Box::new(fees_id),

3869

1

			Box::new(TransferType::DestinationReserve),

3870

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3871

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3872

));

3873

3874

1

		assert_eq!(

3875

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3876

1

			Ok(U256::from(100))

3877

);

3878

1

});

3879

3880

1

	Statemine::execute_with(|| {

3881

		// Check that Bob received the tokens back in AssetHub

3882

1

		assert_eq!(

3883

1

			StatemineBalances::free_balance(RELAYBOB),

3884

			INITIAL_BALANCE + 100

3885

);

3886

1

});

3887

3888

	// Send back tokens from AH to ParaA from Bob's account

3889

1

	Statemine::execute_with(|| {

3890

		// Now send those tokens to ParaA

3891

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3892

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3893

1

			assets: Wild(All),

3894

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3895

1

		}]);

3896

1

		assert_ok!(

3897

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3898

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3899

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3900

1

				Box::new((Location::parent(), 100).into()),

3901

1

				Box::new(TransferType::LocalReserve),

3902

1

				Box::new(fees_id),

3903

1

				Box::new(TransferType::LocalReserve),

3904

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3905

1

				WeightLimit::Unlimited

3906

3907

);

3908

3909

		// 100 DOTs were deducted from Bob's account

3910

1

		assert_eq!(StatemineBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3911

1

});

3912

3913

1

	ParaA::execute_with(|| {

3914

		// Alice should have received 100 DOTs

3915

1

		assert_eq!(

3916

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3917

1

			Ok(U256::from(200))

3918

);

3919

1

});

3920

1

3921

3922

#[test]

3923

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multicurrencies() {

3924

1

	MockNet::reset();

3925

3926

	// Relay asset

3927

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3928

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3929

3930

1

	let relay_asset_metadata = parachain::AssetMetadata {

3931

1

		name: b"RelayToken".to_vec(),

3932

1

		symbol: b"Relay".to_vec(),

3933

1

		decimals: 12,

3934

1

};

3935

3936

	// Statemine asset

3937

1

	let statemine_asset = Location::new(

3938

1,

3939

1

3940

1

			Parachain(1000u32),

3941

1

			PalletInstance(5u8),

3942

1

			GeneralIndex(10u128),

3943

1

],

3944

);

3945

1

	let statemine_location_asset: AssetType = statemine_asset

3946

1

		.clone()

3947

1

		.try_into()

3948

1

		.expect("Location convertion to AssetType should succeed");

3949

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

3950

3951

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3952

1

		name: b"USDC".to_vec(),

3953

1

		symbol: b"USDC".to_vec(),

3954

1

		decimals: 12,

3955

1

};

3956

3957

1

	let dest_para = Location::new(1, [Parachain(1)]);

3958

3959

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3960

1

		polkadot_parachain::primitives::Sibling,

3961

1

		statemine_like::AccountId,

3962

1

	>::convert_location(&dest_para)

3963

1

	.unwrap();

3964

3965

1

	ParaA::execute_with(|| {

3966

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3967

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3968

1

			.try_into()

3969

1

			.expect("v3 to latest location conversion failed");

3970

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3971

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3972

1

			source_id,

3973

1

			source_location_latest,

3974

1

			relay_asset_metadata.decimals,

3975

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3976

1

			relay_asset_metadata.name.try_into().expect("too long"),

3977

));

3978

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3979

3980

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

3981

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

3982

1

			.try_into()

3983

1

			.expect("v3 to latest location conversion failed");

3984

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

3985

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3986

1

			statemine_id,

3987

1

			statemine_location_latest,

3988

1

			asset_metadata_statemine_asset.decimals,

3989

1

			asset_metadata_statemine_asset

3990

1

				.symbol

3991

1

				.try_into()

3992

1

				.expect("too long"),

3993

1

			asset_metadata_statemine_asset

3994

1

				.name

3995

1

				.try_into()

3996

1

				.expect("too long"),

3997

));

3998

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

3999

1

});

4000

4001

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4002

1

		network: None,

4003

1

		key: PARAALICE,

4004

1

4005

1

	.into();

4006

4007

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

4008

1

		network: None,

4009

1

		id: RELAYALICE.into(),

4010

1

4011

1

	.into();

4012

4013

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4014

1

	Relay::execute_with(|| {

4015

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4016

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4017

1

			Box::new(Parachain(1000).into()),

4018

1

			Box::new(

4019

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4020

1

					.clone()

4021

1

					.into()

4022

),

4023

1

			Box::new(([], 200).into()),

4024

0,

4025

1

			WeightLimit::Unlimited

4026

));

4027

1

});

4028

4029

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4030

1

	Statemine::execute_with(|| {

4031

		// Check Alice received 200 tokens on AssetHub

4032

1

		assert_eq!(

4033

1

			StatemineBalances::free_balance(RELAYALICE),

4034

			INITIAL_BALANCE + 200

4035

);

4036

4037

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4038

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4039

1

			sov,

4040

			110000000000000

4041

));

4042

4043

1

		statemine_like::PrefixChanger::set_prefix(

4044

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4045

);

4046

4047

1

		assert_ok!(StatemineAssets::create(

4048

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4049

10,

4050

			RELAYALICE,

4051

4052

));

4053

4054

1

		assert_ok!(StatemineAssets::mint(

4055

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4056

10,

4057

			RELAYALICE,

4058

			300000000000000

4059

));

4060

4061

		// Now send relay tokens to ParaA

4062

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4063

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4064

1

			assets: Wild(All),

4065

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4066

1

		}]);

4067

1

		assert_ok!(

4068

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4069

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4070

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4071

1

				Box::new((Location::parent(), 200).into()),

4072

1

				Box::new(TransferType::LocalReserve),

4073

1

				Box::new(fees_id),

4074

1

				Box::new(TransferType::LocalReserve),

4075

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4076

1

				WeightLimit::Unlimited

4077

4078

);

4079

4080

		// Send USDC

4081

1

		let asset_location = Location::new(

4082

0,

4083

1

4084

1

				xcm::latest::prelude::PalletInstance(

4085

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

4086

1

),

4087

1

				GeneralIndex(10),

4088

1

],

4089

);

4090

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

4091

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4092

1

			assets: Wild(All),

4093

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4094

1

		}]);

4095

1

		assert_ok!(

4096

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4097

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4098

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4099

1

				Box::new((asset_location, 125).into()),

4100

1

				Box::new(TransferType::LocalReserve),

4101

1

				Box::new(fees_id),

4102

1

				Box::new(TransferType::LocalReserve),

4103

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4104

1

				WeightLimit::Unlimited

4105

4106

);

4107

1

});

4108

4109

1

	ParaA::execute_with(|| {

4110

		// Alice should have received the DOTs

4111

1

		assert_eq!(

4112

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4113

1

			Ok(U256::from(200))

4114

);

4115

4116

		// Alice has received 125 USDC

4117

1

		assert_eq!(

4118

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4119

1

			Ok(U256::from(125))

4120

);

4121

1

});

4122

4123

1

	let dest = Location::new(

4124

1,

4125

1

4126

1

			Parachain(1000),

4127

1

			AccountId32 {

4128

1

				network: None,

4129

1

				id: RELAYBOB.into(),

4130

1

},

4131

1

],

4132

);

4133

4134

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4135

4136

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4137

1

	ParaA::execute_with(|| {

4138

1

		let asset_1 = currency_to_asset(

4139

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

4140

			100,

4141

);

4142

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

4143

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4144

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4145

1

			assets: Wild(All),

4146

1

			beneficiary: beneficiary.clone(),

4147

1

		}]);

4148

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4149

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4150

1

			Box::new(VersionedLocation::from(chain_part)),

4151

1

			Box::new(VersionedAssets::from(vec![asset_1, asset_2])),

4152

1

			Box::new(TransferType::DestinationReserve),

4153

1

			Box::new(fees_id),

4154

1

			Box::new(TransferType::DestinationReserve),

4155

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4156

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4157

));

4158

4159

1

		assert_eq!(

4160

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4161

1

			Ok(U256::from(100))

4162

);

4163

1

});

4164

4165

1

	Statemine::execute_with(|| {

4166

		// Check that Bob received relay tokens back in AssetHub

4167

		// (100 - MinXcmFee)

4168

1

		assert_eq!(

4169

1

			StatemineBalances::free_balance(RELAYBOB),

4170

			INITIAL_BALANCE + 100

4171

);

4172

4173

		// Check that BOB received 100 USDC on AssetHub

4174

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4175

1

});

4176

4177

	// Send back tokens from AH to ParaA from Bob's account

4178

1

	Statemine::execute_with(|| {

4179

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4180

4181

		// Now send those tokens to ParaA

4182

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4183

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4184

1

			assets: Wild(All),

4185

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4186

1

		}]);

4187

1

		assert_ok!(

4188

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4189

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

4190

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4191

1

				Box::new((Location::parent(), 100).into()),

4192

1

				Box::new(TransferType::LocalReserve),

4193

1

				Box::new(fees_id),

4194

1

				Box::new(TransferType::LocalReserve),

4195

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4196

1

				WeightLimit::Unlimited

4197

4198

);

4199

4200

		// 100 DOTs were deducted from Bob's account

4201

1

		assert_eq!(

4202

1

			StatemineBalances::free_balance(RELAYBOB),

4203

1

			bob_previous_balance - 100

4204

);

4205

1

});

4206

4207

1

	ParaA::execute_with(|| {

4208

		// Alice should have received 100 DOTs

4209

1

		assert_eq!(

4210

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4211

1

			Ok(U256::from(200))

4212

);

4213

1

});

4214

1

4215

4216

#[test]

4217

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiassets() {

4218

1

	MockNet::reset();

4219

4220

	// Relay asset

4221

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

4222

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

4223

4224

1

	let relay_asset_metadata = parachain::AssetMetadata {

4225

1

		name: b"RelayToken".to_vec(),

4226

1

		symbol: b"Relay".to_vec(),

4227

1

		decimals: 12,

4228

1

};

4229

4230

	// Statemine asset

4231

1

	let statemine_asset = Location::new(

4232

1,

4233

1

4234

1

			Parachain(1000u32),

4235

1

			PalletInstance(5u8),

4236

1

			GeneralIndex(10u128),

4237

1

],

4238

);

4239

1

	let statemine_location_asset: AssetType = statemine_asset

4240

1

		.clone()

4241

1

		.try_into()

4242

1

		.expect("Location convertion to AssetType should succeed");

4243

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

4244

4245

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

4246

1

		name: b"USDC".to_vec(),

4247

1

		symbol: b"USDC".to_vec(),

4248

1

		decimals: 12,

4249

1

};

4250

4251

1

	let dest_para = Location::new(1, [Parachain(1)]);

4252

4253

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

4254

1

		polkadot_parachain::primitives::Sibling,

4255

1

		statemine_like::AccountId,

4256

1

	>::convert_location(&dest_para)

4257

1

	.unwrap();

4258

4259

1

	ParaA::execute_with(|| {

4260

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

4261

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

4262

1

			.try_into()

4263

1

			.expect("v3 to latest location conversion failed");

4264

1

		let source_id: parachain::AssetId = relay_location.clone().into();

4265

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4266

1

			source_id,

4267

1

			source_location_latest,

4268

1

			relay_asset_metadata.decimals,

4269

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

4270

1

			relay_asset_metadata.name.try_into().expect("too long"),

4271

));

4272

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4273

4274

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

4275

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

4276

1

			.try_into()

4277

1

			.expect("v3 to latest location conversion failed");

4278

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

4279

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4280

1

			statemine_id,

4281

1

			statemine_location_latest,

4282

1

			asset_metadata_statemine_asset.decimals,

4283

1

			asset_metadata_statemine_asset

4284

1

				.symbol

4285

1

				.try_into()

4286

1

				.expect("too long"),

4287

1

			asset_metadata_statemine_asset

4288

1

				.name

4289

1

				.try_into()

4290

1

				.expect("too long"),

4291

));

4292

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

4293

1

});

4294

4295

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4296

1

		network: None,

4297

1

		key: PARAALICE,

4298

1

4299

1

	.into();

4300

4301

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

4302

1

		network: None,

4303

1

		id: RELAYALICE.into(),

4304

1

4305

1

	.into();

4306

4307

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4308

1

	Relay::execute_with(|| {

4309

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4310

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4311

1

			Box::new(Parachain(1000).into()),

4312

1

			Box::new(

4313

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4314

1

					.clone()

4315

1

					.into()

4316

),

4317

1

			Box::new(([], 200).into()),

4318

0,

4319

1

			WeightLimit::Unlimited

4320

));

4321

1

});

4322

4323

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4324

1

	Statemine::execute_with(|| {

4325

		// Check Alice received 200 tokens on AssetHub

4326

1

		assert_eq!(

4327

1

			StatemineBalances::free_balance(RELAYALICE),

4328

			INITIAL_BALANCE + 200

4329

);

4330

4331

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4332

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4333

1

			sov,

4334

			110000000000000

4335

));

4336

4337

1

		statemine_like::PrefixChanger::set_prefix(

4338

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4339

);

4340

4341

1

		assert_ok!(StatemineAssets::create(

4342

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4343

10,

4344

			RELAYALICE,

4345

4346

));

4347

4348

1

		assert_ok!(StatemineAssets::mint(

4349

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4350

10,

4351

			RELAYALICE,

4352

			300000000000000

4353

));

4354

4355

		// Now send relay tokens to ParaA

4356

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4357

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4358

1

			assets: Wild(All),

4359

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4360

1

		}]);

4361

1

		assert_ok!(

4362

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4363

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4364

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4365

1

				Box::new((Location::parent(), 200).into()),

4366

1

				Box::new(TransferType::LocalReserve),

4367

1

				Box::new(fees_id),

4368

1

				Box::new(TransferType::LocalReserve),

4369

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4370

1

				WeightLimit::Unlimited

4371

4372

);

4373

4374

		// Send USDC

4375

1

		let asset_location = Location::new(

4376

0,

4377

1

4378

1

				xcm::latest::prelude::PalletInstance(

4379

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

4380

1

),

4381

1

				GeneralIndex(10),

4382

1

],

4383

);

4384

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

4385

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4386

1

			assets: Wild(All),

4387

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4388

1

		}]);

4389

1

		assert_ok!(

4390

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4391

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4392

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4393

1

				Box::new((asset_location, 125).into()),

4394

1

				Box::new(TransferType::LocalReserve),

4395

1

				Box::new(fees_id),

4396

1

				Box::new(TransferType::LocalReserve),

4397

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4398

1

				WeightLimit::Unlimited

4399

4400

);

4401

1

});

4402

4403

1

	ParaA::execute_with(|| {

4404

		// Alice should have received the DOTs

4405

1

		assert_eq!(

4406

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4407

1

			Ok(U256::from(200))

4408

);

4409

4410

		// Alice has received 125 USDC

4411

1

		assert_eq!(

4412

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4413

1

			Ok(U256::from(125))

4414

);

4415

1

});

4416

4417

1

	let dest = Location::new(

4418

1,

4419

1

4420

1

			Parachain(1000),

4421

1

			AccountId32 {

4422

1

				network: None,

4423

1

				id: RELAYBOB.into(),

4424

1

},

4425

1

],

4426

);

4427

4428

1

	let statemine_asset_to_send = Asset {

4429

1

		id: AssetId(statemine_asset),

4430

1

		fun: Fungibility::Fungible(100),

4431

1

};

4432

4433

1

	let relay_asset_to_send = Asset {

4434

1

		id: AssetId(Location::parent()),

4435

1

		fun: Fungibility::Fungible(100),

4436

1

};

4437

4438

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4439

1

	let assets_to_send: XcmAssets =

4440

1

		XcmAssets::from(vec![statemine_asset_to_send, relay_asset_to_send.clone()]);

4441

	// For some reason the order of the assets is inverted when creating the array above.

4442

	// We need to use relay asset for fees, so we pick index 0.

4443

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4444

4445

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4446

1

	ParaA::execute_with(|| {

4447

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4448

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4449

1

			assets: Wild(All),

4450

1

			beneficiary: beneficiary.clone(),

4451

1

		}]);

4452

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4453

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4454

1

			Box::new(VersionedLocation::from(chain_part)),

4455

1

			Box::new(VersionedAssets::from(assets_to_send)),

4456

1

			Box::new(TransferType::DestinationReserve),

4457

1

			Box::new(fees_id),

4458

1

			Box::new(TransferType::DestinationReserve),

4459

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4460

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4461

));

4462

4463

1

		assert_eq!(

4464

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4465

1

			Ok(U256::from(100))

4466

);

4467

1

});

4468

4469

1

	Statemine::execute_with(|| {

4470

		// Check that Bob received relay tokens back in AssetHub

4471

		// (100 - MinXcmFee)

4472

1

		assert_eq!(

4473

1

			StatemineBalances::free_balance(RELAYBOB),

4474

			INITIAL_BALANCE + 100

4475

);

4476

4477

		// Check that BOB received 100 USDC on AssetHub

4478

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4479

1

});

4480

4481

	// Send back tokens from AH to ParaA from Bob's account

4482

1

	Statemine::execute_with(|| {

4483

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4484

4485

		// Now send those tokens to ParaA

4486

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4487

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4488

1

			assets: Wild(All),

4489

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4490

1

		}]);

4491

1

		assert_ok!(

4492

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4493

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

4494

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4495

1

				Box::new((Location::parent(), 100).into()),

4496

1

				Box::new(TransferType::LocalReserve),

4497

1

				Box::new(fees_id),

4498

1

				Box::new(TransferType::LocalReserve),

4499

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4500

1

				WeightLimit::Unlimited

4501

4502

);

4503

4504

		// 100 DOTs were deducted from Bob's account

4505

1

		assert_eq!(

4506

1

			StatemineBalances::free_balance(RELAYBOB),

4507

1

			bob_previous_balance - 100

4508

);

4509

1

});

4510

4511

1

	ParaA::execute_with(|| {

4512

		// Alice should have received 100 DOTs

4513

1

		assert_eq!(

4514

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4515

1

			Ok(U256::from(200))

4516

);

4517

1

});

4518

1

4519

4520

#[test]

4521

1

fn transact_through_signed_multilocation() {

4522

1

	MockNet::reset();

4523

1

	let mut ancestry = Location::parent();

4524

4525

1

	ParaA::execute_with(|| {

4526

		// Root can set transact info

4527

1

		assert_ok!(XcmTransactor::set_transact_info(

4528

1

			parachain::RuntimeOrigin::root(),

4529

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4530

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4531

1

			3000.into(),

4532

1

			20000000000.into(),

4533

			// 4 instructions in transact through signed

4534

1

			Some(4000.into())

4535

));

4536

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4537

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

4538

1

			.expect("must succeed");

4539

1

		ancestry = parachain::UniversalLocation::get().into();

4540

1

});

4541

4542

	// Let's construct the Junction that we will append with DescendOrigin

4543

1

	let signed_origin: Junctions = [AccountKey20 {

4544

1

		network: None,

4545

1

		key: PARAALICE,

4546

1

}]

4547

1

	.into();

4548

4549

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4550

1

	descend_origin_multilocation

4551

1

		.append_with(signed_origin)

4552

1

		.unwrap();

4553

4554

	// To convert it to what the relay will see instead of us

4555

1

	descend_origin_multilocation

4556

1

		.reanchor(&Location::parent(), &ancestry.interior)

4557

1

		.unwrap();

4558

4559

1

	let derived = xcm_builder::Account32Hash::<

4560

1

		relay_chain::KusamaNetwork,

4561

1

		relay_chain::AccountId,

4562

1

	>::convert_location(&descend_origin_multilocation)

4563

1

	.unwrap();

4564

4565

1

	Relay::execute_with(|| {

4566

		// free execution, full amount received

4567

1

		assert_ok!(RelayBalances::transfer_allow_death(

4568

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4569

1

			derived.clone(),

4570

			4000004100u128,

4571

));

4572

		// derived account has all funds

4573

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4574

		// sovereign account has 0 funds

4575

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4576

1

});

4577

4578

	// Encode the call. Balances transact to para_a_account

4579

	// First index

4580

1

	let mut encoded: Vec<u8> = Vec::new();

4581

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4582

1

		relay_chain::Balances,

4583

1

>()

4584

1

	.unwrap() as u8;

4585

4586

1

	encoded.push(index);

4587

4588

	// Then call bytes

4589

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4590

1

		// 100 to sovereign

4591

1

		dest: para_a_account(),

4592

1

		value: 100u32.into(),

4593

1

4594

1

	.encode();

4595

1

	encoded.append(&mut call_bytes);

4596

4597

1

	ParaA::execute_with(|| {

4598

1

		assert_ok!(XcmTransactor::transact_through_signed(

4599

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4600

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4601

1

			CurrencyPayment {

4602

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4603

1

					Location::parent()

4604

1

				))),

4605

1

				fee_amount: None

4606

1

},

4607

1

			encoded,

4608

			// 4000000000 for transfer + 4000 for XCM

4609

			// 1-1 to fee

4610

1

			TransactWeights {

4611

1

				transact_required_weight_at_most: 4000000000.into(),

4612

1

				overall_weight: None

4613

1

},

4614

			false

4615

));

4616

1

});

4617

4618

1

	Relay::execute_with(|| {

4619

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4620

4621

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4622

1

});

4623

1

4624

4625

#[test]

4626

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4627

1

	MockNet::reset();

4628

1

	let mut ancestry = Location::parent();

4629

4630

1

	ParaA::execute_with(|| {

4631

1

		ancestry = parachain::UniversalLocation::get().into();

4632

1

});

4633

4634

	// Let's construct the Junction that we will append with DescendOrigin

4635

1

	let signed_origin: Junctions = [AccountKey20 {

4636

1

		network: None,

4637

1

		key: PARAALICE,

4638

1

}]

4639

1

	.into();

4640

4641

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4642

1

	descend_origin_multilocation

4643

1

		.append_with(signed_origin)

4644

1

		.unwrap();

4645

4646

	// To convert it to what the relay will see instead of us

4647

1

	descend_origin_multilocation

4648

1

		.reanchor(&Location::parent(), &ancestry.interior)

4649

1

		.unwrap();

4650

4651

1

	let derived = xcm_builder::Account32Hash::<

4652

1

		relay_chain::KusamaNetwork,

4653

1

		relay_chain::AccountId,

4654

1

	>::convert_location(&descend_origin_multilocation)

4655

1

	.unwrap();

4656

4657

1

	Relay::execute_with(|| {

4658

		// free execution, full amount received

4659

1

		assert_ok!(RelayBalances::transfer_allow_death(

4660

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4661

1

			derived.clone(),

4662

			4000004100u128,

4663

));

4664

		// derived account has all funds

4665

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4666

		// sovereign account has 0 funds

4667

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4668

1

});

4669

4670

	// Encode the call. Balances transact to para_a_account

4671

	// First index

4672

1

	let mut encoded: Vec<u8> = Vec::new();

4673

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4674

1

		relay_chain::Balances,

4675

1

>()

4676

1

	.unwrap() as u8;

4677

4678

1

	encoded.push(index);

4679

4680

	// Then call bytes

4681

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4682

1

		// 100 to sovereign

4683

1

		dest: para_a_account(),

4684

1

		value: 100u32.into(),

4685

1

4686

1

	.encode();

4687

1

	encoded.append(&mut call_bytes);

4688

4689

1

	let total_weight = 4000004000u64;

4690

1

	ParaA::execute_with(|| {

4691

1

		assert_ok!(XcmTransactor::transact_through_signed(

4692

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4693

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4694

1

			CurrencyPayment {

4695

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4696

1

					Location::parent()

4697

1

				))),

4698

1

				fee_amount: Some(total_weight as u128)

4699

1

},

4700

1

			encoded,

4701

			// 4000000000 for transfer + 4000 for XCM

4702

1

			TransactWeights {

4703

1

				transact_required_weight_at_most: 4000000000.into(),

4704

1

				overall_weight: Some(Limited(total_weight.into()))

4705

1

},

4706

			false

4707

));

4708

1

});

4709

4710

1

	Relay::execute_with(|| {

4711

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4712

4713

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4714

1

});

4715

1

4716

4717

#[test]

4718

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4719

1

	MockNet::reset();

4720

1

	let mut ancestry = Location::parent();

4721

4722

1

	ParaA::execute_with(|| {

4723

1

		ancestry = parachain::UniversalLocation::get().into();

4724

1

});

4725

4726

	// Let's construct the Junction that we will append with DescendOrigin

4727

1

	let signed_origin: Junctions = [AccountKey20 {

4728

1

		network: None,

4729

1

		key: PARAALICE,

4730

1

}]

4731

1

	.into();

4732

4733

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4734

1

	descend_origin_multilocation

4735

1

		.append_with(signed_origin)

4736

1

		.unwrap();

4737

4738

	// To convert it to what the relay will see instead of us

4739

1

	descend_origin_multilocation

4740

1

		.reanchor(&Location::parent(), &ancestry.interior)

4741

1

		.unwrap();

4742

4743

1

	let derived = xcm_builder::Account32Hash::<

4744

1

		relay_chain::KusamaNetwork,

4745

1

		relay_chain::AccountId,

4746

1

	>::convert_location(&descend_origin_multilocation)

4747

1

	.unwrap();

4748

4749

1

	Relay::execute_with(|| {

4750

		// free execution, full amount received

4751

1

		assert_ok!(RelayBalances::transfer_allow_death(

4752

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4753

1

			derived.clone(),

4754

			4000009100u128,

4755

));

4756

		// derived account has all funds

4757

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4758

		// sovereign account has 0 funds

4759

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4760

1

});

4761

4762

	// Encode the call. Balances transact to para_a_account

4763

	// First index

4764

1

	let mut encoded: Vec<u8> = Vec::new();

4765

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4766

1

		relay_chain::Balances,

4767

1

>()

4768

1

	.unwrap() as u8;

4769

4770

1

	encoded.push(index);

4771

4772

	// Then call bytes

4773

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4774

1

		// 100 to sovereign

4775

1

		dest: para_a_account(),

4776

1

		value: 100u32.into(),

4777

1

4778

1

	.encode();

4779

1

	encoded.append(&mut call_bytes);

4780

4781

1

	let total_weight = 4000009000u64;

4782

1

	ParaA::execute_with(|| {

4783

1

		assert_ok!(XcmTransactor::transact_through_signed(

4784

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4785

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4786

1

			CurrencyPayment {

4787

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4788

1

					Location::parent()

4789

1

				))),

4790

1

				fee_amount: Some(total_weight as u128)

4791

1

},

4792

1

			encoded,

4793

			// 4000000000 for transfer + 9000 for XCM

4794

1

			TransactWeights {

4795

1

				transact_required_weight_at_most: 4000000000.into(),

4796

1

				overall_weight: Some(Limited(total_weight.into()))

4797

1

},

4798

			true

4799

));

4800

1

});

4801

4802

1

	Relay::execute_with(|| {

4803

		// 100 transferred

4804

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4805

4806

		// 4000009000 refunded

4807

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4808

1

});

4809

1

4810

4811

#[test]

4812

1

fn transact_through_signed_multilocation_para_to_para() {

4813

1

	MockNet::reset();

4814

1

	let mut ancestry = Location::parent();

4815

4816

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4817

4818

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4819

4820

1

	ParaA::execute_with(|| {

4821

		// Root can set transact info

4822

1

		assert_ok!(XcmTransactor::set_transact_info(

4823

1

			parachain::RuntimeOrigin::root(),

4824

			// ParaB

4825

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4826

			// Para charges 1000 for every instruction, and we have 3, so 3

4827

1

			3.into(),

4828

1

			20000000000.into(),

4829

			// 4 instructions in transact through signed

4830

1

			Some(4.into())

4831

));

4832

		// Root can set transact info

4833

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4834

1

		set_fee_per_second_for_location(

4835

1

			para_b_balances.clone(),

4836

1

			parachain::ParaTokensPerSecond::get(),

4837

4838

1

		.expect("must succeed");

4839

1

		ancestry = parachain::UniversalLocation::get().into();

4840

1

});

4841

4842

	// Let's construct the Junction that we will append with DescendOrigin

4843

1

	let signed_origin: Junctions = [AccountKey20 {

4844

1

		network: None,

4845

1

		key: PARAALICE,

4846

1

}]

4847

1

	.into();

4848

4849

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4850

1

	descend_origin_location.append_with(signed_origin).unwrap();

4851

4852

	// To convert it to what the paraB will see instead of us

4853

1

	descend_origin_location

4854

1

		.reanchor(&para_b_location, &ancestry.interior)

4855

1

		.unwrap();

4856

4857

1

	let derived = xcm_builder::HashedDescription::<

4858

1

		parachain::AccountId,

4859

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4860

1

	>::convert_location(&descend_origin_location)

4861

1

	.unwrap();

4862

4863

1

	ParaB::execute_with(|| {

4864

		// free execution, full amount received

4865

1

		assert_ok!(ParaBalances::transfer_allow_death(

4866

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4867

1

			derived.clone(),

4868

			4000000104u128,

4869

));

4870

		// derived account has all funds

4871

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4872

		// sovereign account has 0 funds

4873

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4874

1

});

4875

4876

	// Encode the call. Balances transact to para_a_account

4877

	// First index

4878

1

	let mut encoded: Vec<u8> = Vec::new();

4879

1

	let index =

4880

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4881

1

			.unwrap() as u8;

4882

4883

1

	encoded.push(index);

4884

4885

	// Then call bytes

4886

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4887

1

		// 100 to sovereign

4888

1

		dest: para_a_account_20(),

4889

1

		value: 100u32.into(),

4890

1

4891

1

	.encode();

4892

1

	encoded.append(&mut call_bytes);

4893

4894

1

	ParaA::execute_with(|| {

4895

1

		assert_ok!(XcmTransactor::transact_through_signed(

4896

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4897

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4898

1

			CurrencyPayment {

4899

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4900

1

					para_b_balances

4901

1

				))),

4902

1

				fee_amount: None

4903

1

},

4904

1

			encoded,

4905

			// 4000000000 for transfer + 4000 for XCM

4906

			// 1-1 to fee

4907

1

			TransactWeights {

4908

1

				transact_required_weight_at_most: 4000000000.into(),

4909

1

				overall_weight: None

4910

1

},

4911

			false

4912

));

4913

1

});

4914

4915

1

	ParaB::execute_with(|| {

4916

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4917

4918

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4919

1

});

4920

1

4921

4922

#[test]

4923

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4924

1

	MockNet::reset();

4925

1

	let mut ancestry = Location::parent();

4926

4927

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4928

4929

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4930

4931

1

	ParaA::execute_with(|| {

4932

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4933

1

		set_fee_per_second_for_location(

4934

1

			para_b_balances.clone(),

4935

1

			parachain::ParaTokensPerSecond::get(),

4936

4937

1

		.expect("must succeed");

4938

1

		ancestry = parachain::UniversalLocation::get().into();

4939

1

});

4940

4941

	// Let's construct the Junction that we will append with DescendOrigin

4942

1

	let signed_origin: Junctions = [AccountKey20 {

4943

1

		network: None,

4944

1

		key: PARAALICE,

4945

1

}]

4946

1

	.into();

4947

4948

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4949

1

	descend_origin_location.append_with(signed_origin).unwrap();

4950

4951

	// To convert it to what the paraB will see instead of us

4952

1

	descend_origin_location

4953

1

		.reanchor(&para_b_location, &ancestry.interior)

4954

1

		.unwrap();

4955

4956

1

	let derived = xcm_builder::HashedDescription::<

4957

1

		parachain::AccountId,

4958

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4959

1

	>::convert_location(&descend_origin_location)

4960

1

	.unwrap();

4961

4962

1

	ParaB::execute_with(|| {

4963

		// free execution, full amount received

4964

1

		assert_ok!(ParaBalances::transfer_allow_death(

4965

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4966

1

			derived.clone(),

4967

			4000009100u128,

4968

));

4969

		// derived account has all funds

4970

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4971

		// sovereign account has 0 funds

4972

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4973

1

});

4974

4975

	// Encode the call. Balances transact to para_a_account

4976

	// First index

4977

1

	let mut encoded: Vec<u8> = Vec::new();

4978

1

	let index =

4979

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4980

1

			.unwrap() as u8;

4981

4982

1

	encoded.push(index);

4983

4984

	// Then call bytes

4985

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4986

1

		// 100 to sovereign

4987

1

		dest: para_a_account_20(),

4988

1

		value: 100u32.into(),

4989

1

4990

1

	.encode();

4991

1

	encoded.append(&mut call_bytes);

4992

4993

1

	let overall_weight = 4000009000u64;

4994

1

	ParaA::execute_with(|| {

4995

1

		assert_ok!(XcmTransactor::transact_through_signed(

4996

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4997

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4998

1

			CurrencyPayment {

4999

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5000

1

					para_b_balances

5001

1

				))),

5002

1

				fee_amount: Some(overall_weight as u128)

5003

1

},

5004

1

			encoded,

5005

			// 4000000000 for transfer + 9000 for XCM

5006

1

			TransactWeights {

5007

1

				transact_required_weight_at_most: 4000000000.into(),

5008

1

				overall_weight: Some(Limited(overall_weight.into()))

5009

1

},

5010

			true

5011

));

5012

1

});

5013

5014

1

	ParaB::execute_with(|| {

5015

		// Check the derived account was refunded

5016

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

5017

5018

		// Check the transfer was executed

5019

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

5020

1

});

5021

1

5022

5023

#[test]

5024

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

5025

1

	MockNet::reset();

5026

1

	let mut ancestry = Location::parent();

5027

5028

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5029

5030

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5031

5032

1

	ParaA::execute_with(|| {

5033

		// Root can set transact info

5034

1

		assert_ok!(XcmTransactor::set_transact_info(

5035

1

			parachain::RuntimeOrigin::root(),

5036

			// ParaB

5037

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5038

			// Para charges 1000 for every instruction, and we have 3, so 3

5039

1

			3.into(),

5040

1

			20000000000.into(),

5041

			// 4 instructions in transact through signed

5042

1

			Some(4.into())

5043

));

5044

		// Root can set transact info

5045

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5046

1

		set_fee_per_second_for_location(

5047

1

			para_b_balances.clone(),

5048

1

			parachain::ParaTokensPerSecond::get(),

5049

5050

1

		.expect("must succeed");

5051

1

		ancestry = parachain::UniversalLocation::get().into();

5052

1

});

5053

5054

	// Let's construct the Junction that we will append with DescendOrigin

5055

1

	let signed_origin: Junctions = [AccountKey20 {

5056

1

		network: None,

5057

1

		key: PARAALICE,

5058

1

}]

5059

1

	.into();

5060

5061

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5062

1

	descend_origin_location.append_with(signed_origin).unwrap();

5063

5064

	// To convert it to what the paraB will see instead of us

5065

1

	descend_origin_location

5066

1

		.reanchor(&para_b_location, &ancestry.interior)

5067

1

		.unwrap();

5068

5069

1

	let derived = xcm_builder::HashedDescription::<

5070

1

		parachain::AccountId,

5071

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5072

1

	>::convert_location(&descend_origin_location)

5073

1

	.unwrap();

5074

5075

1

	let mut parachain_b_alice_balances_before = 0;

5076

1

	ParaB::execute_with(|| {

5077

1

		assert_ok!(ParaBalances::transfer_allow_death(

5078

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5079

1

			derived.clone(),

5080

			4000000104u128,

5081

));

5082

		// derived account has all funds

5083

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5084

		// sovereign account has 0 funds

5085

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5086

5087

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5088

1

});

5089

5090

	// Encode the call. Balances transact to para_a_account

5091

	// First index

5092

1

	let mut encoded: Vec<u8> = Vec::new();

5093

1

	let index =

5094

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5095

1

			.unwrap() as u8;

5096

5097

1

	encoded.push(index);

5098

5099

	use sp_core::U256;

5100

	// Let's do a EVM transfer

5101

1

	let eth_tx =

5102

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5103

1

			gas_limit: U256::from(21000),

5104

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5105

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5106

1

			value: U256::from(100),

5107

1

			input: BoundedVec::<

5108

1

u8,

5109

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5110

1

			>::try_from(vec![]).unwrap(),

5111

1

			access_list: None,

5112

1

});

5113

5114

	// Then call bytes

5115

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

5116

1

		xcm_transaction: eth_tx,

5117

1

5118

1

	.encode();

5119

1

	encoded.append(&mut call_bytes);

5120

5121

1

	ParaA::execute_with(|| {

5122

1

		assert_ok!(XcmTransactor::transact_through_signed(

5123

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5124

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5125

1

			CurrencyPayment {

5126

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5127

1

					para_b_balances

5128

1

				))),

5129

1

				fee_amount: None

5130

1

},

5131

1

			encoded,

5132

			// 4000000000 for transfer + 4000 for XCM

5133

			// 1-1 to fee

5134

1

			TransactWeights {

5135

1

				transact_required_weight_at_most: 4000000000.into(),

5136

1

				overall_weight: None

5137

1

},

5138

			false

5139

));

5140

1

});

5141

5142

1

	ParaB::execute_with(|| {

5143

		// Make sure the EVM transfer went through

5144

1

		assert!(

5145

1

			ParaBalances::free_balance(&PARAALICE.into())

5146

1

				== parachain_b_alice_balances_before + 100

5147

);

5148

1

});

5149

1

5150

5151

#[test]

5152

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

5153

1

	MockNet::reset();

5154

1

	let mut ancestry = Location::parent();

5155

5156

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5157

5158

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5159

5160

1

	ParaA::execute_with(|| {

5161

		// Root can set transact info

5162

1

		assert_ok!(XcmTransactor::set_transact_info(

5163

1

			parachain::RuntimeOrigin::root(),

5164

			// ParaB

5165

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5166

			// Para charges 1000 for every instruction, and we have 3, so 3

5167

1

			3.into(),

5168

1

			20000000000.into(),

5169

			// 4 instructions in transact through signed

5170

1

			Some(4.into())

5171

));

5172

		// Root can set transact info

5173

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5174

1

		set_fee_per_second_for_location(

5175

1

			para_b_balances.clone(),

5176

1

			parachain::ParaTokensPerSecond::get(),

5177

5178

1

		.expect("must succeed");

5179

1

		ancestry = parachain::UniversalLocation::get().into();

5180

1

});

5181

5182

	// Let's construct the Junction that we will append with DescendOrigin

5183

1

	let signed_origin: Junctions = [AccountKey20 {

5184

1

		network: None,

5185

1

		key: PARAALICE,

5186

1

}]

5187

1

	.into();

5188

5189

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5190

1

	descend_origin_location.append_with(signed_origin).unwrap();

5191

5192

	// To convert it to what the paraB will see instead of us

5193

1

	descend_origin_location

5194

1

		.reanchor(&para_b_location, &ancestry.interior)

5195

1

		.unwrap();

5196

5197

1

	let derived = xcm_builder::HashedDescription::<

5198

1

		parachain::AccountId,

5199

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5200

1

	>::convert_location(&descend_origin_location)

5201

1

	.unwrap();

5202

5203

1

	let mut parachain_b_alice_balances_before = 0;

5204

1

	ParaB::execute_with(|| {

5205

1

		assert_ok!(ParaBalances::transfer_allow_death(

5206

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5207

1

			derived.clone(),

5208

			4000000104u128,

5209

));

5210

		// derived account has all funds

5211

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5212

		// sovereign account has 0 funds

5213

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5214

5215

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5216

1

});

5217

5218

	// Encode the call. Balances transact to para_a_account

5219

	// First index

5220

1

	let mut encoded: Vec<u8> = Vec::new();

5221

1

	let index =

5222

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5223

1

			.unwrap() as u8;

5224

5225

1

	encoded.push(index);

5226

5227

	use sp_core::U256;

5228

	// Let's do a EVM transfer

5229

1

	let eth_tx =

5230

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5231

1

			gas_limit: U256::from(21000),

5232

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5233

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5234

1

			value: U256::from(100),

5235

1

			input: BoundedVec::<

5236

1

u8,

5237

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5238

1

			>::try_from(vec![]).unwrap(),

5239

1

			access_list: None,

5240

1

});

5241

5242

	// Then call bytes

5243

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5244

1

		transact_as: PARAALICE.into(),

5245

1

		xcm_transaction: eth_tx,

5246

1

5247

1

	.encode();

5248

1

	encoded.append(&mut call_bytes);

5249

5250

1

	ParaA::execute_with(|| {

5251

1

		assert_ok!(XcmTransactor::transact_through_signed(

5252

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5253

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5254

1

			CurrencyPayment {

5255

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5256

1

					para_b_balances

5257

1

				))),

5258

1

				fee_amount: None

5259

1

},

5260

1

			encoded,

5261

1

			TransactWeights {

5262

1

				transact_required_weight_at_most: 4000000000.into(),

5263

1

				overall_weight: None

5264

1

},

5265

			false

5266

));

5267

1

});

5268

5269

1

	ParaB::execute_with(|| {

5270

		// Make sure the EVM transfer wasn't executed

5271

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

5272

1

});

5273

1

5274

5275

#[test]

5276

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

5277

1

	MockNet::reset();

5278

1

	let mut ancestry = Location::parent();

5279

5280

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5281

5282

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5283

5284

1

	ParaA::execute_with(|| {

5285

		// Root can set transact info

5286

1

		assert_ok!(XcmTransactor::set_transact_info(

5287

1

			parachain::RuntimeOrigin::root(),

5288

			// ParaB

5289

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5290

			// Para charges 1000 for every instruction, and we have 3, so 3

5291

1

			3.into(),

5292

1

			20000000000.into(),

5293

			// 4 instructions in transact through signed

5294

1

			Some(4.into())

5295

));

5296

		// Root can set transact info

5297

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5298

1

		set_fee_per_second_for_location(

5299

1

			para_b_balances.clone(),

5300

1

			parachain::ParaTokensPerSecond::get(),

5301

5302

1

		.expect("must succeed");

5303

1

		ancestry = parachain::UniversalLocation::get().into();

5304

1

});

5305

5306

	// Let's construct the Junction that we will append with DescendOrigin

5307

1

	let signed_origin: Junctions = [AccountKey20 {

5308

1

		network: None,

5309

1

		key: PARAALICE,

5310

1

}]

5311

1

	.into();

5312

5313

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5314

1

	descend_origin_location.append_with(signed_origin).unwrap();

5315

5316

	// To convert it to what the paraB will see instead of us

5317

1

	descend_origin_location

5318

1

		.reanchor(&para_b_location, &ancestry.interior)

5319

1

		.unwrap();

5320

5321

1

	let derived = xcm_builder::HashedDescription::<

5322

1

		parachain::AccountId,

5323

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5324

1

	>::convert_location(&descend_origin_location)

5325

1

	.unwrap();

5326

5327

1

	let transfer_recipient = evm_account();

5328

1

	let mut transfer_recipient_balance_before = 0;

5329

1

	ParaB::execute_with(|| {

5330

1

		assert_ok!(ParaBalances::transfer_allow_death(

5331

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5332

1

			derived.clone(),

5333

			4000000104u128,

5334

));

5335

		// derived account has all funds

5336

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5337

		// sovereign account has 0 funds

5338

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5339

5340

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5341

5342

		// Add proxy ALICE  -> derived

5343

1

		let _ = parachain::Proxy::add_proxy_delegate(

5344

1

			&PARAALICE.into(),

5345

1

			derived,

5346

1

			parachain::ProxyType::Any,

5347

1

0,

5348

1

);

5349

1

});

5350

5351

	// Encode the call. Balances transact to para_a_account

5352

	// First index

5353

1

	let mut encoded: Vec<u8> = Vec::new();

5354

1

	let index =

5355

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5356

1

			.unwrap() as u8;

5357

5358

1

	encoded.push(index);

5359

5360

	use sp_core::U256;

5361

	// Let's do a EVM transfer

5362

1

	let eth_tx =

5363

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5364

1

			gas_limit: U256::from(21000),

5365

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5366

1

			value: U256::from(100),

5367

1

			input: BoundedVec::<

5368

1

u8,

5369

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5370

1

			>::try_from(vec![]).unwrap(),

5371

1

			access_list: None,

5372

1

});

5373

5374

	// Then call bytes

5375

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5376

1

		transact_as: PARAALICE.into(),

5377

1

		xcm_transaction: eth_tx,

5378

1

5379

1

	.encode();

5380

1

	encoded.append(&mut call_bytes);

5381

5382

1

	ParaA::execute_with(|| {

5383

1

		assert_ok!(XcmTransactor::transact_through_signed(

5384

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5385

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5386

1

			CurrencyPayment {

5387

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5388

1

					para_b_balances

5389

1

				))),

5390

1

				fee_amount: None

5391

1

},

5392

1

			encoded,

5393

1

			TransactWeights {

5394

1

				transact_required_weight_at_most: 4000000000.into(),

5395

1

				overall_weight: None

5396

1

},

5397

			false

5398

));

5399

1

});

5400

5401

1

	ParaB::execute_with(|| {

5402

		// Make sure the EVM transfer was executed

5403

1

		assert!(

5404

1

			ParaBalances::free_balance(&transfer_recipient.into())

5405

1

				== transfer_recipient_balance_before + 100

5406

);

5407

1

});

5408

1

5409

5410

#[test]

5411

1

fn hrmp_init_accept_through_root() {

5412

1

	MockNet::reset();

5413

5414

1

	Relay::execute_with(|| {

5415

1

		assert_ok!(RelayBalances::transfer_allow_death(

5416

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5417

1

			para_a_account(),

5418

			1000u128

5419

));

5420

1

		assert_ok!(RelayBalances::transfer_allow_death(

5421

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5422

1

			para_b_account(),

5423

			1000u128

5424

));

5425

1

});

5426

5427

1

	ParaA::execute_with(|| {

5428

1

		let total_fee = 1_000u128;

5429

1

		let total_weight: u64 = 1_000_000_000;

5430

1

		let tx_weight: u64 = 500_000_000;

5431

		// Root can send hrmp init channel

5432

1

		assert_ok!(XcmTransactor::hrmp_manage(

5433

1

			parachain::RuntimeOrigin::root(),

5434

1

			HrmpOperation::InitOpen(HrmpInitParams {

5435

1

				para_id: 2u32.into(),

5436

1

				proposed_max_capacity: 1,

5437

1

				proposed_max_message_size: 1

5438

1

}),

5439

1

			CurrencyPayment {

5440

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5441

1

					Location::parent()

5442

1

				))),

5443

1

				fee_amount: Some(total_fee)

5444

1

},

5445

1

			TransactWeights {

5446

1

				transact_required_weight_at_most: tx_weight.into(),

5447

1

				overall_weight: Some(Limited(total_weight.into()))

5448

1

5449

));

5450

1

});

5451

1

	Relay::execute_with(|| {

5452

1

		let expected_event: relay_chain::RuntimeEvent =

5453

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5454

1

				sender: 1u32.into(),

5455

1

				recipient: 2u32.into(),

5456

1

				proposed_max_capacity: 1u32,

5457

1

				proposed_max_message_size: 1u32,

5458

1

5459

1

			.into();

5460

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5461

1

});

5462

1

	ParaB::execute_with(|| {

5463

1

		let total_fee = 1_000u128;

5464

1

		let total_weight: u64 = 1_000_000_000;

5465

1

		let tx_weight: u64 = 500_000_000;

5466

		// Root can send hrmp accept channel

5467

1

		assert_ok!(XcmTransactor::hrmp_manage(

5468

1

			parachain::RuntimeOrigin::root(),

5469

1

			HrmpOperation::Accept {

5470

1

				para_id: 1u32.into()

5471

1

},

5472

1

			CurrencyPayment {

5473

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5474

1

					Location::parent()

5475

1

				))),

5476

1

				fee_amount: Some(total_fee)

5477

1

},

5478

1

			TransactWeights {

5479

1

				transact_required_weight_at_most: tx_weight.into(),

5480

1

				overall_weight: Some(Limited(total_weight.into()))

5481

1

5482

));

5483

1

});

5484

5485

1

	Relay::execute_with(|| {

5486

1

		let expected_event: relay_chain::RuntimeEvent =

5487

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5488

1

				sender: 1u32.into(),

5489

1

				recipient: 2u32.into(),

5490

1

5491

1

			.into();

5492

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5493

1

});

5494

1

5495

5496

#[test]

5497

1

fn hrmp_close_works() {

5498

1

	MockNet::reset();

5499

5500

1

	Relay::execute_with(|| {

5501

1

		assert_ok!(RelayBalances::transfer_allow_death(

5502

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5503

1

			para_a_account(),

5504

			1000u128

5505

));

5506

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5507

1

			relay_chain::RuntimeOrigin::root(),

5508

1

			1u32.into(),

5509

1

			2u32.into(),

5510

			1u32,

5511

			1u32

5512

));

5513

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5514

1

			relay_chain::RuntimeOrigin::root(),

5515

			1u32

5516

));

5517

1

});

5518

5519

1

	ParaA::execute_with(|| {

5520

1

		let total_fee = 1_000u128;

5521

1

		let total_weight: u64 = 1_000_000_000;

5522

1

		let tx_weight: u64 = 500_000_000;

5523

		// Root can send hrmp close

5524

1

		assert_ok!(XcmTransactor::hrmp_manage(

5525

1

			parachain::RuntimeOrigin::root(),

5526

1

			HrmpOperation::Close(HrmpChannelId {

5527

1

				sender: 1u32.into(),

5528

1

				recipient: 2u32.into()

5529

1

}),

5530

1

			CurrencyPayment {

5531

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5532

1

					Location::parent()

5533

1

				))),

5534

1

				fee_amount: Some(total_fee)

5535

1

},

5536

1

			TransactWeights {

5537

1

				transact_required_weight_at_most: tx_weight.into(),

5538

1

				overall_weight: Some(Limited(total_weight.into()))

5539

1

5540

));

5541

1

});

5542

1

	Relay::execute_with(|| {

5543

1

		let expected_event: relay_chain::RuntimeEvent =

5544

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5545

1

				by_parachain: 1u32.into(),

5546

1

				channel_id: HrmpChannelId {

5547

1

					sender: 1u32.into(),

5548

1

					recipient: 2u32.into(),

5549

1

},

5550

1

5551

1

			.into();

5552

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5553

1

});

5554

1

5555

5556

use crate::xcm_mock::parachain::XcmWeightTrader;

5557

use parity_scale_codec::{Decode, Encode};

5558

use sp_io::hashing::blake2_256;

5559

5560

// Helper to derive accountIds

5561

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5562

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5563

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5564

7