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

25

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

87

25

	Asset {

88

25

		id: AssetId(

89

25

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

90

25

				currency_id,

91

25

92

25

			.unwrap(),

93

25

),

94

25

		fun: Fungibility::Fungible(amount),

95

25

96

25

97

98

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

99

#[test]

100

1

fn receive_relay_asset_from_relay() {

101

1

	MockNet::reset();

102

103

1

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

104

1

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

105

1

	let asset_metadata = parachain::AssetMetadata {

106

1

		name: b"RelayToken".to_vec(),

107

1

		symbol: b"Relay".to_vec(),

108

1

		decimals: 12,

109

1

};

110

	// Register relay asset in parachain A

111

1

	ParaA::execute_with(|| {

112

1

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

113

1

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

114

1

			.try_into()

115

1

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

116

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

117

1

			source_id,

118

1

			source_location_latest,

119

1

			asset_metadata.decimals,

120

1

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

121

1

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

122

));

123

1

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

124

1

});

125

126

	// Actually send relay asset to parachain

127

1

	let dest: Location = AccountKey20 {

128

1

		network: None,

129

1

		key: PARAALICE,

130

1

131

1

	.into();

132

1

	Relay::execute_with(|| {

133

1

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

134

1

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

135

1

			assets: Wild(All),

136

1

			beneficiary: dest.clone(),

137

1

		}]);

138

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

139

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

140

1

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

141

1

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

142

1

			Box::new(TransferType::LocalReserve),

143

1

			Box::new(fees_id),

144

1

			Box::new(TransferType::LocalReserve),

145

1

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

146

1

			WeightLimit::Unlimited

147

));

148

1

});

149

150

	// Verify that parachain received the asset

151

1

	ParaA::execute_with(|| {

152

		// free execution, full amount received

153

1

		assert_eq!(

154

1

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

155

1

			Ok(U256::from(123))

156

);

157

1

});

158

1

159

160

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

161

#[test]

162

1

fn send_relay_asset_to_relay() {

163

1

	MockNet::reset();

164

165

1

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

166

1

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

167

168

1

	let asset_metadata = parachain::AssetMetadata {

169

1

		name: b"RelayToken".to_vec(),

170

1

		symbol: b"Relay".to_vec(),

171

1

		decimals: 12,

172

1

};

173

174

	// Register relay asset in paraA

175

1

	ParaA::execute_with(|| {

176

1

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

177

1

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

178

1

			.try_into()

179

1

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

180

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

181

1

			source_id,

182

1

			source_location_latest,

183

1

			asset_metadata.decimals,

184

1

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

185

1

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

186

));

187

		// free execution

188

1

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

189

1

});

190

191

1

	let dest: Location = Junction::AccountKey20 {

192

1

		network: None,

193

1

		key: PARAALICE,

194

1

195

1

	.into();

196

197

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

198

1

	Relay::execute_with(|| {

199

1

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

200

1

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

201

1

			assets: Wild(All),

202

1

			beneficiary: dest.clone(),

203

1

		}]);

204

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

205

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

206

1

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

207

1

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

208

1

			Box::new(TransferType::LocalReserve),

209

1

			Box::new(fees_id),

210

1

			Box::new(TransferType::LocalReserve),

211

1

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

212

1

			WeightLimit::Unlimited

213

));

214

1

});

215

216

1

	ParaA::execute_with(|| {

217

		// Free execution, full amount received

218

1

		assert_eq!(

219

1

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

220

1

			Ok(U256::from(123))

221

);

222

1

});

223

224

	// Lets gather the balance before sending back money

225

1

	let mut balance_before_sending = 0;

226

1

	Relay::execute_with(|| {

227

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

228

1

});

229

230

	// We now send back some money to the relay

231

1

	let dest_chain = Location::parent();

232

1

	let beneficiary = Location {

233

1

		parents: 0,

234

1

		interior: [AccountId32 {

235

1

			network: None,

236

1

			id: RELAYALICE.into(),

237

1

}]

238

1

		.into(),

239

1

};

240

241

1

	ParaA::execute_with(|| {

242

1

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

243

1

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

244

1

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

245

1

			assets: Wild(All),

246

1

			beneficiary: beneficiary.clone(),

247

1

		}]);

248

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

249

1

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

250

1

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

251

1

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

252

1

			Box::new(TransferType::DestinationReserve),

253

1

			Box::new(fees_id),

254

1

			Box::new(TransferType::DestinationReserve),

255

1

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

256

1

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

257

));

258

1

});

259

260

	// The balances in paraAlice should have been substracted

261

1

	ParaA::execute_with(|| {

262

1

		assert_eq!(

263

1

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

264

1

			Ok(U256::from(0))

265

);

266

1

});

267

268

	// Balances in the relay should have been received

269

1

	Relay::execute_with(|| {

270

1

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

271

1

});

272

1

273

274

#[test]

275

1

fn send_relay_asset_to_para_b() {

276

1

	MockNet::reset();

277

278

1

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

279

1

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

280

281

1

	let asset_metadata = parachain::AssetMetadata {

282

1

		name: b"RelayToken".to_vec(),

283

1

		symbol: b"Relay".to_vec(),

284

1

		decimals: 12,

285

1

};

286

287

	// Register asset in paraA. Free execution

288

1

	ParaA::execute_with(|| {

289

1

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

290

1

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

291

1

			.try_into()

292

1

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

293

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

294

1

			source_id,

295

1

			source_location_latest,

296

1

			asset_metadata.decimals,

297

1

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

298

1

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

299

));

300

1

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

301

1

});

302

303

	// Register asset in paraB. Free execution

304

1

	ParaB::execute_with(|| {

305

1

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

306

1

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

307

1

			.try_into()

308

1

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

309

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

310

1

			source_id,

311

1

			source_location_latest,

312

1

			asset_metadata.decimals,

313

1

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

314

1

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

315

));

316

1

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

317

1

});

318

319

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

320

1

	let dest: Location = Junction::AccountKey20 {

321

1

		network: None,

322

1

		key: PARAALICE,

323

1

324

1

	.into();

325

1

	Relay::execute_with(|| {

326

1

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

327

1

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

328

1

			assets: Wild(All),

329

1

			beneficiary: dest.clone(),

330

1

		}]);

331

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

332

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

333

1

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

334

1

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

335

1

			Box::new(TransferType::LocalReserve),

336

1

			Box::new(fees_id),

337

1

			Box::new(TransferType::LocalReserve),

338

1

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

339

1

			WeightLimit::Unlimited

340

));

341

1

});

342

343

1

	ParaA::execute_with(|| {

344

1

		assert_eq!(

345

1

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

346

1

			Ok(U256::from(123))

347

);

348

1

});

349

350

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

351

1

	let dest = Location {

352

1

		parents: 1,

353

1

		interior: [

354

1

			Parachain(2),

355

1

			AccountKey20 {

356

1

				network: None,

357

1

				key: PARAALICE.into(),

358

1

},

359

1

360

1

		.into(),

361

1

};

362

1

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

363

364

1

	ParaA::execute_with(|| {

365

1

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

366

1

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

367

1

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

368

1

			assets: Wild(All),

369

1

			beneficiary: beneficiary.clone(),

370

1

		}]);

371

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

372

1

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

373

1

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

374

1

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

375

1

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

376

1

			Box::new(fees_id),

377

1

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

378

1

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

379

1

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

380

));

381

1

});

382

383

	// Para A balances should have been substracted

384

1

	ParaA::execute_with(|| {

385

1

		assert_eq!(

386

1

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

387

1

			Ok(U256::from(23))

388

);

389

1

});

390

391

	// Para B balances should have been credited

392

1

	ParaB::execute_with(|| {

393

1

		assert_eq!(

394

1

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

395

1

			Ok(U256::from(100))

396

);

397

1

});

398

1

399

400

#[test]

401

1

fn send_para_a_asset_to_para_b() {

402

1

	MockNet::reset();

403

404

	// This represents the asset in paraA

405

1

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

406

1

	let source_location: AssetType = para_a_balances

407

1

		.try_into()

408

1

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

409

1

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

410

411

1

	let asset_metadata = parachain::AssetMetadata {

412

1

		name: b"ParaAToken".to_vec(),

413

1

		symbol: b"ParaA".to_vec(),

414

1

		decimals: 18,

415

1

};

416

417

	// Register asset in paraB. Free execution

418

1

	ParaB::execute_with(|| {

419

1

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

420

1

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

421

1

			.try_into()

422

1

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

423

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

424

1

			source_id,

425

1

			source_location_latest,

426

1

			asset_metadata.decimals,

427

1

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

428

1

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

429

));

430

1

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

431

1

});

432

433

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

434

1

	let dest = Location {

435

1

		parents: 1,

436

1

		interior: [

437

1

			Parachain(2),

438

1

			AccountKey20 {

439

1

				network: None,

440

1

				key: PARAALICE.into(),

441

1

},

442

1

443

1

		.into(),

444

1

};

445

1

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

446

447

1

	ParaA::execute_with(|| {

448

1

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

449

1

		assert_ok!(PolkadotXcm::transfer_assets(

450

1

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

451

1

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

452

1

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

453

1

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

454

0,

455

1

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

456

));

457

1

});

458

459

	// Native token is substracted in paraA

460

1

	ParaA::execute_with(|| {

461

		// free execution, full amount received

462

1

		assert_eq!(

463

1

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

464

			INITIAL_BALANCE - 100

465

);

466

1

});

467

468

	// Asset is minted in paraB

469

1

	ParaB::execute_with(|| {

470

		// free execution, full amount received

471

1

		assert_eq!(

472

1

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

473

1

			Ok(U256::from(100))

474

);

475

1

});

476

1

477

478

#[test]

479

1

fn send_para_a_asset_from_para_b_to_para_c() {

480

1

	MockNet::reset();

481

482

	// Represents para A asset

483

1

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

484

1

	let source_location: AssetType = para_a_balances

485

1

		.try_into()

486

1

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

487

1

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

488

489

1

	let asset_metadata = parachain::AssetMetadata {

490

1

		name: b"ParaAToken".to_vec(),

491

1

		symbol: b"ParaA".to_vec(),

492

1

		decimals: 18,

493

1

};

494

495

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

496

1

	ParaB::execute_with(|| {

497

1

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

498

1

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

499

1

			.try_into()

500

1

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

501

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

502

1

			source_id,

503

1

			source_location_latest,

504

1

			asset_metadata.decimals,

505

1

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

506

1

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

507

));

508

1

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

509

1

});

510

511

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

512

1

	ParaC::execute_with(|| {

513

1

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

514

1

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

515

1

			.try_into()

516

1

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

517

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

518

1

			source_id,

519

1

			source_location_latest,

520

1

			asset_metadata.decimals,

521

1

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

522

1

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

523

));

524

1

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

525

1

});

526

527

	// Send para A asset to para B

528

1

	let dest = Location {

529

1

		parents: 1,

530

1

		interior: [

531

1

			Parachain(2),

532

1

			AccountKey20 {

533

1

				network: None,

534

1

				key: PARAALICE.into(),

535

1

},

536

1

537

1

		.into(),

538

1

};

539

1

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

540

541

1

	ParaA::execute_with(|| {

542

1

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

543

1

		assert_ok!(PolkadotXcm::transfer_assets(

544

1

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

545

1

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

546

1

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

547

1

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

548

0,

549

1

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

550

));

551

1

});

552

553

	// Para A balances have been substracted

554

1

	ParaA::execute_with(|| {

555

1

		assert_eq!(

556

1

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

557

			INITIAL_BALANCE - 100

558

);

559

1

});

560

561

	// Para B balances have been credited

562

1

	ParaB::execute_with(|| {

563

1

		assert_eq!(

564

1

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

565

1

			Ok(U256::from(100))

566

);

567

1

});

568

569

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

570

1

	let dest = Location {

571

1

		parents: 1,

572

1

		interior: [

573

1

			Parachain(3),

574

1

			AccountKey20 {

575

1

				network: None,

576

1

				key: PARAALICE.into(),

577

1

},

578

1

579

1

		.into(),

580

1

};

581

1

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

582

583

1

	ParaB::execute_with(|| {

584

1

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

585

1

		assert_ok!(PolkadotXcm::transfer_assets(

586

1

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

587

1

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

588

1

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

589

1

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

590

0,

591

1

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

592

));

593

1

});

594

595

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

596

1

	ParaC::execute_with(|| {

597

		// free execution, full amount received

598

1

		assert_eq!(

599

1

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

600

1

			Ok(U256::from(95))

601

);

602

1

});

603

1

604

605

#[test]

606

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

607

1

	MockNet::reset();

608

609

	// Para A asset

610

1

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

611

1

	let source_location: AssetType = para_a_balances

612

1

		.try_into()

613

1

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

614

1

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

615

616

1

	let asset_metadata = parachain::AssetMetadata {

617

1

		name: b"ParaAToken".to_vec(),

618

1

		symbol: b"ParaA".to_vec(),

619

1

		decimals: 18,

620

1

};

621

622

	// Register para A asset in para B

623

1

	ParaB::execute_with(|| {

624

1

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

625

1

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

626

1

			.try_into()

627

1

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

628

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

629

1

			source_id,

630

1

			source_location_latest,

631

1

			asset_metadata.decimals,

632

1

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

633

1

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

634

));

635

1

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

636

1

});

637

638

	// Send para A asset to para B

639

1

	let dest = Location {

640

1

		parents: 1,

641

1

		interior: [

642

1

			Parachain(2),

643

1

			AccountKey20 {

644

1

				network: None,

645

1

				key: PARAALICE.into(),

646

1

},

647

1

648

1

		.into(),

649

1

};

650

1

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

651

652

1

	ParaA::execute_with(|| {

653

1

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

654

1

		assert_ok!(PolkadotXcm::transfer_assets(

655

1

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

656

1

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

657

1

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

658

1

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

659

0,

660

1

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

661

));

662

1

});

663

664

	// Balances have been subtracted

665

1

	ParaA::execute_with(|| {

666

1

		assert_eq!(

667

1

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

668

			INITIAL_BALANCE - 100

669

);

670

1

});

671

672

	// Para B balances have been credited

673

1

	ParaB::execute_with(|| {

674

1

		assert_eq!(

675

1

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

676

1

			Ok(U256::from(100))

677

);

678

1

});

679

680

	// Send back para A asset to para A

681

1

	let dest = Location {

682

1

		parents: 1,

683

1

		interior: [

684

1

			Parachain(1),

685

1

			AccountKey20 {

686

1

				network: None,

687

1

				key: PARAALICE.into(),

688

1

},

689

1

690

1

		.into(),

691

1

};

692

1

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

693

694

1

	ParaB::execute_with(|| {

695

1

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

696

1

		assert_ok!(PolkadotXcm::transfer_assets(

697

1

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

698

1

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

699

1

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

700

1

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

701

0,

702

1

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

703

));

704

1

});

705

706

	// Para A asset has been credited

707

1

	ParaA::execute_with(|| {

708

		// Weight used is 4

709

1

		assert_eq!(

710

1

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

711

			INITIAL_BALANCE - 4

712

);

713

1

});

714

1

715

716

#[test]

717

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

718

1

	MockNet::reset();

719

720

1

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

721

1

	let source_location: AssetType = para_a_balances

722

1

		.try_into()

723

1

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

724

1

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

725

726

1

	let asset_metadata = parachain::AssetMetadata {

727

1

		name: b"ParaAToken".to_vec(),

728

1

		symbol: b"ParaA".to_vec(),

729

1

		decimals: 18,

730

1

};

731

732

1

	ParaB::execute_with(|| {

733

1

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

734

1

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

735

1

			.try_into()

736

1

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

737

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

738

1

			source_id,

739

1

			source_location_latest,

740

1

			asset_metadata.decimals,

741

1

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

742

1

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

743

));

744

1

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

745

1

});

746

747

1

	let dest = Location {

748

1

		parents: 1,

749

1

		interior: [

750

1

			Parachain(2),

751

1

			AccountKey20 {

752

1

				network: None,

753

1

				key: PARAALICE.into(),

754

1

},

755

1

756

1

		.into(),

757

1

};

758

1

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

759

760

1

	ParaA::execute_with(|| {

761

1

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

762

1

		assert_ok!(PolkadotXcm::transfer_assets(

763

1

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

764

1

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

765

1

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

766

1

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

767

0,

768

1

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

769

));

770

1

});

771

772

1

	ParaA::execute_with(|| {

773

		// Free execution, full amount received

774

1

		assert_eq!(

775

1

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

776

			INITIAL_BALANCE - 100

777

);

778

1

});

779

780

1

	ParaB::execute_with(|| {

781

		// Free execution, full amount received

782

1

		assert_eq!(

783

1

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

784

1

			Ok(U256::from(100))

785

);

786

1

});

787

788

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

789

	// Message through polkadotXCM pallet

790

791

1

	let dest = Location {

792

1

		parents: 1,

793

1

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

794

1

};

795

796

1

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

797

798

1

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

799

1

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

800

1

		ClearOrigin,

801

1

		BuyExecution {

802

1

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

803

1

			weight_limit: Limited(80.into()),

804

1

},

805

1

		DepositAsset {

806

1

			assets: All.into(),

807

1

			beneficiary: Location::new(

808

1

0,

809

1

				[AccountKey20 {

810

1

					network: None,

811

1

					key: PARAALICE,

812

1

}],

813

1

),

814

1

},

815

1

	]));

816

1

	ParaB::execute_with(|| {

817

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

818

		// and deposit asset

819

1

		assert_ok!(ParachainPalletXcm::send(

820

1

			parachain::RuntimeOrigin::root(),

821

1

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

822

1

			Box::new(message),

823

));

824

1

});

825

826

1

	ParaB::execute_with(|| {

827

		// free execution, full amount received

828

1

		assert_eq!(

829

1

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

830

1

			Ok(U256::from(100))

831

);

832

1

});

833

834

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

835

	// Message through polkadotXCM pallet

836

837

1

	let dest = Location {

838

1

		parents: 1,

839

1

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

840

1

};

841

842

1

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

843

844

1

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

845

1

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

846

1

		ClearOrigin,

847

1

		BuyExecution {

848

1

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

849

1

			weight_limit: Limited(80.into()),

850

1

},

851

1

		DepositAsset {

852

1

			assets: All.into(),

853

1

			beneficiary: Location::new(

854

1

0,

855

1

				[AccountKey20 {

856

1

					network: None,

857

1

					key: PARAALICE,

858

1

}],

859

1

),

860

1

},

861

1

	]));

862

1

	ParaB::execute_with(|| {

863

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

864

		// and deposit asset

865

1

		assert_ok!(ParachainPalletXcm::send(

866

1

			parachain::RuntimeOrigin::root(),

867

1

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

868

1

			Box::new(message),

869

));

870

1

});

871

872

1

	ParaA::execute_with(|| {

873

		// Weight used is 4

874

1

		assert_eq!(

875

1

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

876

			INITIAL_BALANCE - 4

877

);

878

1

});

