Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonbase Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{ConstU32, PalletInfo, PalletInfoAccess},

23

	weights::constants::WEIGHT_REF_TIME_PER_SECOND,

24

	weights::Weight,

25

	BoundedVec,

26

};

27

use moonbase_runtime::xcm_config::AssetType;

28

use pallet_xcm_transactor::{

29

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

30

};

31

use sp_runtime::traits::Convert;

32

use sp_std::boxed::Box;

33

use xcm::{

34

	latest::prelude::{

35

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

36

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

37

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

38

		WeightLimit, Wild, WithdrawAsset, Xcm,

39

},

40

	VersionedAssetId, VersionedAssets, VersionedXcm,

41

};

42

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

43

use xcm_executor::traits::ConvertLocation;

44

use xcm_executor::traits::TransferType;

45

use xcm_mock::*;

46

use xcm_primitives::{

47

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

48

};

49

use xcm_simulator::TestExt;

50

mod common;

51

use cumulus_primitives_core::relay_chain::HrmpChannelId;

52

use parachain::PolkadotXcm;

53

54

28

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

55

28

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

56

28

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

57

28

		.into_version(xcm::latest::VERSION)

58

28

		.map_err(|_| ())?

59

	else {

60

		return Err(());

61

};

62

	use frame_support::weights::WeightToFee as _;

63

28

	let native_amount_per_second: u128 =

64

28

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

65

28

			&Weight::from_parts(

66

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

67

28

0,

68

28

),

69

70

28

		.try_into()

71

28

		.map_err(|_| ())?;

72

28

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

73

28

	let relative_price: u128 = if units_per_second > 0u128 {

74

10

		native_amount_per_second

75

10

			.saturating_mul(precision_factor)

76

10

			.saturating_div(units_per_second)

77

	} else {

78

18

		0u128

79

};

80

28

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

81

28

		location_v5,

82

28

		(true, relative_price),

83

);

84

28

	Ok(())

85

28

86

87

25

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

88

25

	Asset {

89

25

		id: AssetId(

90

25

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

91

25

				currency_id,

92

25

93

25

			.unwrap(),

94

25

),

95

25

		fun: Fungibility::Fungible(amount),

96

25

97

25

98

99

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

100

#[test]

101

1

fn receive_relay_asset_from_relay() {

102

1

	MockNet::reset();

103

104

1

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

105

1

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

106

1

	let asset_metadata = parachain::AssetMetadata {

107

1

		name: b"RelayToken".to_vec(),

108

1

		symbol: b"Relay".to_vec(),

109

1

		decimals: 12,

110

1

};

111

	// register relay asset in parachain A

112

1

	ParaA::execute_with(|| {

113

1

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

114

1

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

115

1

			.try_into()

116

1

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

117

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

118

1

			source_id,

119

1

			source_location_latest,

120

1

			asset_metadata.decimals,

121

1

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

122

1

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

123

));

124

1

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

125

1

});

126

127

	// Actually send relay asset to parachain

128

1

	let dest: Location = AccountKey20 {

129

1

		network: None,

130

1

		key: PARAALICE,

131

1

132

1

	.into();

133

1

	Relay::execute_with(|| {

134

1

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

135

1

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

136

1

			assets: Wild(All),

137

1

			beneficiary: dest.clone(),

138

1

		}]);

139

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

140

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

141

1

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

142

1

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

143

1

			Box::new(TransferType::LocalReserve),

144

1

			Box::new(fees_id),

145

1

			Box::new(TransferType::LocalReserve),

146

1

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

147

1

			WeightLimit::Unlimited

148

));

149

1

});

150

151

	// Verify that parachain received the asset

152

1

	ParaA::execute_with(|| {

153

		// free execution, full amount received

154

1

		assert_eq!(

155

1

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

156

1

			Ok(U256::from(123))

157

);

158

1

});

159

1

160

161

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

162

#[test]

163

1

fn send_relay_asset_to_relay() {

164

1

	MockNet::reset();

165

166

1

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

167

1

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

168

169

1

	let asset_metadata = parachain::AssetMetadata {

170

1

		name: b"RelayToken".to_vec(),

171

1

		symbol: b"Relay".to_vec(),

172

1

		decimals: 12,

173

1

};

174

175

	// Register relay asset in paraA

176

1

	ParaA::execute_with(|| {

177

1

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

178

1

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

179

1

			.try_into()

180

1

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

181

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

182

1

			source_id,

183

1

			source_location_latest,

184

1

			asset_metadata.decimals,

185

1

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

186

1

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

187

));

188

		// Free execution

189

1

		assert_ok!(add_supported_asset(source_location, 0));

190

1

});

191

192

1

	let dest: Location = Junction::AccountKey20 {

193

1

		network: None,

194

1

		key: PARAALICE,

195

1

196

1

	.into();

197

198

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

199

1

	Relay::execute_with(|| {

200

1

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

201

1

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

202

1

			assets: Wild(All),

203

1

			beneficiary: dest.clone(),

204

1

		}]);

205

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

206

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

207

1

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

208

1

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

209

1

			Box::new(TransferType::LocalReserve),

210

1

			Box::new(fees_id),

211

1

			Box::new(TransferType::LocalReserve),

212

1

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

213

1

			WeightLimit::Unlimited

214

));

215

1

});

216

217

1

	ParaA::execute_with(|| {

218

		// Free execution, full amount received

219

1

		assert_eq!(

220

1

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

221

1

			Ok(U256::from(123))

222

);

223

1

});

224

225

	// Lets gather the balance before sending back money

226

1

	let mut balance_before_sending = 0;

227

1

	Relay::execute_with(|| {

228

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

229

1

});

230

231

	// We now send back some money to the relay

232

1

	let dest = Location {

233

1

		parents: 1,

234

1

		interior: [AccountId32 {

235

1

			network: None,

236

1

			id: RELAYALICE.into(),

237

1

}]

238

1

		.into(),

239

1

};

240

1

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

241

242

1

	ParaA::execute_with(|| {

243

1

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

244

		// free execution, full amount received

245

1

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

246

1

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

247

1

			assets: Wild(All),

248

1

			beneficiary,

249

1

		}]);

250

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

251

1

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

252

1

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

253

1

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

254

1

			Box::new(TransferType::DestinationReserve),

255

1

			Box::new(fees_id),

256

1

			Box::new(TransferType::DestinationReserve),

257

1

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

258

1

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

259

));

260

1

});

261

262

	// The balances in paraAlice should have been substracted

263

1

	ParaA::execute_with(|| {

264

1

		assert_eq!(

265

1

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

266

1

			Ok(U256::from(0))

267

);

268

1

});

269

270

	// Balances in the relay should have been received

271

1

	Relay::execute_with(|| {

272

		// Free execution,x	 full amount received

273

1

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

274

1

});

275

1

276

277

#[test]

278

1

fn send_relay_asset_to_para_b() {

279

1

	MockNet::reset();

280

281

1

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

282

1

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

283

284

1

	let asset_metadata = parachain::AssetMetadata {

285

1

		name: b"RelayToken".to_vec(),

286

1

		symbol: b"Relay".to_vec(),

287

1

		decimals: 12,

288

1

};

289

290

	// Register asset in paraA. Free execution

291

1

	ParaA::execute_with(|| {

292

1

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

293

1

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

294

1

			.try_into()

295

1

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

296

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

297

1

			source_id,

298

1

			source_location_latest,

299

1

			asset_metadata.decimals,

300

1

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

301

1

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

302

));

303

1

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

304

1

});

305

306

	// Register asset in paraB. Free execution

307

1

	ParaB::execute_with(|| {

308

1

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

309

1

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

310

1

			.try_into()

311

1

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

312

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

313

1

			source_id,

314

1

			source_location_latest,

315

1

			asset_metadata.decimals,

316

1

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

317

1

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

318

));

319

1

		assert_ok!(add_supported_asset(source_location, 0));

320

1

});

321

322

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

323

1

	let dest: Location = Junction::AccountKey20 {

324

1

		network: None,

325

1

		key: PARAALICE,

326

1

327

1

	.into();

328

1

	Relay::execute_with(|| {

329

1

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

330

1

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

331

1

			assets: Wild(All),

332

1

			beneficiary: dest.clone(),

333

1

		}]);

334

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

335

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

336

1

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

337

1

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

338

1

			Box::new(TransferType::LocalReserve),

339

1

			Box::new(fees_id),

340

1

			Box::new(TransferType::LocalReserve),

341

1

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

342

1

			WeightLimit::Unlimited

343

));

344

1

});

345

346

1

	ParaA::execute_with(|| {

347

		// Free execution, full amount received

348

1

		assert_eq!(

349

1

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

350

1

			Ok(U256::from(123))

351

);

352

1

});

353

354

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

355

1

	let dest = Location {

356

1

		parents: 1,

357

1

		interior: [

358

1

			Parachain(2),

359

1

			AccountKey20 {

360

1

				network: None,

361

1

				key: PARAALICE.into(),

362

1

},

363

1

364

1

		.into(),

365

1

};

366

1

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

367

368

1

	ParaA::execute_with(|| {

369

1

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

370

1

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

371

1

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

372

1

			assets: Wild(All),

373

1

			beneficiary,

374

1

		}]);

375

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

376

1

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

377

1

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

378

1

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

379

1

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

380

1

			Box::new(fees_id),

381

1

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

382

1

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

383

1

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

384

));

385

1

});

386

387

	// Para A balances should have been subtracted

388

1

	ParaA::execute_with(|| {

389

1

		assert_eq!(

390

1

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

391

1

			Ok(U256::from(23))

392

);

393

1

});

394

395

	// Para B balances should have been credited

396

1

	ParaB::execute_with(|| {

397

1

		assert_eq!(

398

1

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

399

1

			Ok(U256::from(100))

400

);

401

1

});

402

1

403

404

#[test]

405

1

fn send_para_a_asset_to_para_b() {

406

1

	MockNet::reset();

407

408

	// this represents the asset in paraA

409

1

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

410

1

	let source_location: AssetType = para_a_balances

411

1

		.try_into()

412

1

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

413

1

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

414

415

1

	let asset_metadata = parachain::AssetMetadata {

416

1

		name: b"ParaAToken".to_vec(),

417

1

		symbol: b"ParaA".to_vec(),

418

1

		decimals: 18,

419

1

};

420

421

	// Register asset in paraB. Free execution

422

1

	ParaB::execute_with(|| {

423

1

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

424

1

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

425

1

			.try_into()

426

1

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

427

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

428

1

			source_id,

429

1

			source_location_latest,

430

1

			asset_metadata.decimals,

431

1

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

432

1

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

433

));

434

1

		assert_ok!(add_supported_asset(source_location, 0));

435

1

});

436

437

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

438

1

	let dest = Location {

439

1

		parents: 1,

440

1

		interior: [

441

1

			Parachain(2),

442

1

			AccountKey20 {

443

1

				network: None,

444

1

				key: PARAALICE.into(),

445

1

},

446

1

447

1

		.into(),

448

1

};

449

450

1

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

451

452

1

	ParaA::execute_with(|| {

453

1

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

454

		// Free execution, full amount received

455

1

		assert_ok!(PolkadotXcm::transfer_assets(

456

1

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

457

1

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

458

1

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

459

1

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

460

0,

461

1

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

462

));

463

1

});

464

465

	// Native token is substracted in paraA

466

1

	ParaA::execute_with(|| {

467

1

		assert_eq!(

468

1

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

469

			INITIAL_BALANCE - 100

470

);

471

1

});

472

473

	// Asset is minted in paraB

474

1

	ParaB::execute_with(|| {

475

1

		assert_eq!(

476

1

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

477

1

			Ok(U256::from(100))

478

);

479

1

});

480

1

481

482

#[test]

483

1

fn send_para_a_asset_from_para_b_to_para_c() {

484

1

	MockNet::reset();

485

486

	// Represents para A asset

487

1

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

488

1

	let source_location: AssetType = para_a_balances

489

1

		.try_into()

490

1

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

491

1

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

492

493

1

	let asset_metadata = parachain::AssetMetadata {

494

1

		name: b"ParaAToken".to_vec(),

495

1

		symbol: b"ParaA".to_vec(),

496

1

		decimals: 18,

497

1

};

498

499

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

500

1

	ParaB::execute_with(|| {

501

1

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

502

1

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

503

1

			.try_into()

504

1

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

505

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

506

1

			source_id,

507

1

			source_location_latest,

508

1

			asset_metadata.decimals,

509

1

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

510

1

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

511

));

512

1

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

513

1

});

514

515

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

516

1

	ParaC::execute_with(|| {

517

1

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

518

1

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

519

1

			.try_into()

520

1

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

521

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

522

1

			source_id,

523

1

			source_location_latest,

524

1

			asset_metadata.decimals,

525

1

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

526

1

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

527

));

528

1

		assert_ok!(add_supported_asset(source_location, 0));

529

1

});

530

531

	// Send para A asset to para B

532

1

	let dest = Location {

533

1

		parents: 1,

534

1

		interior: [

535

1

			Parachain(2),

536

1

			AccountKey20 {

537

1

				network: None,

538

1

				key: PARAALICE.into(),

539

1

},

540

1

541

1

		.into(),

542

1

};

543

1

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

544

545

1

	ParaA::execute_with(|| {

546

1

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

547

		// free execution, full amount received

548

1

		assert_ok!(PolkadotXcm::transfer_assets(

549

1

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

550

1

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

551

1

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

552

1

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

553

0,

554

1

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

555

));

556

1

});

557

558

	// Para A balances have been substracted

559

1

	ParaA::execute_with(|| {

560

1

		assert_eq!(

561

1

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

562

			INITIAL_BALANCE - 100

563

);

564

1

});

565

566

	// Para B balances have been credited

567

1

	ParaB::execute_with(|| {

568

1

		assert_eq!(

569

1

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

570

1

			Ok(U256::from(100))

571

);

572

1

});

573

574

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

575

1

	let dest = Location {

576

1

		parents: 1,

577

1

		interior: [

578

1

			Parachain(3),

579

1

			AccountKey20 {

580

1

				network: None,

581

1

				key: PARAALICE.into(),

582

1

},

583

1

584

1

		.into(),

585

1

};

586

1

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

587

588

1

	ParaB::execute_with(|| {

589

1

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

590

1

		assert_ok!(PolkadotXcm::transfer_assets(

591

1

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

592

1

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

593

1

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

594

1

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

595

0,

596

1

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

597

));

598

1

});

599

600

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

601

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

602

1

	ParaC::execute_with(|| {

603

1

		assert_eq!(

604

1

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

605

1

			Ok(U256::from(95))

606

);

607

1

});

608

1

609

610

#[test]

611

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

612

1

	MockNet::reset();

613

614

	// Para A asset

615

1

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

616

1

	let source_location: AssetType = para_a_balances

617

1

		.try_into()

618

1

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

619

1

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

620

621

1

	let asset_metadata = parachain::AssetMetadata {

622

1

		name: b"ParaAToken".to_vec(),

623

1

		symbol: b"ParaA".to_vec(),

624

1

		decimals: 18,

625

1

};

626

627

	// Register para A asset in para B

628

1

	ParaB::execute_with(|| {

629

1

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

630

1

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

631

1

			.try_into()

632

1

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

633

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

634

1

			source_id,

635

1

			source_location_latest,

636

1

			asset_metadata.decimals,

637

1

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

638

1

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

639

));

640

1

		assert_ok!(add_supported_asset(source_location, 0));

641

1

});

642

643

	// Send para A asset to para B

644

1

	let dest = Location {

645

1

		parents: 1,

646

1

		interior: [

647

1

			Parachain(2),

648

1

			AccountKey20 {

649

1

				network: None,

650

1

				key: PARAALICE.into(),

651

1

},

652

1

653

1

		.into(),

654

1

};

655

1

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

656

657

1

	ParaA::execute_with(|| {

658

1

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

659

1

		assert_ok!(PolkadotXcm::transfer_assets(

660

1

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

661

1

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

662

1

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

663

1

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

664

0,

665

1

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

666

));

667

1

});

668

669

	// Balances have been subtracted

670

1

	ParaA::execute_with(|| {

671

1

		assert_eq!(

672

1

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

673

			INITIAL_BALANCE - 100

674

);

675

1

});

676

677

	// Para B balances have been credited

678

1

	ParaB::execute_with(|| {

679

1

		assert_eq!(

680

1

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

681

1

			Ok(U256::from(100))

682

);

683

1

});

684

685

	// Send back para A asset to para A

686

1

	let dest = Location {

687

1

		parents: 1,

688

1

		interior: [

689

1

			Parachain(1),

690

1

			AccountKey20 {

691

1

				network: None,

692

1

				key: PARAALICE.into(),

693

1

},

694

1

695

1

		.into(),

696

1

};

697

1

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

698

699

1

	ParaB::execute_with(|| {

700

1

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

701

1

		assert_ok!(PolkadotXcm::transfer_assets(

702

1

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

703

1

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

704

1

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

705

1

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

706

0,

707

1

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

708

));

709

1

});

710

711

1

	ParaA::execute_with(|| {

712

		// Weight used is 4

713

1

		assert_eq!(

714

1

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

715

			INITIAL_BALANCE - 4

716

);

717

1

});

718

1

719

720

#[test]

721

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

722

1

	MockNet::reset();

723

724

1

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

725

1

	let source_location: AssetType = para_a_balances

726

1

		.try_into()

727

1

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

728

1

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

729

730

1

	let asset_metadata = parachain::AssetMetadata {

731

1

		name: b"ParaAToken".to_vec(),

732

1

		symbol: b"ParaA".to_vec(),

733

1

		decimals: 18,

734

1

};

735

736

1

	ParaB::execute_with(|| {

737

1

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

738

1

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

739

1

			.try_into()

740

1

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

741

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

742

1

			source_id,

743

1

			source_location_latest,

744

1

			asset_metadata.decimals,

745

1

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

746

1

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

747

));

748

1

		assert_ok!(add_supported_asset(source_location, 0));

749

1

});

750

751

1

	let dest = Location {

752

1

		parents: 1,

753

1

		interior: [

754

1

			Parachain(2),

755

1

			AccountKey20 {

756

1

				network: None,

757

1

				key: PARAALICE.into(),

758

1

},

759

1

760

1

		.into(),

761

1

};

762

1

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

763

764

1

	ParaA::execute_with(|| {

765

1

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

766

1

		assert_ok!(PolkadotXcm::transfer_assets(

767

1

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

768

1

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

769

1

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

770

1

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

771

0,

772

1

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

773

));

774

1

});

775

776

	// Para A asset has been credited

777

1

	ParaA::execute_with(|| {

778

1

		assert_eq!(

779

1

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

780

			INITIAL_BALANCE - 100

781

);

782

1

});

783

784

1

	ParaB::execute_with(|| {

785

		// free execution, full amount received

786

1

		assert_eq!(

787

1

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

788

1

			Ok(U256::from(100))

789

);

790

1

});

791

792

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

793

	// Message through polkadotXCM pallet

794

795

1

	let dest = Location {

796

1

		parents: 1,

797

1

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

798

1

};

799

800

1

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

801

802

1

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

803

1

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

804

1

		ClearOrigin,

805

1

		BuyExecution {

806

1

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

807

1

			weight_limit: Limited(80.into()),

808

1

},

809

1

		DepositAsset {

810

1

			assets: All.into(),

811

1

			beneficiary: Location::new(

812

1

0,

813

1

				[AccountKey20 {

814

1

					network: None,

815

1

					key: PARAALICE,

816

1

}],

817

1

),

818

1

},

819

1

	]));

820

1

	ParaB::execute_with(|| {

821

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

822

		// and deposit asset

823

1

		assert_ok!(ParachainPalletXcm::send(

824

1

			parachain::RuntimeOrigin::root(),

825

1

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

826

1

			Box::new(message),

827

));

828

1

});

829

830

1

	ParaA::execute_with(|| {

831

		// Weight used is 4

832

1

		assert_eq!(

833

1

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

834

			INITIAL_BALANCE - 4

835

);

836

1

});

837

1

838

839

#[test]

840

1

fn receive_relay_asset_with_trader() {

841

1

	MockNet::reset();

842

843

1

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

844

1

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

845

846

1

	let asset_metadata = parachain::AssetMetadata {

847

1

		name: b"RelayToken".to_vec(),

848

1

		symbol: b"Relay".to_vec(),

849

1

		decimals: 12,

850

1

};

851

852

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

853

	// we know later we will divide by 1e12

854

	// Lets put 1e6 as units per second

855

1

	ParaA::execute_with(|| {

856

1

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

857

1

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

858

1

			.try_into()

859

1

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

860

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

861

1

			source_id,

862

1

			source_location_latest,

863

1

			asset_metadata.decimals,

864

1

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

865

1

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

866

));

867

1

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

868

1

});

869

870

1

	let dest: Location = Junction::AccountKey20 {

871

1

		network: None,

872

1

		key: PARAALICE,

873

1

874

1

	.into();

875

	// We are sending 100 tokens from relay.

876

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

877

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

878

	// Units per second should be 2_500_000_000_000_000

879

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

880

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

881

1

	Relay::execute_with(|| {

882

1

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

883

1

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

884

1

			assets: Wild(All),

885

1

			beneficiary: dest.clone(),

886

1

		}]);

887

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

888

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

889

1

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

890

1

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

891

1

			Box::new(TransferType::LocalReserve),

892

1

			Box::new(fees_id),

893

1

			Box::new(TransferType::LocalReserve),

894

1

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

895

1

			WeightLimit::Unlimited

896

));

897

1

});

898

899

1

	ParaA::execute_with(|| {

900

		// non-free execution, not full amount received

901

1

		assert_eq!(

902

1

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

903

1

			Ok(U256::from(90))

904

);

905

		// Fee should have been received by treasury

906

1

		assert_eq!(

907

1

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

908

1

			Ok(U256::from(10))

909

);

910

1

});

911

1

912

913

#[test]

914

1

fn send_para_a_asset_to_para_b_with_trader() {

915

1

	MockNet::reset();

916

917

1

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

918

1

	let source_location: AssetType = para_a_balances

919

1

		.try_into()

920

1

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

921

1

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

922

923

1

	let asset_metadata = parachain::AssetMetadata {

924

1

		name: b"ParaAToken".to_vec(),

925

1

		symbol: b"ParaA".to_vec(),

926

1

		decimals: 18,

927

1

};

928

929

1

	ParaB::execute_with(|| {

930

1

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

931

1

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

932

1

			.try_into()

933

1

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

934

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

935

1

			source_id,

936

1

			source_location_latest,

937

1

			asset_metadata.decimals,

938

1

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

939

1

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

940

));

941

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

942

1

});

943

944

1

	let dest = Location {

945

1

		parents: 1,

946

1

		interior: [

947

1

			Parachain(2),

948

1

			AccountKey20 {

949

1

				network: None,

950

1

				key: PARAALICE.into(),

951

1

},

952

1

953

1

		.into(),

954

1

};

955

1

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

956

957

	// In destination chain, we only need 4 weight

958

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

959

1

	ParaA::execute_with(|| {

960

1

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

961

1

		assert_ok!(PolkadotXcm::transfer_assets(

962

1

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

963

1

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

964

1

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

965

1

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

966

0,

967

1

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

968

));

969

1

});

970

1

	ParaA::execute_with(|| {

971

		// free execution, full amount received

972

1

		assert_eq!(

973

1

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

974

			INITIAL_BALANCE - 100

975

);

976

1

});

977

978

	// We are sending 100 tokens from para A.

979

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

980

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

981

	// Units per second should be 2_500_000_000_000_000

982

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

983

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

984

	// will be 4

985

1

	ParaB::execute_with(|| {

986

1

		assert_eq!(

987

1

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

988

1

			Ok(U256::from(90))

989

);

990

		// Fee should have been received by treasury

991

1

		assert_eq!(

992

1

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

993

1

			Ok(U256::from(10))

994

);

995

1

});

996

1

997

998

#[test]

999

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1000

1

	MockNet::reset();

1001

1002

1

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

1003

1

	let source_location: AssetType = para_a_balances

1004

1

		.try_into()

1005

1

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

1006

1

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

1007

1008

1

	let asset_metadata = parachain::AssetMetadata {

1009

1

		name: b"ParaAToken".to_vec(),

1010

1

		symbol: b"ParaA".to_vec(),

1011

1

		decimals: 18,

1012

1

};

1013

1014

1

	ParaB::execute_with(|| {

1015

1

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

1016

1

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

1017

1

			.try_into()

1018

1

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

1019

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1020

1

			source_id,

1021

1

			source_location_latest,

1022

1

			asset_metadata.decimals,

1023

1

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

1024

1

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

1025

));

1026

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

1027

1

		assert_ok!(add_supported_asset(source_location, 12500000));

1028

1

});

1029

1030

1

	let dest = Location {

1031

1

		parents: 1,

1032

1

		interior: [

1033

1

			Parachain(2),

1034

1

			AccountKey20 {

1035

1

				network: None,

1036

1

				key: PARAALICE.into(),

1037

1

},

1038

1

1039

1

		.into(),

1040

1

};

1041

1

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

1042

	// we use transfer_with_fee

1043

1

	ParaA::execute_with(|| {

1044

1

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

1045

1

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

1046

1

		assert_ok!(PolkadotXcm::transfer_assets(

1047

1

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

1048

1

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

1049

1

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

1050

1

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

1051

0,

1052

1

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

1053

));

1054

1

});

1055

1

	ParaA::execute_with(|| {

1056

		// 100 tokens transferred plus 1 taken from fees

1057

1

		assert_eq!(

1058

1

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

1059

			INITIAL_BALANCE - 100 - 1

1060

);

1061

1

});

1062

1063

1

	ParaB::execute_with(|| {

1064

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

1065

		// what it is specified

1066

1

		assert_eq!(

1067

1

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

1068

1

			Ok(U256::from(101))

1069

);

1070

1

});

1071

1

1072

1073

#[test]

1074

1

fn error_when_not_paying_enough() {

1075

1

	MockNet::reset();

1076

1077

1

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

1078

1

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

1079

1080

1

	let asset_metadata = parachain::AssetMetadata {

1081

1

		name: b"RelayToken".to_vec(),

1082

1

		symbol: b"Relay".to_vec(),

1083

1

		decimals: 12,

1084

1

};

1085

1086

1

	let dest: Location = Junction::AccountKey20 {

1087

1

		network: None,

1088

1

		key: PARAALICE,

1089

1

1090

1

	.into();

1091

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

1092

	// we know later we will divide by 1e12

1093

	// Lets put 1e6 as units per second

1094

1

	ParaA::execute_with(|| {

1095

1

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

1096

1

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

1097

1

			.try_into()

1098

1

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

1099

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1100

1

			source_id,

1101

1

			source_location_latest,

1102

1

			asset_metadata.decimals,

1103

1

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

1104

1

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

1105

));

1106

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

1107

1

});

1108

1109

1

	ParaA::execute_with(|| {

1110

		// amount not received as it is not paying enough

1111

1

		assert_eq!(

1112

1

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

1113

1

			Ok(U256::from(0))

1114

);

1115

1

});

1116

1117

	// We are sending 100 tokens from relay.

1118

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

1119

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

1120

1

	Relay::execute_with(|| {

1121

1

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

1122

1

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

1123

1

			assets: Wild(All),

1124

1

			beneficiary: dest.clone(),

1125

1

		}]);

1126

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1127

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1128

1

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

1129

1

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

1130

1

			Box::new(TransferType::LocalReserve),

1131

1

			Box::new(fees_id),

1132

1

			Box::new(TransferType::LocalReserve),

1133

1

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

1134

1

			WeightLimit::Unlimited

1135

));

1136

1

});

1137

1138

1

	ParaA::execute_with(|| {

1139

		// amount not received as it is not paying enough

1140

1

		assert_eq!(

1141

1

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

1142

1

			Ok(U256::from(0))

1143

);

1144

1

});

1145

1

1146

1147

#[test]

1148

1

fn transact_through_derivative_multilocation() {

1149

1

	MockNet::reset();

1150

1151

1

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

1152

1

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

1153

1154

1

	let asset_metadata = parachain::AssetMetadata {

1155

1

		name: b"RelayToken".to_vec(),

1156

1

		symbol: b"Relay".to_vec(),

1157

1

		decimals: 12,

1158

1

};

1159

1160

1

	ParaA::execute_with(|| {

1161

1

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

1162

1

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

1163

1

			.try_into()

1164

1

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

1165

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1166

1

			source_id,

1167

1

			source_location_latest,

1168

1

			asset_metadata.decimals,

1169

1

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

1170

1

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

1171

));

1172

1

		assert_ok!(add_supported_asset(source_location, 1));

1173

1174

		// Root can set transact info

1175

1

		assert_ok!(XcmTransactor::set_transact_info(

1176

1

			parachain::RuntimeOrigin::root(),

1177

1

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

1178

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

1179

1

			3000.into(),

1180

1

			20000000000.into(),

1181

1

			None

1182

));

1183

		// Root can set transact info

1184

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1185

1

			parachain::RuntimeOrigin::root(),

1186

1

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

1187

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1188

));

1189

1

});

1190

1191

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

1192

1193

1

	let dest: Location = AccountKey20 {

1194

1

		network: None,

1195

1

		key: PARAALICE,

1196

1

1197

1

	.into();

1198

1

	Relay::execute_with(|| {

1199

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

1200

1

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

1201

1

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

1202

1

			assets: Wild(All),

1203

1

			beneficiary: dest.clone(),

1204

1

		}]);

1205

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1206

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1207

1

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

1208

1

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

1209

1

			Box::new(TransferType::LocalReserve),

1210

1

			Box::new(fees_id),

1211

1

			Box::new(TransferType::LocalReserve),

1212

1

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

1213

1

			WeightLimit::Unlimited

1214

));

1215

1

});

1216

1217

1

	ParaA::execute_with(|| {

1218

		// free execution, full amount received

1219

1

		assert_eq!(

1220

1

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

1221

1

			Ok(U256::from(4000003100u128))

1222

);

1223

1

});

1224

1225

	// Register address

1226

1

	ParaA::execute_with(|| {

1227

1

		assert_ok!(XcmTransactor::register(

1228

1

			parachain::RuntimeOrigin::root(),

1229

1

			PARAALICE.into(),

1230

0,

1231

));

1232

1

});

1233

1234

	// Send to registered address

1235

1236

1

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

1237

1

	let dest = Location {

1238

1

		parents: 1,

1239

1

		interior: [AccountId32 {

1240

1

			network: None,

1241

1

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

1242

1

}]

1243

1

		.into(),

1244

1

};

1245

1

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

1246

1247

1

	ParaA::execute_with(|| {

1248

1

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

1249

1

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

1250

1

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

1251

1

			assets: Wild(All),

1252

1

			beneficiary: beneficiary.clone(),

1253

1

		}]);

1254

		// free execution, full amount received

1255

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1256

1

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

1257

1

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

1258

1

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

1259

1

			Box::new(TransferType::DestinationReserve),

1260

1

			Box::new(fees_id),

1261

1

			Box::new(TransferType::DestinationReserve),

1262

1

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

1263

1

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

1264

));

1265

1

});

1266

1267

1

	ParaA::execute_with(|| {

1268

		// free execution, full amount received

1269

1

		assert_eq!(

1270

1

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

1271

1

			Ok(U256::from(4000003000u128))

1272

);

1273

1

});

1274

1275

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

1276

	// again

1277

1

	Relay::execute_with(|| {

1278

		// free execution,x	 full amount received

1279

1

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

1280

1

});

1281

1282

	// Encode the call. Balances transact to para_a_account

1283

	// First index

1284

1

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

1285

1

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

1286

1

		relay_chain::Balances,

1287

1

>()

1288

1

	.unwrap() as u8;

1289

1290

1

	encoded.push(index);

1291

1292

	// Then call bytes

1293

1

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

1294

1

		dest: para_a_account(),

1295

1

		value: 100u32.into(),

1296

1

1297

1

	.encode();

1298

1

	encoded.append(&mut call_bytes);

1299

1300

1

	ParaA::execute_with(|| {

1301

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1302

1

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

1303

1

			MockTransactors::Relay,

1304

0,

1305

1

			CurrencyPayment {

1306

1

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

1307

1

					Location::parent()

1308

1

				))),

1309

1

				fee_amount: None

1310

1

},

1311

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

1312

1

			encoded,

1313

1

			TransactWeights {

1314

1

				transact_required_weight_at_most: 4000000000.into(),

1315

1

				overall_weight: None

1316

1

},

1317

			false

1318

));

1319

1

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

1320

1

			.iter()

1321

20

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

1322

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

1323

..

1324

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

1325

20

				_ => None,

1326

20

});

1327

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

1328

1

		assert!(event_found.is_none());

1329

1

});

1330

1331

1

	Relay::execute_with(|| {

1332

		// free execution,x	 full amount received

1333

1

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

1334

1335

1

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

1336

1

});

1337

1

1338

1339

#[test]

1340

1

fn transact_through_derivative_with_custom_fee_weight() {

1341

1

	MockNet::reset();

1342

1343

1

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

1344

1

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

1345

1346

1

	let asset_metadata = parachain::AssetMetadata {

1347

1

		name: b"RelayToken".to_vec(),

1348

1

		symbol: b"Relay".to_vec(),

1349

1

		decimals: 12,

1350

1

};

1351

1352

1

	ParaA::execute_with(|| {

1353

1

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

1354

1

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

1355

1

			.try_into()

1356

1

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

1357

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1358

1

			source_id,

1359

1

			source_location_latest,

1360

1

			asset_metadata.decimals,

1361

1

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

1362

1

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

1363

));

1364

1

		assert_ok!(add_supported_asset(source_location, 1));

1365

1

});

1366

1367

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

1368

1369

1

	let dest: Location = AccountKey20 {

1370

1

		network: None,

1371

1

		key: PARAALICE,

1372

1

1373

1

	.into();

1374

1

	Relay::execute_with(|| {

1375

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

1376

1

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

1377

1

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

1378

1

			assets: Wild(All),

1379

1

			beneficiary: dest.clone(),

1380

1

		}]);

1381

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1382

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1383

1

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

1384

1

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

1385

1

			Box::new(TransferType::LocalReserve),

1386

1

			Box::new(fees_id),

1387

1

			Box::new(TransferType::LocalReserve),

1388

1

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

1389

1

			WeightLimit::Unlimited

1390

));

1391

1

});

1392

1393

1

	ParaA::execute_with(|| {

1394

		// free execution, full amount received

1395

1

		assert_eq!(

1396

1

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

1397

1

			Ok(U256::from(4000003100u128))

1398

);

1399

1

});

1400

1401

	// Register address

1402

1

	ParaA::execute_with(|| {

1403

1

		assert_ok!(XcmTransactor::register(

1404

1

			parachain::RuntimeOrigin::root(),

1405

1

			PARAALICE.into(),

1406

0,

1407

));

1408

1

});

1409

1410

	// Send to registered address

1411

1412

1

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

1413

1

	let dest = Location {

1414

1

		parents: 1,

1415

1

		interior: [AccountId32 {

1416

1

			network: None,

1417

1

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

1418

1

}]

1419

1

		.into(),

1420

1

};

1421

1

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

1422

1423

1

	ParaA::execute_with(|| {

1424

1

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

1425

1

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

1426

1

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

1427

1

			assets: Wild(All),

1428

1

			beneficiary: beneficiary.clone(),

1429

1

		}]);

1430

		// free execution, full amount received

1431

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1432

1

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

1433

1

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

1434

1

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

1435

1

			Box::new(TransferType::DestinationReserve),

1436

1

			Box::new(fees_id),

1437

1

			Box::new(TransferType::DestinationReserve),

1438

1

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

1439

1

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

1440

));

1441

1

});

1442

1443

1

	ParaA::execute_with(|| {

1444

		// free execution, full amount received

1445

1

		assert_eq!(

1446

1

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

1447

1

			Ok(U256::from(4000003000u128))

1448

);

1449

1

});

1450

1451

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

1452

	// again

1453

1

	Relay::execute_with(|| {

1454

		// free execution,x	 full amount received

1455

1

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

1456

1

});

1457

1458

	// Encode the call. Balances transact to para_a_account

1459

	// First index

1460

1

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

1461

1

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

1462

1

		relay_chain::Balances,

1463

1

>()

1464

1

	.unwrap() as u8;

1465

1466

1

	encoded.push(index);

1467

1468

	// Then call bytes

1469

1

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

1470

1

		dest: para_a_account(),

1471

1

		value: 100u32.into(),

1472

1

1473

1

	.encode();

1474

1

	encoded.append(&mut call_bytes);

1475

1476

1

	let overall_weight = 4000003000u64;

1477

1

	ParaA::execute_with(|| {

1478

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1479

1

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

1480

1

			MockTransactors::Relay,

1481

0,

1482

1

			CurrencyPayment {

1483

1

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

1484

1

					Location::parent()

1485

1

				))),

1486

1

				// 1-1 fee weight mapping

1487

1

				fee_amount: Some(overall_weight as u128)

1488

1

},

1489

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

1490

1

			encoded,

1491

1

			TransactWeights {

1492

1

				transact_required_weight_at_most: 4000000000.into(),

1493

1

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

1494

1

},

1495

			false

1496

));

1497

1

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

1498

1

			.iter()

1499

18

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

1500

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

1501

..

1502

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

1503

18

				_ => None,

1504

18

});

1505

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

1506

1

		assert!(event_found.is_none());

1507

1

});

1508

1509

1

	Relay::execute_with(|| {

1510

		// free execution,x	 full amount received

1511

1

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

1512

1513

1

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

1514

1

});

1515

1

1516

1517

#[test]

1518

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1519