879

1

880

881

#[test]

882

1

fn receive_relay_asset_with_trader() {

883

1

	MockNet::reset();

884

885

1

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

886

1

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

887

888

1

	let asset_metadata = parachain::AssetMetadata {

889

1

		name: b"RelayToken".to_vec(),

890

1

		symbol: b"Relay".to_vec(),

891

1

		decimals: 12,

892

1

};

893

894

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

895

	// we know later we will divide by 1e12

896

	// Lets put 1e6 as units per second

897

1

	ParaA::execute_with(|| {

898

1

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

899

1

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

900

1

			.try_into()

901

1

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

902

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

903

1

			source_id,

904

1

			source_location_latest,

905

1

			asset_metadata.decimals,

906

1

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

907

1

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

908

));

909

1

		assert_ok!(add_supported_asset(

910

1

			source_location.clone(),

911

			2500000000000u128

912

));

913

1

});

914

915

1

	let dest: Location = Junction::AccountKey20 {

916

1

		network: None,

917

1

		key: PARAALICE,

918

1

919

1

	.into();

920

	// We are sending 100 tokens from relay.

921

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

922

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

923

	// Units per second should be 2_500_000_000_000_000

924

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

925

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

926

1

	Relay::execute_with(|| {

927

1

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

928

1

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

929

1

			assets: Wild(All),

930

1

			beneficiary: dest.clone(),

931

1

		}]);

932

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

933

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

934

1

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

935

1

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

936

1

			Box::new(TransferType::LocalReserve),

937

1

			Box::new(fees_id),

938

1

			Box::new(TransferType::LocalReserve),

939

1

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

940

1

			WeightLimit::Unlimited

941

));

942

1

});

943

944

1

	ParaA::execute_with(|| {

945

		// non-free execution, not full amount received

946

1

		assert_eq!(

947

1

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

948

1

			Ok(U256::from(90))

949

);

950

		// Fee should have been received by treasury

951

1

		assert_eq!(

952

1

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

953

1

			Ok(U256::from(10))

954

);

955

1

});

956

1

957

958

#[test]

959

1

fn send_para_a_asset_to_para_b_with_trader() {

960

1

	MockNet::reset();

961

962

1

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

963

1

	let source_location: AssetType = para_a_balances

964

1

		.try_into()

965

1

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

966

1

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

967

968

1

	let asset_metadata = parachain::AssetMetadata {

969

1

		name: b"ParaAToken".to_vec(),

970

1

		symbol: b"ParaA".to_vec(),

971

1

		decimals: 18,

972

1

};

973

974

1

	ParaB::execute_with(|| {

975

1

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

976

1

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

977

1

			.try_into()

978

1

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

979

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

980

1

			source_id,

981

1

			source_location_latest,

982

1

			asset_metadata.decimals,

983

1

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

984

1

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

985

));

986

1

		assert_ok!(add_supported_asset(

987

1

			source_location.clone(),

988

			2500000000000u128

989

));

990

1

});

991

992

1

	let dest = Location {

993

1

		parents: 1,

994

1

		interior: [

995

1

			Parachain(2),

996

1

			AccountKey20 {

997

1

				network: None,

998

1

				key: PARAALICE.into(),

999

1

},

1000

1

1001

1

		.into(),

1002

1

};

1003

1

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

1004

1005

	// In destination chain, we only need 4 weight

1006

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

1007

1

	ParaA::execute_with(|| {

1008

1

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

1009

1

		assert_ok!(PolkadotXcm::transfer_assets(

1010

1

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

1011

1

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

1012

1

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

1013

1

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

1014

0,

1015

1

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

1016

));

1017

1

});

1018

1

	ParaA::execute_with(|| {

1019

		// free execution, full amount received

1020

1

		assert_eq!(

1021

1

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

1022

			INITIAL_BALANCE - 100

1023

);

1024

1

});

1025

1026

	// We are sending 100 tokens from para A.

1027

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

1028

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

1029

	// Units per second should be 2_500_000_000_000_000

1030

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

1031

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

1032

	// will be 4

1033

1

	ParaB::execute_with(|| {

1034

1

		assert_eq!(

1035

1

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

1036

1

			Ok(U256::from(90))

1037

);

1038

		// Fee should have been received by treasury

1039

1

		assert_eq!(

1040

1

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

1041

1

			Ok(U256::from(10))

1042

);

1043

1

});

1044

1

1045

1046

#[test]

1047

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1048

1

	MockNet::reset();

1049

1050

1

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

1051

1

	let source_location: AssetType = para_a_balances

1052

1

		.try_into()

1053

1

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

1054

1

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

1055

1056

1

	let asset_metadata = parachain::AssetMetadata {

1057

1

		name: b"ParaAToken".to_vec(),

1058

1

		symbol: b"ParaA".to_vec(),

1059

1

		decimals: 18,

1060

1

};

1061

1062

1

	ParaB::execute_with(|| {

1063

1

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

1064

1

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

1065

1

			.try_into()

1066

1

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

1067

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1068

1

			source_id,

1069

1

			source_location_latest,

1070

1

			asset_metadata.decimals,

1071

1

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

1072

1

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

1073

));

1074

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

1075

1

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

1076

1

});

1077

1078

1

	let dest = Location {

1079

1

		parents: 1,

1080

1

		interior: [

1081

1

			Parachain(2),

1082

1

			AccountKey20 {

1083

1

				network: None,

1084

1

				key: PARAALICE.into(),

1085

1

},

1086

1

1087

1

		.into(),

1088

1

};

1089

1

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

1090

1091

	// we use transfer_with_fee

1092

1

	ParaA::execute_with(|| {

1093

1

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

1094

1

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

1095

1

		assert_ok!(PolkadotXcm::transfer_assets(

1096

1

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

1097

1

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

1098

1

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

1099

1

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

1100

0,

1101

1

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

1102

));

1103

1

});

1104

1

	ParaA::execute_with(|| {

1105

		// 100 tokens transferred plus 1 taken from fees

1106

1

		assert_eq!(

1107

1

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

1108

			INITIAL_BALANCE - 100 - 1

1109

);

1110

1

});

1111

1112

1

	ParaB::execute_with(|| {

1113

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

1114

		// what it is specified

1115

1

		assert_eq!(

1116

1

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

1117

1

			Ok(U256::from(101))

1118

);

1119

1

});

1120

1

1121

1122

#[test]

1123

1

fn error_when_not_paying_enough() {

1124

1

	MockNet::reset();

1125

1126

1

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

1127

1

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

1128

1129

1

	let asset_metadata = parachain::AssetMetadata {

1130

1

		name: b"RelayToken".to_vec(),

1131

1

		symbol: b"Relay".to_vec(),

1132

1

		decimals: 12,

1133

1

};

1134

1135

1

	let dest: Location = Junction::AccountKey20 {

1136

1

		network: None,

1137

1

		key: PARAALICE,

1138

1

1139

1

	.into();

1140

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

1141

	// we know later we will divide by 1e12

1142

	// Lets put 1e6 as units per second

1143

1

	ParaA::execute_with(|| {

1144

1

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

1145

1

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

1146

1

			.try_into()

1147

1

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

1148

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1149

1

			source_id,

1150

1

			source_location_latest,

1151

1

			asset_metadata.decimals,

1152

1

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

1153

1

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

1154

));

1155

1

		assert_ok!(add_supported_asset(

1156

1

			source_location.clone(),

1157

			2500000000000u128

1158

));

1159

1

});

1160

1161

	// We are sending 100 tokens from relay.

1162

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

1163

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

1164

1

	Relay::execute_with(|| {

1165

1

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

1166

1

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

1167

1

			assets: Wild(All),

1168

1

			beneficiary: dest.clone(),

1169

1

		}]);

1170

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1171

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1172

1

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

1173

1

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

1174

1

			Box::new(TransferType::LocalReserve),

1175

1

			Box::new(fees_id),

1176

1

			Box::new(TransferType::LocalReserve),

1177

1

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

1178

1

			WeightLimit::Unlimited

1179

));

1180

1

});

1181

1182

1

	ParaA::execute_with(|| {

1183

		// amount not received as it is not paying enough

1184

1

		assert_eq!(

1185

1

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

1186

1

			Ok(U256::from(0))

1187

);

1188

1

});

1189

1

1190

1191

#[test]

1192

1

fn transact_through_derivative_multilocation() {

1193

1

	MockNet::reset();

1194

1195

1

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

1196

1

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

1197

1198

1

	let asset_metadata = parachain::AssetMetadata {

1199

1

		name: b"RelayToken".to_vec(),

1200

1

		symbol: b"Relay".to_vec(),

1201

1

		decimals: 12,

1202

1

};

1203

1204

1

	ParaA::execute_with(|| {

1205

1

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

1206

1

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

1207

1

			.try_into()

1208

1

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

1209

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1210

1

			source_id,

1211

1

			source_location_latest,

1212

1

			asset_metadata.decimals,

1213

1

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

1214

1

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

1215

));

1216

1

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

1217

1218

		// Root can set transact info

1219

1

		assert_ok!(XcmTransactor::set_transact_info(

1220

1

			parachain::RuntimeOrigin::root(),

1221

1

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

1222

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

1223

1

			3000.into(),

1224

1

			20000000000.into(),

1225

1

			None

1226

));

1227

		// Root can set transact info

1228

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1229

1

			parachain::RuntimeOrigin::root(),

1230

1

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

1231

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1232

));

1233

1

});

1234

1235

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

1236

1237

1

	let dest: Location = AccountKey20 {

1238

1

		network: None,

1239

1

		key: PARAALICE,

1240

1

1241

1

	.into();

1242

1

	Relay::execute_with(|| {

1243

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

1244

1

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

1245

1

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

1246

1

			assets: Wild(All),

1247

1

			beneficiary: dest.clone(),

1248

1

		}]);

1249

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1250

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1251

1

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

1252

1

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

1253

1

			Box::new(TransferType::LocalReserve),

1254

1

			Box::new(fees_id),

1255

1

			Box::new(TransferType::LocalReserve),

1256

1

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

1257

1

			WeightLimit::Unlimited

1258

));

1259

1

});

1260

1261

1

	ParaA::execute_with(|| {

1262

		// free execution, full amount received

1263

1

		assert_eq!(

1264

1

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

1265

1

			Ok(U256::from(4000003100u64))

1266

);

1267

1

});

1268

1269

	// Register address

1270

1

	ParaA::execute_with(|| {

1271

1

		assert_ok!(XcmTransactor::register(

1272

1

			parachain::RuntimeOrigin::root(),

1273

1

			PARAALICE.into(),

1274

0,

1275

));

1276

1

});

1277

1278

	// Send to registered address

1279

1280

1

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

1281

1

	let dest = Location {

1282

1

		parents: 1,

1283

1

		interior: [AccountId32 {

1284

1

			network: None,

1285

1

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

1286

1

}]

1287

1

		.into(),

1288

1

};

1289

1

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

1290

1291

1

	ParaA::execute_with(|| {

1292

1

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

1293

		// free execution, full amount received

1294

1

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

1295

1

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

1296

1

			assets: Wild(All),

1297

1

			beneficiary: beneficiary.clone(),

1298

1

		}]);

1299

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1300

1

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

1301

1

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

1302

1

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

1303

1

			Box::new(TransferType::DestinationReserve),

1304

1

			Box::new(fees_id),

1305

1

			Box::new(TransferType::DestinationReserve),

1306

1

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

1307

1

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

1308

));

1309

1

});

1310

1311

1

	ParaA::execute_with(|| {

1312

		// free execution, full amount received

1313

1

		assert_eq!(

1314

1

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

1315

1

			Ok(U256::from(4000003000u64))

1316

);

1317

1

});

1318

1319

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

1320

	// again

1321

1

	Relay::execute_with(|| {

1322

		// free execution,x	 full amount received

1323

1

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

1324

1

});

1325

1326

	// Encode the call. Balances transact to para_a_account

1327

	// First index

1328

1

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

1329

1

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

1330

1

		relay_chain::Balances,

1331

1

>()

1332

1

	.unwrap() as u8;

1333

1334

1

	encoded.push(index);

1335

1336

	// Then call bytes

1337

1

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

1338

1

		dest: para_a_account(),

1339

1

		value: 100u32.into(),

1340

1

1341

1

	.encode();

1342

1

	encoded.append(&mut call_bytes);

1343

1344

1

	ParaA::execute_with(|| {

1345

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1346

1

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

1347

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1348

0,

1349

1

			CurrencyPayment {

1350

1

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

1351

1

					Location::parent()

1352

1

				))),

1353

1

				fee_amount: None

1354

1

},

1355

1

			encoded,

1356

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

1357

1

			TransactWeights {

1358

1

				transact_required_weight_at_most: 4000000000.into(),

1359

1

				overall_weight: None

1360

1

},

1361

			false

1362

));

1363

1

});

1364

1365

1

	Relay::execute_with(|| {

1366

		// free execution,x	 full amount received

1367

1

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

1368

1369

1

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

1370

1

});

1371

1

1372

1373

#[test]

1374

1

fn transact_through_derivative_with_custom_fee_weight() {

1375

1

	MockNet::reset();

1376

1377

1

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

1378

1

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

1379

1380

1

	let asset_metadata = parachain::AssetMetadata {

1381

1

		name: b"RelayToken".to_vec(),

1382

1

		symbol: b"Relay".to_vec(),

1383

1

		decimals: 12,

1384

1

};

1385

1386

1

	ParaA::execute_with(|| {

1387

1

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

1388

1

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

1389

1

			.try_into()

1390

1

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

1391

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1392

1

			source_id,

1393

1

			source_location_latest,

1394

1

			asset_metadata.decimals,

1395

1

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

1396

1

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

1397

));

1398

1

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

1399

1

});

1400

1401

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

1402

1403

1

	let dest: Location = AccountKey20 {

1404

1

		network: None,

1405

1

		key: PARAALICE,

1406

1

1407

1

	.into();

1408

1

	Relay::execute_with(|| {

1409

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

1410

1

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

1411

1

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

1412

1

			assets: Wild(All),

1413

1

			beneficiary: dest.clone(),

1414

1

		}]);

1415

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1416

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1417

1

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

1418

1

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

1419

1

			Box::new(TransferType::LocalReserve),

1420

1

			Box::new(fees_id),

1421

1

			Box::new(TransferType::LocalReserve),

1422

1

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

1423

1

			WeightLimit::Unlimited

1424

));

1425

1

});

1426

1427

1

	ParaA::execute_with(|| {

1428

		// free execution, full amount received

1429

1

		assert_eq!(

1430

1

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

1431

1

			Ok(U256::from(4000003100u64))

1432

);

1433

1

});

1434

1435

	// Register address

1436

1

	ParaA::execute_with(|| {

1437

1

		assert_ok!(XcmTransactor::register(

1438

1

			parachain::RuntimeOrigin::root(),

1439

1

			PARAALICE.into(),

1440

0,

1441

));

1442

1

});

1443

1444

	// Send to registered address

1445

1446

1

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

1447

1

	let dest = Location {

1448

1

		parents: 1,

1449

1

		interior: [AccountId32 {

1450

1

			network: None,

1451

1

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

1452

1

}]

1453

1

		.into(),

1454

1

};

1455

1

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

1456

1457

1

	ParaA::execute_with(|| {

1458

1

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

1459

		// free execution, full amount received

1460

1

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

1461

1

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

1462

1

			assets: Wild(All),

1463

1

			beneficiary: beneficiary.clone(),

1464

1

		}]);

1465

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1466

1

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

1467

1

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

1468

1

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

1469

1

			Box::new(TransferType::DestinationReserve),

1470

1

			Box::new(fees_id),

1471

1

			Box::new(TransferType::DestinationReserve),

1472

1

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

1473

1

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

1474

));

1475

1

});

1476

1477

1

	ParaA::execute_with(|| {

1478

		// free execution, full amount received

1479

1

		assert_eq!(

1480

1

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

1481

1

			Ok(U256::from(4000003000u64))

1482

);

1483

1

});

1484

1485

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

1486

	// again

1487

1

	Relay::execute_with(|| {

1488

		// free execution,x	 full amount received

1489

1

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

1490

1

});

1491

1492

	// Encode the call. Balances transact to para_a_account

1493

	// First index

1494

1

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

1495

1

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

1496

1

		relay_chain::Balances,

1497

1

>()

1498

1

	.unwrap() as u8;

1499

1500

1

	encoded.push(index);

1501

1502

	// Then call bytes

1503

1

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

1504

1

		dest: para_a_account(),

1505

1

		value: 100u32.into(),

1506

1

1507

1

	.encode();

1508

1

	encoded.append(&mut call_bytes);

1509

1510

1

	let overall_weight = 4000003000u64;

1511

1

	ParaA::execute_with(|| {

1512

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1513

1

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

1514

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1515

0,

1516

1

			CurrencyPayment {

1517

1

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

1518

1

					Location::parent()

1519

1

				))),

1520

1

				// 1-1 fee weight mapping

1521

1

				fee_amount: Some(overall_weight as u128)

1522

1

},

1523

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

1524

1

			encoded,

1525

1

			TransactWeights {

1526

1

				transact_required_weight_at_most: 4000000000.into(),

1527

1

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

1528

1

},

1529

			false

1530

));

1531

1

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

1532

1

			.iter()

1533

18

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

1534

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

1535

..

1536

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

1537

18

				_ => None,

1538

18

});

1539

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

1540

1

		assert!(event_found.is_none());

1541

1

});

1542

1543

1

	Relay::execute_with(|| {

1544

		// free execution,x	 full amount received

1545

1

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

1546

1547

1

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

1548

1

});

1549

1

1550

1551

#[test]

1552

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1553

1

	MockNet::reset();

1554

1555

1

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

1556

1

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

1557

1558

1

	let asset_metadata = parachain::AssetMetadata {

1559

1

		name: b"RelayToken".to_vec(),

1560

1

		symbol: b"Relay".to_vec(),

1561

1

		decimals: 12,

1562

1

};

1563

1564

1

	ParaA::execute_with(|| {

1565

1

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

1566

1

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

1567

1

			.try_into()

1568

1

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

1569

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1570

1

			source_id,

1571

1

			source_location_latest,

1572

1

			asset_metadata.decimals,

1573

1

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

1574

1

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

1575

));

1576

1

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

1577

1

});

1578

1579

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

1580

1581

1

	let dest: Location = AccountKey20 {

1582

1

		network: None,

1583

1

		key: PARAALICE,

1584

1

1585

1

	.into();

1586

1

	Relay::execute_with(|| {

1587

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

1588

1

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

1589

1

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

1590

1

			assets: Wild(All),

1591

1

			beneficiary: dest.clone(),

1592

1

		}]);

1593

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1594

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1595

1

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

1596

1

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

1597

1

			Box::new(TransferType::LocalReserve),

1598

1

			Box::new(fees_id),