1

	MockNet::reset();

1520

1521

1

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

1522

1

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

1523

1524

1

	let asset_metadata = parachain::AssetMetadata {

1525

1

		name: b"RelayToken".to_vec(),

1526

1

		symbol: b"Relay".to_vec(),

1527

1

		decimals: 12,

1528

1

};

1529

1530

1

	ParaA::execute_with(|| {

1531

1

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

1532

1

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

1533

1

			.try_into()

1534

1

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

1535

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1536

1

			source_id,

1537

1

			source_location_latest,

1538

1

			asset_metadata.decimals,

1539

1

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

1540

1

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

1541

));

1542

1

		assert_ok!(add_supported_asset(source_location, 1));

1543

1

});

1544

1545

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

1546

1547

1

	let dest: Location = AccountKey20 {

1548

1

		network: None,

1549

1

		key: PARAALICE,

1550

1

1551

1

	.into();

1552

1

	Relay::execute_with(|| {

1553

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

1554

1

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

1555

1

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

1556

1

			assets: Wild(All),

1557

1

			beneficiary: dest.clone(),

1558

1

		}]);

1559

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1560

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1561

1

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

1562

1

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

1563

1

			Box::new(TransferType::LocalReserve),

1564

1

			Box::new(fees_id),

1565

1

			Box::new(TransferType::LocalReserve),

1566

1

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

1567

1

			WeightLimit::Unlimited

1568

));

1569

1

});

1570

1571

1

	ParaA::execute_with(|| {

1572

		// free execution, full amount received

1573

1

		assert_eq!(

1574

1

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

1575

1

			Ok(U256::from(4000009100u128))

1576

);

1577

1

});

1578

1579

	// Register address

1580

1

	ParaA::execute_with(|| {

1581

1

		assert_ok!(XcmTransactor::register(

1582

1

			parachain::RuntimeOrigin::root(),

1583

1

			PARAALICE.into(),

1584

0,

1585

));

1586

1

});

1587

1588

	// Send to registered address

1589

1590

1

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

1591

1

	let dest = Location {

1592

1

		parents: 1,

1593

1

		interior: [AccountId32 {

1594

1

			network: None,

1595

1

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

1596

1

}]

1597

1

		.into(),

1598

1

};

1599

1

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

1600

1601

1

	ParaA::execute_with(|| {

1602

1

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

1603

1

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

1604

1

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

1605

1

			assets: Wild(All),

1606

1

			beneficiary: beneficiary.clone(),

1607

1

		}]);

1608

		// free execution, full amount received

1609

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1610

1

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

1611

1

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

1612

1

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

1613

1

			Box::new(TransferType::DestinationReserve),

1614

1

			Box::new(fees_id),

1615

1

			Box::new(TransferType::DestinationReserve),

1616

1

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

1617

1

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

1618

));

1619

1

});

1620

1621

1

	ParaA::execute_with(|| {

1622

		// free execution, full amount received

1623

1

		assert_eq!(

1624

1

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

1625

1

			Ok(U256::from(4000009000u128))

1626

);

1627

1

});

1628

1629

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

1630

	// again

1631

1

	Relay::execute_with(|| {

1632

		// free execution,x	 full amount received

1633

1

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

1634

1

});

1635

1636

	// Encode the call. Balances transact to para_a_account

1637

	// First index

1638

1

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

1639

1

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

1640

1

		relay_chain::Balances,

1641

1

>()

1642

1

	.unwrap() as u8;

1643

1644

1

	encoded.push(index);

1645

1646

	// Then call bytes

1647

1

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

1648

1

		dest: para_a_account(),

1649

1

		value: 100u32.into(),

1650

1

1651

1

	.encode();

1652

1

	encoded.append(&mut call_bytes);

1653

1654

1

	let overall_weight = 4000009000u64;

1655

1

	ParaA::execute_with(|| {

1656

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1657

1

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

1658

1

			MockTransactors::Relay,

1659

0,

1660

1

			CurrencyPayment {

1661

1

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

1662

1

					Location::parent()

1663

1

				))),

1664

1

				// 1-1 fee weight mapping

1665

1

				fee_amount: Some(overall_weight as u128)

1666

1

},

1667

1

			encoded,

1668

1

			TransactWeights {

1669

1

				transact_required_weight_at_most: 4000000000.into(),

1670

1

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

1671

1

},

1672

			true

1673

));

1674

1

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

1675

1

			.iter()

1676

18

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

1677

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

1678

..

1679

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

1680

18

				_ => None,

1681

18

});

1682

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

1683

1

		assert!(event_found.is_none());

1684

1

});

1685

1686

1

	Relay::execute_with(|| {

1687

		// free execution, full amount received

1688

		// 4000009000 refunded + 100 transferred = 4000009100

1689

1

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

1690

1

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

1691

1

});

1692

1

1693

1694

#[test]

1695

1

fn transact_through_sovereign() {

1696

1

	MockNet::reset();

1697

1698

1

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

1699

1

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

1700

1701

1

	let asset_metadata = parachain::AssetMetadata {

1702

1

		name: b"RelayToken".to_vec(),

1703

1

		symbol: b"Relay".to_vec(),

1704

1

		decimals: 12,

1705

1

};

1706

1707

1

	ParaA::execute_with(|| {

1708

1

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

1709

1

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

1710

1

			.try_into()

1711

1

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

1712

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1713

1

			source_id,

1714

1

			source_location_latest,

1715

1

			asset_metadata.decimals,

1716

1

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

1717

1

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

1718

));

1719

1

		assert_ok!(add_supported_asset(source_location, 1));

1720

1721

		// Root can set transact info

1722

1

		assert_ok!(XcmTransactor::set_transact_info(

1723

1

			parachain::RuntimeOrigin::root(),

1724

1

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

1725

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

1726

1

			3000.into(),

1727

1

			20000000000.into(),

1728

1

			None

1729

));

1730

		// Root can set transact info

1731

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1732

1

			parachain::RuntimeOrigin::root(),

1733

1

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

1734

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1735

));

1736

1

});

1737

1738

1

	let dest: Location = AccountKey20 {

1739

1

		network: None,

1740

1

		key: PARAALICE,

1741

1

1742

1

	.into();

1743

1

	Relay::execute_with(|| {

1744

1

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

1745

1

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

1746

1

			assets: Wild(All),

1747

1

			beneficiary: dest.clone(),

1748

1

		}]);

1749

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1750

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1751

1

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

1752

1

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

1753

1

			Box::new(TransferType::LocalReserve),

1754

1

			Box::new(fees_id),

1755

1

			Box::new(TransferType::LocalReserve),

1756

1

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

1757

1

			WeightLimit::Unlimited

1758

));

1759

1

});

1760

1761

1

	ParaA::execute_with(|| {

1762

		// free execution, full amount received

1763

1

		assert_eq!(

1764

1

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

1765

1

			Ok(U256::from(4000003100u128))

1766

);

1767

1

});

1768

1769

	// Register address

1770

1

	ParaA::execute_with(|| {

1771

1

		assert_ok!(XcmTransactor::register(

1772

1

			parachain::RuntimeOrigin::root(),

1773

1

			PARAALICE.into(),

1774

0,

1775

));

1776

1

});

1777

1778

	// Send to registered address

1779

1

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

1780

1

	let dest = Location {

1781

1

		parents: 1,

1782

1

		interior: [AccountId32 {

1783

1

			network: None,

1784

1

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

1785

1

}]

1786

1

		.into(),

1787

1

};

1788

1

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

1789

1790

1

	ParaA::execute_with(|| {

1791

1

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

1792

1

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

1793

1

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

1794

1

			assets: Wild(All),

1795

1

			beneficiary: beneficiary.clone(),

1796

1

		}]);

1797

		// free execution, full amount received

1798

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1799

1

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

1800

1

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

1801

1

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

1802

1

			Box::new(TransferType::DestinationReserve),

1803

1

			Box::new(fees_id),

1804

1

			Box::new(TransferType::DestinationReserve),

1805

1

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

1806

1

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

1807

));

1808

1

});

1809

1810

1

	ParaA::execute_with(|| {

1811

		// free execution, full amount received

1812

1

		assert_eq!(

1813

1

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

1814

1

			Ok(U256::from(4000003000u128))

1815

);

1816

1

});

1817

1818

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

1819

	// again

1820

1

	Relay::execute_with(|| {

1821

		// free execution,x	 full amount received

1822

1

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

1823

1

1824

1

});

1825

1826

	// We send the xcm transact operation to parent

1827

1

	let dest = Location {

1828

1

		parents: 1,

1829

1

		interior: [].into(),

1830

1

};

1831

1832

	// Encode the call. Balances transact to para_a_account

1833

	// First index

1834

1

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

1835

1

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

1836

1

		relay_chain::Balances,

1837

1

>()

1838

1

	.unwrap() as u8;

1839

1840

1

	encoded.push(index);

1841

1842

	// Then call bytes

1843

1

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

1844

1

		dest: para_a_account(),

1845

1

		value: 100u32.into(),

1846

1

1847

1

	.encode();

1848

1

	encoded.append(&mut call_bytes);

1849

1850

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

1851

1

	ParaA::execute_with(|| {

1852

1

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

1853

1

			moonbase_runtime::xcm_config::Transactors::Relay,

1854

1

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

1855

);

1856

1857

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1858

1

			parachain::RuntimeOrigin::root(),

1859

1

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

1860

1

			Some(PARAALICE.into()),

1861

1

			CurrencyPayment {

1862

1

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

1863

1

					Location::parent()

1864

1

				))),

1865

1

				fee_amount: None

1866

1

},

1867

1

			utility_bytes,

1868

1

			OriginKind::SovereignAccount,

1869

1

			TransactWeights {

1870

1

				transact_required_weight_at_most: 4000000000.into(),

1871

1

				overall_weight: None

1872

1

},

1873

			false

1874

));

1875

1

});

1876

1877

1

	Relay::execute_with(|| {

1878

		// free execution,x	 full amount received

1879

1

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

1880

1881

1

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

1882

1

});

1883

1

1884

1885

#[test]

1886

1

fn transact_through_sovereign_fee_payer_none() {

1887

1

	MockNet::reset();

1888

1889

1

	ParaA::execute_with(|| {

1890

		// Root can set transact info

1891

1

		assert_ok!(XcmTransactor::set_transact_info(

1892

1

			parachain::RuntimeOrigin::root(),

1893

1

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

1894

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

1895

1

			3000.into(),

1896

1

			20000000000.into(),

1897

1

			None

1898

));

1899

		// Root can set transact info

1900

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1901

1

			parachain::RuntimeOrigin::root(),

1902

1

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

1903

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1904

));

1905

1

});

1906

1907

1

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

1908

1909

1

	Relay::execute_with(|| {

1910

		// Transfer 100 tokens to derivative_address on the relay

1911

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1912

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1913

1

			derivative_address.clone(),

1914

			100u128

1915

));

1916

1917

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

1918

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1919

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1920

1

			para_a_account(),

1921

			4000003000u128

1922

));

1923

1

});

1924

1925

	// Check balances before the transact call

1926

1

	Relay::execute_with(|| {

1927

1

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

1928

1

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

1929

1

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

1930

1

});

1931

1932

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

1933

1

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

1934

1

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

1935

1

		relay_chain::Balances,

1936

1

>()

1937

1

	.unwrap() as u8;

1938

1939

1

	encoded.push(index);

1940

1941

1

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

1942

1

		dest: RELAYBOB,

1943

1

		value: 100u32.into(),

1944

1

1945

1

	.encode();

1946

1

	encoded.append(&mut call_bytes);

1947

1948

	// We send the xcm transact operation to parent

1949

1

	let dest = Location {

1950

1

		parents: 1,

1951

1

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

1952

1

};

1953

1954

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

1955

1

	ParaA::execute_with(|| {

1956

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

1957

1

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

1958

1

			moonbase_runtime::xcm_config::Transactors::Relay,

1959

1

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

1960

);

1961

1962

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1963

1

			parachain::RuntimeOrigin::root(),

1964

1

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

1965

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

1966

1

			None,

1967

1

			CurrencyPayment {

1968

1

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

1969

1

					Location::parent()

1970

1

				))),

1971

1

				fee_amount: None

1972

1

},

1973

1

			utility_bytes,

1974

1

			OriginKind::SovereignAccount,

1975

1

			TransactWeights {

1976

1

				transact_required_weight_at_most: 4000000000.into(),

1977

1

				overall_weight: None

1978

1

},

1979

			false

1980

));

1981

1

});

1982

1983

	// Check balances after the transact call are correct

1984

1

	Relay::execute_with(|| {

1985

1

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

1986

1

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

1987

1

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

1988

1

});

1989

1

1990

1991

#[test]

1992

1

fn transact_through_sovereign_with_custom_fee_weight() {

1993

1

	MockNet::reset();

1994

1995

1

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

1996

1

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

1997

1998

1

	let asset_metadata = parachain::AssetMetadata {

1999

1

		name: b"RelayToken".to_vec(),

2000

1

		symbol: b"Relay".to_vec(),

2001

1

		decimals: 12,

2002

1

};

2003

2004

1

	ParaA::execute_with(|| {

2005

1

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

2006

1

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

2007

1

			.try_into()

2008

1

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

2009

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2010

1

			source_id,

2011

1

			source_location_latest,

2012

1

			asset_metadata.decimals,

2013

1

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

2014

1

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

2015

));

2016

1

		assert_ok!(add_supported_asset(source_location, 1));

2017

1

});

2018

2019

1

	let dest: Location = AccountKey20 {

2020

1

		network: None,

2021

1

		key: PARAALICE,

2022

1

2023

1

	.into();

2024

1

	Relay::execute_with(|| {

2025

1

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

2026

1

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

2027

1

			assets: Wild(All),

2028

1

			beneficiary: dest.clone(),

2029

1

		}]);

2030

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2031

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2032

1

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

2033

1

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

2034

1

			Box::new(TransferType::LocalReserve),

2035

1

			Box::new(fees_id),

2036

1

			Box::new(TransferType::LocalReserve),

2037

1

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

2038

1

			WeightLimit::Unlimited

2039

));

2040

1

});

2041

2042

1

	ParaA::execute_with(|| {

2043

		// free execution, full amount received

2044

1

		assert_eq!(

2045

1

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

2046

1

			Ok(U256::from(4000003100u128))

2047

);

2048

1

});

2049

2050

	// Register address

2051

1

	ParaA::execute_with(|| {

2052

1

		assert_ok!(XcmTransactor::register(

2053

1

			parachain::RuntimeOrigin::root(),

2054

1

			PARAALICE.into(),

2055

0,

2056

));

2057

1

});

2058

2059

	// Send to registered address

2060

1

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

2061

1

	let dest = Location {

2062

1

		parents: 1,

2063

1

		interior: [AccountId32 {

2064

1

			network: None,

2065

1

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

2066

1

}]

2067

1

		.into(),

2068

1

};

2069

1

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

2070

2071

1

	ParaA::execute_with(|| {

2072

1

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

2073

1

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

2074

1

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

2075

1

			assets: Wild(All),

2076

1

			beneficiary: beneficiary.clone(),

2077

1

		}]);

2078

		// free execution, full amount received

2079

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2080

1

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

2081

1

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

2082

1

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

2083

1

			Box::new(TransferType::DestinationReserve),

2084

1

			Box::new(fees_id),

2085

1

			Box::new(TransferType::DestinationReserve),

2086

1

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

2087

1

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

2088

));

2089

1

});

2090

2091

1

	ParaA::execute_with(|| {

2092

		// free execution, full amount received

2093

1

		assert_eq!(

2094

1

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

2095

1

			Ok(U256::from(4000003000u128))

2096

);

2097

1

});

2098

2099

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

2100

	// again

2101

1

	Relay::execute_with(|| {

2102

		// free execution,x	 full amount received

2103

1

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

2104

1

2105

1

});

2106

2107

	// We send the xcm transact operation to parent

2108

1

	let dest = Location {

2109

1

		parents: 1,

2110

1

		interior: [].into(),

2111

1

};

2112

2113

	// Encode the call. Balances transact to para_a_account

2114

	// First index

2115

1

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

2116

1

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

2117

1

		relay_chain::Balances,

2118

1

>()

2119

1

	.unwrap() as u8;

2120

2121

1

	encoded.push(index);

2122

2123

	// Then call bytes

2124

1

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

2125

1

		dest: para_a_account(),

2126

1

		value: 100u32.into(),

2127

1

2128

1

	.encode();

2129

1

	encoded.append(&mut call_bytes);

2130

2131

1

	let total_weight = 4000003000u64;

2132

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

2133

1

	ParaA::execute_with(|| {

2134

1

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

2135

1

			moonbase_runtime::xcm_config::Transactors::Relay,

2136

1

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

2137

);

2138

2139

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2140

1

			parachain::RuntimeOrigin::root(),

2141

1

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

2142

1

			Some(PARAALICE.into()),

2143

1

			CurrencyPayment {

2144

1

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

2145

1

					Location::parent()

2146

1

				))),

2147

1

				// 1-1 fee-weight mapping

2148

1

				fee_amount: Some(total_weight as u128)

2149

1

},

2150

1

			utility_bytes,

2151

1

			OriginKind::SovereignAccount,

2152

1

			TransactWeights {

2153

1

				transact_required_weight_at_most: 4000000000.into(),

2154

1

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

2155

1

},

2156

			false

2157

));

2158

1

});

2159

2160

1

	Relay::execute_with(|| {

2161

		// free execution,x	 full amount received

2162

1

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

2163

2164

1

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

2165

1

});

2166

1

2167

2168

#[test]

2169

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2170

1

	MockNet::reset();

2171

2172

1

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

2173

1

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

2174

2175

1

	let asset_metadata = parachain::AssetMetadata {

2176

1

		name: b"RelayToken".to_vec(),

2177

1

		symbol: b"Relay".to_vec(),

2178

1

		decimals: 12,

2179

1

};

2180

2181

1

	ParaA::execute_with(|| {

2182

1

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

2183

1

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

2184

1

			.try_into()

2185

1

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

2186

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2187

1

			source_id,

2188

1

			source_location_latest,

2189

1

			asset_metadata.decimals,

2190

1

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

2191

1

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

2192

));

2193

1

		assert_ok!(add_supported_asset(source_location, 1));

2194

1

});

2195

2196

1

	let dest: Location = AccountKey20 {

2197

1

		network: None,

2198

1

		key: PARAALICE,

2199

1

2200

1

	.into();

2201

1

	Relay::execute_with(|| {

2202

1

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

2203

1

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

2204

1

			assets: Wild(All),

2205

1

			beneficiary: dest.clone(),

2206

1

		}]);

2207

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2208

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2209

1

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

2210

1

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

2211

1

			Box::new(TransferType::LocalReserve),

2212

1

			Box::new(fees_id),

2213

1

			Box::new(TransferType::LocalReserve),

2214

1

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

2215

1

			WeightLimit::Unlimited

2216

));

2217