1599

1

			Box::new(TransferType::LocalReserve),

1600

1

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

1601

1

			WeightLimit::Unlimited

1602

));

1603

1

});

1604

1605

1

	ParaA::execute_with(|| {

1606

		// free execution, full amount received

1607

1

		assert_eq!(

1608

1

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

1609

1

			Ok(U256::from(4000009100u64))

1610

);

1611

1

});

1612

1613

	// Register address

1614

1

	ParaA::execute_with(|| {

1615

1

		assert_ok!(XcmTransactor::register(

1616

1

			parachain::RuntimeOrigin::root(),

1617

1

			PARAALICE.into(),

1618

0,

1619

));

1620

1

});

1621

1622

	// Send to registered address

1623

1624

1

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

1625

1

	let dest = Location {

1626

1

		parents: 1,

1627

1

		interior: [AccountId32 {

1628

1

			network: None,

1629

1

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

1630

1

}]

1631

1

		.into(),

1632

1

};

1633

1

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

1634

1635

1

	ParaA::execute_with(|| {

1636

1

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

1637

		// free execution, full amount received

1638

1

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

1639

1

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

1640

1

			assets: Wild(All),

1641

1

			beneficiary: beneficiary.clone(),

1642

1

		}]);

1643

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1644

1

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

1645

1

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

1646

1

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

1647

1

			Box::new(TransferType::DestinationReserve),

1648

1

			Box::new(fees_id),

1649

1

			Box::new(TransferType::DestinationReserve),

1650

1

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

1651

1

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

1652

));

1653

1

});

1654

1655

1

	ParaA::execute_with(|| {

1656

		// free execution, full amount received

1657

1

		assert_eq!(

1658

1

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

1659

1

			Ok(U256::from(4000009000u64))

1660

);

1661

1

});

1662

1663

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

1664

	// again

1665

1

	Relay::execute_with(|| {

1666

		// free execution,x	 full amount received

1667

1

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

1668

1

});

1669

1670

	// Encode the call. Balances transact to para_a_account

1671

	// First index

1672

1

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

1673

1

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

1674

1

		relay_chain::Balances,

1675

1

>()

1676

1

	.unwrap() as u8;

1677

1678

1

	encoded.push(index);

1679

1680

	// Then call bytes

1681

1

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

1682

1

		dest: para_a_account(),

1683

1

		value: 100u32.into(),

1684

1

1685

1

	.encode();

1686

1

	encoded.append(&mut call_bytes);

1687

1688

1

	let overall_weight = 4000009000u64;

1689

1

	ParaA::execute_with(|| {

1690

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1691

1

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

1692

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1693

0,

1694

1

			CurrencyPayment {

1695

1

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

1696

1

					Location::parent()

1697

1

				))),

1698

1

				// 1-1 fee weight mapping

1699

1

				fee_amount: Some(overall_weight as u128)

1700

1

},

1701

1

			encoded,

1702

1

			TransactWeights {

1703

1

				transact_required_weight_at_most: 4000000000.into(),

1704

1

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

1705

1

},

1706

			true

1707

));

1708

1

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

1709

1

			.iter()

1710

18

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

1711

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

1712

..

1713

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

1714

18

				_ => None,

1715

18

});

1716

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

1717

1

		assert!(event_found.is_none());

1718

1

});

1719

1720

1

	Relay::execute_with(|| {

1721

		// free execution,x	 full amount received

1722

		// 4000009000 refunded + 100 transferred = 4000009100

1723

1

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

1724

1

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

1725

1

});

1726

1

1727

1728

#[test]

1729

1

fn transact_through_sovereign() {

1730

1

	MockNet::reset();

1731

1732

1

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

1733

1

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

1734

1735

1

	let asset_metadata = parachain::AssetMetadata {

1736

1

		name: b"RelayToken".to_vec(),

1737

1

		symbol: b"Relay".to_vec(),

1738

1

		decimals: 12,

1739

1

};

1740

1741

1

	ParaA::execute_with(|| {

1742

1

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

1743

1

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

1744

1

			.try_into()

1745

1

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

1746

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1747

1

			source_id,

1748

1

			source_location_latest,

1749

1

			asset_metadata.decimals,

1750

1

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

1751

1

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

1752

));

1753

1

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

1754

1755

		// Root can set transact info

1756

1

		assert_ok!(XcmTransactor::set_transact_info(

1757

1

			parachain::RuntimeOrigin::root(),

1758

1

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

1759

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

1760

1

			3000.into(),

1761

1

			20000000000.into(),

1762

1

			None

1763

));

1764

		// Root can set transact info

1765

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1766

1

			parachain::RuntimeOrigin::root(),

1767

1

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

1768

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1769

));

1770

1

});

1771

1772

1

	let dest: Location = AccountKey20 {

1773

1

		network: None,

1774

1

		key: PARAALICE,

1775

1

1776

1

	.into();

1777

1

	Relay::execute_with(|| {

1778

1

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

1779

1

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

1780

1

			assets: Wild(All),

1781

1

			beneficiary: dest.clone(),

1782

1

		}]);

1783

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1784

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1785

1

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

1786

1

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

1787

1

			Box::new(TransferType::LocalReserve),

1788

1

			Box::new(fees_id),

1789

1

			Box::new(TransferType::LocalReserve),

1790

1

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

1791

1

			WeightLimit::Unlimited

1792

));

1793

1

});

1794

1795

1

	ParaA::execute_with(|| {

1796

		// free execution, full amount received

1797

1

		assert_eq!(

1798

1

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

1799

1

			Ok(U256::from(4000003100u64))

1800

);

1801

1

});

1802

1803

	// Register address

1804

1

	ParaA::execute_with(|| {

1805

1

		assert_ok!(XcmTransactor::register(

1806

1

			parachain::RuntimeOrigin::root(),

1807

1

			PARAALICE.into(),

1808

0,

1809

));

1810

1

});

1811

1812

	// Send to registered address

1813

1

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

1814

1

	let dest = Location {

1815

1

		parents: 1,

1816

1

		interior: [AccountId32 {

1817

1

			network: None,

1818

1

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

1819

1

}]

1820

1

		.into(),

1821

1

};

1822

1

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

1823

1824

1

	ParaA::execute_with(|| {

1825

1

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

1826

		// free execution, full amount received

1827

1

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

1828

1

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

1829

1

			assets: Wild(All),

1830

1

			beneficiary: beneficiary.clone(),

1831

1

		}]);

1832

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1833

1

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

1834

1

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

1835

1

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

1836

1

			Box::new(TransferType::DestinationReserve),

1837

1

			Box::new(fees_id),

1838

1

			Box::new(TransferType::DestinationReserve),

1839

1

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

1840

1

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

1841

));

1842

1

});

1843

1844

1

	ParaA::execute_with(|| {

1845

		// free execution, full amount received

1846

1

		assert_eq!(

1847

1

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

1848

1

			Ok(U256::from(4000003000u64))

1849

);

1850

1

});

1851

1852

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

1853

	// again

1854

1

	Relay::execute_with(|| {

1855

		// free execution,x	 full amount received

1856

1

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

1857

1

1858

1

});

1859

1860

	// We send the xcm transact operation to parent

1861

1

	let dest = Location {

1862

1

		parents: 1,

1863

1

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

1864

1

};

1865

1866

	// Encode the call. Balances transact to para_a_account

1867

	// First index

1868

1

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

1869

1

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

1870

1

		relay_chain::Balances,

1871

1

>()

1872

1

	.unwrap() as u8;

1873

1874

1

	encoded.push(index);

1875

1876

	// Then call bytes

1877

1

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

1878

1

		dest: para_a_account(),

1879

1

		value: 100u32.into(),

1880

1

1881

1

	.encode();

1882

1

	encoded.append(&mut call_bytes);

1883

1884

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

1885

1

	ParaA::execute_with(|| {

1886

1

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

1887

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1888

1

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

1889

);

1890

1891

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1892

1

			parachain::RuntimeOrigin::root(),

1893

1

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

1894

1

			Some(PARAALICE.into()),

1895

1

			CurrencyPayment {

1896

1

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

1897

1

					Location::parent()

1898

1

				))),

1899

1

				fee_amount: None

1900

1

},

1901

1

			utility_bytes,

1902

1

			OriginKind::SovereignAccount,

1903

1

			TransactWeights {

1904

1

				transact_required_weight_at_most: 4000000000.into(),

1905

1

				overall_weight: None

1906

1

},

1907

			false

1908

));

1909

1

});

1910

1911

1

	Relay::execute_with(|| {

1912

		// free execution,x	 full amount received

1913

1

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

1914

1915

1

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

1916

1

});

1917

1

1918

1919

#[test]

1920

1

fn transact_through_sovereign_fee_payer_none() {

1921

1

	MockNet::reset();

1922

1923

1

	ParaA::execute_with(|| {

1924

		// Root can set transact info

1925

1

		assert_ok!(XcmTransactor::set_transact_info(

1926

1

			parachain::RuntimeOrigin::root(),

1927

1

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

1928

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

1929

1

			3000.into(),

1930

1

			20000000000.into(),

1931

1

			None

1932

));

1933

		// Root can set transact info

1934

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1935

1

			parachain::RuntimeOrigin::root(),

1936

1

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

1937

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1938

));

1939

1

});

1940

1941

1

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

1942

1943

1

	Relay::execute_with(|| {

1944

		// Transfer 100 tokens to derivative_address on the relay

1945

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1946

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1947

1

			derivative_address.clone(),

1948

			100u128

1949

));

1950

1951

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

1952

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1953

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1954

1

			para_a_account(),

1955

			4000003000u128

1956

));

1957

1

});

1958

1959

	// Check balances before the transact call

1960

1

	Relay::execute_with(|| {

1961

1

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

1962

1

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

1963

1

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

1964

1

});

1965

1966

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

1967

1

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

1968

1

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

1969

1

		relay_chain::Balances,

1970

1

>()

1971

1

	.unwrap() as u8;

1972

1973

1

	encoded.push(index);

1974

1975

1

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

1976

1

		dest: RELAYBOB,

1977

1

		value: 100u32.into(),

1978

1

1979

1

	.encode();

1980

1

	encoded.append(&mut call_bytes);

1981

1982

	// We send the xcm transact operation to parent

1983

1

	let dest = Location {

1984

1

		parents: 1,

1985

1

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

1986

1

};

1987

1988

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

1989

1

	ParaA::execute_with(|| {

1990

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

1991

1

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

1992

1

			moonriver_runtime::xcm_config::Transactors::Relay,

1993

1

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

1994

);

1995

1996

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1997

1

			parachain::RuntimeOrigin::root(),

1998

1

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

1999

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

2000

1

			None,

2001

1

			CurrencyPayment {

2002

1

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

2003

1

					Location::parent()

2004

1

				))),

2005

1

				fee_amount: None

2006

1

},

2007

1

			utility_bytes,

2008

1

			OriginKind::SovereignAccount,

2009

1

			TransactWeights {

2010

1

				transact_required_weight_at_most: 4000000000.into(),

2011

1

				overall_weight: None

2012

1

},

2013

			false

2014

));

2015

1

});

2016

2017

	// Check balances after the transact call are correct

2018

1

	Relay::execute_with(|| {

2019

1

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

2020

1

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

2021

1

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

2022

1

});

2023

1

2024

2025

#[test]

2026

1

fn transact_through_sovereign_with_custom_fee_weight() {

2027

1

	MockNet::reset();

2028

2029

1

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

2030

1

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

2031

2032

1

	let asset_metadata = parachain::AssetMetadata {

2033

1

		name: b"RelayToken".to_vec(),

2034

1

		symbol: b"Relay".to_vec(),

2035

1

		decimals: 12,

2036

1

};

2037

2038

1

	ParaA::execute_with(|| {

2039

1

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

2040

1

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

2041

1

			.try_into()

2042

1

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

2043

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2044

1

			source_id,

2045

1

			source_location_latest,

2046

1

			asset_metadata.decimals,

2047

1

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

2048

1

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

2049

));

2050

1

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

2051

1

});

2052

2053

1

	let dest: Location = AccountKey20 {

2054

1

		network: None,

2055

1

		key: PARAALICE,

2056

1

2057

1

	.into();

2058

1

	Relay::execute_with(|| {

2059

1

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

2060

1

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

2061

1

			assets: Wild(All),

2062

1

			beneficiary: dest.clone(),

2063

1

		}]);

2064

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2065

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2066

1

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

2067

1

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

2068

1

			Box::new(TransferType::LocalReserve),

2069

1

			Box::new(fees_id),

2070

1

			Box::new(TransferType::LocalReserve),

2071

1

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

2072

1

			WeightLimit::Unlimited

2073

));

2074

1

});

2075

2076

1

	ParaA::execute_with(|| {

2077

		// free execution, full amount received

2078

1

		assert_eq!(

2079

1

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

2080

1

			Ok(U256::from(4000003100u64))

2081

);

2082

1

});

2083

2084

	// Register address

2085

1

	ParaA::execute_with(|| {

2086

1

		assert_ok!(XcmTransactor::register(

2087

1

			parachain::RuntimeOrigin::root(),

2088

1

			PARAALICE.into(),

2089

0,

2090

));

2091

1

});

2092

2093

	// Send to registered address

2094

1

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

2095

1

	let dest = Location {

2096

1

		parents: 1,

2097

1

		interior: [AccountId32 {

2098

1

			network: None,

2099

1

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

2100

1

}]

2101

1

		.into(),

2102

1

};

2103

1

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

2104

2105

1

	ParaA::execute_with(|| {

2106

1

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

2107

		// free execution, full amount received

2108

1

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

2109

1

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

2110

1

			assets: Wild(All),

2111

1

			beneficiary: beneficiary.clone(),

2112

1

		}]);

2113

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2114

1

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

2115

1

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

2116

1

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

2117

1

			Box::new(TransferType::DestinationReserve),

2118

1

			Box::new(fees_id),

2119

1

			Box::new(TransferType::DestinationReserve),

2120

1

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

2121

1

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

2122

));

2123

1

});

2124

2125

1

	ParaA::execute_with(|| {

2126

		// free execution, full amount received

2127

1

		assert_eq!(

2128

1

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

2129

1

			Ok(U256::from(4000003000u64))

2130

);

2131

1

});

2132

2133

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

2134

	// again

2135

1

	Relay::execute_with(|| {

2136

		// free execution,x	 full amount received

2137

1

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

2138

1

2139

1

});

2140

2141

	// We send the xcm transact operation to parent

2142

1

	let dest = Location {

2143

1

		parents: 1,

2144

1

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

2145

1

};

2146

2147

	// Encode the call. Balances transact to para_a_account

2148

	// First index

2149

1

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

2150

1

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

2151

1

		relay_chain::Balances,

2152

1

>()

2153

1

	.unwrap() as u8;

2154

2155

1

	encoded.push(index);

2156

2157

	// Then call bytes

2158

1

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

2159

1

		dest: para_a_account(),

2160

1

		value: 100u32.into(),

2161

1

2162

1

	.encode();

2163

1

	encoded.append(&mut call_bytes);

2164

2165

1

	let total_weight = 4000003000u64;

2166

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

2167

1

	ParaA::execute_with(|| {

2168

1

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

2169

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2170

1

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

2171

);

2172

2173

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2174

1

			parachain::RuntimeOrigin::root(),

2175

1

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

2176

1

			Some(PARAALICE.into()),

2177

1

			CurrencyPayment {

2178

1

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

2179

1

					Location::parent()

2180

1

				))),

2181

1

				// 1-1 fee-weight mapping

2182

1

				fee_amount: Some(total_weight as u128)

2183

1

},

2184

1

			utility_bytes,

2185

1

			OriginKind::SovereignAccount,

2186

1

			TransactWeights {

2187

1

				transact_required_weight_at_most: 4000000000.into(),

2188

1

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

2189

1

},

2190

			false

2191

));

2192

1

});

2193

2194

1

	Relay::execute_with(|| {

2195

		// free execution,x	 full amount received

2196

1

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

2197

2198

1

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

2199

1

});

2200

1

2201

2202

#[test]

2203

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2204

1

	MockNet::reset();

2205

2206

1

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

2207

1

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

2208

2209

1

	let asset_metadata = parachain::AssetMetadata {

2210

1

		name: b"RelayToken".to_vec(),

2211

1

		symbol: b"Relay".to_vec(),

2212

1

		decimals: 12,

2213

1

};

2214

2215

1

	ParaA::execute_with(|| {

2216

1

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

2217

1

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

2218

1

			.try_into()

2219

1

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

2220

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2221

1

			source_id,

2222

1

			source_location_latest,

2223

1

			asset_metadata.decimals,

2224

1

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

2225

1

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

2226

));

2227

1

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

2228

1

});

2229

2230

1

	let dest: Location = AccountKey20 {

2231

1

		network: None,

2232

1

		key: PARAALICE,

2233

1

2234

1

	.into();

2235

1

	Relay::execute_with(|| {

2236

1

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

2237

1

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

2238

1

			assets: Wild(All),

2239

1

			beneficiary: dest.clone(),

2240

1

		}]);

2241

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2242

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2243

1

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

2244

1

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

2245

1

			Box::new(TransferType::LocalReserve),

2246

1

			Box::new(fees_id),

2247

1

			Box::new(TransferType::LocalReserve),

2248

1

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

2249

1

			WeightLimit::Unlimited

2250

));

2251

1

});

2252

2253

1

	ParaA::execute_with(|| {

2254

		// free execution, full amount received

2255

1

		assert_eq!(

2256

1

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

2257

1

			Ok(U256::from(4000009100u64))

2258

);

2259

1

});

2260

2261

	// Register address

2262

1

	ParaA::execute_with(|| {

2263

1

		assert_ok!(XcmTransactor::register(

2264

1

			parachain::RuntimeOrigin::root(),

2265

1

			PARAALICE.into(),

2266

0,

2267

));

2268

1

});

2269

2270

	// Send to registered address

2271

1

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

2272

1

	let dest = Location {

2273

1

		parents: 1,

2274

1

		interior: [AccountId32 {

2275

1

			network: None,

2276

1

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

2277

1

}]

2278

1

		.into(),

2279

1

};

2280

1

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

2281

2282

1

	ParaA::execute_with(|| {

2283

1

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

2284

		// free execution, full amount received

2285

1

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

2286

1

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

2287

1

			assets: Wild(All),

2288

1

			beneficiary: beneficiary.clone(),

2289

1

		}]);

2290

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2291

1

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

2292

1

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

2293

1

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

2294

1

			Box::new(TransferType::DestinationReserve),

2295

1

			Box::new(fees_id),

2296

1

			Box::new(TransferType::DestinationReserve),

2297

1

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

2298

1

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

2299

));

2300

1

});

2301

2302

1

	ParaA::execute_with(|| {

2303

		// free execution, full amount received

2304

1

		assert_eq!(

2305

1

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

2306

1

			Ok(U256::from(4000009000u64))

2307

);

2308

1

});

2309

2310

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

2311

	// again

2312

1

	Relay::execute_with(|| {

2313

		// free execution,x	 full amount received

2314

1

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

2315

1

2316

1

});

2317

2318

	// We send the xcm transact operation to parent

2319

1

	let dest = Location {

2320

1

		parents: 1,

2321

1

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

2322

1

};

2323

2324

	// Encode the call. Balances transact to para_a_account

2325

	// First index

2326

1

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

2327

1

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

2328

1

		relay_chain::Balances,

2329

1

>()

2330

1

	.unwrap() as u8;

2331

2332

1

	encoded.push(index);

2333

2334

	// Then call bytes

2335

1

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

2336

1

		dest: para_a_account(),

2337

1

		value: 100u32.into(),

2338

1

2339

1

	.encode();

2340

1

	encoded.append(&mut call_bytes);

2341

2342

1

	let total_weight = 4000009000u64;

2343

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

2344

1

	ParaA::execute_with(|| {

2345

1

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

2346

1

			moonriver_runtime::xcm_config::Transactors::Relay,

2347

1

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

2348

);

2349

2350

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2351

1

			parachain::RuntimeOrigin::root(),

2352

1

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

2353

1

			Some(PARAALICE.into()),

2354

1

			CurrencyPayment {

2355

1

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

2356

1

					Location::parent()

2357

1

				))),

2358

1

				// 1-1 fee-weight mapping

2359

1

				fee_amount: Some(total_weight as u128)

2360

1

},

2361

1

			utility_bytes,

2362

1

			OriginKind::SovereignAccount,

2363

1

			TransactWeights {

2364

1

				transact_required_weight_at_most: 4000000000.into(),

2365

1

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

2366

1

},

2367

			true

2368

));

2369

1

});

2370

2371

1

	Relay::execute_with(|| {

2372

		// free execution, full amount received

2373

		// 4000009000 refunded + 100 transferred = 4000009100

2374

1

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

2375

2376

1

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

2377

1

});

2378

1

2379

2380

#[test]

2381

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2382

1

	MockNet::reset();

2383

2384

1

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

2385

1

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

2386

1

	let asset_metadata = parachain::AssetMetadata {

2387

1

		name: b"RelayToken".to_vec(),

2388

1

		symbol: b"Relay".to_vec(),

2389

1

		decimals: 12,

2390

1

};

2391

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

2392

1

	ParaA::execute_with(|| {

2393

1

		parachain::XcmVersioner::set_version(1);

2394

1

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

2395

1

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

2396

1

			.try_into()

2397

1

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

2398

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2399

1

			source_id,

2400

1

			source_location_latest,

2401

1

			asset_metadata.decimals,

2402

1

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

2403

1

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

2404

));

2405

1

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

2406

1

});

2407

2408

1

	let response = Response::Version(2);

2409

1

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

2410

2411

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

2412

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

2413

1

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

2414

1

		query_id: 0,

2415

1

		response,

2416

1

		max_weight: Weight::zero(),

2417

1

		querier: Some(querier),

2418

1

	}]);

2419

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

2420

	// it directly here

2421

	// Actually send relay asset to parachain

2422

1

	let dest: Location = AccountKey20 {

2423

1

		network: None,

2424

1

		key: PARAALICE,

2425

1

2426

1

	.into();

2427

2428

1

	Relay::execute_with(|| {

2429

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

2430

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2431

1

			relay_chain::RuntimeOrigin::root(),

2432

1

			Some(3)

2433

));

2434

2435

		// Wrap version, which sets VersionedStorage

2436

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

2437

		// this is not necessary in prod

2438

1

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

2439

1

			&Parachain(1).into(),

2440

1

			mock_message

2441

));

2442

2443

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

2444

1

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

2445

1

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

2446

1

			assets: Wild(All),

2447

1

			beneficiary: dest.clone(),

2448

1

		}]);

2449

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2450

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2451

1

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

2452

1

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

2453

1

			Box::new(TransferType::LocalReserve),

2454

1

			Box::new(fees_id),

2455

1

			Box::new(TransferType::LocalReserve),

2456

1

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

2457

1

			WeightLimit::Unlimited

2458

));

2459

2460

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

2461

1

		relay_chain::relay_roll_to(2);

2462

2463

		// queries should have been updated

2464

1

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

2465

1

});

2466

2467

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2468

1

		pallet_xcm::Event::SupportedVersionChanged {

2469

1

			location: Location {

2470

1

				parents: 0,

2471

1

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

2472

1

},

2473

1

			version: 1,

2474

1

2475

1

		.into();

2476

2477

1

	Relay::execute_with(|| {

2478

		// Assert that the events vector contains the version change

2479

1

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

2480

1

});

2481

2482

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

2483

	// of the new version change

2484

1

	ParaA::execute_with(|| {

2485

		// Set version

2486

1

		parachain::XcmVersioner::set_version(2);

2487

		// Do runtime upgrade

2488

1

		parachain::on_runtime_upgrade();

2489

		// Initialize block, to call on_initialize and notify targets

2490

1

		parachain::para_roll_to(2);

2491

		// Expect the event in the parachain

2492

1

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

2493

2

e,

2494

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

2495

				result: 2,

2496

..

2497

})

2498

		)));

2499

1

});

2500

2501

	// This event should have been seen in the relay

2502

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2503

1

		pallet_xcm::Event::SupportedVersionChanged {

2504

1

			location: Location {

2505

1

				parents: 0,

2506

1

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

2507

1

},

2508

1

			version: 2,

2509

1

2510

1

		.into();

2511

2512

1

	Relay::execute_with(|| {

2513

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

2514

1

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

2515

1

});

2516

1

2517

2518

#[test]

2519

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2520

1

	MockNet::reset();

2521

2522

1

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

2523

1

	let source_location: AssetType = para_a_balances

2524

1

		.try_into()

2525

1

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

2526

1

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

2527

2528

1

	let asset_metadata = parachain::AssetMetadata {

2529

1

		name: b"ParaAToken".to_vec(),

2530

1

		symbol: b"ParaA".to_vec(),

2531

1

		decimals: 18,

2532

1

};

2533

1

	let response = Response::Version(2);

2534

1

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

2535

1

		.into();

2536

2537

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

2538

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

2539

1

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

2540

1

		query_id: 0,

2541

1

		response,

2542

1

		max_weight: Weight::zero(),

2543

1

		querier: Some(querier),

2544

1

	}]);

2545

2546

1

	ParaA::execute_with(|| {

2547

		// advertised version

2548

1

		parachain::XcmVersioner::set_version(2);

2549

1

});

2550

2551

1

	ParaB::execute_with(|| {

2552

		// Let's try with v0

2553

1

		parachain::XcmVersioner::set_version(0);

2554

2555

1

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

2556

1

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

2557

1

			.try_into()

2558

1

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

2559

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2560

1

			source_id,

2561

1

			source_location_latest,

2562

1

			asset_metadata.decimals,

2563

1

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

2564

1

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

2565

));

2566

1

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

2567

1

});

2568

2569

1

	ParaA::execute_with(|| {

2570

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

2571

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2572

1

			parachain::RuntimeOrigin::root(),

2573

1

			Some(3)

2574

));

2575

		// Wrap version, which sets VersionedStorage

2576

1

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

2577

1

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

2578

1

			mock_message

2579

));

2580

2581

1

		parachain::para_roll_to(2);

2582

2583

		// queries should have been updated

2584

1

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

2585

1

});

2586

2587

1

	let expected_supported_version: parachain::RuntimeEvent =

2588

1

		pallet_xcm::Event::SupportedVersionChanged {

2589

1

			location: Location {

2590

1

				parents: 1,

2591

1

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

2592

1

},

2593

1

			version: 0,

2594

1

2595

1

		.into();

2596

2597

1

	ParaA::execute_with(|| {

2598

		// Assert that the events vector contains the version change

2599

1

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

2600

1

});

2601

2602

	// Let's ensure talking in v0 works

2603

1

	let dest = Location {

2604

1

		parents: 1,

2605

1

		interior: [

2606

1

			Parachain(2),

2607

1

			AccountKey20 {

2608

1

				network: None,

2609

1

				key: PARAALICE.into(),

2610

1

},

2611

1

2612

1

		.into(),

2613

1

};

2614

1

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

2615

1

	ParaA::execute_with(|| {

2616

1

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

2617

		// free execution, full amount received

2618

1

		assert_ok!(PolkadotXcm::transfer_assets(

2619

1

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

2620

1

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

2621

1

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

2622

1

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

2623

0,

2624

1

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

2625

));

2626

		// free execution, full amount received

2627

1

		assert_eq!(

2628

1

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

2629

			INITIAL_BALANCE - 100

2630

);

2631

1

});

2632

2633

1

	ParaB::execute_with(|| {

2634

		// free execution, full amount received

2635

1

		assert_eq!(

2636

1

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

2637

1

			Ok(U256::from(100))

2638

);

2639

1

});

2640

2641

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

2642

	// of the new version change

2643

1

	ParaB::execute_with(|| {

2644

		// Set version

2645

1

		parachain::XcmVersioner::set_version(2);

2646

		// Do runtime upgrade

2647

1

		parachain::on_runtime_upgrade();

2648

		// Initialize block, to call on_initialize and notify targets

2649

1

		parachain::para_roll_to(2);

2650

		// Expect the event in the parachain

2651

1

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

2652

2

e,

2653

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

2654

				result: 2,

2655

..

2656

})

2657

		)));

2658

1

});

2659

2660

	// This event should have been seen in para A

2661

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2662

1

		pallet_xcm::Event::SupportedVersionChanged {

2663

1

			location: Location {

2664

1

				parents: 1,

2665

1

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

2666

1

},

2667

1

			version: 2,

2668

1

2669

1

		.into();

2670

2671

	// Para A should have received the version change

2672

1

	ParaA::execute_with(|| {

2673

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

2674

1

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

2675

1

});

2676

1

2677

2678

#[test]

2679

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2680

1

	MockNet::reset();

2681

2682

1

	let fresh_account = PARABOB;

2683

1

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

2684

1

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

2685

1

	let asset_metadata = parachain::AssetMetadata {

2686

1

		name: b"RelayToken".to_vec(),

2687

1

		symbol: b"Relay".to_vec(),

2688

1

		decimals: 12,

2689

1

};

2690

	// register relay asset in parachain A

2691

1

	ParaA::execute_with(|| {

2692

1

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

2693

1

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

2694

1

			.try_into()

2695

1

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

2696

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2697

1

			source_id,

2698

1

			source_location_latest,

2699

1

			asset_metadata.decimals,

2700

1

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

2701

1

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

2702

));

2703

1

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

2704

1

});

2705

2706

	// Actually send relay asset to parachain

2707

1

	let dest: Location = AccountKey20 {

2708

1

		network: None,

2709

1

		key: fresh_account,

2710

1

2711

1

	.into();

2712

1

	Relay::execute_with(|| {

2713

1

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

2714

1

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

2715

1

			assets: Wild(All),

2716

1

			beneficiary: dest.clone(),

2717

1

		}]);

2718

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2719

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2720

1

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

2721

1

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

2722

1

			Box::new(TransferType::LocalReserve),

2723

1

			Box::new(fees_id),

2724

1

			Box::new(TransferType::LocalReserve),

2725

1

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

2726

1

			WeightLimit::Unlimited

2727

));

2728

1

});

2729

2730

	// parachain should have received assets

2731

1

	ParaA::execute_with(|| {

2732

		// free execution, full amount received

2733

1

		assert_eq!(

2734

1

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

2735

1

			Ok(U256::from(123))

2736

);

2737

1

});

2738

1

2739

2740

#[test]

2741

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2742

1

	MockNet::reset();

2743

2744

1

	let fresh_account = [2u8; 20];

2745

1

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

2746

1

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

2747

1

	let asset_metadata = parachain::AssetMetadata {

2748

1

		name: b"RelayToken".to_vec(),

2749

1

		symbol: b"Relay".to_vec(),

2750

1

		decimals: 12,

2751

1

};

2752

	// register relay asset in parachain A

2753

1

	ParaA::execute_with(|| {

2754

1

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

2755

1

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

2756

1

			.try_into()

2757

1

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

2758

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2759

1

			source_id,

2760

1

			source_location_latest,

2761

1

			asset_metadata.decimals,

2762

1

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

2763

1

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

2764

));

2765

1

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

2766

1

});

2767

2768

	// Actually send relay asset to parachain

2769

1

	let dest: Location = AccountKey20 {

2770

1

		network: None,

2771

1

		key: fresh_account,

2772

1

2773

1

	.into();

2774

1

	Relay::execute_with(|| {

2775

1

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

2776

1

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

2777

1

			assets: Wild(All),

2778

1

			beneficiary: dest.clone(),

2779

1

		}]);

2780

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2781

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2782

1

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

2783

1

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

2784

1

			Box::new(TransferType::LocalReserve),

2785

1

			Box::new(fees_id),

2786

1

			Box::new(TransferType::LocalReserve),

2787

1

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

2788

1

			WeightLimit::Unlimited

2789

));

2790

1

});

2791

2792

	// parachain should have received assets

2793

1

	ParaA::execute_with(|| {

2794

		// free execution, full amount received

2795

1

		assert_eq!(

2796

1

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

2797

1

			Ok(U256::from(123))

2798

);

2799

1

});

2800

1

2801

2802

#[test]

2803

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2804

1

	MockNet::reset();

2805

2806

1

	let mut sufficient_account = [0u8; 20];

2807

1

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

2808

2809

1

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

2810

2811

	// Evm account is self sufficient

2812

1

	ParaA::execute_with(|| {

2813

1

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

2814

1

});

2815

2816

1

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

2817

1

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

2818

1

	let asset_metadata = parachain::AssetMetadata {

2819

1

		name: b"RelayToken".to_vec(),

2820

1

		symbol: b"Relay".to_vec(),

2821

1

		decimals: 12,

2822

1

};

2823

	// register relay asset in parachain A

2824

1

	ParaA::execute_with(|| {

2825

1

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

2826

1

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

2827

1

			.try_into()

2828

1

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

2829

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2830

1

			source_id,

2831

1

			source_location_latest,

2832

1

			asset_metadata.decimals,

2833

1

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

2834

1

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

2835

));

2836

1

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

2837

1

});

2838

2839

	// Actually send relay asset to parachain

2840

1

	let dest: Location = AccountKey20 {

2841

1

		network: None,

2842

1

		key: sufficient_account,

2843

1

2844

1

	.into();

2845

1

	Relay::execute_with(|| {

2846

1

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

2847

1

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

2848

1

			assets: Wild(All),

2849

1

			beneficiary: dest.clone(),

2850

1

		}]);

2851

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2852

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2853

1

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

2854

1

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

2855

1

			Box::new(TransferType::LocalReserve),

2856

1

			Box::new(fees_id),

2857

1

			Box::new(TransferType::LocalReserve),

2858

1

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

2859

1

			WeightLimit::Unlimited

2860

));

2861

1

});

2862

2863

	// Evm account sufficient ref count increased by 1.

2864

1

	ParaA::execute_with(|| {

2865

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

2866

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

2867

		// will be implemented in a future release

2868

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

2869

1

});

2870

2871

1

	ParaA::execute_with(|| {

2872

		// Remove the account from the evm context.

2873

1

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

2874

		// Evm account sufficient ref count decreased by 1.

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, 1);

2879

1

});

2880

1

2881

2882

#[test]

2883

1

fn empty_account_should_not_be_reset() {

2884

1

	MockNet::reset();

2885

2886

	// Test account has nonce 1 on genesis.

2887

1

	let sufficient_account = PARABOB;

2888

2889

1

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

2890

2891

1

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

2892

1

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

2893

1

	let asset_metadata = parachain::AssetMetadata {

2894

1

		name: b"RelayToken".to_vec(),

2895

1

		symbol: b"Relay".to_vec(),

2896

1

		decimals: 12,

2897

1

};

2898

	// register relay asset in parachain A

2899

1

	ParaA::execute_with(|| {

2900

1

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

2901

1

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

2902

1

			.try_into()

2903

1

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

2904

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2905

1

			source_id,

2906

1

			source_location_latest,

2907

1

			asset_metadata.decimals,

2908

1

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

2909

1

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

2910

));

2911

1

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

2912

1

});

2913

2914

	// Send native token to evm_account

2915

1

	ParaA::execute_with(|| {

2916

1

		assert_ok!(ParaBalances::transfer_allow_death(

2917

1

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

2918

1

			evm_account_id,

2919

2920

));

2921

1

});

2922

2923

	// Actually send relay asset to parachain

2924

1

	let dest: Location = AccountKey20 {

2925

1

		network: None,

2926

1

		key: sufficient_account,

2927

1

2928

1

	.into();

2929

1

	Relay::execute_with(|| {

2930

1

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

2931

1

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

2932

1

			assets: Wild(All),

2933

1

			beneficiary: dest.clone(),

2934

1

		}]);

2935

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2936

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2937

1

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

2938

1

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

2939

1

			Box::new(TransferType::LocalReserve),

2940

1

			Box::new(fees_id),

2941

1

			Box::new(TransferType::LocalReserve),

2942

1

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

2943

1

			WeightLimit::Unlimited

2944

));

2945

1

});

2946

2947

1

	ParaA::execute_with(|| {

2948

		// Empty the assets from the account.

2949

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

2950

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

2951

		// Transfer the assets from evm_account to PARAALICE

2952

1

		assert_ok!(EvmForeignAssets::transfer(

2953

1

			source_id,

2954

1

			evm_account_id,

2955

1

			PARAALICE.into(),

2956

1

			U256::from(123)

2957

));

2958

		// Verify account asset balance is Zero.

2959

1

		assert_eq!(

2960

1

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

2961

1

			Ok(U256::from(0))

2962

);

2963

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

2964

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

2965

1

		assert_ok!(ParaBalances::force_set_balance(

2966

1

			parachain::RuntimeOrigin::root(),

2967

1

			evm_account_id,

2968

0,

2969

));

2970

		// Verify account native balance is Zero.

2971

1

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

2972

		// Remove the account from the evm context.

2973

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

2974

1

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

2975

		// Verify reference count.

2976

1

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

2977

1

		assert_eq!(account.sufficients, 0);

2978

1

		assert_eq!(account.consumers, 0);

2979

1

		assert_eq!(account.providers, 1);

2980

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

2981

1

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

2982

1

});

2983

1

2984

2985

#[test]

2986

1

fn test_statemine_like() {

2987

1

	MockNet::reset();

2988

2989

1

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

2990

2991

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2992

1

		polkadot_parachain::primitives::Sibling,

2993

1

		statemine_like::AccountId,

2994

1

	>::convert_location(&dest_para)

2995

1

	.unwrap();

2996

2997

1

	let statemine_asset_a_balances = Location::new(

2998

1,

2999

1

3000

1

			Parachain(1000),

3001

1

			PalletInstance(5),

3002

1

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

3003

1

],

3004

);