1

});

2218

2219

1

	ParaA::execute_with(|| {

2220

		// free execution, full amount received

2221

1

		assert_eq!(

2222

1

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

2223

1

			Ok(U256::from(4000009100u128))

2224

);

2225

1

});

2226

2227

	// Register address

2228

1

	ParaA::execute_with(|| {

2229

1

		assert_ok!(XcmTransactor::register(

2230

1

			parachain::RuntimeOrigin::root(),

2231

1

			PARAALICE.into(),

2232

0,

2233

));

2234

1

});

2235

2236

	// Send to registered address

2237

1

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

2238

1

	let dest = Location {

2239

1

		parents: 1,

2240

1

		interior: [AccountId32 {

2241

1

			network: None,

2242

1

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

2243

1

}]

2244

1

		.into(),

2245

1

};

2246

1

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

2247

2248

1

	ParaA::execute_with(|| {

2249

1

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

2250

1

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

2251

1

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

2252

1

			assets: Wild(All),

2253

1

			beneficiary: beneficiary.clone(),

2254

1

		}]);

2255

		// free execution, full amount received

2256

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2257

1

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

2258

1

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

2259

1

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

2260

1

			Box::new(TransferType::DestinationReserve),

2261

1

			Box::new(fees_id),

2262

1

			Box::new(TransferType::DestinationReserve),

2263

1

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

2264

1

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

2265

));

2266

1

});

2267

2268

1

	ParaA::execute_with(|| {

2269

		// free execution, full amount received

2270

1

		assert_eq!(

2271

1

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

2272

1

			Ok(U256::from(4000009000u128))

2273

);

2274

1

});

2275

2276

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

2277

	// again

2278

1

	Relay::execute_with(|| {

2279

		// free execution,x	 full amount received

2280

1

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

2281

1

2282

1

});

2283

2284

	// We send the xcm transact operation to parent

2285

1

	let dest = Location {

2286

1

		parents: 1,

2287

1

		interior: [].into(),

2288

1

};

2289

2290

	// Encode the call. Balances transact to para_a_account

2291

	// First index

2292

1

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

2293

1

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

2294

1

		relay_chain::Balances,

2295

1

>()

2296

1

	.unwrap() as u8;

2297

2298

1

	encoded.push(index);

2299

2300

	// Then call bytes

2301

1

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

2302

1

		dest: para_a_account(),

2303

1

		value: 100u32.into(),

2304

1

2305

1

	.encode();

2306

1

	encoded.append(&mut call_bytes);

2307

2308

1

	let total_weight = 4000009000u64;

2309

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

2310

1

	ParaA::execute_with(|| {

2311

1

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

2312

1

			moonbase_runtime::xcm_config::Transactors::Relay,

2313

1

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

2314

);

2315

2316

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2317

1

			parachain::RuntimeOrigin::root(),

2318

1

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

2319

1

			Some(PARAALICE.into()),

2320

1

			CurrencyPayment {

2321

1

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

2322

1

					Location::parent()

2323

1

				))),

2324

1

				// 1-1 fee-weight mapping

2325

1

				fee_amount: Some(total_weight as u128)

2326

1

},

2327

1

			utility_bytes,

2328

1

			OriginKind::SovereignAccount,

2329

1

			TransactWeights {

2330

1

				transact_required_weight_at_most: 4000000000.into(),

2331

1

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

2332

1

},

2333

			true

2334

));

2335

1

});

2336

2337

1

	Relay::execute_with(|| {

2338

		// free execution, full amount received

2339

		// 4000009000 refunded + 100 transferred = 4000009100

2340

1

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

2341

2342

1

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

2343

1

});

2344

1

2345

2346

#[test]

2347

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2348

1

	MockNet::reset();

2349

2350

1

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

2351

1

	let asset_metadata = parachain::AssetMetadata {

2352

1

		name: b"RelayToken".to_vec(),

2353

1

		symbol: b"Relay".to_vec(),

2354

1

		decimals: 12,

2355

1

};

2356

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

2357

1

	ParaA::execute_with(|| {

2358

1

		parachain::XcmVersioner::set_version(1);

2359

1

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

2360

1

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

2361

1

			.try_into()

2362

1

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

2363

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2364

3,

2365

1

			source_location_latest,

2366

1

			asset_metadata.decimals,

2367

1

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

2368

1

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

2369

));

2370

1

		assert_ok!(add_supported_asset(source_location, 0));

2371

1

});

2372

2373

1

	let response = Response::Version(2);

2374

1

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

2375

2376

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

2377

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

2378

1

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

2379

1

		query_id: 0,

2380

1

		response,

2381

1

		max_weight: Weight::zero(),

2382

1

		querier: Some(querier),

2383

1

	}]);

2384

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

2385

	// it directly here

2386

	// Actually send relay asset to parachain

2387

1

	let dest: Location = AccountKey20 {

2388

1

		network: None,

2389

1

		key: PARAALICE,

2390

1

2391

1

	.into();

2392

2393

1

	Relay::execute_with(|| {

2394

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

2395

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2396

1

			relay_chain::RuntimeOrigin::root(),

2397

1

			Some(3)

2398

));

2399

2400

		// Wrap version, which sets VersionedStorage

2401

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

2402

		// this is not necessary in prod

2403

1

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

2404

1

			&Parachain(1).into(),

2405

1

			mock_message

2406

));

2407

2408

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

2409

1

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

2410

1

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

2411

1

			assets: Wild(All),

2412

1

			beneficiary: dest.clone(),

2413

1

		}]);

2414

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2415

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2416

1

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

2417

1

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

2418

1

			Box::new(TransferType::LocalReserve),

2419

1

			Box::new(fees_id),

2420

1

			Box::new(TransferType::LocalReserve),

2421

1

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

2422

1

			WeightLimit::Unlimited

2423

));

2424

2425

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

2426

1

		relay_chain::relay_roll_to(2);

2427

2428

		// queries should have been updated

2429

1

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

2430

1

});

2431

2432

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2433

1

		pallet_xcm::Event::SupportedVersionChanged {

2434

1

			location: Location {

2435

1

				parents: 0,

2436

1

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

2437

1

},

2438

1

			version: 1,

2439

1

2440

1

		.into();

2441

2442

1

	Relay::execute_with(|| {

2443

		// Assert that the events vector contains the version change

2444

1

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

2445

1

});

2446

2447

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

2448

	// of the new version change

2449

1

	ParaA::execute_with(|| {

2450

		// Set version

2451

1

		parachain::XcmVersioner::set_version(2);

2452

		// Do runtime upgrade

2453

1

		parachain::on_runtime_upgrade();

2454

		// Initialize block, to call on_initialize and notify targets

2455

1

		parachain::para_roll_to(2);

2456

		// Expect the event in the parachain

2457

1

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

2458

2

e,

2459

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

2460

				result: 2,

2461

..

2462

})

2463

		)));

2464

1

});

2465

2466

	// This event should have been seen in the relay

2467

1

	let expected_supported_version_2: 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: 2,

2474

1

2475

1

		.into();

2476

2477

1

	Relay::execute_with(|| {

2478

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

2479

1

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

2480

1

});

2481

1

2482

2483

#[test]

2484

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2485

1

	MockNet::reset();

2486

2487

1

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

2488

1

	let source_location: AssetType = para_a_balances

2489

1

		.try_into()

2490

1

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

2491

1

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

2492

2493

1

	let asset_metadata = parachain::AssetMetadata {

2494

1

		name: b"ParaAToken".to_vec(),

2495

1

		symbol: b"ParaA".to_vec(),

2496

1

		decimals: 18,

2497

1

};

2498

1

	let response = Response::Version(2);

2499

1

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

2500

2501

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

2502

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

2503

1

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

2504

1

		query_id: 0,

2505

1

		response,

2506

1

		max_weight: Weight::zero(),

2507

1

		querier: Some(querier),

2508

1

	}]);

2509

2510

1

	ParaA::execute_with(|| {

2511

		// advertised version

2512

1

		parachain::XcmVersioner::set_version(2);

2513

1

});

2514

2515

1

	ParaB::execute_with(|| {

2516

		// Let's try with v0

2517

1

		parachain::XcmVersioner::set_version(0);

2518

2519

1

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

2520

1

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

2521

1

			.try_into()

2522

1

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

2523

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2524

1

			source_id,

2525

1

			source_location_latest,

2526

1

			asset_metadata.decimals,

2527

1

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

2528

1

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

2529

));

2530

1

		assert_ok!(add_supported_asset(source_location, 0));

2531

1

});

2532

2533

1

	ParaA::execute_with(|| {

2534

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

2535

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2536

1

			parachain::RuntimeOrigin::root(),

2537

1

			Some(3)

2538

));

2539

		// Wrap version, which sets VersionedStorage

2540

1

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

2541

1

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

2542

1

			mock_message

2543

));

2544

2545

1

		parachain::para_roll_to(2);

2546

2547

		// queries should have been updated

2548

1

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

2549

1

});

2550

2551

1

	let expected_supported_version: parachain::RuntimeEvent =

2552

1

		pallet_xcm::Event::SupportedVersionChanged {

2553

1

			location: Location {

2554

1

				parents: 1,

2555

1

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

2556

1

},

2557

1

			version: 0,

2558

1

2559

1

		.into();

2560

2561

1

	ParaA::execute_with(|| {

2562

		// Assert that the events vector contains the version change

2563

1

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

2564

1

});

2565

2566

	// Let's ensure talking in v0 works

2567

1

	let dest = Location {

2568

1

		parents: 1,

2569

1

		interior: [

2570

1

			Parachain(2),

2571

1

			AccountKey20 {

2572

1

				network: None,

2573

1

				key: PARAALICE.into(),

2574

1

},

2575

1

2576

1

		.into(),

2577

1

2578

1

	.into();

2579

1

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

2580

1

	ParaA::execute_with(|| {

2581

1

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

2582

		// free execution, full amount received

2583

1

		assert_ok!(PolkadotXcm::transfer_assets(

2584

1

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

2585

1

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

2586

1

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

2587

1

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

2588

0,

2589

1

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

2590

));

2591

		// free execution, full amount received

2592

1

		assert_eq!(

2593

1

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

2594

			INITIAL_BALANCE - 100

2595

);

2596

1

});

2597

2598

1

	ParaB::execute_with(|| {

2599

		// free execution, full amount received

2600

1

		assert_eq!(

2601

1

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

2602

1

			Ok(U256::from(100))

2603

);

2604

1

});

2605

2606

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

2607

	// of the new version change

2608

1

	ParaB::execute_with(|| {

2609

		// Set version

2610

1

		parachain::XcmVersioner::set_version(2);

2611

		// Do runtime upgrade

2612

1

		parachain::on_runtime_upgrade();

2613

		// Initialize block, to call on_initialize and notify targets

2614

1

		parachain::para_roll_to(2);

2615

		// Expect the event in the parachain

2616

1

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

2617

2

e,

2618

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

2619

				result: 2,

2620

..

2621

})

2622

		)));

2623

1

});

2624

2625

	// This event should have been seen in para A

2626

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2627

1

		pallet_xcm::Event::SupportedVersionChanged {

2628

1

			location: Location {

2629

1

				parents: 1,

2630

1

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

2631

1

},

2632

1

			version: 2,

2633

1

2634

1

		.into();

2635

2636

	// Para A should have received the version change

2637

1

	ParaA::execute_with(|| {

2638

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

2639

1

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

2640

1

});

2641

1

2642

2643

#[test]

2644

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2645

1

	MockNet::reset();

2646

2647

1

	let fresh_account = PARABOB;

2648

1

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

2649

1

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

2650

1

	let asset_metadata = parachain::AssetMetadata {

2651

1

		name: b"RelayToken".to_vec(),

2652

1

		symbol: b"Relay".to_vec(),

2653

1

		decimals: 12,

2654

1

};

2655

	// register relay asset in parachain A

2656

1

	ParaA::execute_with(|| {

2657

1

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

2658

1

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

2659

1

			.try_into()

2660

1

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

2661

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2662

1

			source_id,

2663

1

			source_location_latest,

2664

1

			asset_metadata.decimals,

2665

1

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

2666

1

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

2667

));

2668

1

		assert_ok!(add_supported_asset(source_location, 0));

2669

1

});

2670

2671

	// Actually send relay asset to parachain

2672

1

	let dest: Location = AccountKey20 {

2673

1

		network: None,

2674

1

		key: fresh_account,

2675

1

2676

1

	.into();

2677

1

	Relay::execute_with(|| {

2678

1

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

2679

1

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

2680

1

			assets: Wild(All),

2681

1

			beneficiary: dest.clone(),

2682

1

		}]);

2683

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2684

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2685

1

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

2686

1

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

2687

1

			Box::new(TransferType::LocalReserve),

2688

1

			Box::new(fees_id),

2689

1

			Box::new(TransferType::LocalReserve),

2690

1

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

2691

1

			WeightLimit::Unlimited

2692

));

2693

1

});

2694

2695

	// parachain should not have received assets

2696

1

	ParaA::execute_with(|| {

2697

		// free execution, full amount received

2698

1

		assert_eq!(

2699

1

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

2700

1

			Ok(U256::from(123))

2701

);

2702

1

});

2703

1

2704

2705

#[test]

2706

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2707

1

	MockNet::reset();

2708

2709

1

	let fresh_account = [2u8; 20];

2710

1

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

2711

1

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

2712

1

	let asset_metadata = parachain::AssetMetadata {

2713

1

		name: b"RelayToken".to_vec(),

2714

1

		symbol: b"Relay".to_vec(),

2715

1

		decimals: 12,

2716

1

};

2717

	// register relay asset in parachain A

2718

1

	ParaA::execute_with(|| {

2719

1

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

2720

1

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

2721

1

			.try_into()

2722

1

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

2723

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2724

1

			source_id,

2725

1

			source_location_latest,

2726

1

			asset_metadata.decimals,

2727

1

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

2728

1

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

2729

));

2730

1

		assert_ok!(add_supported_asset(source_location, 0));

2731

1

});

2732

2733

	// Actually send relay asset to parachain

2734

1

	let dest: Location = AccountKey20 {

2735

1

		network: None,

2736

1

		key: fresh_account,

2737

1

2738

1

	.into();

2739

1

	Relay::execute_with(|| {

2740

1

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

2741

1

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

2742

1

			assets: Wild(All),

2743

1

			beneficiary: dest.clone(),

2744

1

		}]);

2745

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2746

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2747

1

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

2748

1

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

2749

1

			Box::new(TransferType::LocalReserve),

2750

1

			Box::new(fees_id),

2751

1

			Box::new(TransferType::LocalReserve),

2752

1

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

2753

1

			WeightLimit::Unlimited

2754

));

2755

1

});

2756

2757

	// parachain should have received assets

2758

1

	ParaA::execute_with(|| {

2759

		// free execution, full amount received

2760

1

		assert_eq!(

2761

1

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

2762

1

			Ok(U256::from(123))

2763

);

2764

1

});

2765

1

2766

2767

#[test]

2768

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2769

1

	MockNet::reset();

2770

2771

1

	let mut sufficient_account = [0u8; 20];

2772

1

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

2773

2774

1

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

2775

2776

	// Evm account is self sufficient

2777

1

	ParaA::execute_with(|| {

2778

1

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

2779

1

});

2780

2781

1

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

2782

1

	let asset_metadata = parachain::AssetMetadata {

2783

1

		name: b"RelayToken".to_vec(),

2784

1

		symbol: b"Relay".to_vec(),

2785

1

		decimals: 12,

2786

1

};

2787

	// register relay asset in parachain A

2788

1

	ParaA::execute_with(|| {

2789

1

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

2790

1

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

2791

1

			.try_into()

2792

1

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

2793

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2794

1,

2795

1

			source_location_latest,

2796

1

			asset_metadata.decimals,

2797

1

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

2798

1

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

2799

));

2800

1

		assert_ok!(add_supported_asset(source_location, 0));

2801

1

});

2802

2803

	// Actually send relay asset to parachain

2804

1

	let dest: Location = AccountKey20 {

2805

1

		network: None,

2806

1

		key: sufficient_account,

2807

1

2808

1

	.into();

2809

1

	Relay::execute_with(|| {

2810

1

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

2811

1

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

2812

1

			assets: Wild(All),

2813

1

			beneficiary: dest.clone(),

2814

1

		}]);

2815

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2816

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2817

1

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

2818

1

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

2819

1

			Box::new(TransferType::LocalReserve),

2820

1

			Box::new(fees_id),

2821

1

			Box::new(TransferType::LocalReserve),

2822

1

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

2823

1

			WeightLimit::Unlimited

2824

));

2825

1

});

2826

2827

	// Evm account sufficient ref count increased by 1.

2828

1

	ParaA::execute_with(|| {

2829

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

2830

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

2831

		// remove contract data

2832

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

2833

1

});

2834

2835

1

	ParaA::execute_with(|| {

2836

		// Remove the account from the evm context.

2837

1

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

2838

		// Evm account sufficient ref count decreased by 1.

2839

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

2840

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

2841

		// remove contract data

2842

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

2843

1

});

2844

1

2845

2846

#[test]

2847

1

fn empty_account_should_not_be_reset() {

2848

1

	MockNet::reset();

2849

2850

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

2851

1

	let sufficient_account = PARABOB;

2852

2853

1

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

2854

2855

1

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

2856

1

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

2857

1

	let asset_metadata = parachain::AssetMetadata {

2858

1

		name: b"RelayToken".to_vec(),

2859

1

		symbol: b"Relay".to_vec(),

2860

1

		decimals: 12,

2861

1

};

2862

	// register relay asset in parachain A

2863

1

	ParaA::execute_with(|| {

2864

1

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

2865

1

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

2866

1

			.try_into()

2867

1

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

2868

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2869

1

			source_id,

2870

1

			source_location_latest,

2871

1

			asset_metadata.decimals,

2872

1

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

2873

1

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

2874

));

2875

1

		assert_ok!(add_supported_asset(source_location, 0));

2876

1

});

2877

2878

	// Send native token to evm_account

2879

1

	ParaA::execute_with(|| {

2880

1

		assert_ok!(ParaBalances::transfer_allow_death(

2881

1

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

2882

1

			evm_account_id,

2883

2884

));

2885

1

});

2886

2887

	// Actually send relay asset to parachain

2888

1

	let dest: Location = AccountKey20 {

2889

1

		network: None,

2890

1

		key: sufficient_account,

2891

1

2892

1

	.into();

2893

1

	Relay::execute_with(|| {

2894

1

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

2895

1

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

2896

1

			assets: Wild(All),

2897

1

			beneficiary: dest.clone(),

2898

1

		}]);

2899

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2900

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2901

1

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

2902

1

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

2903

1

			Box::new(TransferType::LocalReserve),

2904

1

			Box::new(fees_id),

2905

1

			Box::new(TransferType::LocalReserve),

2906

1

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

2907

1

			WeightLimit::Unlimited

2908

));

2909

1

});

2910