3005

1

	let source_location: AssetType = statemine_asset_a_balances

3006

1

		.try_into()

3007

1

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

3008

1

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

3009

3010

1

	let asset_metadata = parachain::AssetMetadata {

3011

1

		name: b"StatemineToken".to_vec(),

3012

1

		symbol: b"StatemineToken".to_vec(),

3013

1

		decimals: 12,

3014

1

};

3015

3016

1

	ParaA::execute_with(|| {

3017

1

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

3018

1

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

3019

1

			.try_into()

3020

1

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

3021

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3022

1

			source_id,

3023

1

			source_location_latest,

3024

1

			asset_metadata.decimals,

3025

1

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

3026

1

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

3027

));

3028

1

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

3029

1

});

3030

3031

1

	Statemine::execute_with(|| {

3032

		// Set new prefix

3033

1

		statemine_like::PrefixChanger::set_prefix(

3034

1

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

3035

);

3036

1

		assert_ok!(StatemineAssets::create(

3037

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3038

0,

3039

			RELAYALICE,

3040

3041

));

3042

3043

1

		assert_ok!(StatemineAssets::mint(

3044

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3045

0,

3046

			RELAYALICE,

3047

			300000000000000

3048

));

3049

3050

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

3051

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3052

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3053

1

			sov,

3054

			100000000000000

3055

));

3056

3057

		// Actually send relay asset to parachain

3058

1

		let dest: Location = AccountKey20 {

3059

1

			network: None,

3060

1

			key: PARAALICE,

3061

1

3062

1

		.into();

3063

3064

		// Send with new prefix

3065

1

		let asset_location = Location::new(

3066

0,

3067

1

3068

1

				xcm::latest::prelude::PalletInstance(

3069

1

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

3070

1

),

3071

1

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

3072

1

],

3073

);

3074

1

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

3075

1

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

3076

1

			assets: Wild(All),

3077

1

			beneficiary: dest.clone(),

3078

1

		}]);

3079

1

		assert_ok!(

3080

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3081

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3082

1

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

3083

1

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

3084

1

				Box::new(TransferType::LocalReserve),

3085

1

				Box::new(fees_id),

3086

1

				Box::new(TransferType::LocalReserve),

3087

1

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

3088

1

				WeightLimit::Unlimited

3089

3090

);

3091

1

});

3092

3093

1

	ParaA::execute_with(|| {

3094

1

		assert_eq!(

3095

1

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

3096

1

			Ok(U256::from(123))

3097

);

3098

1

});

3099

1

3100

3101

#[test]

3102

1

fn send_statemine_asset_from_para_a_to_statemine_with_relay_fee() {

3103

1

	MockNet::reset();

3104

3105

	// Relay asset

3106

1

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

3107

1

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

3108

3109

1

	let relay_asset_metadata = parachain::AssetMetadata {

3110

1

		name: b"RelayToken".to_vec(),

3111

1

		symbol: b"Relay".to_vec(),

3112

1

		decimals: 12,

3113

1

};

3114

3115

	// Statemine asset

3116

1

	let statemine_asset = Location::new(

3117

1,

3118

1

3119

1

			Parachain(1000u32),

3120

1

			PalletInstance(5u8),

3121

1

			GeneralIndex(10u128),

3122

1

],

3123

);

3124

1

	let statemine_location_asset: AssetType = statemine_asset

3125

1

		.clone()

3126

1

		.try_into()

3127

1

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

3128

1

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

3129

3130

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3131

1

		name: b"USDC".to_vec(),

3132

1

		symbol: b"USDC".to_vec(),

3133

1

		decimals: 12,

3134

1

};

3135

3136

1

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

3137

3138

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3139

1

		polkadot_parachain::primitives::Sibling,

3140

1

		statemine_like::AccountId,

3141

1

	>::convert_location(&dest_para)

3142

1

	.unwrap();

3143

3144

1

	ParaA::execute_with(|| {

3145

1

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

3146

1

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

3147

1

			.try_into()

3148

1

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

3149

1

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

3150

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3151

1

			relay_id,

3152

1

			relay_location_latest,

3153

1

			relay_asset_metadata.decimals,

3154

1

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

3155

1

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

3156

));

3157

1

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

3158

3159

1

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

3160

1

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

3161

1

			.try_into()

3162

1

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

3163

1

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

3164

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3165

1

			statemine_id,

3166

1

			statemine_location_latest,

3167

1

			asset_metadata_statemine_asset.decimals,

3168

1

			asset_metadata_statemine_asset

3169

1

				.symbol

3170

1

				.try_into()

3171

1

				.expect("too long"),

3172

1

			asset_metadata_statemine_asset

3173

1

				.name

3174

1

				.try_into()

3175

1

				.expect("too long"),

3176

));

3177

1

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

3178

1

});

3179

3180

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3181

1

		network: None,

3182

1

		key: PARAALICE,

3183

1

3184

1

	.into();

3185

3186

	// Send relay chain asset to Alice in Parachain A

3187

1

	Relay::execute_with(|| {

3188

1

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

3189

1

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

3190

1

			assets: Wild(All),

3191

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

3192

1

		}]);

3193

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

3194

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3195

1

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

3196

1

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

3197

1

			Box::new(TransferType::LocalReserve),

3198

1

			Box::new(fees_id),

3199

1

			Box::new(TransferType::LocalReserve),

3200

1

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

3201

1

			WeightLimit::Unlimited

3202

));

3203

1

});

3204

3205

1

	Statemine::execute_with(|| {

3206

		// Set new prefix

3207

1

		statemine_like::PrefixChanger::set_prefix(

3208

1

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

3209

);

3210

3211

1

		assert_ok!(StatemineAssets::create(

3212

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3213

10,

3214

			RELAYALICE,

3215

3216

));

3217

3218

1

		assert_ok!(StatemineAssets::mint(

3219

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3220

10,

3221

			RELAYALICE,

3222

			300000000000000

3223

));

3224

3225

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

3226

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

3227

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3228

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3229

1

			sov,

3230

			100000000000000

3231

));

3232

3233

		// Send statemine USDC asset to Alice in Parachain A

3234

1

		let parachain_beneficiary_from_statemine: Location = AccountKey20 {

3235

1

			network: None,

3236

1

			key: PARAALICE,

3237

1

3238

1

		.into();

3239

3240

		// Send with new prefix

3241

1

		let asset_location = Location::new(

3242

0,

3243

1

3244

1

				xcm::latest::prelude::PalletInstance(

3245

1

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

3246

1

),

3247

1

				GeneralIndex(10),

3248

1

],

3249

);

3250

1

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

3251

1

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

3252

1

			assets: Wild(All),

3253

1

			beneficiary: parachain_beneficiary_from_statemine.clone(),

3254

1

		}]);

3255

1

		assert_ok!(

3256

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3257

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3258

1

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

3259

1

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

3260

1

				Box::new(TransferType::LocalReserve),

3261

1

				Box::new(fees_id),

3262

1

				Box::new(TransferType::LocalReserve),

3263

1

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

3264

1

				WeightLimit::Unlimited

3265

3266

);

3267

1

});

3268

3269

1

	let statemine_beneficiary = Location {

3270

1

		parents: 1,

3271

1

		interior: [

3272

1

			Parachain(1000),

3273

1

			AccountId32 {

3274

1

				network: None,

3275

1

				id: RELAYBOB.into(),

3276

1

},

3277

1

3278

1

		.into(),

3279

1

};

3280

3281

1

	ParaA::execute_with(|| {

3282

		// Alice has received 125 USDC

3283

1

		assert_eq!(

3284

1

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

3285

1

			Ok(U256::from(125))

3286

);

3287

3288

		// Alice has received 200 Relay assets

3289

1

		assert_eq!(

3290

1

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

3291

1

			Ok(U256::from(200))

3292

);

3293

1

});

3294

3295

1

	Statemine::execute_with(|| {

3296

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

3297

1

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

3298

1

});

3299

1

	let (chain_part, beneficiary) =

3300

1

		split_location_into_chain_part_and_beneficiary(statemine_beneficiary).unwrap();

3301

3302

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

3303

1

	ParaA::execute_with(|| {

3304

1

		let asset_1 = currency_to_asset(

3305

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

3306

			100,

3307

);

3308

1

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

3309

1

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

3310

1

		let assets_to_send = vec![asset_1, asset_2];

3311

1

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

3312

1

			assets: Wild(All),

3313

1

			beneficiary: beneficiary.clone(),

3314

1

		}]);

3315

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3316

1

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

3317

1

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

3318

1

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

3319

1

			Box::new(TransferType::DestinationReserve),

3320

1

			Box::new(fees_id),

3321

1

			Box::new(TransferType::DestinationReserve),

3322

1

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

3323

1

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

3324

));

3325

1

});

3326

3327

1

	ParaA::execute_with(|| {

3328

		// Alice has 100 USDC less

3329

1

		assert_eq!(

3330

1

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

3331

1

			Ok(U256::from(25))

3332

);

3333

3334

		// Alice has 100 relay asset less

3335

1

		assert_eq!(

3336

1

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

3337

1

			Ok(U256::from(100))

3338

);

3339

1

});

3340

3341

1

	Statemine::execute_with(|| {

3342

		// Check that BOB received 100 USDC on statemine

3343

1

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

3344

1

});

3345

1

3346

3347

#[test]

3348

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer() {

3349

1

	MockNet::reset();

3350

3351

	// Relay asset

3352

1

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

3353

1

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

3354

3355

1

	let relay_asset_metadata = parachain::AssetMetadata {

3356

1

		name: b"RelayToken".to_vec(),

3357

1

		symbol: b"Relay".to_vec(),

3358

1

		decimals: 12,

3359

1

};

3360

3361

1

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

3362

3363

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3364

1

		polkadot_parachain::primitives::Sibling,

3365

1

		statemine_like::AccountId,

3366

1

	>::convert_location(&dest_para)

3367

1

	.unwrap();

3368

3369

1

	ParaA::execute_with(|| {

3370

1

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

3371

1

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

3372

1

			.try_into()

3373

1

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

3374

1

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

3375

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3376

1

			source_id,

3377

1

			source_location_latest,

3378

1

			relay_asset_metadata.decimals,

3379

1

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

3380

1

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

3381

));

3382

1

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

3383

1

});

3384

3385

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3386

1

		network: None,

3387

1

		key: PARAALICE,

3388

1

3389

1

	.into();

3390

3391

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3392

1

		network: None,

3393

1

		id: RELAYALICE.into(),

3394

1

3395

1

	.into();

3396

3397

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

3398

1

	Relay::execute_with(|| {

3399

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3400

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3401

1

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

3402

1

			Box::new(

3403

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3404

1

					.clone()

3405

1

					.into()

3406

),

3407

1

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

3408

0,

3409

1

			WeightLimit::Unlimited

3410

));

3411

1

});

3412

3413

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3414

1

	Statemine::execute_with(|| {

3415

		// Check Alice received 200 tokens on AssetHub

3416

1

		assert_eq!(

3417

1

			StatemineBalances::free_balance(RELAYALICE),

3418

			INITIAL_BALANCE + 200

3419

);

3420

3421

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3422

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3423

1

			sov,

3424

			110000000000000

3425

));

3426

3427

		// Now send those tokens to ParaA

3428

1

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

3429

1

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

3430

1

			assets: Wild(All),

3431

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3432

1

		}]);

3433

1

		assert_ok!(

3434

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3435

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3436

1

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

3437

1

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

3438

1

				Box::new(TransferType::LocalReserve),

3439

1

				Box::new(fees_id),

3440

1

				Box::new(TransferType::LocalReserve),

3441

1

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

3442

1

				WeightLimit::Unlimited

3443

3444

);

3445

1

});

3446

3447

1

	ParaA::execute_with(|| {

3448

		// Alice should have received the DOTs

3449

1

		assert_eq!(

3450

1

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

3451

1

			Ok(U256::from(200))

3452

);

3453

1

});

3454

3455

1

	let dest = Location::new(

3456

1,

3457

1

3458

1

			Parachain(1000),

3459

1

			AccountId32 {

3460

1

				network: None,

3461

1

				id: RELAYBOB.into(),

3462

1

},

3463

1

],

3464

);

3465

1

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

3466

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

3467

1

	ParaA::execute_with(|| {

3468

1

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

3469

1

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

3470

1

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

3471

1

			assets: Wild(All),

3472

1

			beneficiary: beneficiary.clone(),

3473

1

		}]);

3474

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3475

1

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

3476

1

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

3477

1

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

3478

1

			Box::new(TransferType::DestinationReserve),

3479

1

			Box::new(fees_id),

3480

1

			Box::new(TransferType::DestinationReserve),

3481

1

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

3482

1

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

3483

));

3484

3485

1

		assert_eq!(

3486

1

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

3487

1

			Ok(U256::from(100))

3488

);

3489

1

});

3490

3491

1

	Statemine::execute_with(|| {

3492

		// Check that Bob received the tokens back in AssetHub

3493

1

		assert_eq!(

3494

1

			StatemineBalances::free_balance(RELAYBOB),

3495

			INITIAL_BALANCE + 100

3496

);

3497

1

});

3498

3499

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

3500

1

	Statemine::execute_with(|| {

3501

		// Now send those tokens to ParaA

3502

1

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

3503

1

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

3504

1

			assets: Wild(All),

3505

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3506

1

		}]);

3507

1

		assert_ok!(

3508

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3509

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3510

1

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

3511

1

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

3512

1

				Box::new(TransferType::LocalReserve),

3513

1

				Box::new(fees_id),

3514

1

				Box::new(TransferType::LocalReserve),

3515

1

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

3516

1

				WeightLimit::Unlimited

3517

3518

);

3519

3520

		// 100 DOTs were deducted from Bob's account

3521

1

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

3522

1

});

3523

3524

1

	ParaA::execute_with(|| {

3525

		// Alice should have received 100 DOTs

3526

1

		assert_eq!(

3527

1

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

3528

1

			Ok(U256::from(200))

3529

);

3530

1

});

3531

1

3532

3533

#[test]

3534

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_with_fee() {

3535

1

	MockNet::reset();

3536

3537

	// Relay asset

3538

1

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

3539

1

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

3540

3541

1

	let relay_asset_metadata = parachain::AssetMetadata {

3542

1

		name: b"RelayToken".to_vec(),

3543

1

		symbol: b"Relay".to_vec(),

3544

1

		decimals: 12,

3545

1

};

3546

3547

1

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

3548

3549

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3550

1

		polkadot_parachain::primitives::Sibling,

3551

1

		statemine_like::AccountId,

3552

1

	>::convert_location(&dest_para)

3553

1

	.unwrap();

3554

3555

1

	ParaA::execute_with(|| {

3556

1

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

3557

1

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

3558

1

			.try_into()

3559

1

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

3560

1

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

3561

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3562

1

			source_id,

3563

1

			source_location_latest,

3564

1

			relay_asset_metadata.decimals,

3565

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3566

1

			relay_asset_metadata.name.try_into().expect("too long"),

3567

));

3568

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3569

1

});

3570

3571

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3572

1

		network: None,

3573

1

		key: PARAALICE,

3574

1

3575

1

	.into();

3576

3577

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3578

1

		network: None,

3579

1

		id: RELAYALICE.into(),

3580

1

3581

1

	.into();

3582

3583

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3584

1

	Relay::execute_with(|| {

3585

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3586

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3587

1

			Box::new(Parachain(1000).into()),

3588

1

			Box::new(

3589

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3590

1

					.clone()

3591

1

					.into()

3592

),

3593

1

			Box::new(([], 200).into()),

3594

0,

3595

1

			WeightLimit::Unlimited

3596

));

3597

1

});

3598

3599

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3600

1

	Statemine::execute_with(|| {

3601

		// Check Alice received 200 tokens on AssetHub

3602

1

		assert_eq!(

3603

1

			StatemineBalances::free_balance(RELAYALICE),

3604

			INITIAL_BALANCE + 200

3605

);

3606

3607

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3608

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3609

1

			sov,

3610

			110000000000000

3611

));

3612

3613

		// Now send those tokens to ParaA

3614

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3615

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3616

1

			assets: Wild(All),

3617

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3618

1

		}]);

3619

1

		assert_ok!(

3620

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3621

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3622

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3623

1

				Box::new((Location::parent(), 200).into()),

3624

1

				Box::new(TransferType::LocalReserve),

3625

1

				Box::new(fees_id),

3626

1

				Box::new(TransferType::LocalReserve),

3627

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3628

1

				WeightLimit::Unlimited

3629

3630

);

3631

1

});

3632

3633

1

	ParaA::execute_with(|| {

3634

		// Alice should have received the DOTs

3635

1

		assert_eq!(

3636

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3637

1

			Ok(U256::from(200))

3638

);

3639

1

});

3640

3641

1

	let dest = Location::new(

3642

1,

3643

1

3644

1

			Parachain(1000),

3645

1

			AccountId32 {

3646

1

				network: None,

3647

1

				id: RELAYBOB.into(),

3648

1

},

3649

1

],

3650

);

3651

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3652

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3653

1

	ParaA::execute_with(|| {

3654

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3655

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3656

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3657

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3658

1

			assets: Wild(All),

3659

1

			beneficiary: beneficiary.clone(),

3660

1

		}]);

3661

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3662

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3663

1

			Box::new(VersionedLocation::from(chain_part)),

3664

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

3665

1

			Box::new(TransferType::DestinationReserve),

3666

1

			Box::new(fees_id),

3667

1

			Box::new(TransferType::DestinationReserve),

3668

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3669

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3670

));

3671

3672

1

		assert_eq!(

3673

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3674

1

			Ok(U256::from(90))

3675

);

3676

1

});

3677

3678

1

	Statemine::execute_with(|| {

3679

		// Free execution: check that Bob received the tokens back in AssetHub

3680

1

		assert_eq!(

3681

1

			StatemineBalances::free_balance(RELAYBOB),

3682

			INITIAL_BALANCE + 110

3683

);

3684

1

});

3685

3686

	// Send back tokens from AH to ParaA from Bob's account

3687

1

	Statemine::execute_with(|| {

3688

		// Now send those tokens to ParaA

3689

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3690

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3691

1

			assets: Wild(All),

3692

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3693

1

		}]);

3694

1

		assert_ok!(

3695

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3696

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3697

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3698

1

				Box::new((Location::parent(), 100).into()),

3699

1

				Box::new(TransferType::LocalReserve),

3700

1

				Box::new(fees_id),

3701

1

				Box::new(TransferType::LocalReserve),

3702

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3703

1

				WeightLimit::Unlimited

3704

3705

);

3706

3707

		// 100 DOTs were deducted from Bob's account

3708

1

		assert_eq!(

3709

1

			StatemineBalances::free_balance(RELAYBOB),

3710

			INITIAL_BALANCE + 10

3711

);

3712

1

});

3713