2911

1

	ParaA::execute_with(|| {

2912

		// Empty the assets from the account.

2913

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

2914

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

2915

1

		assert_ok!(parachain::EvmForeignAssets::transfer(

2916

1

			source_id,

2917

1

			evm_account_id,

2918

1

			PARAALICE.into(),

2919

1

			U256::from(123)

2920

));

2921

		// Verify account asset balance is Zero.

2922

1

		assert_eq!(

2923

1

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

2924

1

			Ok(U256::from(0))

2925

);

2926

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

2927

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

2928

1

		assert_ok!(ParaBalances::force_set_balance(

2929

1

			parachain::RuntimeOrigin::root(),

2930

1

			evm_account_id,

2931

0,

2932

));

2933

		// Verify account native balance is Zero.

2934

1

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

2935

		// Remove the account from the evm context.

2936

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

2937

1

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

2938

		// Verify reference count.

2939

1

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

2940

1

		assert_eq!(account.sufficients, 0);

2941

1

		assert_eq!(account.consumers, 0);

2942

1

		assert_eq!(account.providers, 1);

2943

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

2944

1

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

2945

1

});

2946

1

2947

2948

#[test]

2949

1

fn test_statemint_like() {

2950

1

	MockNet::reset();

2951

2952

1

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

2953

2954

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2955

1

		polkadot_parachain::primitives::Sibling,

2956

1

		statemint_like::AccountId,

2957

1

	>::convert_location(&dest_para)

2958

1

	.unwrap();

2959

2960

1

	let statemint_asset_a_balances = Location::new(

2961

1,

2962

1

2963

1

			Parachain(1000),

2964

1

			PalletInstance(5),

2965

1

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

2966

1

],

2967

);

2968

1

	let source_location: AssetType = statemint_asset_a_balances

2969

1

		.try_into()

2970

1

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

2971

1

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

2972

2973

1

	let asset_metadata = parachain::AssetMetadata {

2974

1

		name: b"StatemintToken".to_vec(),

2975

1

		symbol: b"StatemintToken".to_vec(),

2976

1

		decimals: 12,

2977

1

};

2978

2979

1

	ParaA::execute_with(|| {

2980

1

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

2981

1

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

2982

1

			.try_into()

2983

1

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

2984

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2985

1

			source_id,

2986

1

			source_location_latest,

2987

1

			asset_metadata.decimals,

2988

1

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

2989

1

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

2990

));

2991

1

		assert_ok!(add_supported_asset(source_location, 0));

2992

1

});

2993

2994

1

	Statemint::execute_with(|| {

2995

		// Set new prefix

2996

1

		statemint_like::PrefixChanger::set_prefix(

2997

1

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

2998

);

2999

1

		assert_ok!(StatemintAssets::create(

3000

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3001

0,

3002

			RELAYALICE,

3003

3004

));

3005

3006

1

		assert_ok!(StatemintAssets::mint(

3007

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3008

0,

3009

			RELAYALICE,

3010

			300000000000000

3011

));

3012

3013

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

3014

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3015

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3016

1

			sov,

3017

			100000000000000

3018

));

3019

3020

		// Actually send relay asset to parachain

3021

1

		let dest: Location = AccountKey20 {

3022

1

			network: None,

3023

1

			key: PARAALICE,

3024

1

3025

1

		.into();

3026

3027

		// Send asset with previous prefix

3028

1

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

3029

1

0,

3030

1

3031

1

				xcm::latest::prelude::PalletInstance(

3032

1

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

3033

1

),

3034

1

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

3035

1

],

3036

1

))

3037

1

		.into();

3038

1

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

3039

1

			assets: Wild(All),

3040

1

			beneficiary: dest.clone(),

3041

1

		}]);

3042

1

		assert_ok!(

3043

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3044

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3045

1

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

3046

1

				Box::new(

3047

1

3048

1

3049

1

							xcm::latest::prelude::PalletInstance(

3050

1

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

3051

1

),

3052

1

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

3053

1

],

3054

1

3055

1

3056

1

						.into()

3057

),

3058

1

				Box::new(TransferType::LocalReserve),

3059

1

				Box::new(fees_id),

3060

1

				Box::new(TransferType::LocalReserve),

3061

1

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

3062

1

				WeightLimit::Unlimited

3063

3064

);

3065

1

});

3066

3067

1

	ParaA::execute_with(|| {

3068

1

		assert_eq!(

3069

1

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

3070

1

			Ok(U256::from(123))

3071

);

3072

1

});

3073

1

3074

3075

#[test]

3076

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

3077

1

	MockNet::reset();

3078

3079

	// Relay asset

3080

1

	let relay_location = Location::parent();

3081

1

	let relay_location_v3 =

3082

1

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

3083

1

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

3084

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

3085

};

3086

1

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

3087

1

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

3088

3089

1

	let relay_asset_metadata = parachain::AssetMetadata {

3090

1

		name: b"RelayToken".to_vec(),

3091

1

		symbol: b"Relay".to_vec(),

3092

1

		decimals: 12,

3093

1

};

3094

3095

	// Statemint asset

3096

1

	let statemint_asset = Location::new(

3097

1,

3098

1

3099

1

			Parachain(1000u32),

3100

1

			PalletInstance(5u8),

3101

1

			GeneralIndex(10u128),

3102

1

],

3103

);

3104

1

	let statemint_location_asset: AssetType = statemint_asset

3105

1

		.clone()

3106

1

		.try_into()

3107

1

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

3108

1

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

3109

3110

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3111

1

		name: b"USDC".to_vec(),

3112

1

		symbol: b"USDC".to_vec(),

3113

1

		decimals: 12,

3114

1

};

3115

3116

1

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

3117

3118

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3119

1

		polkadot_parachain::primitives::Sibling,

3120

1

		statemint_like::AccountId,

3121

1

	>::convert_location(&dest_para)

3122

1

	.unwrap();

3123

3124

1

	ParaA::execute_with(|| {

3125

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3126

1

			source_relay_id,

3127

1

			relay_location.clone(),

3128

1

			relay_asset_metadata.decimals,

3129

1

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

3130

1

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

3131

));

3132

1

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

3133

3134

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3135

1

			source_statemint_asset_id,

3136

1

			statemint_asset.clone(),

3137

1

			asset_metadata_statemint_asset.decimals,

3138

1

			asset_metadata_statemint_asset

3139

1

				.symbol

3140

1

				.try_into()

3141

1

				.expect("too long"),

3142

1

			asset_metadata_statemint_asset

3143

1

				.name

3144

1

				.try_into()

3145

1

				.expect("too long"),

3146

));

3147

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0));

3148

1

});

3149

3150

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3151

1

		network: None,

3152

1

		key: PARAALICE,

3153

1

3154

1

	.into();

3155

3156

	// Send relay chain asset to Alice in Parachain A

3157

1

	Relay::execute_with(|| {

3158

1

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

3159

1

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

3160

1

			assets: Wild(All),

3161

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

3162

1

		}]);

3163

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

3164

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3165

1

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

3166

1

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

3167

1

			Box::new(TransferType::LocalReserve),

3168

1

			Box::new(fees_id),

3169

1

			Box::new(TransferType::LocalReserve),

3170

1

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

3171

1

			WeightLimit::Unlimited

3172

));

3173

1

});

3174

3175

1

	Statemint::execute_with(|| {

3176

		// Set new prefix

3177

1

		statemint_like::PrefixChanger::set_prefix(

3178

1

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

3179

);

3180

3181

1

		assert_ok!(StatemintAssets::create(

3182

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3183

10,

3184

			RELAYALICE,

3185

3186

));

3187

3188

1

		assert_ok!(StatemintAssets::mint(

3189

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3190

10,

3191

			RELAYALICE,

3192

			300000000000000

3193

));

3194

3195

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

3196

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

3197

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3198

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3199

1

			sov,

3200

			100000000000000

3201

));

3202

3203

		// Send statemint USDC asset to Alice in Parachain A

3204

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

3205

1

			network: None,

3206

1

			key: PARAALICE,

3207

1

3208

1

		.into();

3209

3210

		// Send with new prefix

3211

1

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

3212

1

0,

3213

1

3214

1

				xcm::latest::prelude::PalletInstance(

3215

1

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

3216

1

),

3217

1

				GeneralIndex(10),

3218

1

],

3219

1

))

3220

1

		.into();

3221

1

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

3222

1

			assets: Wild(All),

3223

1

			beneficiary: parachain_beneficiary_from_statemint.clone(),

3224

1

		}]);

3225

1

		assert_ok!(

3226

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3227

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3228

1

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

3229

1

				Box::new(

3230

1

3231

1

3232

1

							xcm::latest::prelude::PalletInstance(

3233

1

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

3234

1

),

3235

1

							GeneralIndex(10),

3236

1

],

3237

1

3238

1

3239

1

						.into()

3240

),

3241

1

				Box::new(TransferType::LocalReserve),

3242

1

				Box::new(fees_id),

3243

1

				Box::new(TransferType::LocalReserve),

3244

1

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

3245

1

				WeightLimit::Unlimited

3246

3247

);

3248

1

});

3249

3250

1

	let statemint_beneficiary = Location {

3251

1

		parents: 1,

3252

1

		interior: [

3253

1

			Parachain(1000),

3254

1

			AccountId32 {

3255

1

				network: None,

3256

1

				id: RELAYBOB.into(),

3257

1

},

3258

1

3259

1

		.into(),

3260

1

};

3261

3262

1

	ParaA::execute_with(|| {

3263

		// Alice has received 125 USDC

3264

1

		assert_eq!(

3265

1

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

3266

1

			Ok(U256::from(125))

3267

);

3268

3269

		// Alice has received 200 Relay assets

3270

1

		assert_eq!(

3271

1

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

3272

1

			Ok(U256::from(200))

3273

);

3274

1

});

3275

3276

1

	Statemint::execute_with(|| {

3277

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

3278

1

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

3279

1

});

3280

3281

1

	let (chain_part, beneficiary) =

3282

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

3283

3284

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

3285

1

	ParaA::execute_with(|| {

3286

1

		let asset = currency_to_asset(

3287

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3288

			100,

3289

);

3290

1

		let asset_fee =

3291

1

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

3292

1

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

3293

1

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

3294

1

			assets: Wild(All),

3295

1

			beneficiary: beneficiary.clone(),

3296

1

		}]);

3297

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3298

1

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

3299

1

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

3300

1

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

3301

1

			Box::new(TransferType::DestinationReserve),

3302

1

			Box::new(fees_id),

3303

1

			Box::new(TransferType::DestinationReserve),

3304

1

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

3305

1

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

3306

));

3307

1

});

3308

3309

1

	ParaA::execute_with(|| {

3310

		// Alice has 100 USDC less

3311

1

		assert_eq!(

3312

1

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

3313

1

			Ok(U256::from(25))

3314

);

3315

3316

		// Alice has 100 relay asset less

3317

1

		assert_eq!(

3318

1

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

3319

1

			Ok(U256::from(100))

3320

);

3321

1

});

3322

3323

1

	Statemint::execute_with(|| {

3324

		// Check that BOB received 100 USDC on statemint

3325

1

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

3326

1

});

3327

1

3328

3329

#[test]

3330

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3331

1

	MockNet::reset();

3332

3333

	// Relay asset

3334

1

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

3335

1

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

3336

1

	let relay_location_v5 = Location::parent();

3337

1

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

3338

3339

1

	let relay_asset_metadata = parachain::AssetMetadata {

3340

1

		name: b"RelayToken".to_vec(),

3341

1

		symbol: b"Relay".to_vec(),

3342

1

		decimals: 12,

3343

1

};

3344

3345

1

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

3346

3347

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3348

1

		polkadot_parachain::primitives::Sibling,

3349

1

		statemint_like::AccountId,

3350

1

	>::convert_location(&dest_para)

3351

1

	.unwrap();

3352

3353

1

	ParaA::execute_with(|| {

3354

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3355

1

			source_relay_id,

3356

1

			relay_location_v5.clone(),

3357

1

			relay_asset_metadata.decimals,

3358

1

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

3359

1

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

3360

));

3361

1

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

3362

1

});

3363

3364

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3365

1

		network: None,

3366

1

		key: PARAALICE,

3367

1

3368

1

	.into();

3369

3370

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3371

1

		network: None,

3372

1

		id: RELAYALICE.into(),

3373

1

3374

1

	.into();

3375

3376

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

3377

1

	Relay::execute_with(|| {

3378

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3379

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3380

1

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

3381

1

			Box::new(

3382

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3383

1

					.clone()

3384

1

					.into()

3385

),

3386

1

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

3387

0,

3388

1

			WeightLimit::Unlimited

3389

));

3390

1

});

3391

3392

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3393

1

	Statemint::execute_with(|| {

3394

		// Check Alice received 200 tokens on AssetHub

3395

1

		assert_eq!(

3396

1

			StatemintBalances::free_balance(RELAYALICE),

3397

			INITIAL_BALANCE + 200

3398

);

3399

3400

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3401

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3402

1

			sov,

3403

			110000000000000

3404

));

3405

3406

		// Now send those tokens to ParaA

3407

1

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

3408

1

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

3409

1

			assets: Wild(All),

3410

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3411

1

		}]);

3412

1

		assert_ok!(

3413

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3414

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3415

1

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

3416

1

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

3417

1

				Box::new(TransferType::LocalReserve),

3418

1

				Box::new(fees_id),

3419

1

				Box::new(TransferType::LocalReserve),

3420

1

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

3421

1

				WeightLimit::Unlimited

3422

3423

);

3424

1

});

3425

3426

1

	ParaA::execute_with(|| {

3427

		// Alice should have received the DOTs

3428

1

		assert_eq!(

3429

1

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

3430

1

			Ok(U256::from(200))

3431

);

3432

1

});

3433

3434

1

	let dest = Location::new(

3435

1,

3436

1

3437

1

			Parachain(1000),

3438

1

			AccountId32 {

3439

1

				network: None,

3440

1

				id: RELAYBOB.into(),

3441

1

},

3442

1

],

3443

);

3444

1

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

3445

3446

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

3447

1

	ParaA::execute_with(|| {

3448

1

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

3449

1

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

3450

1

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

3451

1

			assets: Wild(All),

3452

1

			beneficiary: beneficiary.clone(),

3453

1

		}]);

3454

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3455

1

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

3456

1

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

3457

1

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

3458

1

			Box::new(TransferType::DestinationReserve),

3459

1

			Box::new(fees_id),

3460

1

			Box::new(TransferType::DestinationReserve),

3461

1

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

3462

1

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

3463

));

3464

3465

1

		assert_eq!(

3466

1

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

3467

1

			Ok(U256::from(100))

3468

);

3469

1

});

3470

3471

1

	Statemint::execute_with(|| {

3472

		// Check that Bob received the tokens back in AssetHub

3473

1

		assert_eq!(

3474

1

			StatemintBalances::free_balance(RELAYBOB),

3475

			INITIAL_BALANCE + 100

3476

);

3477

1

});

3478

3479

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

3480

1

	Statemint::execute_with(|| {

3481

		// Now send those tokens to ParaA

3482

1

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

3483

1

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

3484

1

			assets: Wild(All),

3485

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3486

1

		}]);

3487

1

		assert_ok!(

3488

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3489

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3490

1

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

3491

1

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

3492

1

				Box::new(TransferType::LocalReserve),

3493

1

				Box::new(fees_id),

3494

1

				Box::new(TransferType::LocalReserve),

3495

1

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

3496

1

				WeightLimit::Unlimited

3497

3498

);

3499

3500

		// 100 DOTs were deducted from Bob's account

3501

1

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

3502

1

});

3503

3504

1

	ParaA::execute_with(|| {

3505

		// Alice should have received 100 DOTs

3506

1

		assert_eq!(

3507

1

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

3508

1

			Ok(U256::from(200))

3509

);

3510

1

});

3511

1

3512

3513

#[test]

3514

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3515

1

	MockNet::reset();

3516

3517

	// Relay asset

3518

1

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

3519

1

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

3520

1

	let relay_location_v5 = Location::parent();

3521

1

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

3522

3523

1

	let relay_asset_metadata = parachain::AssetMetadata {

3524

1

		name: b"RelayToken".to_vec(),

3525

1

		symbol: b"Relay".to_vec(),

3526

1

		decimals: 12,

3527

1

};

3528

3529

1

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

3530

3531

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3532

1

		polkadot_parachain::primitives::Sibling,

3533

1

		statemint_like::AccountId,

3534

1

	>::convert_location(&dest_para)

3535

1

	.unwrap();

3536

3537

1

	ParaA::execute_with(|| {

3538

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3539

1

			source_relay_id,

3540

1

			relay_location_v5.clone(),

3541

1

			relay_asset_metadata.decimals,

3542

1

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

3543

1

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

3544

));

3545

1

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

3546

1

});

3547

3548

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3549

1

		network: None,

3550

1

		key: PARAALICE,

3551

1

3552

1

	.into();

3553

3554

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3555

1

		network: None,

3556

1

		id: RELAYALICE.into(),

3557

1

3558

1

	.into();

3559

3560

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

3561

1

	Relay::execute_with(|| {

3562

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3563

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3564

1

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

3565

1

			Box::new(

3566

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3567

1

					.clone()

3568

1

					.into()

3569

),

3570

1

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

3571

0,

3572

1

			WeightLimit::Unlimited

3573

));

3574

1

});

3575

3576

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3577

1

	Statemint::execute_with(|| {

3578

		// Check Alice received 200 tokens on AssetHub

3579

1

		assert_eq!(

3580

1

			StatemintBalances::free_balance(RELAYALICE),

3581

			INITIAL_BALANCE + 200

3582

);

3583

3584

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3585

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3586

1

			sov,

3587

			110000000000000

3588

));

3589

3590

		// Now send those tokens to ParaA

3591

1

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

3592

1

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

3593

1

			assets: Wild(All),

3594

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3595

1

		}]);

3596

1

		assert_ok!(

3597

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3598

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3599

1

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

3600

1

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

3601

1

				Box::new(TransferType::LocalReserve),

3602

1

				Box::new(fees_id),

3603

1

				Box::new(TransferType::LocalReserve),

3604

1

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

3605

1

				WeightLimit::Unlimited

3606

3607

);

3608

1

});

3609

3610

1

	ParaA::execute_with(|| {

3611

		// Alice should have received the DOTs

3612

1

		assert_eq!(

3613

1

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

3614

1

			Ok(U256::from(200))

3615

);

3616

1

});

3617

3618

1

	let dest = Location::new(

3619

1,

3620

1

3621

1

			Parachain(1000),

3622

1

			AccountId32 {

3623

1

				network: None,

3624

1

				id: RELAYBOB.into(),

3625

1

},

3626

1

],

3627

);

3628

1

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

3629

3630

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

3631

1

	ParaA::execute_with(|| {

3632

1

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

3633

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3634

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3635

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3636

1

			assets: Wild(All),

3637

1

			beneficiary: beneficiary.clone(),

3638

1

		}]);

3639

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3640

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3641

1

			Box::new(VersionedLocation::from(chain_part)),

3642

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

3643

1

			Box::new(TransferType::DestinationReserve),

3644

1

			Box::new(fees_id),

3645

1

			Box::new(TransferType::DestinationReserve),

3646

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3647

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3648

));

3649

3650

1

		assert_eq!(

3651

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3652

1

			Ok(U256::from(90))

3653

);

3654

1

});

3655

3656

1

	Statemint::execute_with(|| {

3657

		// Free execution: check that Bob received the tokens back in AssetHub

3658

1

		assert_eq!(

3659

1

			StatemintBalances::free_balance(RELAYBOB),

3660

			INITIAL_BALANCE + 110

3661

);

3662

1

});

3663

3664

	// Send back tokens from AH to ParaA from Bob's account

3665

1

	Statemint::execute_with(|| {

3666

		// Now send those tokens to ParaA

3667

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3668

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3669

1

			assets: Wild(All),

3670

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3671

1

		}]);

3672

1

		assert_ok!(

3673

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3674

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3675

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3676

1

				Box::new((Location::parent(), 100).into()),

3677

1

				Box::new(TransferType::LocalReserve),

3678

1

				Box::new(fees_id),

3679

1

				Box::new(TransferType::LocalReserve),

3680

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3681

1

				WeightLimit::Unlimited

3682

3683

);

3684

3685

		// 100 DOTs were deducted from Bob's account

3686

1

		assert_eq!(

3687

1

			StatemintBalances::free_balance(RELAYBOB),

3688

			INITIAL_BALANCE + 10

3689

);

3690

1

});

3691

3692

1

	ParaA::execute_with(|| {

3693

		// Alice should have received 100 DOTs

3694

1

		assert_eq!(

3695

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3696

1

			Ok(U256::from(190))

3697

);

3698

1

});

3699

1

3700

3701

#[test]

3702

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3703

1

	MockNet::reset();

3704

3705

	// Relay asset

3706

1

	let relay_location_v3 = xcm::v3::Location::parent();

3707

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3708

1

	let relay_location_v5 = Location::parent();

3709

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3710

3711

1

	let relay_asset_metadata = parachain::AssetMetadata {

3712

1

		name: b"RelayToken".to_vec(),

3713

1

		symbol: b"Relay".to_vec(),

3714

1

		decimals: 12,

3715

1

};

3716

3717

1

	let dest_para = Location::new(1, [Parachain(1)]);

3718

3719

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3720

1

		polkadot_parachain::primitives::Sibling,

3721

1

		statemint_like::AccountId,

3722

1

	>::convert_location(&dest_para)

3723

1

	.unwrap();

3724

3725

1

	ParaA::execute_with(|| {

3726

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3727

1

			source_relay_id,

3728

1

			relay_location_v5.clone(),

3729

1

			relay_asset_metadata.decimals,

3730

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3731

1

			relay_asset_metadata.name.try_into().expect("too long"),

3732

));

3733

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3734

1

});

3735

3736

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3737

1

		network: None,

3738

1

		key: PARAALICE,

3739

1

3740

1

	.into();

3741

3742

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3743

1

		network: None,

3744

1

		id: RELAYALICE.into(),

3745

1

3746

1

	.into();

3747

3748

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3749

1

	Relay::execute_with(|| {

3750

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3751

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3752

1

			Box::new(Parachain(1000).into()),

3753

1

			Box::new(

3754

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3755

1

					.clone()

3756

1

					.into()

3757

),

3758

1

			Box::new(([], 200).into()),

3759

0,

3760

1

			WeightLimit::Unlimited

3761

));

3762

1

});

3763

3764

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3765

1

	Statemint::execute_with(|| {

3766

		// Check Alice received 200 tokens on AssetHub

3767

1

		assert_eq!(

3768

1

			StatemintBalances::free_balance(RELAYALICE),

3769

			INITIAL_BALANCE + 200

3770

);

3771

3772

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3773

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3774

1

			sov,

3775

			110000000000000

3776

));

3777

3778

		// Now send those tokens to ParaA

3779

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3780

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3781

1

			assets: Wild(All),

3782

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3783

1

		}]);

3784

1

		assert_ok!(

3785

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3786

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3787

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3788

1

				Box::new((Location::parent(), 200).into()),

3789

1

				Box::new(TransferType::LocalReserve),

3790

1

				Box::new(fees_id),

3791

1

				Box::new(TransferType::LocalReserve),

3792

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3793

1

				WeightLimit::Unlimited

3794

3795

);

3796

1

});

3797

3798

1

	ParaA::execute_with(|| {

3799

		// Alice should have received the DOTs

3800

1

		assert_eq!(

3801

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3802

1

			Ok(U256::from(200))

3803

);

3804

1

});

3805

3806

1

	let dest = Location::new(

3807

1,

3808

1

3809

1

			Parachain(1000),

3810

1

			AccountId32 {

3811

1

				network: None,

3812

1

				id: RELAYBOB.into(),

3813

1

},

3814

1

],

3815

);

3816

3817

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3818

1

	let asset = Asset {

3819

1

		id: AssetId(Location::parent()),

3820

1

		fun: Fungibility::Fungible(100),

3821

1

};

3822

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3823

1

	ParaA::execute_with(|| {

3824

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3825

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3826

1

			assets: Wild(All),

3827

1

			beneficiary,

3828

1

		}]);

3829

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3830

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3831

1

			Box::new(VersionedLocation::from(chain_part)),

3832

1

			Box::new(VersionedAssets::from(asset)),

3833

1

			Box::new(TransferType::DestinationReserve),

3834

1

			Box::new(fees_id),

3835

1

			Box::new(TransferType::DestinationReserve),

3836

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3837

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3838

));

3839

3840

1

		assert_eq!(

3841

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3842

1

			Ok(U256::from(100))

3843

);

3844

1

});

3845

3846

1

	Statemint::execute_with(|| {

3847

		// Check that Bob received the tokens back in AssetHub

3848

1

		assert_eq!(

3849

1

			StatemintBalances::free_balance(RELAYBOB),

3850

			INITIAL_BALANCE + 100

3851

);

3852

1

});

3853

3854

	// Send back tokens from AH to ParaA from Bob's account

3855

1

	Statemint::execute_with(|| {

3856

		// Now send those tokens to ParaA

3857

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3858

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3859

1

			assets: Wild(All),

3860

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3861

1

		}]);

3862

1

		assert_ok!(

3863

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3864

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3865

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3866

1

				Box::new((Location::parent(), 100).into()),

3867

1

				Box::new(TransferType::LocalReserve),

3868

1

				Box::new(fees_id),

3869

1

				Box::new(TransferType::LocalReserve),

3870

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3871

1

				WeightLimit::Unlimited

3872

3873

);

3874

3875

		// 100 DOTs were deducted from Bob's account

3876

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3877

1

});

3878

3879

1

	ParaA::execute_with(|| {

3880

		// Alice should have received 100 DOTs

3881

1

		assert_eq!(

3882

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3883

1

			Ok(U256::from(200))

3884

);

3885

1

});

3886

1

3887

3888

#[test]

3889

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3890

1

	MockNet::reset();

3891

3892

	// Relay asset

3893

1

	let relay_location_v3 = xcm::v3::Location::parent();

3894

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3895

1

	let relay_location_v5 = Location::parent();

3896

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3897

3898

1

	let relay_asset_metadata = parachain::AssetMetadata {

3899

1

		name: b"RelayToken".to_vec(),

3900

1

		symbol: b"Relay".to_vec(),

3901

1

		decimals: 12,

3902

1

};

3903

3904

	// Statemint asset

3905

1

	let statemint_asset = Location::new(

3906

1,

3907

1

3908

1

			Parachain(1000u32),

3909

1

			PalletInstance(5u8),

3910

1

			GeneralIndex(10u128),

3911

1

],

3912

);

3913

1

	let statemint_location_asset: AssetType = statemint_asset

3914

1

		.clone()

3915

1

		.try_into()

3916

1

		.expect("Location convertion to AssetType should succeed");

3917

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3918

3919

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3920

1

		name: b"USDC".to_vec(),

3921

1

		symbol: b"USDC".to_vec(),

3922

1

		decimals: 12,

3923

1

};

3924

3925

1

	let dest_para = Location::new(1, [Parachain(1)]);

3926

3927

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3928

1

		polkadot_parachain::primitives::Sibling,

3929

1

		statemint_like::AccountId,

3930

1

	>::convert_location(&dest_para)

3931

1

	.unwrap();

3932

3933

1

	ParaA::execute_with(|| {

3934

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3935

1

			source_relay_id,

3936

1

			relay_location_v5.clone(),

3937

1

			relay_asset_metadata.decimals,

3938

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3939

1

			relay_asset_metadata.name.try_into().expect("too long"),

3940

));

3941

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3942

3943

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3944

1

			source_statemint_asset_id,

3945

1

			statemint_asset.clone(),

3946

1

			asset_metadata_statemint_asset.decimals,

3947

1

			asset_metadata_statemint_asset

3948

1

				.symbol

3949

1

				.try_into()

3950

1

				.expect("too long"),

3951

1

			asset_metadata_statemint_asset

3952

1

				.name

3953

1

				.try_into()

3954

1

				.expect("too long"),

3955

));

3956

1

		XcmWeightTrader::set_asset_price(statemint_asset, 0u128);

3957

1

});

3958

3959

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3960

1

		network: None,

3961

1

		key: PARAALICE,

3962

1

3963

1

	.into();

3964

3965

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3966

1

		network: None,

3967

1

		id: RELAYALICE.into(),

3968

1

3969

1

	.into();

3970

3971

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3972

1

	Relay::execute_with(|| {

3973

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3974

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3975

1

			Box::new(Parachain(1000).into()),

3976

1

			Box::new(

3977

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3978

1

					.clone()

3979

1

					.into()

3980

),

3981

1

			Box::new(([], 200).into()),

3982

0,

3983

1

			WeightLimit::Unlimited

3984

));

3985

1

});

3986

3987

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3988

1

	Statemint::execute_with(|| {

3989

		// Check Alice received 200 tokens on AssetHub

3990

1

		assert_eq!(

3991

1

			StatemintBalances::free_balance(RELAYALICE),

3992

			INITIAL_BALANCE + 200

3993

);

3994

3995

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3996

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3997

1

			sov,

3998

			110000000000000

3999

));

4000

4001

1

		statemint_like::PrefixChanger::set_prefix(

4002

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4003

);

4004

4005

1

		assert_ok!(StatemintAssets::create(

4006

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4007

10,

4008

			RELAYALICE,

4009

4010

));

4011

4012

1

		assert_ok!(StatemintAssets::mint(

4013

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4014

10,

4015

			RELAYALICE,

4016

			300000000000000

4017

));

4018

4019

		// Now send relay tokens to ParaA

4020

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4021

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4022

1

			assets: Wild(All),

4023

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4024

1

		}]);

4025

1

		assert_ok!(

4026

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4027

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4028

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4029

1

				Box::new((Location::parent(), 200).into()),

4030

1

				Box::new(TransferType::LocalReserve),

4031

1

				Box::new(fees_id),

4032

1

				Box::new(TransferType::LocalReserve),

4033

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4034

1

				WeightLimit::Unlimited

4035

4036

);

4037

4038

		// Send USDC

4039

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4040

1

0,

4041

1

4042

1

				xcm::latest::prelude::PalletInstance(

4043

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4044

1

),

4045

1

				GeneralIndex(10),

4046

1

],

4047

1

))

4048

1

		.into();

4049

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4050

1

			assets: Wild(All),

4051

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4052

1

		}]);

4053

1

		assert_ok!(

4054

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4055

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4056

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4057

1

				Box::new(

4058

1

4059

1

4060

1

							xcm::latest::prelude::PalletInstance(

4061

1

								<StatemintAssets as PalletInfoAccess>::index() as u8

4062

1

),

4063

1

							GeneralIndex(10),

4064

1

],

4065

1

4066

1

4067

1

						.into()

4068

),

4069

1

				Box::new(TransferType::LocalReserve),

4070

1

				Box::new(fees_id),

4071

1

				Box::new(TransferType::LocalReserve),

4072

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4073

1

				WeightLimit::Unlimited

4074

4075

);

4076

1

});

4077

4078

1

	ParaA::execute_with(|| {

4079

		// Alice should have received the DOTs

4080

1

		assert_eq!(

4081

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4082

1

			Ok(U256::from(200))

4083

);

4084

4085

		// Alice has received 125 USDC

4086

1

		assert_eq!(

4087

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4088

1

			Ok(U256::from(125))

4089

);

4090

1

});

4091

4092

1

	let dest = Location::new(

4093

1,

4094

1

4095

1

			Parachain(1000),

4096

1

			AccountId32 {

4097

1

				network: None,

4098

1

				id: RELAYBOB.into(),

4099

1

},

4100

1

],

4101

);

4102

4103

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4104

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4105

1

	ParaA::execute_with(|| {

4106

1

		let asset = currency_to_asset(

4107

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

4108

			100,

4109

);

4110

1

		let asset_fee =

4111

1

			currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

4112

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4113

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4114

1

			assets: Wild(All),

4115

1

			beneficiary: beneficiary.clone(),

4116

1

		}]);

4117

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4118

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4119

1

			Box::new(VersionedLocation::from(chain_part)),

4120

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

4121

1

			Box::new(TransferType::DestinationReserve),

4122

1

			Box::new(fees_id),

4123

1

			Box::new(TransferType::DestinationReserve),

4124

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4125

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4126

));

4127

4128

1

		assert_eq!(

4129

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4130

1

			Ok(U256::from(100))

4131

);

4132

1

});

4133

4134

1

	Statemint::execute_with(|| {

4135

		// Check that Bob received relay tokens back in AssetHub

4136

1

		assert_eq!(

4137

1

			StatemintBalances::free_balance(RELAYBOB),

4138

			INITIAL_BALANCE + 100

4139

);

4140

4141

		// Check that BOB received 100 USDC on AssetHub

4142

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4143

1

});

4144

4145

	// Send back tokens from AH to ParaA from Bob's account

4146

1

	Statemint::execute_with(|| {

4147

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4148

4149

		// Now send those tokens to ParaA

4150

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4151

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4152

1

			assets: Wild(All),

4153

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4154

1

		}]);

4155

1

		assert_ok!(

4156

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4157

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4158

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4159

1

				Box::new((Location::parent(), 100).into()),

4160

1

				Box::new(TransferType::LocalReserve),

4161

1

				Box::new(fees_id),

4162

1

				Box::new(TransferType::LocalReserve),

4163

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4164

1

				WeightLimit::Unlimited

4165

4166

);

4167

4168

		// 100 DOTs were deducted from Bob's account

4169

1

		assert_eq!(

4170

1

			StatemintBalances::free_balance(RELAYBOB),

4171

1

			bob_previous_balance - 100

4172

);

4173

1

});

4174

4175

1

	ParaA::execute_with(|| {

4176

		// Alice should have received 100 DOTs

4177

1

		assert_eq!(

4178

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4179

1

			Ok(U256::from(200))

4180

);

4181

1

});

4182

1

4183

4184

#[test]

4185

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

4186

1

	MockNet::reset();

4187

4188

	// Relay asset

4189

1

	let relay_location_v3 = xcm::v3::Location::parent();

4190

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

4191

1

	let relay_location_v5 = Location::parent();

4192

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

4193

4194

1

	let relay_asset_metadata = parachain::AssetMetadata {

4195

1

		name: b"RelayToken".to_vec(),

4196

1

		symbol: b"Relay".to_vec(),

4197

1

		decimals: 12,

4198

1

};

4199

4200

	// Statemint asset

4201

1

	let statemint_asset = Location::new(

4202

1,

4203

1

4204

1

			Parachain(1000u32),

4205

1

			PalletInstance(5u8),

4206

1

			GeneralIndex(10u128),

4207

1

],

4208

);

4209

1

	let statemint_location_asset: AssetType = statemint_asset

4210

1

		.clone()

4211

1

		.try_into()

4212

1

		.expect("Location convertion to AssetType should succeed");

4213

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

4214

4215

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

4216

1

		name: b"USDC".to_vec(),

4217

1

		symbol: b"USDC".to_vec(),

4218

1

		decimals: 12,

4219

1

};

4220

4221

1

	let dest_para = Location::new(1, [Parachain(1)]);

4222

4223

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

4224

1

		polkadot_parachain::primitives::Sibling,

4225

1

		statemint_like::AccountId,

4226

1

	>::convert_location(&dest_para)

4227

1

	.unwrap();

4228

4229

1

	ParaA::execute_with(|| {

4230

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4231

1

			source_relay_id,

4232

1

			relay_location_v5.clone(),

4233

1

			relay_asset_metadata.decimals,

4234

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

4235

1

			relay_asset_metadata.name.try_into().expect("too long"),

4236

));

4237

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4238

4239

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4240

1

			source_statemint_asset_id,

4241

1

			statemint_asset.clone(),

4242

1

			asset_metadata_statemint_asset.decimals,

4243

1

			asset_metadata_statemint_asset

4244

1

				.symbol

4245

1

				.try_into()

4246

1

				.expect("too long"),

4247

1

			asset_metadata_statemint_asset

4248

1

				.name

4249

1

				.try_into()

4250

1

				.expect("too long"),

4251

));

4252

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

4253

1

});

4254

4255

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4256

1

		network: None,

4257

1

		key: PARAALICE,

4258

1

4259

1

	.into();

4260

4261

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

4262

1

		network: None,

4263

1

		id: RELAYALICE.into(),

4264

1

4265

1

	.into();

4266

4267

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4268

1

	Relay::execute_with(|| {

4269

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4270

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4271

1

			Box::new(Parachain(1000).into()),

4272

1

			Box::new(

4273

1

				VersionedLocation::from(statemint_beneficiary_absolute)

4274

1

					.clone()

4275

1

					.into()

4276

),

4277

1

			Box::new(([], 200).into()),

4278

0,

4279

1

			WeightLimit::Unlimited

4280

));

4281

1

});

4282

4283

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4284

1

	Statemint::execute_with(|| {

4285

		// Check Alice received 200 tokens on AssetHub

4286

1

		assert_eq!(

4287

1

			StatemintBalances::free_balance(RELAYALICE),

4288

			INITIAL_BALANCE + 200

4289

);

4290

4291

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4292

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4293

1

			sov,

4294

			110000000000000

4295

));

4296

4297

1

		statemint_like::PrefixChanger::set_prefix(

4298

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4299

);

4300

4301

1

		assert_ok!(StatemintAssets::create(

4302

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4303

10,

4304

			RELAYALICE,

4305

4306

));

4307

4308

1

		assert_ok!(StatemintAssets::mint(

4309

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4310

10,

4311

			RELAYALICE,

4312

			300000000000000

4313

));

4314

4315

		// Now send relay tokens to ParaA

4316

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4317

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4318