3714

1

	ParaA::execute_with(|| {

3715

		// Alice should have received 100 DOTs

3716

1

		assert_eq!(

3717

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3718

1

			Ok(U256::from(190))

3719

);

3720

1

});

3721

1

3722

3723

#[test]

3724

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiasset() {

3725

1

	MockNet::reset();

3726

3727

	// Relay asset

3728

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3729

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3730

3731

1

	let relay_asset_metadata = parachain::AssetMetadata {

3732

1

		name: b"RelayToken".to_vec(),

3733

1

		symbol: b"Relay".to_vec(),

3734

1

		decimals: 12,

3735

1

};

3736

3737

1

	let dest_para = Location::new(1, [Parachain(1)]);

3738

3739

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3740

1

		polkadot_parachain::primitives::Sibling,

3741

1

		statemine_like::AccountId,

3742

1

	>::convert_location(&dest_para)

3743

1

	.unwrap();

3744

3745

1

	ParaA::execute_with(|| {

3746

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3747

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3748

1

			.try_into()

3749

1

			.expect("v3 to latest location conversion failed");

3750

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3751

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3752

1

			source_id,

3753

1

			source_location_latest,

3754

1

			relay_asset_metadata.decimals,

3755

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3756

1

			relay_asset_metadata.name.try_into().expect("too long"),

3757

));

3758

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3759

1

});

3760

3761

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3762

1

		network: None,

3763

1

		key: PARAALICE,

3764

1

3765

1

	.into();

3766

3767

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3768

1

		network: None,

3769

1

		id: RELAYALICE.into(),

3770

1

3771

1

	.into();

3772

3773

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3774

1

	Relay::execute_with(|| {

3775

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3776

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3777

1

			Box::new(Parachain(1000).into()),

3778

1

			Box::new(

3779

1

				VersionedLocation::from(statemine_beneficiary_absolute)

3780

1

					.clone()

3781

1

					.into()

3782

),

3783

1

			Box::new(([], 200).into()),

3784

0,

3785

1

			WeightLimit::Unlimited

3786

));

3787

1

});

3788

3789

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3790

1

	Statemine::execute_with(|| {

3791

		// Check Alice received 200 tokens on AssetHub

3792

1

		assert_eq!(

3793

1

			StatemineBalances::free_balance(RELAYALICE),

3794

			INITIAL_BALANCE + 200

3795

);

3796

3797

1

		assert_ok!(StatemineBalances::transfer_allow_death(

3798

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

3799

1

			sov,

3800

			110000000000000

3801

));

3802

3803

		// Now send those tokens to ParaA

3804

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3805

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3806

1

			assets: Wild(All),

3807

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3808

1

		}]);

3809

1

		assert_ok!(

3810

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3811

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

3812

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3813

1

				Box::new((Location::parent(), 200).into()),

3814

1

				Box::new(TransferType::LocalReserve),

3815

1

				Box::new(fees_id),

3816

1

				Box::new(TransferType::LocalReserve),

3817

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3818

1

				WeightLimit::Unlimited

3819

3820

);

3821

1

});

3822

3823

1

	ParaA::execute_with(|| {

3824

		// Alice should have received the DOTs

3825

1

		assert_eq!(

3826

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3827

1

			Ok(U256::from(200))

3828

);

3829

1

});

3830

3831

1

	let dest = Location::new(

3832

1,

3833

1

3834

1

			Parachain(1000),

3835

1

			AccountId32 {

3836

1

				network: None,

3837

1

				id: RELAYBOB.into(),

3838

1

},

3839

1

],

3840

);

3841

3842

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3843

3844

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3845

1

	ParaA::execute_with(|| {

3846

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3847

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3848

1

			assets: Wild(All),

3849

1

			beneficiary: beneficiary.clone(),

3850

1

		}]);

3851

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3852

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3853

1

			Box::new(VersionedLocation::from(chain_part)),

3854

1

			Box::new(VersionedAssets::from(

3855

1

				vec![(Location::parent(), 100).into()]

3856

)),

3857

1

			Box::new(TransferType::DestinationReserve),

3858

1

			Box::new(fees_id),

3859

1

			Box::new(TransferType::DestinationReserve),

3860

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3861

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3862

));

3863

3864

1

		assert_eq!(

3865

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3866

1

			Ok(U256::from(100))

3867

);

3868

1

});

3869

3870

1

	Statemine::execute_with(|| {

3871

		// Check that Bob received the tokens back in AssetHub

3872

1

		assert_eq!(

3873

1

			StatemineBalances::free_balance(RELAYBOB),

3874

			INITIAL_BALANCE + 100

3875

);

3876

1

});

3877

3878

	// Send back tokens from AH to ParaA from Bob's account

3879

1

	Statemine::execute_with(|| {

3880

		// Now send those tokens to ParaA

3881

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3882

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3883

1

			assets: Wild(All),

3884

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3885

1

		}]);

3886

1

		assert_ok!(

3887

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

3888

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

3889

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3890

1

				Box::new((Location::parent(), 100).into()),

3891

1

				Box::new(TransferType::LocalReserve),

3892

1

				Box::new(fees_id),

3893

1

				Box::new(TransferType::LocalReserve),

3894

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3895

1

				WeightLimit::Unlimited

3896

3897

);

3898

3899

		// 100 DOTs were deducted from Bob's account

3900

1

		assert_eq!(StatemineBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3901

1

});

3902

3903

1

	ParaA::execute_with(|| {

3904

		// Alice should have received 100 DOTs

3905

1

		assert_eq!(

3906

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3907

1

			Ok(U256::from(200))

3908

);

3909

1

});

3910

1

3911

3912

#[test]

3913

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multicurrencies() {

3914

1

	MockNet::reset();

3915

3916

	// Relay asset

3917

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

3918

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3919

3920

1

	let relay_asset_metadata = parachain::AssetMetadata {

3921

1

		name: b"RelayToken".to_vec(),

3922

1

		symbol: b"Relay".to_vec(),

3923

1

		decimals: 12,

3924

1

};

3925

3926

	// Statemine asset

3927

1

	let statemine_asset = Location::new(

3928

1,

3929

1

3930

1

			Parachain(1000u32),

3931

1

			PalletInstance(5u8),

3932

1

			GeneralIndex(10u128),

3933

1

],

3934

);

3935

1

	let statemine_location_asset: AssetType = statemine_asset

3936

1

		.clone()

3937

1

		.try_into()

3938

1

		.expect("Location convertion to AssetType should succeed");

3939

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

3940

3941

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

3942

1

		name: b"USDC".to_vec(),

3943

1

		symbol: b"USDC".to_vec(),

3944

1

		decimals: 12,

3945

1

};

3946

3947

1

	let dest_para = Location::new(1, [Parachain(1)]);

3948

3949

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3950

1

		polkadot_parachain::primitives::Sibling,

3951

1

		statemine_like::AccountId,

3952

1

	>::convert_location(&dest_para)

3953

1

	.unwrap();

3954

3955

1

	ParaA::execute_with(|| {

3956

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

3957

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

3958

1

			.try_into()

3959

1

			.expect("v3 to latest location conversion failed");

3960

1

		let source_id: parachain::AssetId = relay_location.clone().into();

3961

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3962

1

			source_id,

3963

1

			source_location_latest,

3964

1

			relay_asset_metadata.decimals,

3965

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3966

1

			relay_asset_metadata.name.try_into().expect("too long"),

3967

));

3968

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3969

3970

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

3971

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

3972

1

			.try_into()

3973

1

			.expect("v3 to latest location conversion failed");

3974

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

3975

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3976

1

			statemine_id,

3977

1

			statemine_location_latest,

3978

1

			asset_metadata_statemine_asset.decimals,

3979

1

			asset_metadata_statemine_asset

3980

1

				.symbol

3981

1

				.try_into()

3982

1

				.expect("too long"),

3983

1

			asset_metadata_statemine_asset

3984

1

				.name

3985

1

				.try_into()

3986

1

				.expect("too long"),

3987

));

3988

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

3989

1

});

3990

3991

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3992

1

		network: None,

3993

1

		key: PARAALICE,

3994

1

3995

1

	.into();

3996

3997

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

3998

1

		network: None,

3999

1

		id: RELAYALICE.into(),

4000

1

4001

1

	.into();

4002

4003

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4004

1

	Relay::execute_with(|| {

4005

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4006

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4007

1

			Box::new(Parachain(1000).into()),

4008

1

			Box::new(

4009

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4010

1

					.clone()

4011

1

					.into()

4012

),

4013

1

			Box::new(([], 200).into()),

4014

0,

4015

1

			WeightLimit::Unlimited

4016

));

4017

1

});

4018

4019

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4020

1

	Statemine::execute_with(|| {

4021

		// Check Alice received 200 tokens on AssetHub

4022

1

		assert_eq!(

4023

1

			StatemineBalances::free_balance(RELAYALICE),

4024

			INITIAL_BALANCE + 200

4025

);

4026

4027

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4028

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4029

1

			sov,

4030

			110000000000000

4031

));

4032

4033

1

		statemine_like::PrefixChanger::set_prefix(

4034

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4035

);

4036

4037

1

		assert_ok!(StatemineAssets::create(

4038

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4039

10,

4040

			RELAYALICE,

4041

4042

));

4043

4044

1

		assert_ok!(StatemineAssets::mint(

4045

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4046

10,

4047

			RELAYALICE,

4048

			300000000000000

4049

));

4050

4051

		// Now send relay tokens to ParaA

4052

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4053

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4054

1

			assets: Wild(All),

4055

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4056

1

		}]);

4057

1

		assert_ok!(

4058

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4059

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4060

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4061

1

				Box::new((Location::parent(), 200).into()),

4062

1

				Box::new(TransferType::LocalReserve),

4063

1

				Box::new(fees_id),

4064

1

				Box::new(TransferType::LocalReserve),

4065

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4066

1

				WeightLimit::Unlimited

4067

4068

);

4069

4070

		// Send USDC

4071

1

		let asset_location = Location::new(

4072

0,

4073

1

4074

1

				xcm::latest::prelude::PalletInstance(

4075

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

4076

1

),

4077

1

				GeneralIndex(10),

4078

1

],

4079

);

4080

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

4081

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4082

1

			assets: Wild(All),

4083

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4084

1

		}]);

4085

1

		assert_ok!(

4086

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4087

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4088

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4089

1

				Box::new((asset_location, 125).into()),

4090

1

				Box::new(TransferType::LocalReserve),

4091

1

				Box::new(fees_id),

4092

1

				Box::new(TransferType::LocalReserve),

4093

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4094

1

				WeightLimit::Unlimited

4095

4096

);

4097

1

});

4098

4099

1

	ParaA::execute_with(|| {

4100

		// Alice should have received the DOTs

4101

1

		assert_eq!(

4102

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4103

1

			Ok(U256::from(200))

4104

);

4105

4106

		// Alice has received 125 USDC

4107

1

		assert_eq!(

4108

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4109

1

			Ok(U256::from(125))

4110

);

4111

1

});

4112

4113

1

	let dest = Location::new(

4114

1,

4115

1

4116

1

			Parachain(1000),

4117

1

			AccountId32 {

4118

1

				network: None,

4119

1

				id: RELAYBOB.into(),

4120

1

},

4121

1

],

4122

);

4123

4124

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4125

4126

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4127

1

	ParaA::execute_with(|| {

4128

1

		let asset_1 = currency_to_asset(

4129

1

			parachain::CurrencyId::ForeignAsset(source_statemine_asset_id),

4130

			100,

4131

);

4132

1

		let asset_2 = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

4133

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4134

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4135

1

			assets: Wild(All),

4136

1

			beneficiary: beneficiary.clone(),

4137

1

		}]);

4138

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4139

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4140

1

			Box::new(VersionedLocation::from(chain_part)),

4141

1

			Box::new(VersionedAssets::from(vec![asset_1, asset_2])),

4142

1

			Box::new(TransferType::DestinationReserve),

4143

1

			Box::new(fees_id),

4144

1

			Box::new(TransferType::DestinationReserve),

4145

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4146

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4147

));

4148

4149

1

		assert_eq!(

4150

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4151

1

			Ok(U256::from(100))

4152

);

4153

1

});

4154

4155

1

	Statemine::execute_with(|| {

4156

		// Check that Bob received relay tokens back in AssetHub

4157

		// (100 - MinXcmFee)

4158

1

		assert_eq!(

4159

1

			StatemineBalances::free_balance(RELAYBOB),

4160

			INITIAL_BALANCE + 100

4161

);

4162

4163

		// Check that BOB received 100 USDC on AssetHub

4164

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4165

1

});

4166

4167

	// Send back tokens from AH to ParaA from Bob's account

4168

1

	Statemine::execute_with(|| {

4169

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4170

4171

		// Now send those tokens to ParaA

4172

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4173

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4174

1

			assets: Wild(All),

4175

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4176

1

		}]);

4177

1

		assert_ok!(

4178

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4179

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

4180

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4181

1

				Box::new((Location::parent(), 100).into()),

4182

1

				Box::new(TransferType::LocalReserve),

4183

1

				Box::new(fees_id),

4184

1

				Box::new(TransferType::LocalReserve),

4185

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4186

1

				WeightLimit::Unlimited

4187

4188

);

4189

4190

		// 100 DOTs were deducted from Bob's account

4191

1

		assert_eq!(

4192

1

			StatemineBalances::free_balance(RELAYBOB),

4193

1

			bob_previous_balance - 100

4194

);

4195

1

});

4196

4197

1

	ParaA::execute_with(|| {

4198

		// Alice should have received 100 DOTs

4199

1

		assert_eq!(

4200

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4201

1

			Ok(U256::from(200))

4202

);

4203

1

});

4204

1

4205

4206

#[test]

4207

1

fn send_dot_from_moonbeam_to_statemine_via_xtokens_transfer_multiassets() {

4208

1

	MockNet::reset();

4209

4210

	// Relay asset

4211

1

	let relay_location = parachain::AssetType::Xcm(xcm::v3::Location::parent());

4212

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

4213

4214

1

	let relay_asset_metadata = parachain::AssetMetadata {

4215

1

		name: b"RelayToken".to_vec(),

4216

1

		symbol: b"Relay".to_vec(),

4217

1

		decimals: 12,

4218

1

};

4219

4220

	// Statemine asset

4221

1

	let statemine_asset = Location::new(

4222

1,

4223

1

4224

1

			Parachain(1000u32),

4225

1

			PalletInstance(5u8),

4226

1

			GeneralIndex(10u128),

4227

1

],

4228

);

4229

1

	let statemine_location_asset: AssetType = statemine_asset

4230

1

		.clone()

4231

1

		.try_into()

4232

1

		.expect("Location convertion to AssetType should succeed");

4233

1

	let source_statemine_asset_id: parachain::AssetId = statemine_location_asset.clone().into();

4234

4235

1

	let asset_metadata_statemine_asset = parachain::AssetMetadata {

4236

1

		name: b"USDC".to_vec(),

4237

1

		symbol: b"USDC".to_vec(),

4238

1

		decimals: 12,

4239

1

};

4240

4241

1

	let dest_para = Location::new(1, [Parachain(1)]);

4242

4243

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

4244

1

		polkadot_parachain::primitives::Sibling,

4245

1

		statemine_like::AccountId,

4246

1

	>::convert_location(&dest_para)

4247

1

	.unwrap();

4248

4249

1

	ParaA::execute_with(|| {

4250

1

		let parachain::AssetType::Xcm(source_location_v3) = relay_location.clone();

4251

1

		let source_location_latest: Location = xcm::VersionedLocation::V3(source_location_v3)

4252

1

			.try_into()

4253

1

			.expect("v3 to latest location conversion failed");

4254

1

		let source_id: parachain::AssetId = relay_location.clone().into();

4255

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4256

1

			source_id,

4257

1

			source_location_latest,

4258

1

			relay_asset_metadata.decimals,

4259

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

4260

1

			relay_asset_metadata.name.try_into().expect("too long"),

4261

));

4262

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4263

4264

1

		let parachain::AssetType::Xcm(statemine_location_v3) = statemine_location_asset.clone();

4265

1

		let statemine_location_latest: Location = xcm::VersionedLocation::V3(statemine_location_v3)

4266

1

			.try_into()

4267

1

			.expect("v3 to latest location conversion failed");

4268

1

		let statemine_id: parachain::AssetId = statemine_location_asset.clone().into();

4269

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4270

1

			statemine_id,

4271

1

			statemine_location_latest,

4272

1

			asset_metadata_statemine_asset.decimals,

4273

1

			asset_metadata_statemine_asset

4274

1

				.symbol

4275

1

				.try_into()

4276

1

				.expect("too long"),

4277

1

			asset_metadata_statemine_asset

4278

1

				.name

4279

1

				.try_into()

4280

1

				.expect("too long"),

4281

));

4282

1

		XcmWeightTrader::set_asset_price(statemine_asset.clone(), 0u128);

4283

1

});

4284

4285

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4286

1

		network: None,

4287

1

		key: PARAALICE,

4288

1

4289

1

	.into();

4290

4291

1

	let statemine_beneficiary_absolute: Location = Junction::AccountId32 {

4292

1

		network: None,

4293

1

		id: RELAYALICE.into(),

4294

1

4295

1

	.into();

4296

4297

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4298

1

	Relay::execute_with(|| {

4299

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4300

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4301

1

			Box::new(Parachain(1000).into()),

4302

1

			Box::new(

4303

1

				VersionedLocation::from(statemine_beneficiary_absolute)

4304

1

					.clone()

4305

1

					.into()

4306

),

4307

1

			Box::new(([], 200).into()),

4308

0,

4309

1

			WeightLimit::Unlimited

4310

));

4311

1

});

4312

4313

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4314

1

	Statemine::execute_with(|| {

4315

		// Check Alice received 200 tokens on AssetHub

4316

1

		assert_eq!(

4317

1

			StatemineBalances::free_balance(RELAYALICE),

4318

			INITIAL_BALANCE + 200

4319

);

4320

4321

1

		assert_ok!(StatemineBalances::transfer_allow_death(

4322

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4323

1

			sov,

4324

			110000000000000

4325

));

4326

4327

1

		statemine_like::PrefixChanger::set_prefix(

4328

1

			PalletInstance(<StatemineAssets as PalletInfoAccess>::index() as u8).into(),

4329

);

4330

4331

1

		assert_ok!(StatemineAssets::create(

4332

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4333

10,

4334

			RELAYALICE,

4335

4336

));

4337

4338

1

		assert_ok!(StatemineAssets::mint(

4339

1

			statemine_like::RuntimeOrigin::signed(RELAYALICE),

4340

10,

4341

			RELAYALICE,

4342

			300000000000000

4343

));

4344

4345

		// Now send relay tokens to ParaA

4346

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4347

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4348

1

			assets: Wild(All),

4349

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4350

1

		}]);

4351