1

			assets: Wild(All),

4319

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4320

1

		}]);

4321

1

		assert_ok!(

4322

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4323

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4324

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4325

1

				Box::new((Location::parent(), 200).into()),

4326

1

				Box::new(TransferType::LocalReserve),

4327

1

				Box::new(fees_id),

4328

1

				Box::new(TransferType::LocalReserve),

4329

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4330

1

				WeightLimit::Unlimited

4331

4332

);

4333

4334

		// Send USDC

4335

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4336

1

0,

4337

1

4338

1

				xcm::latest::prelude::PalletInstance(

4339

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4340

1

),

4341

1

				GeneralIndex(10),

4342

1

],

4343

1

))

4344

1

		.into();

4345

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4346

1

			assets: Wild(All),

4347

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4348

1

		}]);

4349

1

		assert_ok!(

4350

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4351

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4352

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4353

1

				Box::new(

4354

1

4355

1

4356

1

							xcm::latest::prelude::PalletInstance(

4357

1

								<StatemintAssets as PalletInfoAccess>::index() as u8

4358

1

),

4359

1

							GeneralIndex(10),

4360

1

],

4361

1

4362

1

4363

1

						.into()

4364

),

4365

1

				Box::new(TransferType::LocalReserve),

4366

1

				Box::new(fees_id),

4367

1

				Box::new(TransferType::LocalReserve),

4368

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4369

1

				WeightLimit::Unlimited

4370

4371

);

4372

1

});

4373

4374

1

	ParaA::execute_with(|| {

4375

		// Alice should have received the DOTs

4376

1

		assert_eq!(

4377

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4378

1

			Ok(U256::from(200))

4379

);

4380

4381

		// Alice has received 125 USDC

4382

1

		assert_eq!(

4383

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4384

1

			Ok(U256::from(125))

4385

);

4386

1

});

4387

4388

1

	let dest = Location::new(

4389

1,

4390

1

4391

1

			Parachain(1000),

4392

1

			AccountId32 {

4393

1

				network: None,

4394

1

				id: RELAYBOB.into(),

4395

1

},

4396

1

],

4397

);

4398

4399

1

	let statemint_asset_to_send = Asset {

4400

1

		id: AssetId(statemint_asset),

4401

1

		fun: Fungibility::Fungible(100),

4402

1

};

4403

4404

1

	let relay_asset_to_send = Asset {

4405

1

		id: AssetId(Location::parent()),

4406

1

		fun: Fungibility::Fungible(100),

4407

1

};

4408

4409

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4410

1

	let assets_to_send: XcmAssets =

4411

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

4412

4413

	// For some reason the order of the assets is inverted when creating the array above.

4414

	// We need to use relay asset for fees, so we pick index 0.

4415

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4416

4417

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4418

1

	ParaA::execute_with(|| {

4419

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4420

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4421

1

			assets: Wild(All),

4422

1

			beneficiary,

4423

1

		}]);

4424

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4425

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4426

1

			Box::new(VersionedLocation::from(chain_part)),

4427

1

			Box::new(VersionedAssets::from(assets_to_send)),

4428

1

			Box::new(TransferType::DestinationReserve),

4429

1

			Box::new(fees_id),

4430

1

			Box::new(TransferType::DestinationReserve),

4431

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4432

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4433

));

4434

4435

1

		assert_eq!(

4436

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4437

1

			Ok(U256::from(100))

4438

);

4439

1

});

4440

4441

1

	Statemint::execute_with(|| {

4442

		// Check that Bob received relay tokens back in AssetHub

4443

1

		assert_eq!(

4444

1

			StatemintBalances::free_balance(RELAYBOB),

4445

			INITIAL_BALANCE + 100

4446

);

4447

4448

		// Check that BOB received 100 USDC on AssetHub

4449

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4450

1

});

4451

4452

	// Send back tokens from AH to ParaA from Bob's account

4453

1

	Statemint::execute_with(|| {

4454

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4455

4456

		// Now send those tokens to ParaA

4457

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4458

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4459

1

			assets: Wild(All),

4460

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4461

1

		}]);

4462

1

		assert_ok!(

4463

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4464

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4465

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4466

1

				Box::new((Location::parent(), 100).into()),

4467

1

				Box::new(TransferType::LocalReserve),

4468

1

				Box::new(fees_id),

4469

1

				Box::new(TransferType::LocalReserve),

4470

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4471

1

				WeightLimit::Unlimited

4472

4473

);

4474

4475

		// 100 DOTs were deducted from Bob's account

4476

1

		assert_eq!(

4477

1

			StatemintBalances::free_balance(RELAYBOB),

4478

1

			bob_previous_balance - 100

4479

);

4480

1

});

4481

4482

1

	ParaA::execute_with(|| {

4483

		// Alice should have received 100 DOTs

4484

1

		assert_eq!(

4485

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4486

1

			Ok(U256::from(200))

4487

);

4488

1

});

4489

1

4490

4491

#[test]

4492

1

fn transact_through_signed_multilocation() {

4493

1

	MockNet::reset();

4494

1

	let mut ancestry = Location::parent();

4495

4496

1

	ParaA::execute_with(|| {

4497

		// Root can set transact info

4498

1

		assert_ok!(XcmTransactor::set_transact_info(

4499

1

			parachain::RuntimeOrigin::root(),

4500

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4501

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4502

1

			3000.into(),

4503

1

			20000000000.into(),

4504

			// 4 instructions in transact through signed

4505

1

			Some(4000.into())

4506

));

4507

		// Root can set transact info

4508

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4509

1

			parachain::RuntimeOrigin::root(),

4510

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4511

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

4512

));

4513

1

		ancestry = parachain::UniversalLocation::get().into();

4514

1

});

4515

4516

	// Let's construct the Junction that we will append with DescendOrigin

4517

1

	let signed_origin: Junctions = [AccountKey20 {

4518

1

		network: None,

4519

1

		key: PARAALICE,

4520

1

}]

4521

1

	.into();

4522

4523

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4524

1

	descend_origin_multilocation

4525

1

		.append_with(signed_origin)

4526

1

		.unwrap();

4527

4528

	// To convert it to what the relay will see instead of us

4529

1

	descend_origin_multilocation

4530

1

		.reanchor(&Location::parent(), &ancestry.interior)

4531

1

		.unwrap();

4532

4533

1

	let derived = xcm_builder::Account32Hash::<

4534

1

		relay_chain::KusamaNetwork,

4535

1

		relay_chain::AccountId,

4536

1

	>::convert_location(&descend_origin_multilocation)

4537

1

	.unwrap();

4538

4539

1

	Relay::execute_with(|| {

4540

		// free execution, full amount received

4541

1

		assert_ok!(RelayBalances::transfer_allow_death(

4542

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4543

1

			derived.clone(),

4544

			4000004100u128,

4545

));

4546

		// derived account has all funds

4547

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4548

		// sovereign account has 0 funds

4549

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4550

1

});

4551

4552

	// Encode the call. Balances transact to para_a_account

4553

	// First index

4554

1

	let mut encoded: Vec<u8> = Vec::new();

4555

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4556

1

		relay_chain::Balances,

4557

1

>()

4558

1

	.unwrap() as u8;

4559

4560

1

	encoded.push(index);

4561

4562

	// Then call bytes

4563

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4564

1

		// 100 to sovereign

4565

1

		dest: para_a_account(),

4566

1

		value: 100u32.into(),

4567

1

4568

1

	.encode();

4569

1

	encoded.append(&mut call_bytes);

4570

4571

1

	ParaA::execute_with(|| {

4572

1

		assert_ok!(XcmTransactor::transact_through_signed(

4573

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4574

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4575

1

			CurrencyPayment {

4576

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4577

1

					Location::parent()

4578

1

				))),

4579

1

				fee_amount: None

4580

1

},

4581

1

			encoded,

4582

			// 4000000000 for transfer + 4000 for XCM

4583

1

			TransactWeights {

4584

1

				transact_required_weight_at_most: 4000000000.into(),

4585

1

				overall_weight: None

4586

1

},

4587

			false

4588

));

4589

1

});

4590

4591

1

	Relay::execute_with(|| {

4592

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4593

4594

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4595

1

});

4596

1

4597

4598

#[test]

4599

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4600

1

	MockNet::reset();

4601

1

	let mut ancestry = Location::parent();

4602

4603

1

	ParaA::execute_with(|| {

4604

1

		ancestry = parachain::UniversalLocation::get().into();

4605

1

});

4606

4607

	// Let's construct the Junction that we will append with DescendOrigin

4608

1

	let signed_origin: Junctions = [AccountKey20 {

4609

1

		network: None,

4610

1

		key: PARAALICE,

4611

1

}]

4612

1

	.into();

4613

4614

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4615

1

	descend_origin_multilocation

4616

1

		.append_with(signed_origin)

4617

1

		.unwrap();

4618

4619

	// To convert it to what the relay will see instead of us

4620

1

	descend_origin_multilocation

4621

1

		.reanchor(&Location::parent(), &ancestry.interior)

4622

1

		.unwrap();

4623

4624

1

	let derived = xcm_builder::Account32Hash::<

4625

1

		relay_chain::KusamaNetwork,

4626

1

		relay_chain::AccountId,

4627

1

	>::convert_location(&descend_origin_multilocation)

4628

1

	.unwrap();

4629

4630

1

	Relay::execute_with(|| {

4631

		// free execution, full amount received

4632

1

		assert_ok!(RelayBalances::transfer_allow_death(

4633

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4634

1

			derived.clone(),

4635

			4000004100u128,

4636

));

4637

		// derived account has all funds

4638

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4639

		// sovereign account has 0 funds

4640

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4641

1

});

4642

4643

	// Encode the call. Balances transact to para_a_account

4644

	// First index

4645

1

	let mut encoded: Vec<u8> = Vec::new();

4646

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4647

1

		relay_chain::Balances,

4648

1

>()

4649

1

	.unwrap() as u8;

4650

4651

1

	encoded.push(index);

4652

4653

	// Then call bytes

4654

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4655

1

		// 100 to sovereign

4656

1

		dest: para_a_account(),

4657

1

		value: 100u32.into(),

4658

1

4659

1

	.encode();

4660

1

	encoded.append(&mut call_bytes);

4661

4662

1

	let total_weight = 4000004000u64;

4663

1

	ParaA::execute_with(|| {

4664

1

		assert_ok!(XcmTransactor::transact_through_signed(

4665

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4666

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4667

1

			CurrencyPayment {

4668

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4669

1

					Location::parent()

4670

1

				))),

4671

1

				fee_amount: Some(total_weight as u128)

4672

1

},

4673

1

			encoded,

4674

			// 4000000000 for transfer + 4000 for XCM

4675

1

			TransactWeights {

4676

1

				transact_required_weight_at_most: 4000000000.into(),

4677

1

				overall_weight: Some(Limited(total_weight.into()))

4678

1

},

4679

			false

4680

));

4681

1

});

4682

4683

1

	Relay::execute_with(|| {

4684

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4685

4686

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4687

1

});

4688

1

4689

4690

#[test]

4691

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4692

1

	MockNet::reset();

4693

1

	let mut ancestry = Location::parent();

4694

4695

1

	ParaA::execute_with(|| {

4696

1

		ancestry = parachain::UniversalLocation::get().into();

4697

1

});

4698

4699

	// Let's construct the Junction that we will append with DescendOrigin

4700

1

	let signed_origin: Junctions = [AccountKey20 {

4701

1

		network: None,

4702

1

		key: PARAALICE,

4703

1

}]

4704

1

	.into();

4705

4706

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4707

1

	descend_origin_multilocation

4708

1

		.append_with(signed_origin)

4709

1

		.unwrap();

4710

4711

	// To convert it to what the relay will see instead of us

4712

1

	descend_origin_multilocation

4713

1

		.reanchor(&Location::parent(), &ancestry.interior)

4714

1

		.unwrap();

4715

4716

1

	let derived = xcm_builder::Account32Hash::<

4717

1

		relay_chain::KusamaNetwork,

4718

1

		relay_chain::AccountId,

4719

1

	>::convert_location(&descend_origin_multilocation)

4720

1

	.unwrap();

4721

4722

1

	Relay::execute_with(|| {

4723

		// free execution, full amount received

4724

1

		assert_ok!(RelayBalances::transfer_allow_death(

4725

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4726

1

			derived.clone(),

4727

			4000009100u128,

4728

));

4729

		// derived account has all funds

4730

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4731

		// sovereign account has 0 funds

4732

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4733

1

});

4734

4735

	// Encode the call. Balances transact to para_a_account

4736

	// First index

4737

1

	let mut encoded: Vec<u8> = Vec::new();

4738

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4739

1

		relay_chain::Balances,

4740

1

>()

4741

1

	.unwrap() as u8;

4742

4743

1

	encoded.push(index);

4744

4745

	// Then call bytes

4746

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4747

1

		// 100 to sovereign

4748

1

		dest: para_a_account(),

4749

1

		value: 100u32.into(),

4750

1

4751

1

	.encode();

4752

1

	encoded.append(&mut call_bytes);

4753

4754

1

	let total_weight = 4000009000u64;

4755

1

	ParaA::execute_with(|| {

4756

1

		assert_ok!(XcmTransactor::transact_through_signed(

4757

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4758

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4759

1

			CurrencyPayment {

4760

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4761

1

					Location::parent()

4762

1

				))),

4763

1

				fee_amount: Some(total_weight as u128)

4764

1

},

4765

1

			encoded,

4766

			// 4000000000 for transfer + 9000 for XCM

4767

1

			TransactWeights {

4768

1

				transact_required_weight_at_most: 4000000000.into(),

4769

1

				overall_weight: Some(Limited(total_weight.into()))

4770

1

},

4771

			true

4772

));

4773

1

});

4774

4775

1

	Relay::execute_with(|| {

4776

		// 100 transferred

4777

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4778

4779

		// 4000009000 refunded

4780

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4781

1

});

4782

1

4783

4784

#[test]

4785

1

fn transact_through_signed_multilocation_para_to_para() {

4786

1

	frame_support::__private::sp_tracing::init_for_tests();

4787

1

	MockNet::reset();

4788

1

	let mut ancestry = Location::parent();

4789

4790

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4791

4792

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4793

4794

1

	ParaA::execute_with(|| {

4795

		// Root can set transact info

4796

1

		assert_ok!(XcmTransactor::set_transact_info(

4797

1

			parachain::RuntimeOrigin::root(),

4798

			// ParaB

4799

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4800

			// Para charges 1000 for every instruction, and we have 3, so 3

4801

1

			3.into(),

4802

1

			20000000000.into(),

4803

			// 4 instructions in transact through signed

4804

1

			Some(4.into())

4805

));

4806

		// Root can set transact info

4807

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4808

1

			parachain::RuntimeOrigin::root(),

4809

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4810

1

			parachain::ParaTokensPerSecond::get(),

4811

));

4812

1

		ancestry = parachain::UniversalLocation::get().into();

4813

1

});

4814

4815

	// Let's construct the Junction that we will append with DescendOrigin

4816

1

	let signed_origin: Junctions = [AccountKey20 {

4817

1

		network: None,

4818

1

		key: PARAALICE,

4819

1

}]

4820

1

	.into();

4821

4822

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4823

1

	descend_origin_multilocation

4824

1

		.append_with(signed_origin)

4825

1

		.unwrap();

4826

4827

	// To convert it to what the paraB will see instead of us

4828

1

	descend_origin_multilocation

4829

1

		.reanchor(&para_b_location, &ancestry.interior)

4830

1

		.unwrap();

4831

4832

1

	let derived = xcm_builder::HashedDescription::<

4833

1

		parachain::AccountId,

4834

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4835

1

	>::convert_location(&descend_origin_multilocation)

4836

1

	.unwrap();

4837

4838

1

	ParaB::execute_with(|| {

4839

		// free execution, full amount received

4840

1

		assert_ok!(ParaBalances::transfer_allow_death(

4841

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4842

1

			derived.clone(),

4843

			4000000104u128,

4844

));

4845

		// derived account has all funds

4846

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4847

		// sovereign account has 0 funds

4848

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4849

1

});

4850

4851

	// Encode the call. Balances transact to para_a_account

4852

	// First index

4853

1

	let mut encoded: Vec<u8> = Vec::new();

4854

1

	let index =

4855

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4856

1

			.unwrap() as u8;

4857

4858

1

	encoded.push(index);

4859

4860

	// Then call bytes

4861

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4862

1

		// 100 to sovereign

4863

1

		dest: para_a_account_20(),

4864

1

		value: 100u32.into(),

4865

1

4866

1

	.encode();

4867

1

	encoded.append(&mut call_bytes);

4868

4869

1

	ParaA::execute_with(|| {

4870

1

		assert_ok!(XcmTransactor::transact_through_signed(

4871

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4872

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4873

1

			CurrencyPayment {

4874

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4875

1

					para_b_balances

4876

1

				))),

4877

1

				fee_amount: None

4878

1

},

4879

1

			encoded,

4880

			// 4000000000 for transfer + 4000 for XCM

4881

			// 1-1 to fee

4882

1

			TransactWeights {

4883

1

				transact_required_weight_at_most: 4000000000.into(),

4884

1

				overall_weight: None

4885

1

},

4886

			false

4887

));

4888

1

});

4889

4890

1

	ParaB::execute_with(|| {

4891

1

		assert_eq!(ParaBalances::free_balance(&derived), 0);

4892

4893

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4894

1

});

4895

1

4896

4897

#[test]

4898

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4899

1

	MockNet::reset();

4900

1

	let mut ancestry = Location::parent();

4901

4902

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4903

4904

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4905

4906

1

	ParaA::execute_with(|| {

4907

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4908

1

			parachain::RuntimeOrigin::root(),

4909

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4910

1

			parachain::ParaTokensPerSecond::get(),

4911

));

4912

1

		ancestry = parachain::UniversalLocation::get().into();

4913

1

});

4914

4915

	// Let's construct the Junction that we will append with DescendOrigin

4916

1

	let signed_origin: Junctions = [AccountKey20 {

4917

1

		network: None,

4918

1

		key: PARAALICE,

4919

1

}]

4920

1

	.into();

4921

4922

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4923

1

	descend_origin_multilocation

4924

1

		.append_with(signed_origin)

4925

1

		.unwrap();

4926

4927

	// To convert it to what the paraB will see instead of us

4928

1

	descend_origin_multilocation

4929

1

		.reanchor(&para_b_location, &ancestry.interior)

4930

1

		.unwrap();

4931

4932

1

	let derived = xcm_builder::HashedDescription::<

4933

1

		parachain::AccountId,

4934

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4935

1

	>::convert_location(&descend_origin_multilocation)

4936

1

	.unwrap();

4937

4938

1

	ParaB::execute_with(|| {

4939

		// free execution, full amount received

4940

1

		assert_ok!(ParaBalances::transfer_allow_death(

4941

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4942

1

			derived.clone(),

4943

			4000009100u128,

4944

));

4945

		// derived account has all funds

4946

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4947

		// sovereign account has 0 funds

4948

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4949

1

});