1

		assert_ok!(

4352

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4353

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4354

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4355

1

				Box::new((Location::parent(), 200).into()),

4356

1

				Box::new(TransferType::LocalReserve),

4357

1

				Box::new(fees_id),

4358

1

				Box::new(TransferType::LocalReserve),

4359

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4360

1

				WeightLimit::Unlimited

4361

4362

);

4363

4364

		// Send USDC

4365

1

		let asset_location = Location::new(

4366

0,

4367

1

4368

1

				xcm::latest::prelude::PalletInstance(

4369

1

					<StatemineAssets as PalletInfoAccess>::index() as u8,

4370

1

),

4371

1

				GeneralIndex(10),

4372

1

],

4373

);

4374

1

		let fees_id: VersionedAssetId = AssetId(asset_location.clone()).into();

4375

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4376

1

			assets: Wild(All),

4377

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4378

1

		}]);

4379

1

		assert_ok!(

4380

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4381

1

				statemine_like::RuntimeOrigin::signed(RELAYALICE),

4382

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4383

1

				Box::new((asset_location, 125).into()),

4384

1

				Box::new(TransferType::LocalReserve),

4385

1

				Box::new(fees_id),

4386

1

				Box::new(TransferType::LocalReserve),

4387

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4388

1

				WeightLimit::Unlimited

4389

4390

);

4391

1

});

4392

4393

1

	ParaA::execute_with(|| {

4394

		// Alice should have received the DOTs

4395

1

		assert_eq!(

4396

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4397

1

			Ok(U256::from(200))

4398

);

4399

4400

		// Alice has received 125 USDC

4401

1

		assert_eq!(

4402

1

			EvmForeignAssets::balance(source_statemine_asset_id, PARAALICE.into()),

4403

1

			Ok(U256::from(125))

4404

);

4405

1

});

4406

4407

1

	let dest = Location::new(

4408

1,

4409

1

4410

1

			Parachain(1000),

4411

1

			AccountId32 {

4412

1

				network: None,

4413

1

				id: RELAYBOB.into(),

4414

1

},

4415

1

],

4416

);

4417

4418

1

	let statemine_asset_to_send = Asset {

4419

1

		id: AssetId(statemine_asset),

4420

1

		fun: Fungibility::Fungible(100),

4421

1

};

4422

4423

1

	let relay_asset_to_send = Asset {

4424

1

		id: AssetId(Location::parent()),

4425

1

		fun: Fungibility::Fungible(100),

4426

1

};

4427

4428

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4429

1

	let assets_to_send: XcmAssets =

4430

1

		XcmAssets::from(vec![statemine_asset_to_send, relay_asset_to_send.clone()]);

4431

	// For some reason the order of the assets is inverted when creating the array above.

4432

	// We need to use relay asset for fees, so we pick index 0.

4433

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4434

4435

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4436

1

	ParaA::execute_with(|| {

4437

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4438

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4439

1

			assets: Wild(All),

4440

1

			beneficiary: beneficiary.clone(),

4441

1

		}]);

4442

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4443

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4444

1

			Box::new(VersionedLocation::from(chain_part)),

4445

1

			Box::new(VersionedAssets::from(assets_to_send)),

4446

1

			Box::new(TransferType::DestinationReserve),

4447

1

			Box::new(fees_id),

4448

1

			Box::new(TransferType::DestinationReserve),

4449

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4450

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4451

));

4452

4453

1

		assert_eq!(

4454

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4455

1

			Ok(U256::from(100))

4456

);

4457

1

});

4458

4459

1

	Statemine::execute_with(|| {

4460

		// Check that Bob received relay tokens back in AssetHub

4461

		// (100 - MinXcmFee)

4462

1

		assert_eq!(

4463

1

			StatemineBalances::free_balance(RELAYBOB),

4464

			INITIAL_BALANCE + 100

4465

);

4466

4467

		// Check that BOB received 100 USDC on AssetHub

4468

1

		assert_eq!(StatemineAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4469

1

});

4470

4471

	// Send back tokens from AH to ParaA from Bob's account

4472

1

	Statemine::execute_with(|| {

4473

1

		let bob_previous_balance = StatemineBalances::free_balance(RELAYBOB);

4474

4475

		// Now send those tokens to ParaA

4476

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4477

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4478

1

			assets: Wild(All),

4479

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4480

1

		}]);

4481

1

		assert_ok!(

4482

1

			StatemineChainPalletXcm::transfer_assets_using_type_and_then(

4483

1

				statemine_like::RuntimeOrigin::signed(RELAYBOB),

4484

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4485

1

				Box::new((Location::parent(), 100).into()),

4486

1

				Box::new(TransferType::LocalReserve),

4487

1

				Box::new(fees_id),

4488

1

				Box::new(TransferType::LocalReserve),

4489

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4490

1

				WeightLimit::Unlimited

4491

4492

);

4493

4494

		// 100 DOTs were deducted from Bob's account

4495

1

		assert_eq!(

4496

1

			StatemineBalances::free_balance(RELAYBOB),

4497

1

			bob_previous_balance - 100

4498

);

4499

1

});

4500

4501

1

	ParaA::execute_with(|| {

4502

		// Alice should have received 100 DOTs

4503

1

		assert_eq!(

4504

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4505

1

			Ok(U256::from(200))

4506

);

4507

1

});

4508

1

4509

4510

#[test]

4511

1

fn transact_through_signed_multilocation() {

4512

1

	MockNet::reset();

4513

1

	let mut ancestry = Location::parent();

4514

4515

1

	ParaA::execute_with(|| {

4516

		// Root can set transact info

4517

1

		assert_ok!(XcmTransactor::set_transact_info(

4518

1

			parachain::RuntimeOrigin::root(),

4519

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4520

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4521

1

			3000.into(),

4522

1

			20000000000.into(),

4523

			// 4 instructions in transact through signed

4524

1

			Some(4000.into())

4525

));

4526

		// Root can set transact info

4527

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4528

1

			parachain::RuntimeOrigin::root(),

4529

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4530

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

4531

));

4532

1

		ancestry = parachain::UniversalLocation::get().into();

4533

1

});

4534

4535

	// Let's construct the Junction that we will append with DescendOrigin

4536

1

	let signed_origin: Junctions = [AccountKey20 {

4537

1

		network: None,

4538

1

		key: PARAALICE,

4539

1

}]

4540

1

	.into();

4541

4542

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4543

1

	descend_origin_multilocation

4544

1

		.append_with(signed_origin)

4545

1

		.unwrap();

4546

4547

	// To convert it to what the relay will see instead of us

4548

1

	descend_origin_multilocation

4549

1

		.reanchor(&Location::parent(), &ancestry.interior)

4550

1

		.unwrap();

4551

4552

1

	let derived = xcm_builder::Account32Hash::<

4553

1

		relay_chain::KusamaNetwork,

4554

1

		relay_chain::AccountId,

4555

1

	>::convert_location(&descend_origin_multilocation)

4556

1

	.unwrap();

4557

4558

1

	Relay::execute_with(|| {

4559

		// free execution, full amount received

4560

1

		assert_ok!(RelayBalances::transfer_allow_death(

4561

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4562

1

			derived.clone(),

4563

			4000004100u128,

4564

));

4565

		// derived account has all funds

4566

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4567

		// sovereign account has 0 funds

4568

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4569

1

});

4570

4571

	// Encode the call. Balances transact to para_a_account

4572

	// First index

4573

1

	let mut encoded: Vec<u8> = Vec::new();

4574

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4575

1

		relay_chain::Balances,

4576

1

>()

4577

1

	.unwrap() as u8;

4578

4579

1

	encoded.push(index);

4580

4581

	// Then call bytes

4582

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4583

1

		// 100 to sovereign

4584

1

		dest: para_a_account(),

4585

1

		value: 100u32.into(),

4586

1

4587

1

	.encode();

4588

1

	encoded.append(&mut call_bytes);

4589

4590

1

	ParaA::execute_with(|| {

4591

1

		assert_ok!(XcmTransactor::transact_through_signed(

4592

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4593

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4594

1

			CurrencyPayment {

4595

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4596

1

					Location::parent()

4597

1

				))),

4598

1

				fee_amount: None

4599

1

},

4600

1

			encoded,

4601

			// 4000000000 for transfer + 4000 for XCM

4602

			// 1-1 to fee

4603

1

			TransactWeights {

4604

1

				transact_required_weight_at_most: 4000000000.into(),

4605

1

				overall_weight: None

4606

1

},

4607

			false

4608

));

4609

1

});

4610

4611

1

	Relay::execute_with(|| {

4612

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4613

4614

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4615

1

});

4616

1

4617

4618

#[test]

4619

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4620

1

	MockNet::reset();

4621

1

	let mut ancestry = Location::parent();

4622

4623

1

	ParaA::execute_with(|| {

4624

1

		ancestry = parachain::UniversalLocation::get().into();

4625

1

});

4626

4627

	// Let's construct the Junction that we will append with DescendOrigin

4628

1

	let signed_origin: Junctions = [AccountKey20 {

4629

1

		network: None,

4630

1

		key: PARAALICE,

4631

1

}]

4632

1

	.into();

4633

4634

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4635

1

	descend_origin_multilocation

4636

1

		.append_with(signed_origin)

4637

1

		.unwrap();

4638

4639

	// To convert it to what the relay will see instead of us

4640

1

	descend_origin_multilocation

4641

1

		.reanchor(&Location::parent(), &ancestry.interior)

4642

1

		.unwrap();

4643

4644

1

	let derived = xcm_builder::Account32Hash::<

4645

1

		relay_chain::KusamaNetwork,

4646

1

		relay_chain::AccountId,

4647

1

	>::convert_location(&descend_origin_multilocation)

4648

1

	.unwrap();

4649

4650

1

	Relay::execute_with(|| {

4651

		// free execution, full amount received

4652

1

		assert_ok!(RelayBalances::transfer_allow_death(

4653

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4654

1

			derived.clone(),

4655

			4000004100u128,

4656

));

4657

		// derived account has all funds

4658

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4659

		// sovereign account has 0 funds

4660

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4661

1

});

4662

4663

	// Encode the call. Balances transact to para_a_account

4664

	// First index

4665

1

	let mut encoded: Vec<u8> = Vec::new();

4666

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4667

1

		relay_chain::Balances,

4668

1

>()

4669

1

	.unwrap() as u8;

4670

4671

1

	encoded.push(index);

4672

4673

	// Then call bytes

4674

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4675

1

		// 100 to sovereign

4676

1

		dest: para_a_account(),

4677

1

		value: 100u32.into(),

4678

1

4679

1

	.encode();

4680

1

	encoded.append(&mut call_bytes);

4681

4682

1

	let total_weight = 4000004000u64;

4683

1

	ParaA::execute_with(|| {

4684

1

		assert_ok!(XcmTransactor::transact_through_signed(

4685

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4686

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4687

1

			CurrencyPayment {

4688

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4689

1

					Location::parent()

4690

1

				))),

4691

1

				fee_amount: Some(total_weight as u128)

4692

1

},

4693

1

			encoded,

4694

			// 4000000000 for transfer + 4000 for XCM

4695

1

			TransactWeights {

4696

1

				transact_required_weight_at_most: 4000000000.into(),

4697

1

				overall_weight: Some(Limited(total_weight.into()))

4698

1

},

4699

			false

4700

));

4701

1

});

4702

4703

1

	Relay::execute_with(|| {

4704

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4705

4706

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4707

1

});

4708

1

4709

4710

#[test]

4711

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4712

1

	MockNet::reset();

4713

1

	let mut ancestry = Location::parent();

4714

4715

1

	ParaA::execute_with(|| {

4716

1

		ancestry = parachain::UniversalLocation::get().into();

4717

1

});

4718

4719

	// Let's construct the Junction that we will append with DescendOrigin

4720

1

	let signed_origin: Junctions = [AccountKey20 {

4721

1

		network: None,

4722

1

		key: PARAALICE,

4723

1

}]

4724

1

	.into();

4725

4726

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4727

1

	descend_origin_multilocation

4728

1

		.append_with(signed_origin)

4729

1

		.unwrap();

4730

4731

	// To convert it to what the relay will see instead of us

4732

1

	descend_origin_multilocation

4733

1

		.reanchor(&Location::parent(), &ancestry.interior)

4734

1

		.unwrap();

4735

4736

1

	let derived = xcm_builder::Account32Hash::<

4737

1

		relay_chain::KusamaNetwork,

4738

1

		relay_chain::AccountId,

4739

1

	>::convert_location(&descend_origin_multilocation)

4740

1

	.unwrap();

4741

4742

1

	Relay::execute_with(|| {

4743

		// free execution, full amount received

4744

1

		assert_ok!(RelayBalances::transfer_allow_death(

4745

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4746

1

			derived.clone(),

4747

			4000009100u128,

4748

));

4749

		// derived account has all funds

4750

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4751

		// sovereign account has 0 funds

4752

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4753

1

});

4754

4755

	// Encode the call. Balances transact to para_a_account

4756

	// First index

4757

1

	let mut encoded: Vec<u8> = Vec::new();

4758

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4759

1

		relay_chain::Balances,

4760

1

>()

4761

1

	.unwrap() as u8;

4762

4763

1

	encoded.push(index);

4764

4765

	// Then call bytes

4766

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4767

1

		// 100 to sovereign

4768

1

		dest: para_a_account(),

4769

1

		value: 100u32.into(),

4770

1

4771

1

	.encode();

4772

1

	encoded.append(&mut call_bytes);

4773

4774

1

	let total_weight = 4000009000u64;

4775

1

	ParaA::execute_with(|| {

4776

1

		assert_ok!(XcmTransactor::transact_through_signed(

4777

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4778

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4779

1

			CurrencyPayment {

4780

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4781

1

					Location::parent()

4782

1

				))),

4783

1

				fee_amount: Some(total_weight as u128)

4784

1

},

4785

1

			encoded,

4786

			// 4000000000 for transfer + 9000 for XCM

4787

1

			TransactWeights {

4788

1

				transact_required_weight_at_most: 4000000000.into(),

4789

1

				overall_weight: Some(Limited(total_weight.into()))

4790

1

},

4791

			true

4792

));

4793

1

});

4794

4795

1

	Relay::execute_with(|| {

4796

		// 100 transferred

4797

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4798

4799

		// 4000009000 refunded

4800

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4801

1

});

4802

1

4803

4804

#[test]

4805

1

fn transact_through_signed_multilocation_para_to_para() {

4806

1

	MockNet::reset();

4807

1

	let mut ancestry = Location::parent();

4808

4809

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4810

4811

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4812

4813

1

	ParaA::execute_with(|| {

4814

		// Root can set transact info

4815

1

		assert_ok!(XcmTransactor::set_transact_info(

4816

1

			parachain::RuntimeOrigin::root(),

4817

			// ParaB

4818

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4819

			// Para charges 1000 for every instruction, and we have 3, so 3

4820

1

			3.into(),

4821

1

			20000000000.into(),

4822

			// 4 instructions in transact through signed

4823

1

			Some(4.into())

4824

));

4825

		// Root can set transact info

4826

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4827

1

			parachain::RuntimeOrigin::root(),

4828

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4829

1

			parachain::ParaTokensPerSecond::get(),

4830

));

4831

1

		ancestry = parachain::UniversalLocation::get().into();

4832

1

});

4833

4834

	// Let's construct the Junction that we will append with DescendOrigin

4835

1

	let signed_origin: Junctions = [AccountKey20 {

4836

1

		network: None,

4837

1

		key: PARAALICE,

4838

1

}]

4839

1

	.into();

4840

4841

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4842

1

	descend_origin_location.append_with(signed_origin).unwrap();

4843

4844

	// To convert it to what the paraB will see instead of us

4845

1

	descend_origin_location

4846

1

		.reanchor(&para_b_location, &ancestry.interior)

4847

1

		.unwrap();

4848

4849

1

	let derived = xcm_builder::HashedDescription::<

4850

1

		parachain::AccountId,

4851

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4852

1

	>::convert_location(&descend_origin_location)

4853

1

	.unwrap();

4854

4855

1

	ParaB::execute_with(|| {

4856

		// free execution, full amount received

4857

1

		assert_ok!(ParaBalances::transfer_allow_death(

4858

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4859

1

			derived.clone(),

4860

			4000000104u128,

4861

));

4862

		// derived account has all funds

4863

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4864

		// sovereign account has 0 funds

4865

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4866

1

});

4867

4868

	// Encode the call. Balances transact to para_a_account

4869

	// First index

4870

1

	let mut encoded: Vec<u8> = Vec::new();

4871

1

	let index =

4872

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4873

1

			.unwrap() as u8;

4874

4875

1

	encoded.push(index);

4876

4877

	// Then call bytes

4878

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4879

1

		// 100 to sovereign

4880

1

		dest: para_a_account_20(),

4881

1

		value: 100u32.into(),

4882

1

4883

1

	.encode();

4884

1

	encoded.append(&mut call_bytes);

4885

4886

1

	ParaA::execute_with(|| {

4887

1

		assert_ok!(XcmTransactor::transact_through_signed(

4888

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4889

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4890

1

			CurrencyPayment {

4891

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4892

1

					para_b_balances

4893

1

				))),

4894

1

				fee_amount: None

4895

1

},

4896

1

			encoded,

4897

			// 4000000000 for transfer + 4000 for XCM

4898

			// 1-1 to fee

4899

1

			TransactWeights {

4900

1

				transact_required_weight_at_most: 4000000000.into(),

4901

1

				overall_weight: None

4902

1

},

4903

			false

4904

));

4905

1

});

4906

4907

1

	ParaB::execute_with(|| {

4908

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4909

4910

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4911

1

});

4912

1

4913

4914

#[test]

4915

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4916

1

	MockNet::reset();

4917

1

	let mut ancestry = Location::parent();

4918

4919

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4920

4921

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4922

4923

1

	ParaA::execute_with(|| {

4924

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4925

1

			parachain::RuntimeOrigin::root(),

4926

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4927

1

			parachain::ParaTokensPerSecond::get(),

4928

));

4929

1

		ancestry = parachain::UniversalLocation::get().into();

4930

1

});

4931

4932

	// Let's construct the Junction that we will append with DescendOrigin

4933

1

	let signed_origin: Junctions = [AccountKey20 {

4934

1

		network: None,

4935

1

		key: PARAALICE,

4936

1

}]

4937

1

	.into();

4938

4939

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4940

1

	descend_origin_location.append_with(signed_origin).unwrap();

4941

4942

	// To convert it to what the paraB will see instead of us

4943

1

	descend_origin_location

4944

1

		.reanchor(&para_b_location, &ancestry.interior)

4945

1

		.unwrap();

4946

4947

1

	let derived = xcm_builder::HashedDescription::<

4948

1

		parachain::AccountId,

4949

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4950

1

	>::convert_location(&descend_origin_location)

4951

1

	.unwrap();

4952

4953

1

	ParaB::execute_with(|| {

4954

		// free execution, full amount received

4955

1

		assert_ok!(ParaBalances::transfer_allow_death(

4956

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4957

1

			derived.clone(),

4958

			4000009100u128,

4959

));

4960

		// derived account has all funds

4961

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4962

		// sovereign account has 0 funds

4963

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4964

1

});

4965

4966

	// Encode the call. Balances transact to para_a_account

4967

	// First index

4968

1

	let mut encoded: Vec<u8> = Vec::new();

4969

1

	let index =

4970

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4971

1

			.unwrap() as u8;

4972

4973

1

	encoded.push(index);

4974

4975

	// Then call bytes

4976

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4977

1

		// 100 to sovereign

4978

1

		dest: para_a_account_20(),

4979

1

		value: 100u32.into(),

4980

1

4981

1

	.encode();

4982

1

	encoded.append(&mut call_bytes);

4983

4984

1

	let overall_weight = 4000009000u64;

4985

1

	ParaA::execute_with(|| {

4986

1

		assert_ok!(XcmTransactor::transact_through_signed(

4987

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4988

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4989

1

			CurrencyPayment {

4990

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4991

1

					para_b_balances

4992

1

				))),

4993

1

				fee_amount: Some(overall_weight as u128)

4994

1

},

4995

1

			encoded,

4996

			// 4000000000 for transfer + 9000 for XCM

4997

1

			TransactWeights {

4998

1

				transact_required_weight_at_most: 4000000000.into(),

4999

1

				overall_weight: Some(Limited(overall_weight.into()))

5000

1

},

5001

			true

5002

));

5003

1

});

5004

5005

1

	ParaB::execute_with(|| {

5006

		// Check the derived account was refunded

5007

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

5008

5009

		// Check the transfer was executed

5010

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

5011

1

});

5012

1

5013

5014

#[test]

5015

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

5016

1

	MockNet::reset();

5017

1

	let mut ancestry = Location::parent();

5018

5019

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5020

5021

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5022

5023

1

	ParaA::execute_with(|| {

5024

		// Root can set transact info

5025

1

		assert_ok!(XcmTransactor::set_transact_info(

5026

1

			parachain::RuntimeOrigin::root(),

5027

			// ParaB

5028

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5029

			// Para charges 1000 for every instruction, and we have 3, so 3

5030

1

			3.into(),

5031

1

			20000000000.into(),

5032

			// 4 instructions in transact through signed

5033

1

			Some(4.into())

5034

));

5035

		// Root can set transact info

5036

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5037

1

			parachain::RuntimeOrigin::root(),

5038

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5039

1

			parachain::ParaTokensPerSecond::get(),

5040

));

5041

1

		ancestry = parachain::UniversalLocation::get().into();

5042

1

});

5043

5044

	// Let's construct the Junction that we will append with DescendOrigin

5045

1

	let signed_origin: Junctions = [AccountKey20 {

5046

1

		network: None,

5047

1

		key: PARAALICE,

5048

1

}]

5049

1

	.into();

5050

5051

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5052

1

	descend_origin_location.append_with(signed_origin).unwrap();

5053

5054

	// To convert it to what the paraB will see instead of us

5055

1

	descend_origin_location

5056

1

		.reanchor(&para_b_location, &ancestry.interior)

5057

1

		.unwrap();

5058

5059

1

	let derived = xcm_builder::HashedDescription::<

5060

1

		parachain::AccountId,

5061

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5062

1

	>::convert_location(&descend_origin_location)

5063

1

	.unwrap();

5064

5065

1

	let mut parachain_b_alice_balances_before = 0;

5066

1

	ParaB::execute_with(|| {

5067

1

		assert_ok!(ParaBalances::transfer_allow_death(

5068

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5069

1

			derived.clone(),

5070

			4000000104u128,

5071

));

5072

		// derived account has all funds

5073

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5074

		// sovereign account has 0 funds

5075

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5076

5077

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5078

1

});

5079

5080

	// Encode the call. Balances transact to para_a_account

5081

	// First index

5082

1

	let mut encoded: Vec<u8> = Vec::new();

5083

1

	let index =

5084

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5085

1

			.unwrap() as u8;

5086

5087

1

	encoded.push(index);

5088

5089

	use sp_core::U256;

5090

	// Let's do a EVM transfer

5091

1

	let eth_tx =

5092

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5093

1

			gas_limit: U256::from(21000),

5094

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5095

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5096

1

			value: U256::from(100),

5097

1

			input: BoundedVec::<

5098

1

u8,

5099

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5100

1

			>::try_from(vec![]).unwrap(),

5101

1

			access_list: None,

5102

1

});

5103

5104

	// Then call bytes

5105

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

5106

1

		xcm_transaction: eth_tx,

5107

1

5108

1

	.encode();

5109

1

	encoded.append(&mut call_bytes);

5110

5111

1

	ParaA::execute_with(|| {

5112

1

		assert_ok!(XcmTransactor::transact_through_signed(

5113

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5114

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5115

1

			CurrencyPayment {

5116

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5117

1

					para_b_balances

5118

1

				))),

5119

1

				fee_amount: None

5120

1

},

5121

1

			encoded,

5122

			// 4000000000 for transfer + 4000 for XCM

5123

			// 1-1 to fee

5124

1

			TransactWeights {

5125

1

				transact_required_weight_at_most: 4000000000.into(),

5126

1

				overall_weight: None

5127

1

},

5128

			false

5129

));

5130

1

});

5131

5132

1

	ParaB::execute_with(|| {

5133

		// Make sure the EVM transfer went through

5134

1

		assert!(

5135

1

			ParaBalances::free_balance(&PARAALICE.into())

5136

1

				== parachain_b_alice_balances_before + 100

5137

);

5138

1

});

5139

1

5140

5141

#[test]

5142

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

5143

1

	MockNet::reset();

5144

1

	let mut ancestry = Location::parent();

5145

5146

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5147

5148

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5149

5150

1

	ParaA::execute_with(|| {

5151

		// Root can set transact info

5152

1

		assert_ok!(XcmTransactor::set_transact_info(

5153

1

			parachain::RuntimeOrigin::root(),

5154

			// ParaB

5155

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5156

			// Para charges 1000 for every instruction, and we have 3, so 3

5157

1

			3.into(),

5158

1

			20000000000.into(),

5159

			// 4 instructions in transact through signed

5160

1

			Some(4.into())

5161

));

5162

		// Root can set transact info

5163

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5164

1

			parachain::RuntimeOrigin::root(),

5165

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5166

1

			parachain::ParaTokensPerSecond::get(),

5167

));

5168

1

		ancestry = parachain::UniversalLocation::get().into();

5169

1

});

5170

5171

	// Let's construct the Junction that we will append with DescendOrigin

5172

1

	let signed_origin: Junctions = [AccountKey20 {

5173

1

		network: None,

5174

1

		key: PARAALICE,

5175

1

}]

5176

1

	.into();

5177

5178

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5179

1

	descend_origin_location.append_with(signed_origin).unwrap();

5180

5181

	// To convert it to what the paraB will see instead of us

5182

1

	descend_origin_location

5183

1

		.reanchor(&para_b_location, &ancestry.interior)

5184

1

		.unwrap();

5185

5186

1

	let derived = xcm_builder::HashedDescription::<

5187

1

		parachain::AccountId,

5188

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5189

1

	>::convert_location(&descend_origin_location)

5190

1

	.unwrap();

5191

5192

1

	let mut parachain_b_alice_balances_before = 0;

5193

1

	ParaB::execute_with(|| {

5194

1

		assert_ok!(ParaBalances::transfer_allow_death(

5195

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5196

1

			derived.clone(),

5197

			4000000104u128,

5198

));

5199

		// derived account has all funds

5200

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5201

		// sovereign account has 0 funds

5202

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5203

5204

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5205

1

});

5206

5207

	// Encode the call. Balances transact to para_a_account

5208

	// First index

5209

1

	let mut encoded: Vec<u8> = Vec::new();

5210

1

	let index =

5211

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5212

1

			.unwrap() as u8;

5213

5214

1

	encoded.push(index);

5215

5216

	use sp_core::U256;

5217

	// Let's do a EVM transfer

5218

1

	let eth_tx =

5219

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5220

1

			gas_limit: U256::from(21000),

5221

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5222

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5223

1

			value: U256::from(100),

5224

1

			input: BoundedVec::<

5225

1

u8,

5226

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5227

1

			>::try_from(vec![]).unwrap(),

5228

1

			access_list: None,

5229

1

});

5230

5231

	// Then call bytes

5232

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5233

1

		transact_as: PARAALICE.into(),

5234

1

		xcm_transaction: eth_tx,

5235

1

5236

1

	.encode();

5237

1

	encoded.append(&mut call_bytes);

5238

5239

1

	ParaA::execute_with(|| {

5240

1

		assert_ok!(XcmTransactor::transact_through_signed(

5241

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5242

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5243

1

			CurrencyPayment {

5244

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5245

1

					para_b_balances

5246

1

				))),

5247

1

				fee_amount: None

5248

1

},

5249

1

			encoded,

5250

1

			TransactWeights {

5251

1

				transact_required_weight_at_most: 4000000000.into(),

5252

1

				overall_weight: None

5253

1

},

5254

			false

5255

));

5256

1

});

5257

5258

1

	ParaB::execute_with(|| {

5259

		// Make sure the EVM transfer wasn't executed

5260

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

5261

1

});

5262

1

5263

5264

#[test]

5265

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

5266

1

	MockNet::reset();

5267

1

	let mut ancestry = Location::parent();

5268

5269

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5270

5271

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5272

5273

1

	ParaA::execute_with(|| {

5274

		// Root can set transact info

5275

1

		assert_ok!(XcmTransactor::set_transact_info(

5276

1

			parachain::RuntimeOrigin::root(),

5277

			// ParaB

5278

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5279

			// Para charges 1000 for every instruction, and we have 3, so 3

5280

1

			3.into(),

5281

1

			20000000000.into(),

5282

			// 4 instructions in transact through signed

5283

1

			Some(4.into())

5284

));

5285

		// Root can set transact info

5286

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5287

1

			parachain::RuntimeOrigin::root(),

5288

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5289

1

			parachain::ParaTokensPerSecond::get(),

5290

));

5291

1

		ancestry = parachain::UniversalLocation::get().into();

5292

1

});

5293

5294

	// Let's construct the Junction that we will append with DescendOrigin

5295

1

	let signed_origin: Junctions = [AccountKey20 {

5296

1

		network: None,

5297

1

		key: PARAALICE,

5298

1

}]

5299

1

	.into();

5300

5301

1

	let mut descend_origin_location = parachain::SelfLocation::get();

5302

1

	descend_origin_location.append_with(signed_origin).unwrap();

5303

5304

	// To convert it to what the paraB will see instead of us

5305

1

	descend_origin_location

5306

1

		.reanchor(&para_b_location, &ancestry.interior)

5307

1

		.unwrap();

5308

5309

1

	let derived = xcm_builder::HashedDescription::<

5310

1

		parachain::AccountId,

5311

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5312

1

	>::convert_location(&descend_origin_location)

5313

1

	.unwrap();

5314

5315

1

	let transfer_recipient = evm_account();

5316

1

	let mut transfer_recipient_balance_before = 0;

5317

1

	ParaB::execute_with(|| {

5318

1

		assert_ok!(ParaBalances::transfer_allow_death(

5319

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5320

1

			derived.clone(),

5321

			4000000104u128,

5322

));

5323

		// derived account has all funds

5324

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5325

		// sovereign account has 0 funds

5326

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5327

5328

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5329

5330

		// Add proxy ALICE  -> derived

5331

1

		let _ = parachain::Proxy::add_proxy_delegate(

5332

1

			&PARAALICE.into(),

5333

1

			derived,

5334

1

			parachain::ProxyType::Any,

5335

1

0,

5336

1

);

5337

1

});

5338

5339

	// Encode the call. Balances transact to para_a_account

5340

	// First index

5341

1

	let mut encoded: Vec<u8> = Vec::new();

5342

1

	let index =

5343

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5344

1

			.unwrap() as u8;

5345

5346

1

	encoded.push(index);

5347

5348

	use sp_core::U256;

5349

	// Let's do a EVM transfer

5350

1

	let eth_tx =

5351

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5352

1

			gas_limit: U256::from(21000),

5353

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5354

1

			value: U256::from(100),

5355

1

			input: BoundedVec::<

5356

1

u8,

5357

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5358

1

			>::try_from(vec![]).unwrap(),

5359

1

			access_list: None,

5360

1

});

5361

5362

	// Then call bytes

5363

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5364

1

		transact_as: PARAALICE.into(),

5365

1

		xcm_transaction: eth_tx,

5366

1

5367

1

	.encode();

5368

1

	encoded.append(&mut call_bytes);

5369

5370

1

	ParaA::execute_with(|| {

5371

1

		assert_ok!(XcmTransactor::transact_through_signed(

5372

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5373

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5374

1

			CurrencyPayment {

5375

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5376

1

					para_b_balances

5377

1

				))),

5378

1

				fee_amount: None

5379

1

},

5380

1

			encoded,

5381

1

			TransactWeights {

5382

1

				transact_required_weight_at_most: 4000000000.into(),

5383

1

				overall_weight: None

5384

1

},

5385

			false

5386

));

5387

1

});

5388

5389

1

	ParaB::execute_with(|| {

5390

		// Make sure the EVM transfer was executed

5391

1

		assert!(

5392

1

			ParaBalances::free_balance(&transfer_recipient.into())

5393

1

				== transfer_recipient_balance_before + 100

5394

);

5395

1

});

5396

1

5397

5398

#[test]

5399

1

fn hrmp_init_accept_through_root() {

5400

1

	MockNet::reset();

5401

5402

1

	Relay::execute_with(|| {

5403

1

		assert_ok!(RelayBalances::transfer_allow_death(

5404

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5405

1

			para_a_account(),

5406

			1000u128

5407

));

5408

1

		assert_ok!(RelayBalances::transfer_allow_death(

5409

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5410

1

			para_b_account(),

5411

			1000u128

5412

));

5413

1

});

5414

5415

1

	ParaA::execute_with(|| {

5416

1

		let total_fee = 1_000u128;

5417

1

		let total_weight: u64 = 1_000_000_000;

5418

1

		let tx_weight: u64 = 500_000_000;

5419

		// Root can send hrmp init channel

5420

1

		assert_ok!(XcmTransactor::hrmp_manage(

5421

1

			parachain::RuntimeOrigin::root(),

5422

1

			HrmpOperation::InitOpen(HrmpInitParams {

5423

1

				para_id: 2u32.into(),

5424

1

				proposed_max_capacity: 1,

5425

1

				proposed_max_message_size: 1

5426

1

}),

5427

1

			CurrencyPayment {

5428

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5429

1

					Location::parent()

5430

1

				))),

5431

1

				fee_amount: Some(total_fee)

5432

1

},

5433

1

			TransactWeights {

5434

1

				transact_required_weight_at_most: tx_weight.into(),

5435

1

				overall_weight: Some(Limited(total_weight.into()))

5436

1

5437

));

5438

1

});

5439

1

	Relay::execute_with(|| {

5440

1

		let expected_event: relay_chain::RuntimeEvent =

5441

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5442

1

				sender: 1u32.into(),

5443

1

				recipient: 2u32.into(),

5444

1

				proposed_max_capacity: 1u32,

5445

1

				proposed_max_message_size: 1u32,

5446

1

5447

1

			.into();

5448

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5449

1

});

5450

1

	ParaB::execute_with(|| {

5451

1

		let total_fee = 1_000u128;

5452

1

		let total_weight: u64 = 1_000_000_000;

5453

1

		let tx_weight: u64 = 500_000_000;

5454

		// Root can send hrmp accept channel

5455

1

		assert_ok!(XcmTransactor::hrmp_manage(

5456

1

			parachain::RuntimeOrigin::root(),

5457

1

			HrmpOperation::Accept {

5458

1

				para_id: 1u32.into()

5459

1

},

5460

1

			CurrencyPayment {

5461

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5462

1

					Location::parent()

5463

1

				))),

5464

1

				fee_amount: Some(total_fee)

5465

1

},

5466

1

			TransactWeights {

5467

1

				transact_required_weight_at_most: tx_weight.into(),

5468

1

				overall_weight: Some(Limited(total_weight.into()))

5469

1

5470

));

5471

1

});

5472

5473

1

	Relay::execute_with(|| {

5474

1

		let expected_event: relay_chain::RuntimeEvent =

5475

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5476

1

				sender: 1u32.into(),

5477

1

				recipient: 2u32.into(),

5478

1

5479

1

			.into();

5480

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5481

1

});

5482

1

5483

5484

#[test]

5485

1

fn hrmp_close_works() {

5486

1

	MockNet::reset();

5487

5488

1

	Relay::execute_with(|| {

5489

1

		assert_ok!(RelayBalances::transfer_allow_death(

5490

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5491

1

			para_a_account(),

5492

			1000u128

5493

));

5494

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5495

1

			relay_chain::RuntimeOrigin::root(),

5496

1

			1u32.into(),

5497

1

			2u32.into(),

5498

			1u32,

5499

			1u32

5500

));

5501

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5502

1

			relay_chain::RuntimeOrigin::root(),

5503

			1u32

5504

));

5505

1

});

5506

5507

1

	ParaA::execute_with(|| {

5508

1

		let total_fee = 1_000u128;

5509

1

		let total_weight: u64 = 1_000_000_000;

5510

1

		let tx_weight: u64 = 500_000_000;

5511

		// Root can send hrmp close

5512

1

		assert_ok!(XcmTransactor::hrmp_manage(

5513

1

			parachain::RuntimeOrigin::root(),

5514

1

			HrmpOperation::Close(HrmpChannelId {

5515

1

				sender: 1u32.into(),

5516

1

				recipient: 2u32.into()

5517

1

}),

5518

1

			CurrencyPayment {

5519

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5520

1

					Location::parent()

5521

1

				))),

5522

1

				fee_amount: Some(total_fee)

5523

1

},

5524

1

			TransactWeights {

5525

1

				transact_required_weight_at_most: tx_weight.into(),

5526

1

				overall_weight: Some(Limited(total_weight.into()))

5527

1

5528

));

5529

1

});

5530

1

	Relay::execute_with(|| {

5531

1

		let expected_event: relay_chain::RuntimeEvent =

5532

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5533

1

				by_parachain: 1u32.into(),

5534

1

				channel_id: HrmpChannelId {

5535

1

					sender: 1u32.into(),

5536

1

					recipient: 2u32.into(),

5537

1

},

5538

1

5539

1

			.into();

5540

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5541

1

});

5542

1

5543

5544

use crate::xcm_mock::parachain::XcmWeightTrader;

5545

use parity_scale_codec::{Decode, Encode};

5546

use sp_io::hashing::blake2_256;

5547

5548

// Helper to derive accountIds

5549

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5550

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5551

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5552

7