4950

4951

	// Encode the call. Balances transact to para_a_account

4952

	// First index

4953

1

	let mut encoded: Vec<u8> = Vec::new();

4954

1

	let index =

4955

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4956

1

			.unwrap() as u8;

4957

4958

1

	encoded.push(index);

4959

4960

	// Then call bytes

4961

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4962

1

		// 100 to sovereign

4963

1

		dest: para_a_account_20(),

4964

1

		value: 100u32.into(),

4965

1

4966

1

	.encode();

4967

1

	encoded.append(&mut call_bytes);

4968

4969

1

	let overall_weight = 4000009000u64;

4970

1

	ParaA::execute_with(|| {

4971

1

		assert_ok!(XcmTransactor::transact_through_signed(

4972

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4973

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4974

1

			CurrencyPayment {

4975

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4976

1

					para_b_balances

4977

1

				))),

4978

1

				fee_amount: Some(overall_weight as u128)

4979

1

},

4980

1

			encoded,

4981

			// 4000000000 for transfer + 9000 for XCM

4982

1

			TransactWeights {

4983

1

				transact_required_weight_at_most: 4000000000.into(),

4984

1

				overall_weight: Some(Limited(overall_weight.into()))

4985

1

},

4986

			true

4987

));

4988

1

});

4989

4990

1

	ParaB::execute_with(|| {

4991

		// Check the derived account was refunded

4992

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4993

4994

		// Check the transfer was executed

4995

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4996

1

});

4997

1

4998

4999

#[test]

5000

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

5001

1

	MockNet::reset();

5002

1

	let mut ancestry = Location::parent();

5003

5004

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5005

5006

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5007

5008

1

	ParaA::execute_with(|| {

5009

		// Root can set transact info

5010

1

		assert_ok!(XcmTransactor::set_transact_info(

5011

1

			parachain::RuntimeOrigin::root(),

5012

			// ParaB

5013

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5014

			// Para charges 1000 for every instruction, and we have 3, so 3

5015

1

			3.into(),

5016

1

			20000000000.into(),

5017

			// 4 instructions in transact through signed

5018

1

			Some(4.into())

5019

));

5020

		// Root can set transact info

5021

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5022

1

			parachain::RuntimeOrigin::root(),

5023

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5024

1

			parachain::ParaTokensPerSecond::get(),

5025

));

5026

1

		ancestry = parachain::UniversalLocation::get().into();

5027

1

});

5028

5029

	// Let's construct the Junction that we will append with DescendOrigin

5030

1

	let signed_origin: Junctions = [AccountKey20 {

5031

1

		network: None,

5032

1

		key: PARAALICE,

5033

1

}]

5034

1

	.into();

5035

5036

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5037

1

	descend_origin_multilocation

5038

1

		.append_with(signed_origin)

5039

1

		.unwrap();

5040

5041

	// To convert it to what the paraB will see instead of us

5042

1

	descend_origin_multilocation

5043

1

		.reanchor(&para_b_location, &ancestry.interior)

5044

1

		.unwrap();

5045

5046

1

	let derived = xcm_builder::HashedDescription::<

5047

1

		parachain::AccountId,

5048

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5049

1

	>::convert_location(&descend_origin_multilocation)

5050

1

	.unwrap();

5051

5052

1

	let mut parachain_b_alice_balances_before = 0;

5053

1

	ParaB::execute_with(|| {

5054

1

		assert_ok!(ParaBalances::transfer_allow_death(

5055

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5056

1

			derived.clone(),

5057

			4000000104u128,

5058

));

5059

		// derived account has all funds

5060

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5061

		// sovereign account has 0 funds

5062

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5063

5064

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5065

1

});

5066

5067

	// Encode the call. Balances transact to para_a_account

5068

	// First index

5069

1

	let mut encoded: Vec<u8> = Vec::new();

5070

1

	let index =

5071

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5072

1

			.unwrap() as u8;

5073

5074

1

	encoded.push(index);

5075

5076

	use sp_core::U256;

5077

	// Let's do a EVM transfer

5078

1

	let eth_tx =

5079

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5080

1

			gas_limit: U256::from(21000),

5081

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5082

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5083

1

			value: U256::from(100),

5084

1

			input: BoundedVec::<

5085

1

u8,

5086

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5087

1

			>::try_from(vec![]).unwrap(),

5088

1

			access_list: None,

5089

1

});

5090

5091

	// Then call bytes

5092

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

5093

1

		xcm_transaction: eth_tx,

5094

1

5095

1

	.encode();

5096

1

	encoded.append(&mut call_bytes);

5097

5098

1

	ParaA::execute_with(|| {

5099

1

		assert_ok!(XcmTransactor::transact_through_signed(

5100

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5101

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5102

1

			CurrencyPayment {

5103

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5104

1

					para_b_balances

5105

1

				))),

5106

1

				fee_amount: None

5107

1

},

5108

1

			encoded,

5109

			// 4000000000 for transfer + 4000 for XCM

5110

			// 1-1 to fee

5111

1

			TransactWeights {

5112

1

				transact_required_weight_at_most: 4000000000.into(),

5113

1

				overall_weight: None

5114

1

},

5115

			false

5116

));

5117

1

});

5118

5119

1

	ParaB::execute_with(|| {

5120

		// Make sure the EVM transfer went through

5121

1

		assert!(

5122

1

			ParaBalances::free_balance(&PARAALICE.into())

5123

1

				== parachain_b_alice_balances_before + 100

5124

);

5125

1

});

5126

1

5127

5128

#[test]

5129

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

5130

1

	MockNet::reset();

5131

1

	let mut ancestry = Location::parent();

5132

5133

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5134

5135

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5136

5137

1

	ParaA::execute_with(|| {

5138

		// Root can set transact info

5139

1

		assert_ok!(XcmTransactor::set_transact_info(

5140

1

			parachain::RuntimeOrigin::root(),

5141

			// ParaB

5142

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5143

			// Para charges 1000 for every instruction, and we have 3, so 3

5144

1

			3.into(),

5145

1

			20000000000.into(),

5146

			// 4 instructions in transact through signed

5147

1

			Some(4.into())

5148

));

5149

		// Root can set transact info

5150

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5151

1

			parachain::RuntimeOrigin::root(),

5152

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5153

1

			parachain::ParaTokensPerSecond::get(),

5154

));

5155

1

		ancestry = parachain::UniversalLocation::get().into();

5156

1

});

5157

5158

	// Let's construct the Junction that we will append with DescendOrigin

5159

1

	let signed_origin: Junctions = [AccountKey20 {

5160

1

		network: None,

5161

1

		key: PARAALICE,

5162

1

}]

5163

1

	.into();

5164

5165

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5166

1

	descend_origin_multilocation

5167

1

		.append_with(signed_origin)

5168

1

		.unwrap();

5169

5170

	// To convert it to what the paraB will see instead of us

5171

1

	descend_origin_multilocation

5172

1

		.reanchor(&para_b_location, &ancestry.interior)

5173

1

		.unwrap();

5174

5175

1

	let derived = xcm_builder::HashedDescription::<

5176

1

		parachain::AccountId,

5177

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5178

1

	>::convert_location(&descend_origin_multilocation)

5179

1

	.unwrap();

5180

5181

1

	let mut parachain_b_alice_balances_before = 0;

5182

1

	ParaB::execute_with(|| {

5183

1

		assert_ok!(ParaBalances::transfer_allow_death(

5184

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5185

1

			derived.clone(),

5186

			4000000104u128,

5187

));

5188

		// derived account has all funds

5189

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5190

		// sovereign account has 0 funds

5191

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5192

5193

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5194

1

});

5195

5196

	// Encode the call. Balances transact to para_a_account

5197

	// First index

5198

1

	let mut encoded: Vec<u8> = Vec::new();

5199

1

	let index =

5200

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5201

1

			.unwrap() as u8;

5202

5203

1

	encoded.push(index);

5204

5205

	use sp_core::U256;

5206

	// Let's do a EVM transfer

5207

1

	let eth_tx =

5208

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5209

1

			gas_limit: U256::from(21000),

5210

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5211

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5212

1

			value: U256::from(100),

5213

1

			input: BoundedVec::<

5214

1

u8,

5215

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5216

1

			>::try_from(vec![]).unwrap(),

5217

1

			access_list: None,

5218

1

});

5219

5220

	// Then call bytes

5221

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5222

1

		transact_as: PARAALICE.into(),

5223

1

		xcm_transaction: eth_tx,

5224

1

5225

1

	.encode();

5226

1

	encoded.append(&mut call_bytes);

5227

5228

1

	ParaA::execute_with(|| {

5229

1

		assert_ok!(XcmTransactor::transact_through_signed(

5230

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5231

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5232

1

			CurrencyPayment {

5233

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5234

1

					para_b_balances

5235

1

				))),

5236

1

				fee_amount: None

5237

1

},

5238

1

			encoded,

5239

1

			TransactWeights {

5240

1

				transact_required_weight_at_most: 4000000000.into(),

5241

1

				overall_weight: None

5242

1

},

5243

			false

5244

));

5245

1

});

5246

5247

1

	ParaB::execute_with(|| {

5248

		// Make sure the EVM transfer wasn't executed

5249

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

5250

1

});

5251

1

5252

5253

#[test]

5254

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

5255

1

	MockNet::reset();

5256

1

	let mut ancestry = Location::parent();

5257

5258

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5259

5260

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5261

5262

1

	ParaA::execute_with(|| {

5263

		// Root can set transact info

5264

1

		assert_ok!(XcmTransactor::set_transact_info(

5265

1

			parachain::RuntimeOrigin::root(),

5266

			// ParaB

5267

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5268

			// Para charges 1000 for every instruction, and we have 3, so 3

5269

1

			3.into(),

5270

1

			20000000000.into(),

5271

			// 4 instructions in transact through signed

5272

1

			Some(4.into())

5273

));

5274

		// Root can set transact info

5275

1

		assert_ok!(XcmTransactor::set_fee_per_second(

5276

1

			parachain::RuntimeOrigin::root(),

5277

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

5278

1

			parachain::ParaTokensPerSecond::get(),

5279

));

5280

1

		ancestry = parachain::UniversalLocation::get().into();

5281

1

});

5282

5283

	// Let's construct the Junction that we will append with DescendOrigin

5284

1

	let signed_origin: Junctions = [AccountKey20 {

5285

1

		network: None,

5286

1

		key: PARAALICE,

5287

1

}]

5288

1

	.into();

5289

5290

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5291

1

	descend_origin_multilocation

5292

1

		.append_with(signed_origin)

5293

1

		.unwrap();

5294

5295

	// To convert it to what the paraB will see instead of us

5296

1

	descend_origin_multilocation

5297

1

		.reanchor(&para_b_location, &ancestry.interior)

5298

1

		.unwrap();

5299

5300

1

	let derived = xcm_builder::HashedDescription::<

5301

1

		parachain::AccountId,

5302

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5303

1

	>::convert_location(&descend_origin_multilocation)

5304

1

	.unwrap();

5305

5306

1

	let transfer_recipient = evm_account();

5307

1

	let mut transfer_recipient_balance_before = 0;

5308

1

	ParaB::execute_with(|| {

5309

1

		assert_ok!(ParaBalances::transfer_allow_death(

5310

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5311

1

			derived.clone(),

5312

			4000000104u128,

5313

));

5314

		// derived account has all funds

5315

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5316

		// sovereign account has 0 funds

5317

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5318

5319

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5320

5321

		// Add proxy ALICE  -> derived

5322

1

		let _ = parachain::Proxy::add_proxy_delegate(

5323

1

			&PARAALICE.into(),

5324

1

			derived,

5325

1

			parachain::ProxyType::Any,

5326

1

0,

5327

1

);

5328

1

});

5329

5330

	// Encode the call. Balances transact to para_a_account

5331

	// First index

5332

1

	let mut encoded: Vec<u8> = Vec::new();

5333

1

	let index =

5334

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5335

1

			.unwrap() as u8;

5336

5337

1

	encoded.push(index);

5338

5339

	use sp_core::U256;

5340

	// Let's do a EVM transfer

5341

1

	let eth_tx =

5342

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5343

1

			gas_limit: U256::from(21000),

5344

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5345

1

			value: U256::from(100),

5346

1

			input: BoundedVec::<

5347

1

u8,

5348

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5349

1

			>::try_from(vec![]).unwrap(),

5350

1

			access_list: None,

5351

1

});

5352

5353

	// Then call bytes

5354

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5355

1

		transact_as: PARAALICE.into(),

5356

1

		xcm_transaction: eth_tx,

5357

1

5358

1

	.encode();

5359

1

	encoded.append(&mut call_bytes);

5360

5361

1

	ParaA::execute_with(|| {

5362

1

		assert_ok!(XcmTransactor::transact_through_signed(

5363

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5364

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5365

1

			CurrencyPayment {

5366

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5367

1

					para_b_balances

5368

1

				))),

5369

1

				fee_amount: None

5370

1

},

5371

1

			encoded,

5372

1

			TransactWeights {

5373

1

				transact_required_weight_at_most: 4000000000.into(),

5374

1

				overall_weight: None

5375

1

},

5376

			false

5377

));

5378

1

});

5379

5380

1

	ParaB::execute_with(|| {

5381

		// Make sure the EVM transfer was executed

5382

1

		assert!(

5383

1

			ParaBalances::free_balance(&transfer_recipient.into())

5384

1

				== transfer_recipient_balance_before + 100

5385

);

5386

1

});

5387

1

5388

5389

#[test]

5390

1

fn hrmp_init_accept_through_root() {

5391

1

	MockNet::reset();

5392

5393

1

	Relay::execute_with(|| {

5394

1

		assert_ok!(RelayBalances::transfer_allow_death(

5395

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5396

1

			para_a_account(),

5397

			1000u128

5398

));

5399

1

		assert_ok!(RelayBalances::transfer_allow_death(

5400

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5401

1

			para_b_account(),

5402

			1000u128

5403

));

5404

1

});

5405

5406

1

	ParaA::execute_with(|| {

5407

1

		let total_fee = 1_000u128;

5408

1

		let total_weight: u64 = 1_000_000_000;

5409

1

		let tx_weight: u64 = 500_000_000;

5410

		// Root can send hrmp init channel

5411

1

		assert_ok!(XcmTransactor::hrmp_manage(

5412

1

			parachain::RuntimeOrigin::root(),

5413

1

			HrmpOperation::InitOpen(HrmpInitParams {

5414

1

				para_id: 2u32.into(),

5415

1

				proposed_max_capacity: 1,

5416

1

				proposed_max_message_size: 1

5417

1

}),

5418

1

			CurrencyPayment {

5419

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5420

1

					Location::parent()

5421

1

				))),

5422

1

				fee_amount: Some(total_fee)

5423

1

},

5424

1

			TransactWeights {

5425

1

				transact_required_weight_at_most: tx_weight.into(),

5426

1

				overall_weight: Some(Limited(total_weight.into()))

5427

1

5428

));

5429

1

});

5430

1

	Relay::execute_with(|| {

5431

1

		let expected_event: relay_chain::RuntimeEvent =

5432

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5433

1

				sender: 1u32.into(),

5434

1

				recipient: 2u32.into(),

5435

1

				proposed_max_capacity: 1u32,

5436

1

				proposed_max_message_size: 1u32,

5437

1

5438

1

			.into();

5439

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5440

1

});

5441

1

	ParaB::execute_with(|| {

5442

1

		let total_fee = 1_000u128;

5443

1

		let total_weight: u64 = 1_000_000_000;

5444

1

		let tx_weight: u64 = 500_000_000;

5445

		// Root can send hrmp accept channel

5446

1

		assert_ok!(XcmTransactor::hrmp_manage(

5447

1

			parachain::RuntimeOrigin::root(),

5448

1

			HrmpOperation::Accept {

5449

1

				para_id: 1u32.into()

5450

1

},

5451

1

			CurrencyPayment {

5452

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5453

1

					Location::parent()

5454

1

				))),

5455

1

				fee_amount: Some(total_fee)

5456

1

},

5457

1

			TransactWeights {

5458

1

				transact_required_weight_at_most: tx_weight.into(),

5459

1

				overall_weight: Some(Limited(total_weight.into()))

5460

1

5461

));

5462

1

});

5463

5464

1

	Relay::execute_with(|| {

5465

1

		let expected_event: relay_chain::RuntimeEvent =

5466

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5467

1

				sender: 1u32.into(),

5468

1

				recipient: 2u32.into(),

5469

1

5470

1

			.into();

5471

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5472

1

});

5473

1

5474

5475

#[test]

5476

1

fn hrmp_close_works() {

5477

1

	MockNet::reset();

5478

5479

1

	Relay::execute_with(|| {

5480

1

		assert_ok!(RelayBalances::transfer_allow_death(

5481

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5482

1

			para_a_account(),

5483

			1000u128

5484

));

5485

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5486

1

			relay_chain::RuntimeOrigin::root(),

5487

1

			1u32.into(),

5488

1

			2u32.into(),

5489

			1u32,

5490

			1u32

5491

));

5492

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5493

1

			relay_chain::RuntimeOrigin::root(),

5494

			1u32

5495

));

5496

1

});

5497

5498

1

	ParaA::execute_with(|| {

5499

1

		let total_fee = 1_000u128;

5500

1

		let total_weight: u64 = 1_000_000_000;

5501

1

		let tx_weight: u64 = 500_000_000;

5502

1

		assert_ok!(XcmTransactor::hrmp_manage(

5503

1

			parachain::RuntimeOrigin::root(),

5504

1

			HrmpOperation::Close(HrmpChannelId {

5505

1

				sender: 1u32.into(),

5506

1

				recipient: 2u32.into()

5507

1

}),

5508

1

			CurrencyPayment {

5509

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5510

1

					Location::parent()

5511

1

				))),

5512

1

				fee_amount: Some(total_fee)

5513

1

},

5514

1

			TransactWeights {

5515

1

				transact_required_weight_at_most: tx_weight.into(),

5516

1

				overall_weight: Some(Limited(total_weight.into()))

5517

1

5518

));

5519

1

});

5520

1

	Relay::execute_with(|| {

5521

1

		let expected_event: relay_chain::RuntimeEvent =

5522

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5523

1

				by_parachain: 1u32.into(),

5524

1

				channel_id: HrmpChannelId {

5525

1

					sender: 1u32.into(),

5526

1

					recipient: 2u32.into(),

5527

1

},

5528

1

5529

1

			.into();

5530

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5531

1

});

5532

1

5533

5534

use crate::xcm_mock::parachain::{EvmForeignAssets, MockTransactors, Treasury, XcmWeightTrader};

5535

use parity_scale_codec::{Decode, Encode};

5536

use sp_core::U256;

5537

use sp_io::hashing::blake2_256;

5538

5539

// Helper to derive accountIds

5540

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5541

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5542

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5543

7