Grcov report - xcm

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

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

5

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

6

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

7

// (at your option) any later version.

8

9

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

10

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

11

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

12

// GNU General Public License for more details.

13

14

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

15

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

16

17

//! Moonbase Runtime Xcm Tests

18

19

mod xcm_mock;

20

use frame_support::{

21

	assert_ok,

22

	traits::{ConstU32, PalletInfo, PalletInfoAccess},

23

	weights::constants::WEIGHT_REF_TIME_PER_SECOND,

24

	weights::Weight,

25

	BoundedVec,

26

};

27

use moonbase_runtime::xcm_config::AssetType;

28

use pallet_xcm_transactor::{

29

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

30

};

31

use sp_runtime::traits::Convert;

32

use sp_std::boxed::Box;

33

use xcm::{

34

	latest::prelude::{

35

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

36

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

37

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

38

		WeightLimit, Wild, WithdrawAsset, Xcm,

39

},

40

	VersionedAssetId, VersionedAssets, VersionedXcm,

41

};

42

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

43

use xcm_executor::traits::ConvertLocation;

44

use xcm_executor::traits::TransferType;

45

use xcm_mock::*;

46

use xcm_primitives::{

47

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

48

};

49

use xcm_simulator::TestExt;

50

mod common;

51

use cumulus_primitives_core::relay_chain::HrmpChannelId;

52

use parachain::PolkadotXcm;

53

54

28

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

55

28

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

56

28

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

57

28

		.into_version(xcm::latest::VERSION)

58

28

		.map_err(|_| ())?

59

	else {

60

		return Err(());

61

};

62

	use frame_support::weights::WeightToFee as _;

63

28

	let native_amount_per_second: u128 =

64

28

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

65

28

			&Weight::from_parts(

66

28

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

67

28

0,

68

28

),

69

70

28

		.try_into()

71

28

		.map_err(|_| ())?;

72

28

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

73

28

	let relative_price: u128 = if units_per_second > 0u128 {

74

10

		native_amount_per_second

75

10

			.saturating_mul(precision_factor)

76

10

			.saturating_div(units_per_second)

77

	} else {

78

18

		0u128

79

};

80

28

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

81

28

		location_v5,

82

28

		(true, relative_price),

83

);

84

28

	Ok(())

85

28

86

87

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

88

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

89

9

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

90

	use moonbeam_tests_primitives::MemoryFeeTrader;

91

	use xcm_primitives::XcmFeeTrader;

92

93

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

94

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

95

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

96

9

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

97

9

	let native_amount_per_second =

98

9

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

99

9

	let relative_price = native_amount_per_second

100

9

		.saturating_mul(precision_factor)

101

9

		.checked_div(fee_per_second)

102

9

		.ok_or(())?;

103

104

9

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

105

9

106

107

25

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

108

25

	Asset {

109

25

		id: AssetId(

110

25

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

111

25

				currency_id,

112

25

113

25

			.unwrap(),

114

25

),

115

25

		fun: Fungibility::Fungible(amount),

116

25

117

25

118

119

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

120

#[test]

121

1

fn receive_relay_asset_from_relay() {

122

1

	MockNet::reset();

123

124

1

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

125

1

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

126

1

	let asset_metadata = parachain::AssetMetadata {

127

1

		name: b"RelayToken".to_vec(),

128

1

		symbol: b"Relay".to_vec(),

129

1

		decimals: 12,

130

1

};

131

	// register relay asset in parachain A

132

1

	ParaA::execute_with(|| {

133

1

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

134

1

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

135

1

			.try_into()

136

1

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

137

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

138

1

			source_id,

139

1

			source_location_latest,

140

1

			asset_metadata.decimals,

141

1

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

142

1

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

143

));

144

1

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

145

1

});

146

147

	// Actually send relay asset to parachain

148

1

	let dest: Location = AccountKey20 {

149

1

		network: None,

150

1

		key: PARAALICE,

151

1

152

1

	.into();

153

1

	Relay::execute_with(|| {

154

1

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

155

1

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

156

1

			assets: Wild(All),

157

1

			beneficiary: dest.clone(),

158

1

		}]);

159

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

160

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

161

1

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

162

1

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

163

1

			Box::new(TransferType::LocalReserve),

164

1

			Box::new(fees_id),

165

1

			Box::new(TransferType::LocalReserve),

166

1

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

167

1

			WeightLimit::Unlimited

168

));

169

1

});

170

171

	// Verify that parachain received the asset

172

1

	ParaA::execute_with(|| {

173

		// free execution, full amount received

174

1

		assert_eq!(

175

1

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

176

1

			Ok(U256::from(123))

177

);

178

1

});

179

1

180

181

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

182

#[test]

183

1

fn send_relay_asset_to_relay() {

184

1

	MockNet::reset();

185

186

1

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

187

1

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

188

189

1

	let asset_metadata = parachain::AssetMetadata {

190

1

		name: b"RelayToken".to_vec(),

191

1

		symbol: b"Relay".to_vec(),

192

1

		decimals: 12,

193

1

};

194

195

	// Register relay asset in paraA

196

1

	ParaA::execute_with(|| {

197

1

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

198

1

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

199

1

			.try_into()

200

1

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

201

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

202

1

			source_id,

203

1

			source_location_latest,

204

1

			asset_metadata.decimals,

205

1

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

206

1

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

207

));

208

		// Free execution

209

1

		assert_ok!(add_supported_asset(source_location, 0));

210

1

});

211

212

1

	let dest: Location = Junction::AccountKey20 {

213

1

		network: None,

214

1

		key: PARAALICE,

215

1

216

1

	.into();

217

218

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

219

1

	Relay::execute_with(|| {

220

1

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

221

1

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

222

1

			assets: Wild(All),

223

1

			beneficiary: dest.clone(),

224

1

		}]);

225

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

226

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

227

1

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

228

1

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

229

1

			Box::new(TransferType::LocalReserve),

230

1

			Box::new(fees_id),

231

1

			Box::new(TransferType::LocalReserve),

232

1

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

233

1

			WeightLimit::Unlimited

234

));

235

1

});

236

237

1

	ParaA::execute_with(|| {

238

		// Free execution, full amount received

239

1

		assert_eq!(

240

1

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

241

1

			Ok(U256::from(123))

242

);

243

1

});

244

245

	// Lets gather the balance before sending back money

246

1

	let mut balance_before_sending = 0;

247

1

	Relay::execute_with(|| {

248

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

249

1

});

250

251

	// We now send back some money to the relay

252

1

	let dest = Location {

253

1

		parents: 1,

254

1

		interior: [AccountId32 {

255

1

			network: None,

256

1

			id: RELAYALICE.into(),

257

1

}]

258

1

		.into(),

259

1

};

260

1

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

261

262

1

	ParaA::execute_with(|| {

263

1

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

264

		// free execution, full amount received

265

1

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

266

1

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

267

1

			assets: Wild(All),

268

1

			beneficiary,

269

1

		}]);

270

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

271

1

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

272

1

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

273

1

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

274

1

			Box::new(TransferType::DestinationReserve),

275

1

			Box::new(fees_id),

276

1

			Box::new(TransferType::DestinationReserve),

277

1

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

278

1

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

279

));

280

1

});

281

282

	// The balances in paraAlice should have been substracted

283

1

	ParaA::execute_with(|| {

284

1

		assert_eq!(

285

1

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

286

1

			Ok(U256::from(0))

287

);

288

1

});

289

290

	// Balances in the relay should have been received

291

1

	Relay::execute_with(|| {

292

		// Free execution,x	 full amount received

293

1

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

294

1

});

295

1

296

297

#[test]

298

1

fn send_relay_asset_to_para_b() {

299

1

	MockNet::reset();

300

301

1

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

302

1

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

303

304

1

	let asset_metadata = parachain::AssetMetadata {

305

1

		name: b"RelayToken".to_vec(),

306

1

		symbol: b"Relay".to_vec(),

307

1

		decimals: 12,

308

1

};

309

310

	// Register asset in paraA. Free execution

311

1

	ParaA::execute_with(|| {

312

1

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

313

1

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

314

1

			.try_into()

315

1

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

316

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

317

1

			source_id,

318

1

			source_location_latest,

319

1

			asset_metadata.decimals,

320

1

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

321

1

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

322

));

323

1

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

324

1

});

325

326

	// Register asset in paraB. Free execution

327

1

	ParaB::execute_with(|| {

328

1

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

329

1

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

330

1

			.try_into()

331

1

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

332

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

333

1

			source_id,

334

1

			source_location_latest,

335

1

			asset_metadata.decimals,

336

1

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

337

1

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

338

));

339

1

		assert_ok!(add_supported_asset(source_location, 0));

340

1

});

341

342

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

343

1

	let dest: Location = Junction::AccountKey20 {

344

1

		network: None,

345

1

		key: PARAALICE,

346

1

347

1

	.into();

348

1

	Relay::execute_with(|| {

349

1

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

350

1

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

351

1

			assets: Wild(All),

352

1

			beneficiary: dest.clone(),

353

1

		}]);

354

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

355

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

356

1

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

357

1

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

358

1

			Box::new(TransferType::LocalReserve),

359

1

			Box::new(fees_id),

360

1

			Box::new(TransferType::LocalReserve),

361

1

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

362

1

			WeightLimit::Unlimited

363

));

364

1

});

365

366

1

	ParaA::execute_with(|| {

367

		// Free execution, full amount received

368

1

		assert_eq!(

369

1

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

370

1

			Ok(U256::from(123))

371

);

372

1

});

373

374

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

375

1

	let dest = Location {

376

1

		parents: 1,

377

1

		interior: [

378

1

			Parachain(2),

379

1

			AccountKey20 {

380

1

				network: None,

381

1

				key: PARAALICE.into(),

382

1

},

383

1

384

1

		.into(),

385

1

};

386

1

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

387

388

1

	ParaA::execute_with(|| {

389

1

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

390

1

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

391

1

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

392

1

			assets: Wild(All),

393

1

			beneficiary,

394

1

		}]);

395

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

396

1

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

397

1

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

398

1

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

399

1

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

400

1

			Box::new(fees_id),

401

1

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

402

1

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

403

1

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

404

));

405

1

});

406

407

	// Para A balances should have been subtracted

408

1

	ParaA::execute_with(|| {

409

1

		assert_eq!(

410

1

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

411

1

			Ok(U256::from(23))

412

);

413

1

});

414

415

	// Para B balances should have been credited

416

1

	ParaB::execute_with(|| {

417

1

		assert_eq!(

418

1

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

419

1

			Ok(U256::from(100))

420

);

421

1

});

422

1

423

424

#[test]

425

1

fn send_para_a_asset_to_para_b() {

426

1

	MockNet::reset();

427

428

	// this represents the asset in paraA

429

1

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

430

1

	let source_location: AssetType = para_a_balances

431

1

		.try_into()

432

1

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

433

1

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

434

435

1

	let asset_metadata = parachain::AssetMetadata {

436

1

		name: b"ParaAToken".to_vec(),

437

1

		symbol: b"ParaA".to_vec(),

438

1

		decimals: 18,

439

1

};

440

441

	// Register asset in paraB. Free execution

442

1

	ParaB::execute_with(|| {

443

1

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

444

1

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

445

1

			.try_into()

446

1

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

447

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

448

1

			source_id,

449

1

			source_location_latest,

450

1

			asset_metadata.decimals,

451

1

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

452

1

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

453

));

454

1

		assert_ok!(add_supported_asset(source_location, 0));

455

1

});

456

457

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

458

1

	let dest = Location {

459

1

		parents: 1,

460

1

		interior: [

461

1

			Parachain(2),

462

1

			AccountKey20 {

463

1

				network: None,

464

1

				key: PARAALICE.into(),

465

1

},

466

1

467

1

		.into(),

468

1

};

469

470

1

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

471

472

1

	ParaA::execute_with(|| {

473

1

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

474

		// Free execution, full amount received

475

1

		assert_ok!(PolkadotXcm::transfer_assets(

476

1

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

477

1

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

478

1

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

479

1

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

480

0,

481

1

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

482

));

483

1

});

484

485

	// Native token is substracted in paraA

486

1

	ParaA::execute_with(|| {

487

1

		assert_eq!(

488

1

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

489

			INITIAL_BALANCE - 100

490

);

491

1

});

492

493

	// Asset is minted in paraB

494

1

	ParaB::execute_with(|| {

495

1

		assert_eq!(

496

1

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

497

1

			Ok(U256::from(100))

498

);

499

1

});

500

1

501

502

#[test]

503

1

fn send_para_a_asset_from_para_b_to_para_c() {

504

1

	MockNet::reset();

505

506

	// Represents para A asset

507

1

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

508

1

	let source_location: AssetType = para_a_balances

509

1

		.try_into()

510

1

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

511

1

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

512

513

1

	let asset_metadata = parachain::AssetMetadata {

514

1

		name: b"ParaAToken".to_vec(),

515

1

		symbol: b"ParaA".to_vec(),

516

1

		decimals: 18,

517

1

};

518

519

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

520

1

	ParaB::execute_with(|| {

521

1

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

522

1

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

523

1

			.try_into()

524

1

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

525

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

526

1

			source_id,

527

1

			source_location_latest,

528

1

			asset_metadata.decimals,

529

1

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

530

1

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

531

));

532

1

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

533

1

});

534

535

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

536

1

	ParaC::execute_with(|| {

537

1

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

538

1

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

539

1

			.try_into()

540

1

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

541

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

542

1

			source_id,

543

1

			source_location_latest,

544

1

			asset_metadata.decimals,

545

1

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

546

1

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

547

));

548

1

		assert_ok!(add_supported_asset(source_location, 0));

549

1

});

550

551

	// Send para A asset to para B

552

1

	let dest = Location {

553

1

		parents: 1,

554

1

		interior: [

555

1

			Parachain(2),

556

1

			AccountKey20 {

557

1

				network: None,

558

1

				key: PARAALICE.into(),

559

1

},

560

1

561

1

		.into(),

562

1

};

563

1

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

564

565

1

	ParaA::execute_with(|| {

566

1

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

567

		// free execution, full amount received

568

1

		assert_ok!(PolkadotXcm::transfer_assets(

569

1

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

570

1

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

571

1

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

572

1

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

573

0,

574

1

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

575

));

576

1

});

577

578

	// Para A balances have been substracted

579

1

	ParaA::execute_with(|| {

580

1

		assert_eq!(

581

1

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

582

			INITIAL_BALANCE - 100

583

);

584

1

});

585

586

	// Para B balances have been credited

587

1

	ParaB::execute_with(|| {

588

1

		assert_eq!(

589

1

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

590

1

			Ok(U256::from(100))

591

);

592

1

});

593

594

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

595

1

	let dest = Location {

596

1

		parents: 1,

597

1

		interior: [

598

1

			Parachain(3),

599

1

			AccountKey20 {

600

1

				network: None,

601

1

				key: PARAALICE.into(),

602

1

},

603

1

604

1

		.into(),

605

1

};

606

1

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

607

608

1

	ParaB::execute_with(|| {

609

1

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

610

1

		assert_ok!(PolkadotXcm::transfer_assets(

611

1

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

612

1

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

613

1

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

614

1

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

615

0,

616

1

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

617

));

618

1

});

619

620

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

621

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

622

1

	ParaC::execute_with(|| {

623

1

		assert_eq!(

624

1

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

625

1

			Ok(U256::from(95))

626

);

627

1

});

628

1

629

630

#[test]

631

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

632

1

	MockNet::reset();

633

634

	// Para A asset

635

1

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

636

1

	let source_location: AssetType = para_a_balances

637

1

		.try_into()

638

1

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

639

1

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

640

641

1

	let asset_metadata = parachain::AssetMetadata {

642

1

		name: b"ParaAToken".to_vec(),

643

1

		symbol: b"ParaA".to_vec(),

644

1

		decimals: 18,

645

1

};

646

647

	// Register para A asset in para B

648

1

	ParaB::execute_with(|| {

649

1

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

650

1

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

651

1

			.try_into()

652

1

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

653

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

654

1

			source_id,

655

1

			source_location_latest,

656

1

			asset_metadata.decimals,

657

1

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

658

1

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

659

));

660

1

		assert_ok!(add_supported_asset(source_location, 0));

661

1

});

662

663

	// Send para A asset to para B

664

1

	let dest = Location {

665

1

		parents: 1,

666

1

		interior: [

667

1

			Parachain(2),

668

1

			AccountKey20 {

669

1

				network: None,

670

1

				key: PARAALICE.into(),

671

1

},

672

1

673

1

		.into(),

674

1

};

675

1

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

676

677

1

	ParaA::execute_with(|| {

678

1

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

679

1

		assert_ok!(PolkadotXcm::transfer_assets(

680

1

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

681

1

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

682

1

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

683

1

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

684

0,

685

1

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

686

));

687

1

});

688

689

	// Balances have been subtracted

690

1

	ParaA::execute_with(|| {

691

1

		assert_eq!(

692

1

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

693

			INITIAL_BALANCE - 100

694

);

695

1

});

696

697

	// Para B balances have been credited

698

1

	ParaB::execute_with(|| {

699

1

		assert_eq!(

700

1

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

701

1

			Ok(U256::from(100))

702

);

703

1

});

704

705

	// Send back para A asset to para A

706

1

	let dest = Location {

707

1

		parents: 1,

708

1

		interior: [

709

1

			Parachain(1),

710

1

			AccountKey20 {

711

1

				network: None,

712

1

				key: PARAALICE.into(),

713

1

},

714

1

715

1

		.into(),

716

1

};

717

1

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

718

719

1

	ParaB::execute_with(|| {

720

1

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

721

1

		assert_ok!(PolkadotXcm::transfer_assets(

722

1

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

723

1

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

724

1

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

725

1

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

726

0,

727

1

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

728

));

729

1

});

730

731

1

	ParaA::execute_with(|| {

732

		// Weight used is 4

733

1

		assert_eq!(

734

1

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

735

			INITIAL_BALANCE - 4

736

);

737

1

});

738

1

739

740

#[test]

741

1

fn send_para_a_asset_to_para_b_and_back_to_para_a_with_new_reanchoring() {

742

1

	MockNet::reset();

743

744

1

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

745

1

	let source_location: AssetType = para_a_balances

746

1

		.try_into()

747

1

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

748

1

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

749

750

1

	let asset_metadata = parachain::AssetMetadata {

751

1

		name: b"ParaAToken".to_vec(),

752

1

		symbol: b"ParaA".to_vec(),

753

1

		decimals: 18,

754

1

};

755

756

1

	ParaB::execute_with(|| {

757

1

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

758

1

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

759

1

			.try_into()

760

1

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

761

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

762

1

			source_id,

763

1

			source_location_latest,

764

1

			asset_metadata.decimals,

765

1

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

766

1

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

767

));

768

1

		assert_ok!(add_supported_asset(source_location, 0));

769

1

});

770

771

1

	let dest = Location {

772

1

		parents: 1,

773

1

		interior: [

774

1

			Parachain(2),

775

1

			AccountKey20 {

776

1

				network: None,

777

1

				key: PARAALICE.into(),

778

1

},

779

1

780

1

		.into(),

781

1

};

782

1

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

783

784

1

	ParaA::execute_with(|| {

785

1

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

786

1

		assert_ok!(PolkadotXcm::transfer_assets(

787

1

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

788

1

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

789

1

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

790

1

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

791

0,

792

1

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

793

));

794

1

});

795

796

	// Para A asset has been credited

797

1

	ParaA::execute_with(|| {

798

1

		assert_eq!(

799

1

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

800

			INITIAL_BALANCE - 100

801

);

802

1

});

803

804

1

	ParaB::execute_with(|| {

805

		// free execution, full amount received

806

1

		assert_eq!(

807

1

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

808

1

			Ok(U256::from(100))

809

);

810

1

});

811

812

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

813

	// Message through polkadotXCM pallet

814

815

1

	let dest = Location {

816

1

		parents: 1,

817

1

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

818

1

};

819

820

1

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

821

822

1

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

823

1

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

824

1

		ClearOrigin,

825

1

		BuyExecution {

826

1

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

827

1

			weight_limit: Limited(80.into()),

828

1

},

829

1

		DepositAsset {

830

1

			assets: All.into(),

831

1

			beneficiary: Location::new(

832

1

0,

833

1

				[AccountKey20 {

834

1

					network: None,

835

1

					key: PARAALICE,

836

1

}],

837

1

),

838

1

},

839

1

	]));

840

1

	ParaB::execute_with(|| {

841

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

842

		// and deposit asset

843

1

		assert_ok!(ParachainPalletXcm::send(

844

1

			parachain::RuntimeOrigin::root(),

845

1

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

846

1

			Box::new(message),

847

));

848

1

});

849

850

1

	ParaA::execute_with(|| {

851

		// Weight used is 4

852

1

		assert_eq!(

853

1

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

854

			INITIAL_BALANCE - 4

855

);

856

1

});

857

1

858

859

#[test]

860

1

fn receive_relay_asset_with_trader() {

861

1

	MockNet::reset();

862

863

1

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

864

1

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

865

866

1

	let asset_metadata = parachain::AssetMetadata {

867

1

		name: b"RelayToken".to_vec(),

868

1

		symbol: b"Relay".to_vec(),

869

1

		decimals: 12,

870

1

};

871

872

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

873

	// we know later we will divide by 1e12

874

	// Lets put 1e6 as units per second

875

1

	ParaA::execute_with(|| {

876

1

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

877

1

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

878

1

			.try_into()

879

1

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

880

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

881

1

			source_id,

882

1

			source_location_latest,

883

1

			asset_metadata.decimals,

884

1

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

885

1

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

886

));

887

1

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

888

1

});

889

890

1

	let dest: Location = Junction::AccountKey20 {

891

1

		network: None,

892

1

		key: PARAALICE,

893

1

894

1

	.into();

895

	// We are sending 100 tokens from relay.

896

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

897

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

898

	// Units per second should be 2_500_000_000_000_000

899

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

900

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

901

1

	Relay::execute_with(|| {

902

1

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

903

1

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

904

1

			assets: Wild(All),

905

1

			beneficiary: dest.clone(),

906

1

		}]);

907

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

908

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

909

1

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

910

1

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

911

1

			Box::new(TransferType::LocalReserve),

912

1

			Box::new(fees_id),

913

1

			Box::new(TransferType::LocalReserve),

914

1

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

915

1

			WeightLimit::Unlimited

916

));

917

1

});

918

919

1

	ParaA::execute_with(|| {

920

		// non-free execution, not full amount received

921

1

		assert_eq!(

922

1

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

923

1

			Ok(U256::from(90))

924

);

925

		// Fee should have been received by treasury

926

1

		assert_eq!(

927

1

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

928

1

			Ok(U256::from(10))

929

);

930

1

});

931

1

932

933

#[test]

934

1

fn send_para_a_asset_to_para_b_with_trader() {

935

1

	MockNet::reset();

936

937

1

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

938

1

	let source_location: AssetType = para_a_balances

939

1

		.try_into()

940

1

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

941

1

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

942

943

1

	let asset_metadata = parachain::AssetMetadata {

944

1

		name: b"ParaAToken".to_vec(),

945

1

		symbol: b"ParaA".to_vec(),

946

1

		decimals: 18,

947

1

};

948

949

1

	ParaB::execute_with(|| {

950

1

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

951

1

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

952

1

			.try_into()

953

1

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

954

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

955

1

			source_id,

956

1

			source_location_latest,

957

1

			asset_metadata.decimals,

958

1

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

959

1

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

960

));

961

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

962

1

});

963

964

1

	let dest = Location {

965

1

		parents: 1,

966

1

		interior: [

967

1

			Parachain(2),

968

1

			AccountKey20 {

969

1

				network: None,

970

1

				key: PARAALICE.into(),

971

1

},

972

1

973

1

		.into(),

974

1

};

975

1

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

976

977

	// In destination chain, we only need 4 weight

978

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

979

1

	ParaA::execute_with(|| {

980

1

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

981

1

		assert_ok!(PolkadotXcm::transfer_assets(

982

1

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

983

1

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

984

1

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

985

1

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

986

0,

987

1

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

988

));

989

1

});

990

1

	ParaA::execute_with(|| {

991

		// free execution, full amount received

992

1

		assert_eq!(

993

1

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

994

			INITIAL_BALANCE - 100

995

);

996

1

});

997

998

	// We are sending 100 tokens from para A.

999

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

1000

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

1001

	// Units per second should be 2_500_000_000_000_000

1002

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

1003

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

1004

	// will be 4

1005

1

	ParaB::execute_with(|| {

1006

1

		assert_eq!(

1007

1

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

1008

1

			Ok(U256::from(90))

1009

);

1010

		// Fee should have been received by treasury

1011

1

		assert_eq!(

1012

1

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

1013

1

			Ok(U256::from(10))

1014

);

1015

1

});

1016

1

1017

1018

#[test]

1019

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

1020

1

	MockNet::reset();

1021

1022

1

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

1023

1

	let source_location: AssetType = para_a_balances

1024

1

		.try_into()

1025

1

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

1026

1

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

1027

1028

1

	let asset_metadata = parachain::AssetMetadata {

1029

1

		name: b"ParaAToken".to_vec(),

1030

1

		symbol: b"ParaA".to_vec(),

1031

1

		decimals: 18,

1032

1

};

1033

1034

1

	ParaB::execute_with(|| {

1035

1

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

1036

1

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

1037

1

			.try_into()

1038

1

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

1039

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1040

1

			source_id,

1041

1

			source_location_latest,

1042

1

			asset_metadata.decimals,

1043

1

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

1044

1

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

1045

));

1046

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

1047

1

		assert_ok!(add_supported_asset(source_location, 12500000));

1048

1

});

1049

1050

1

	let dest = Location {

1051

1

		parents: 1,

1052

1

		interior: [

1053

1

			Parachain(2),

1054

1

			AccountKey20 {

1055

1

				network: None,

1056

1

				key: PARAALICE.into(),

1057

1

},

1058

1

1059

1

		.into(),

1060

1

};

1061

1

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

1062

	// we use transfer_with_fee

1063

1

	ParaA::execute_with(|| {

1064

1

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

1065

1

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

1066

1

		assert_ok!(PolkadotXcm::transfer_assets(

1067

1

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

1068

1

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

1069

1

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

1070

1

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

1071

0,

1072

1

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

1073

));

1074

1

});

1075

1

	ParaA::execute_with(|| {

1076

		// 100 tokens transferred plus 1 taken from fees

1077

1

		assert_eq!(

1078

1

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

1079

			INITIAL_BALANCE - 100 - 1

1080

);

1081

1

});

1082

1083

1

	ParaB::execute_with(|| {

1084

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

1085

		// what it is specified

1086

1

		assert_eq!(

1087

1

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

1088

1

			Ok(U256::from(101))

1089

);

1090

1

});

1091

1

1092

1093

#[test]

1094

1

fn error_when_not_paying_enough() {

1095

1

	MockNet::reset();

1096

1097

1

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

1098

1

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

1099

1100

1

	let asset_metadata = parachain::AssetMetadata {

1101

1

		name: b"RelayToken".to_vec(),

1102

1

		symbol: b"Relay".to_vec(),

1103

1

		decimals: 12,

1104

1

};

1105

1106

1

	let dest: Location = Junction::AccountKey20 {

1107

1

		network: None,

1108

1

		key: PARAALICE,

1109

1

1110

1

	.into();

1111

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

1112

	// we know later we will divide by 1e12

1113

	// Lets put 1e6 as units per second

1114

1

	ParaA::execute_with(|| {

1115

1

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

1116

1

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

1117

1

			.try_into()

1118

1

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

1119

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1120

1

			source_id,

1121

1

			source_location_latest,

1122

1

			asset_metadata.decimals,

1123

1

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

1124

1

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

1125

));

1126

1

		assert_ok!(add_supported_asset(source_location, 2500000000000));

1127

1

});

1128

1129

1

	ParaA::execute_with(|| {

1130

		// amount not received as it is not paying enough

1131

1

		assert_eq!(

1132

1

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

1133

1

			Ok(U256::from(0))

1134

);

1135

1

});

1136

1137

	// We are sending 100 tokens from relay.

1138

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

1139

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

1140

1

	Relay::execute_with(|| {

1141

1

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

1142

1

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

1143

1

			assets: Wild(All),

1144

1

			beneficiary: dest.clone(),

1145

1

		}]);

1146

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1147

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1148

1

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

1149

1

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

1150

1

			Box::new(TransferType::LocalReserve),

1151

1

			Box::new(fees_id),

1152

1

			Box::new(TransferType::LocalReserve),

1153

1

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

1154

1

			WeightLimit::Unlimited

1155

));

1156

1

});

1157

1158

1

	ParaA::execute_with(|| {

1159

		// amount not received as it is not paying enough

1160

1

		assert_eq!(

1161

1

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

1162

1

			Ok(U256::from(0))

1163

);

1164

1

});

1165

1

1166

1167

#[test]

1168

1

fn transact_through_derivative_multilocation() {

1169

1

	MockNet::reset();

1170

1171

1

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

1172

1

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

1173

1174

1

	let asset_metadata = parachain::AssetMetadata {

1175

1

		name: b"RelayToken".to_vec(),

1176

1

		symbol: b"Relay".to_vec(),

1177

1

		decimals: 12,

1178

1

};

1179

1180

1

	ParaA::execute_with(|| {

1181

1

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

1182

1

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

1183

1

			.try_into()

1184

1

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

1185

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1186

1

			source_id,

1187

1

			source_location_latest,

1188

1

			asset_metadata.decimals,

1189

1

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

1190

1

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

1191

));

1192

1

		assert_ok!(add_supported_asset(source_location, 1));

1193

1194

		// Root can set transact info

1195

1

		assert_ok!(XcmTransactor::set_transact_info(

1196

1

			parachain::RuntimeOrigin::root(),

1197

1

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

1198

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

1199

1

			3000.into(),

1200

1

			20000000000.into(),

1201

1

			None

1202

));

1203

		// Root can set transact info

1204

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

1205

1

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

1206

1

			.expect("must succeed");

1207

1

});

1208

1209

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

1210

1211

1

	let dest: Location = AccountKey20 {

1212

1

		network: None,

1213

1

		key: PARAALICE,

1214

1

1215

1

	.into();

1216

1

	Relay::execute_with(|| {

1217

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

1218

1

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

1219

1

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

1220

1

			assets: Wild(All),

1221

1

			beneficiary: dest.clone(),

1222

1

		}]);

1223

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1224

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1225

1

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

1226

1

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

1227

1

			Box::new(TransferType::LocalReserve),

1228

1

			Box::new(fees_id),

1229

1

			Box::new(TransferType::LocalReserve),

1230

1

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

1231

1

			WeightLimit::Unlimited

1232

));

1233

1

});

1234

1235

1

	ParaA::execute_with(|| {

1236

		// free execution, full amount received

1237

1

		assert_eq!(

1238

1

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

1239

1

			Ok(U256::from(4000003100u128))

1240

);

1241

1

});

1242

1243

	// Register address

1244

1

	ParaA::execute_with(|| {

1245

1

		assert_ok!(XcmTransactor::register(

1246

1

			parachain::RuntimeOrigin::root(),

1247

1

			PARAALICE.into(),

1248

0,

1249

));

1250

1

});

1251

1252

	// Send to registered address

1253

1254

1

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

1255

1

	let dest = Location {

1256

1

		parents: 1,

1257

1

		interior: [AccountId32 {

1258

1

			network: None,

1259

1

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

1260

1

}]

1261

1

		.into(),

1262

1

};

1263

1

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

1264

1265

1

	ParaA::execute_with(|| {

1266

1

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

1267

1

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

1268

1

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

1269

1

			assets: Wild(All),

1270

1

			beneficiary: beneficiary.clone(),

1271

1

		}]);

1272

		// free execution, full amount received

1273

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1274

1

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

1275

1

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

1276

1

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

1277

1

			Box::new(TransferType::DestinationReserve),

1278

1

			Box::new(fees_id),

1279

1

			Box::new(TransferType::DestinationReserve),

1280

1

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

1281

1

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

1282

));

1283

1

});

1284

1285

1

	ParaA::execute_with(|| {

1286

		// free execution, full amount received

1287

1

		assert_eq!(

1288

1

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

1289

1

			Ok(U256::from(4000003000u128))

1290

);

1291

1

});

1292

1293

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

1294

	// again

1295

1

	Relay::execute_with(|| {

1296

		// free execution,x	 full amount received

1297

1

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

1298

1

});

1299

1300

	// Encode the call. Balances transact to para_a_account

1301

	// First index

1302

1

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

1303

1

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

1304

1

		relay_chain::Balances,

1305

1

>()

1306

1

	.unwrap() as u8;

1307

1308

1

	encoded.push(index);

1309

1310

	// Then call bytes

1311

1

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

1312

1

		dest: para_a_account(),

1313

1

		value: 100u32.into(),

1314

1

1315

1

	.encode();

1316

1

	encoded.append(&mut call_bytes);

1317

1318

1

	ParaA::execute_with(|| {

1319

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1320

1

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

1321

1

			MockTransactors::Relay,

1322

0,

1323

1

			CurrencyPayment {

1324

1

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

1325

1

					Location::parent()

1326

1

				))),

1327

1

				fee_amount: None

1328

1

},

1329

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

1330

1

			encoded,

1331

1

			TransactWeights {

1332

1

				transact_required_weight_at_most: 4000000000.into(),

1333

1

				overall_weight: None

1334

1

},

1335

			false

1336

));

1337

1

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

1338

1

			.iter()

1339

19

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

1340

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

1341

..

1342

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

1343

19

				_ => None,

1344

19

});

1345

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

1346

1

		assert!(event_found.is_none());

1347

1

});

1348

1349

1

	Relay::execute_with(|| {

1350

		// free execution,x	 full amount received

1351

1

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

1352

1353

1

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

1354

1

});

1355

1

1356

1357

#[test]

1358

1

fn transact_through_derivative_with_custom_fee_weight() {

1359

1

	MockNet::reset();

1360

1361

1

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

1362

1

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

1363

1364

1

	let asset_metadata = parachain::AssetMetadata {

1365

1

		name: b"RelayToken".to_vec(),

1366

1

		symbol: b"Relay".to_vec(),

1367

1

		decimals: 12,

1368

1

};

1369

1370

1

	ParaA::execute_with(|| {

1371

1

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

1372

1

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

1373

1

			.try_into()

1374

1

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

1375

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1376

1

			source_id,

1377

1

			source_location_latest,

1378

1

			asset_metadata.decimals,

1379

1

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

1380

1

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

1381

));

1382

1

		assert_ok!(add_supported_asset(source_location, 1));

1383

1

});

1384

1385

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

1386

1387

1

	let dest: Location = AccountKey20 {

1388

1

		network: None,

1389

1

		key: PARAALICE,

1390

1

1391

1

	.into();

1392

1

	Relay::execute_with(|| {

1393

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

1394

1

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

1395

1

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

1396

1

			assets: Wild(All),

1397

1

			beneficiary: dest.clone(),

1398

1

		}]);

1399

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1400

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1401

1

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

1402

1

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

1403

1

			Box::new(TransferType::LocalReserve),

1404

1

			Box::new(fees_id),

1405

1

			Box::new(TransferType::LocalReserve),

1406

1

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

1407

1

			WeightLimit::Unlimited

1408

));

1409

1

});

1410

1411

1

	ParaA::execute_with(|| {

1412

		// free execution, full amount received

1413

1

		assert_eq!(

1414

1

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

1415

1

			Ok(U256::from(4000003100u128))

1416

);

1417

1

});

1418

1419

	// Register address

1420

1

	ParaA::execute_with(|| {

1421

1

		assert_ok!(XcmTransactor::register(

1422

1

			parachain::RuntimeOrigin::root(),

1423

1

			PARAALICE.into(),

1424

0,

1425

));

1426

1

});

1427

1428

	// Send to registered address

1429

1430

1

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

1431

1

	let dest = Location {

1432

1

		parents: 1,

1433

1

		interior: [AccountId32 {

1434

1

			network: None,

1435

1

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

1436

1

}]

1437

1

		.into(),

1438

1

};

1439

1

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

1440

1441

1

	ParaA::execute_with(|| {

1442

1

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

1443

1

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

1444

1

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

1445

1

			assets: Wild(All),

1446

1

			beneficiary: beneficiary.clone(),

1447

1

		}]);

1448

		// free execution, full amount received

1449

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1450

1

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

1451

1

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

1452

1

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

1453

1

			Box::new(TransferType::DestinationReserve),

1454

1

			Box::new(fees_id),

1455

1

			Box::new(TransferType::DestinationReserve),

1456

1

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

1457

1

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

1458

));

1459

1

});

1460

1461

1

	ParaA::execute_with(|| {

1462

		// free execution, full amount received

1463

1

		assert_eq!(

1464

1

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

1465

1

			Ok(U256::from(4000003000u128))

1466

);

1467

1

});

1468

1469

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

1470

	// again

1471

1

	Relay::execute_with(|| {

1472

		// free execution,x	 full amount received

1473

1

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

1474

1

});

1475

1476

	// Encode the call. Balances transact to para_a_account

1477

	// First index

1478

1

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

1479

1

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

1480

1

		relay_chain::Balances,

1481

1

>()

1482

1

	.unwrap() as u8;

1483

1484

1

	encoded.push(index);

1485

1486

	// Then call bytes

1487

1

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

1488

1

		dest: para_a_account(),

1489

1

		value: 100u32.into(),

1490

1

1491

1

	.encode();

1492

1

	encoded.append(&mut call_bytes);

1493

1494

1

	let overall_weight = 4000003000u64;

1495

1

	ParaA::execute_with(|| {

1496

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1497

1

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

1498

1

			MockTransactors::Relay,

1499

0,

1500

1

			CurrencyPayment {

1501

1

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

1502

1

					Location::parent()

1503

1

				))),

1504

1

				// 1-1 fee weight mapping

1505

1

				fee_amount: Some(overall_weight as u128)

1506

1

},

1507

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

1508

1

			encoded,

1509

1

			TransactWeights {

1510

1

				transact_required_weight_at_most: 4000000000.into(),

1511

1

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

1512

1

},

1513

			false

1514

));

1515

1

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

1516

1

			.iter()

1517

18

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

1518

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

1519

..

1520

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

1521

18

				_ => None,

1522

18

});

1523

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

1524

1

		assert!(event_found.is_none());

1525

1

});

1526

1527

1

	Relay::execute_with(|| {

1528

		// free execution,x	 full amount received

1529

1

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

1530

1531

1

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

1532

1

});

1533

1

1534

1535

#[test]

1536

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1537

1

	MockNet::reset();

1538

1539

1

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

1540

1

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

1541

1542

1

	let asset_metadata = parachain::AssetMetadata {

1543

1

		name: b"RelayToken".to_vec(),

1544

1

		symbol: b"Relay".to_vec(),

1545

1

		decimals: 12,

1546

1

};

1547

1548

1

	ParaA::execute_with(|| {

1549

1

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

1550

1

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

1551

1

			.try_into()

1552

1

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

1553

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1554

1

			source_id,

1555

1

			source_location_latest,

1556

1

			asset_metadata.decimals,

1557

1

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

1558

1

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

1559

));

1560

1

		assert_ok!(add_supported_asset(source_location, 1));

1561

1

});

1562

1563

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

1564

1565

1

	let dest: Location = AccountKey20 {

1566

1

		network: None,

1567

1

		key: PARAALICE,

1568

1

1569

1

	.into();

1570

1

	Relay::execute_with(|| {

1571

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

1572

1

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

1573

1

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

1574

1

			assets: Wild(All),

1575

1

			beneficiary: dest.clone(),

1576

1

		}]);

1577

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1578

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1579

1

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

1580

1

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

1581

1

			Box::new(TransferType::LocalReserve),

1582

1

			Box::new(fees_id),

1583

1

			Box::new(TransferType::LocalReserve),

1584

1

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

1585

1

			WeightLimit::Unlimited

1586

));

1587

1

});

1588

1589

1

	ParaA::execute_with(|| {

1590

		// free execution, full amount received

1591

1

		assert_eq!(

1592

1

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

1593

1

			Ok(U256::from(4000009100u128))

1594

);

1595

1

});

1596

1597

	// Register address

1598

1

	ParaA::execute_with(|| {

1599

1

		assert_ok!(XcmTransactor::register(

1600

1

			parachain::RuntimeOrigin::root(),

1601

1

			PARAALICE.into(),

1602

0,

1603

));

1604

1

});

1605

1606

	// Send to registered address

1607

1608

1

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

1609

1

	let dest = Location {

1610

1

		parents: 1,

1611

1

		interior: [AccountId32 {

1612

1

			network: None,

1613

1

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

1614

1

}]

1615

1

		.into(),

1616

1

};

1617

1

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

1618

1619

1

	ParaA::execute_with(|| {

1620

1

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

1621

1

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

1622

1

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

1623

1

			assets: Wild(All),

1624

1

			beneficiary: beneficiary.clone(),

1625

1

		}]);

1626

		// free execution, full amount received

1627

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1628

1

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

1629

1

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

1630

1

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

1631

1

			Box::new(TransferType::DestinationReserve),

1632

1

			Box::new(fees_id),

1633

1

			Box::new(TransferType::DestinationReserve),

1634

1

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

1635

1

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

1636

));

1637

1

});

1638

1639

1

	ParaA::execute_with(|| {

1640

		// free execution, full amount received

1641

1

		assert_eq!(

1642

1

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

1643

1

			Ok(U256::from(4000009000u128))

1644

);

1645

1

});

1646

1647

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

1648

	// again

1649

1

	Relay::execute_with(|| {

1650

		// free execution,x	 full amount received

1651

1

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

1652

1

});

1653

1654

	// Encode the call. Balances transact to para_a_account

1655

	// First index

1656

1

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

1657

1

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

1658

1

		relay_chain::Balances,

1659

1

>()

1660

1

	.unwrap() as u8;

1661

1662

1

	encoded.push(index);

1663

1664

	// Then call bytes

1665

1

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

1666

1

		dest: para_a_account(),

1667

1

		value: 100u32.into(),

1668

1

1669

1

	.encode();

1670

1

	encoded.append(&mut call_bytes);

1671

1672

1

	let overall_weight = 4000009000u64;

1673

1

	ParaA::execute_with(|| {

1674

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1675

1

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

1676

1

			MockTransactors::Relay,

1677

0,

1678

1

			CurrencyPayment {

1679

1

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

1680

1

					Location::parent()

1681

1

				))),

1682

1

				// 1-1 fee weight mapping

1683

1

				fee_amount: Some(overall_weight as u128)

1684

1

},

1685

1

			encoded,

1686

1

			TransactWeights {

1687

1

				transact_required_weight_at_most: 4000000000.into(),

1688

1

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

1689

1

},

1690

			true

1691

));

1692

1

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

1693

1

			.iter()

1694

18

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

1695

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

1696

..

1697

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

1698

18

				_ => None,

1699

18

});

1700

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

1701

1

		assert!(event_found.is_none());

1702

1

});

1703

1704

1

	Relay::execute_with(|| {

1705

		// free execution, full amount received

1706

		// 4000009000 refunded + 100 transferred = 4000009100

1707

1

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

1708

1

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

1709

1

});

1710

1

1711

1712

#[test]

1713

1

fn transact_through_sovereign() {

1714

1

	MockNet::reset();

1715

1716

1

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

1717

1

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

1718

1719

1

	let asset_metadata = parachain::AssetMetadata {

1720

1

		name: b"RelayToken".to_vec(),

1721

1

		symbol: b"Relay".to_vec(),

1722

1

		decimals: 12,

1723

1

};

1724

1725

1

	ParaA::execute_with(|| {

1726

1

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

1727

1

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

1728

1

			.try_into()

1729

1

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

1730

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1731

1

			source_id,

1732

1

			source_location_latest,

1733

1

			asset_metadata.decimals,

1734

1

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

1735

1

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

1736

));

1737

1

		assert_ok!(add_supported_asset(source_location, 1));

1738

1739

		// Root can set transact info

1740

1

		assert_ok!(XcmTransactor::set_transact_info(

1741

1

			parachain::RuntimeOrigin::root(),

1742

1

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

1743

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

1744

1

			3000.into(),

1745

1

			20000000000.into(),

1746

1

			None

1747

));

1748

		// Root can set transact info

1749

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

1750

1

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

1751

1

			.expect("must succeed");

1752

1

});

1753

1754

1

	let dest: Location = AccountKey20 {

1755

1

		network: None,

1756

1

		key: PARAALICE,

1757

1

1758

1

	.into();

1759

1

	Relay::execute_with(|| {

1760

1

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

1761

1

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

1762

1

			assets: Wild(All),

1763

1

			beneficiary: dest.clone(),

1764

1

		}]);

1765

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

1766

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1767

1

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

1768

1

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

1769

1

			Box::new(TransferType::LocalReserve),

1770

1

			Box::new(fees_id),

1771

1

			Box::new(TransferType::LocalReserve),

1772

1

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

1773

1

			WeightLimit::Unlimited

1774

));

1775

1

});

1776

1777

1

	ParaA::execute_with(|| {

1778

		// free execution, full amount received

1779

1

		assert_eq!(

1780

1

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

1781

1

			Ok(U256::from(4000003100u128))

1782

);

1783

1

});

1784

1785

	// Register address

1786

1

	ParaA::execute_with(|| {

1787

1

		assert_ok!(XcmTransactor::register(

1788

1

			parachain::RuntimeOrigin::root(),

1789

1

			PARAALICE.into(),

1790

0,

1791

));

1792

1

});

1793

1794

	// Send to registered address

1795

1

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

1796

1

	let dest = Location {

1797

1

		parents: 1,

1798

1

		interior: [AccountId32 {

1799

1

			network: None,

1800

1

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

1801

1

}]

1802

1

		.into(),

1803

1

};

1804

1

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

1805

1806

1

	ParaA::execute_with(|| {

1807

1

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

1808

1

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

1809

1

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

1810

1

			assets: Wild(All),

1811

1

			beneficiary: beneficiary.clone(),

1812

1

		}]);

1813

		// free execution, full amount received

1814

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1815

1

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

1816

1

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

1817

1

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

1818

1

			Box::new(TransferType::DestinationReserve),

1819

1

			Box::new(fees_id),

1820

1

			Box::new(TransferType::DestinationReserve),

1821

1

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

1822

1

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

1823

));

1824

1

});

1825

1826

1

	ParaA::execute_with(|| {

1827

		// free execution, full amount received

1828

1

		assert_eq!(

1829

1

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

1830

1

			Ok(U256::from(4000003000u128))

1831

);

1832

1

});

1833

1834

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

1835

	// again

1836

1

	Relay::execute_with(|| {

1837

		// free execution,x	 full amount received

1838

1

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

1839

1

1840

1

});

1841

1842

	// We send the xcm transact operation to parent

1843

1

	let dest = Location {

1844

1

		parents: 1,

1845

1

		interior: [].into(),

1846

1

};

1847

1848

	// Encode the call. Balances transact to para_a_account

1849

	// First index

1850

1

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

1851

1

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

1852

1

		relay_chain::Balances,

1853

1

>()

1854

1

	.unwrap() as u8;

1855

1856

1

	encoded.push(index);

1857

1858

	// Then call bytes

1859

1

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

1860

1

		dest: para_a_account(),

1861

1

		value: 100u32.into(),

1862

1

1863

1

	.encode();

1864

1

	encoded.append(&mut call_bytes);

1865

1866

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

1867

1

	ParaA::execute_with(|| {

1868

1

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

1869

1

			moonbase_runtime::xcm_config::Transactors::Relay,

1870

1

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

1871

);

1872

1873

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1874

1

			parachain::RuntimeOrigin::root(),

1875

1

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

1876

1

			Some(PARAALICE.into()),

1877

1

			CurrencyPayment {

1878

1

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

1879

1

					Location::parent()

1880

1

				))),

1881

1

				fee_amount: None

1882

1

},

1883

1

			utility_bytes,

1884

1

			OriginKind::SovereignAccount,

1885

1

			TransactWeights {

1886

1

				transact_required_weight_at_most: 4000000000.into(),

1887

1

				overall_weight: None

1888

1

},

1889

			false

1890

));

1891

1

});

1892

1893

1

	Relay::execute_with(|| {

1894

		// free execution,x	 full amount received

1895

1

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

1896

1897

1

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

1898

1

});

1899

1

1900

1901

#[test]

1902

1

fn transact_through_sovereign_fee_payer_none() {

1903

1

	MockNet::reset();

1904

1905

1

	ParaA::execute_with(|| {

1906

		// Root can set transact info

1907

1

		assert_ok!(XcmTransactor::set_transact_info(

1908

1

			parachain::RuntimeOrigin::root(),

1909

1

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

1910

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

1911

1

			3000.into(),

1912

1

			20000000000.into(),

1913

1

			None

1914

));

1915

		// Root can set transact info

1916

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

1917

1

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

1918

1

			.expect("must succeed");

1919

1

});

1920

1921

1

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

1922

1923

1

	Relay::execute_with(|| {

1924

		// Transfer 100 tokens to derivative_address on the relay

1925

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1926

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1927

1

			derivative_address.clone(),

1928

			100u128

1929

));

1930

1931

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

1932

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1933

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1934

1

			para_a_account(),

1935

			4000003000u128

1936

));

1937

1

});

1938

1939

	// Check balances before the transact call

1940

1

	Relay::execute_with(|| {

1941

1

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

1942

1

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

1943

1

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

1944

1

});

1945

1946

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

1947

1

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

1948

1

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

1949

1

		relay_chain::Balances,

1950

1

>()

1951

1

	.unwrap() as u8;

1952

1953

1

	encoded.push(index);

1954

1955

1

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

1956

1

		dest: RELAYBOB,

1957

1

		value: 100u32.into(),

1958

1

1959

1

	.encode();

1960

1

	encoded.append(&mut call_bytes);

1961

1962

	// We send the xcm transact operation to parent

1963

1

	let dest = Location {

1964

1

		parents: 1,

1965

1

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

1966

1

};

1967

1968

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

1969

1

	ParaA::execute_with(|| {

1970

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

1971

1

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

1972

1

			moonbase_runtime::xcm_config::Transactors::Relay,

1973

1

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

1974

);

1975

1976

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1977

1

			parachain::RuntimeOrigin::root(),

1978

1

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

1979

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

1980

1

			None,

1981

1

			CurrencyPayment {

1982

1

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

1983

1

					Location::parent()

1984

1

				))),

1985

1

				fee_amount: None

1986

1

},

1987

1

			utility_bytes,

1988

1

			OriginKind::SovereignAccount,

1989

1

			TransactWeights {

1990

1

				transact_required_weight_at_most: 4000000000.into(),

1991

1

				overall_weight: None

1992

1

},

1993

			false

1994

));

1995

1

});

1996

1997

	// Check balances after the transact call are correct

1998

1

	Relay::execute_with(|| {

1999

1

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

2000

1

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

2001

1

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

2002

1

});

2003

1

2004

2005

#[test]

2006

1

fn transact_through_sovereign_with_custom_fee_weight() {

2007

1

	MockNet::reset();

2008

2009

1

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

2010

1

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

2011

2012

1

	let asset_metadata = parachain::AssetMetadata {

2013

1

		name: b"RelayToken".to_vec(),

2014

1

		symbol: b"Relay".to_vec(),

2015

1

		decimals: 12,

2016

1

};

2017

2018

1

	ParaA::execute_with(|| {

2019

1

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

2020

1

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

2021

1

			.try_into()

2022

1

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

2023

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2024

1

			source_id,

2025

1

			source_location_latest,

2026

1

			asset_metadata.decimals,

2027

1

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

2028

1

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

2029

));

2030

1

		assert_ok!(add_supported_asset(source_location, 1));

2031

1

});

2032

2033

1

	let dest: Location = AccountKey20 {

2034

1

		network: None,

2035

1

		key: PARAALICE,

2036

1

2037

1

	.into();

2038

1

	Relay::execute_with(|| {

2039

1

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

2040

1

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

2041

1

			assets: Wild(All),

2042

1

			beneficiary: dest.clone(),

2043

1

		}]);

2044

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2045

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2046

1

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

2047

1

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

2048

1

			Box::new(TransferType::LocalReserve),

2049

1

			Box::new(fees_id),

2050

1

			Box::new(TransferType::LocalReserve),

2051

1

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

2052

1

			WeightLimit::Unlimited

2053

));

2054

1

});

2055

2056

1

	ParaA::execute_with(|| {

2057

		// free execution, full amount received

2058

1

		assert_eq!(

2059

1

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

2060

1

			Ok(U256::from(4000003100u128))

2061

);

2062

1

});

2063

2064

	// Register address

2065

1

	ParaA::execute_with(|| {

2066

1

		assert_ok!(XcmTransactor::register(

2067

1

			parachain::RuntimeOrigin::root(),

2068

1

			PARAALICE.into(),

2069

0,

2070

));

2071

1

});

2072

2073

	// Send to registered address

2074

1

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

2075

1

	let dest = Location {

2076

1

		parents: 1,

2077

1

		interior: [AccountId32 {

2078

1

			network: None,

2079

1

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

2080

1

}]

2081

1

		.into(),

2082

1

};

2083

1

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

2084

2085

1

	ParaA::execute_with(|| {

2086

1

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

2087

1

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

2088

1

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

2089

1

			assets: Wild(All),

2090

1

			beneficiary: beneficiary.clone(),

2091

1

		}]);

2092

		// free execution, full amount received

2093

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2094

1

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

2095

1

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

2096

1

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

2097

1

			Box::new(TransferType::DestinationReserve),

2098

1

			Box::new(fees_id),

2099

1

			Box::new(TransferType::DestinationReserve),

2100

1

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

2101

1

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

2102

));

2103

1

});

2104

2105

1

	ParaA::execute_with(|| {

2106

		// free execution, full amount received

2107

1

		assert_eq!(

2108

1

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

2109

1

			Ok(U256::from(4000003000u128))

2110

);

2111

1

});

2112

2113

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

2114

	// again

2115

1

	Relay::execute_with(|| {

2116

		// free execution,x	 full amount received

2117

1

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

2118

1

2119

1

});

2120

2121

	// We send the xcm transact operation to parent

2122

1

	let dest = Location {

2123

1

		parents: 1,

2124

1

		interior: [].into(),

2125

1

};

2126

2127

	// Encode the call. Balances transact to para_a_account

2128

	// First index

2129

1

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

2130

1

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

2131

1

		relay_chain::Balances,

2132

1

>()

2133

1

	.unwrap() as u8;

2134

2135

1

	encoded.push(index);

2136

2137

	// Then call bytes

2138

1

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

2139

1

		dest: para_a_account(),

2140

1

		value: 100u32.into(),

2141

1

2142

1

	.encode();

2143

1

	encoded.append(&mut call_bytes);

2144

2145

1

	let total_weight = 4000003000u64;

2146

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

2147

1

	ParaA::execute_with(|| {

2148

1

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

2149

1

			moonbase_runtime::xcm_config::Transactors::Relay,

2150

1

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

2151

);

2152

2153

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2154

1

			parachain::RuntimeOrigin::root(),

2155

1

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

2156

1

			Some(PARAALICE.into()),

2157

1

			CurrencyPayment {

2158

1

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

2159

1

					Location::parent()

2160

1

				))),

2161

1

				// 1-1 fee-weight mapping

2162

1

				fee_amount: Some(total_weight as u128)

2163

1

},

2164

1

			utility_bytes,

2165

1

			OriginKind::SovereignAccount,

2166

1

			TransactWeights {

2167

1

				transact_required_weight_at_most: 4000000000.into(),

2168

1

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

2169

1

},

2170

			false

2171

));

2172

1

});

2173

2174

1

	Relay::execute_with(|| {

2175

		// free execution,x	 full amount received

2176

1

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

2177

2178

1

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

2179

1

});

2180

1

2181

2182

#[test]

2183

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

2184

1

	MockNet::reset();

2185

2186

1

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

2187

1

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

2188

2189

1

	let asset_metadata = parachain::AssetMetadata {

2190

1

		name: b"RelayToken".to_vec(),

2191

1

		symbol: b"Relay".to_vec(),

2192

1

		decimals: 12,

2193

1

};

2194

2195

1

	ParaA::execute_with(|| {

2196

1

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

2197

1

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

2198

1

			.try_into()

2199

1

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

2200

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2201

1

			source_id,

2202

1

			source_location_latest,

2203

1

			asset_metadata.decimals,

2204

1

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

2205

1

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

2206

));

2207

1

		assert_ok!(add_supported_asset(source_location, 1));

2208

1

});

2209

2210

1

	let dest: Location = AccountKey20 {

2211

1

		network: None,

2212

1

		key: PARAALICE,

2213

1

2214

1

	.into();

2215

1

	Relay::execute_with(|| {

2216

1

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

2217

1

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

2218

1

			assets: Wild(All),

2219

1

			beneficiary: dest.clone(),

2220

1

		}]);

2221

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2222

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2223

1

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

2224

1

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

2225

1

			Box::new(TransferType::LocalReserve),

2226

1

			Box::new(fees_id),

2227

1

			Box::new(TransferType::LocalReserve),

2228

1

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

2229

1

			WeightLimit::Unlimited

2230

));

2231

1

});

2232

2233

1

	ParaA::execute_with(|| {

2234

		// free execution, full amount received

2235

1

		assert_eq!(

2236

1

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

2237

1

			Ok(U256::from(4000009100u128))

2238

);

2239

1

});

2240

2241

	// Register address

2242

1

	ParaA::execute_with(|| {

2243

1

		assert_ok!(XcmTransactor::register(

2244

1

			parachain::RuntimeOrigin::root(),

2245

1

			PARAALICE.into(),

2246

0,

2247

));

2248

1

});

2249

2250

	// Send to registered address

2251

1

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

2252

1

	let dest = Location {

2253

1

		parents: 1,

2254

1

		interior: [AccountId32 {

2255

1

			network: None,

2256

1

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

2257

1

}]

2258

1

		.into(),

2259

1

};

2260

1

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

2261

2262

1

	ParaA::execute_with(|| {

2263

1

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

2264

1

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

2265

1

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

2266

1

			assets: Wild(All),

2267

1

			beneficiary: beneficiary.clone(),

2268

1

		}]);

2269

		// free execution, full amount received

2270

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

2271

1

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

2272

1

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

2273

1

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

2274

1

			Box::new(TransferType::DestinationReserve),

2275

1

			Box::new(fees_id),

2276

1

			Box::new(TransferType::DestinationReserve),

2277

1

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

2278

1

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

2279

));

2280

1

});

2281

2282

1

	ParaA::execute_with(|| {

2283

		// free execution, full amount received

2284

1

		assert_eq!(

2285

1

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

2286

1

			Ok(U256::from(4000009000u128))

2287

);

2288

1

});

2289

2290

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

2291

	// again

2292

1

	Relay::execute_with(|| {

2293

		// free execution,x	 full amount received

2294

1

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

2295

1

2296

1

});

2297

2298

	// We send the xcm transact operation to parent

2299

1

	let dest = Location {

2300

1

		parents: 1,

2301

1

		interior: [].into(),

2302

1

};

2303

2304

	// Encode the call. Balances transact to para_a_account

2305

	// First index

2306

1

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

2307

1

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

2308

1

		relay_chain::Balances,

2309

1

>()

2310

1

	.unwrap() as u8;

2311

2312

1

	encoded.push(index);

2313

2314

	// Then call bytes

2315

1

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

2316

1

		dest: para_a_account(),

2317

1

		value: 100u32.into(),

2318

1

2319

1

	.encode();

2320

1

	encoded.append(&mut call_bytes);

2321

2322

1

	let total_weight = 4000009000u64;

2323

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

2324

1

	ParaA::execute_with(|| {

2325

1

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

2326

1

			moonbase_runtime::xcm_config::Transactors::Relay,

2327

1

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

2328

);

2329

2330

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2331

1

			parachain::RuntimeOrigin::root(),

2332

1

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

2333

1

			Some(PARAALICE.into()),

2334

1

			CurrencyPayment {

2335

1

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

2336

1

					Location::parent()

2337

1

				))),

2338

1

				// 1-1 fee-weight mapping

2339

1

				fee_amount: Some(total_weight as u128)

2340

1

},

2341

1

			utility_bytes,

2342

1

			OriginKind::SovereignAccount,

2343

1

			TransactWeights {

2344

1

				transact_required_weight_at_most: 4000000000.into(),

2345

1

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

2346

1

},

2347

			true

2348

));

2349

1

});

2350

2351

1

	Relay::execute_with(|| {

2352

		// free execution, full amount received

2353

		// 4000009000 refunded + 100 transferred = 4000009100

2354

1

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

2355

2356

1

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

2357

1

});

2358

1

2359

2360

#[test]

2361

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2362

1

	MockNet::reset();

2363

2364

1

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

2365

1

	let asset_metadata = parachain::AssetMetadata {

2366

1

		name: b"RelayToken".to_vec(),

2367

1

		symbol: b"Relay".to_vec(),

2368

1

		decimals: 12,

2369

1

};

2370

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

2371

1

	ParaA::execute_with(|| {

2372

1

		parachain::XcmVersioner::set_version(1);

2373

1

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

2374

1

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

2375

1

			.try_into()

2376

1

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

2377

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2378

3,

2379

1

			source_location_latest,

2380

1

			asset_metadata.decimals,

2381

1

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

2382

1

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

2383

));

2384

1

		assert_ok!(add_supported_asset(source_location, 0));

2385

1

});

2386

2387

1

	let response = Response::Version(2);

2388

1

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

2389

2390

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

2391

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

2392

1

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

2393

1

		query_id: 0,

2394

1

		response,

2395

1

		max_weight: Weight::zero(),

2396

1

		querier: Some(querier),

2397

1

	}]);

2398

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

2399

	// it directly here

2400

	// Actually send relay asset to parachain

2401

1

	let dest: Location = AccountKey20 {

2402

1

		network: None,

2403

1

		key: PARAALICE,

2404

1

2405

1

	.into();

2406

2407

1

	Relay::execute_with(|| {

2408

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

2409

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2410

1

			relay_chain::RuntimeOrigin::root(),

2411

1

			Some(3)

2412

));

2413

2414

		// Wrap version, which sets VersionedStorage

2415

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

2416

		// this is not necessary in prod

2417

1

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

2418

1

			&Parachain(1).into(),

2419

1

			mock_message

2420

));

2421

2422

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

2423

1

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

2424

1

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

2425

1

			assets: Wild(All),

2426

1

			beneficiary: dest.clone(),

2427

1

		}]);

2428

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2429

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2430

1

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

2431

1

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

2432

1

			Box::new(TransferType::LocalReserve),

2433

1

			Box::new(fees_id),

2434

1

			Box::new(TransferType::LocalReserve),

2435

1

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

2436

1

			WeightLimit::Unlimited

2437

));

2438

2439

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

2440

1

		relay_chain::relay_roll_to(2);

2441

2442

		// queries should have been updated

2443

1

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

2444

1

});

2445

2446

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2447

1

		pallet_xcm::Event::SupportedVersionChanged {

2448

1

			location: Location {

2449

1

				parents: 0,

2450

1

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

2451

1

},

2452

1

			version: 1,

2453

1

2454

1

		.into();

2455

2456

1

	Relay::execute_with(|| {

2457

		// Assert that the events vector contains the version change

2458

1

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

2459

1

});

2460

2461

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

2462

	// of the new version change

2463

1

	ParaA::execute_with(|| {

2464

		// Set version

2465

1

		parachain::XcmVersioner::set_version(2);

2466

		// Do runtime upgrade

2467

1

		parachain::on_runtime_upgrade();

2468

		// Initialize block, to call on_initialize and notify targets

2469

1

		parachain::para_roll_to(2);

2470

		// Expect the event in the parachain

2471

1

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

2472

2

e,

2473

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

2474

				result: 2,

2475

..

2476

})

2477

		)));

2478

1

});

2479

2480

	// This event should have been seen in the relay

2481

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2482

1

		pallet_xcm::Event::SupportedVersionChanged {

2483

1

			location: Location {

2484

1

				parents: 0,

2485

1

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

2486

1

},

2487

1

			version: 2,

2488

1

2489

1

		.into();

2490

2491

1

	Relay::execute_with(|| {

2492

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

2493

1

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

2494

1

});

2495

1

2496

2497

#[test]

2498

1

fn test_automatic_versioning_on_runtime_upgrade_with_para_b() {

2499

1

	MockNet::reset();

2500

2501

1

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

2502

1

	let source_location: AssetType = para_a_balances

2503

1

		.try_into()

2504

1

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

2505

1

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

2506

2507

1

	let asset_metadata = parachain::AssetMetadata {

2508

1

		name: b"ParaAToken".to_vec(),

2509

1

		symbol: b"ParaA".to_vec(),

2510

1

		decimals: 18,

2511

1

};

2512

1

	let response = Response::Version(2);

2513

1

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

2514

2515

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

2516

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

2517

1

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

2518

1

		query_id: 0,

2519

1

		response,

2520

1

		max_weight: Weight::zero(),

2521

1

		querier: Some(querier),

2522

1

	}]);

2523

2524

1

	ParaA::execute_with(|| {

2525

		// advertised version

2526

1

		parachain::XcmVersioner::set_version(2);

2527

1

});

2528

2529

1

	ParaB::execute_with(|| {

2530

		// Let's try with v0

2531

1

		parachain::XcmVersioner::set_version(0);

2532

2533

1

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

2534

1

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

2535

1

			.try_into()

2536

1

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

2537

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2538

1

			source_id,

2539

1

			source_location_latest,

2540

1

			asset_metadata.decimals,

2541

1

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

2542

1

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

2543

));

2544

1

		assert_ok!(add_supported_asset(source_location, 0));

2545

1

});

2546

2547

1

	ParaA::execute_with(|| {

2548

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

2549

1

		assert_ok!(ParachainPalletXcm::force_default_xcm_version(

2550

1

			parachain::RuntimeOrigin::root(),

2551

1

			Some(3)

2552

));

2553

		// Wrap version, which sets VersionedStorage

2554

1

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

2555

1

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

2556

1

			mock_message

2557

));

2558

2559

1

		parachain::para_roll_to(2);

2560

2561

		// queries should have been updated

2562

1

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

2563

1

});

2564

2565

1

	let expected_supported_version: parachain::RuntimeEvent =

2566

1

		pallet_xcm::Event::SupportedVersionChanged {

2567

1

			location: Location {

2568

1

				parents: 1,

2569

1

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

2570

1

},

2571

1

			version: 0,

2572

1

2573

1

		.into();

2574

2575

1

	ParaA::execute_with(|| {

2576

		// Assert that the events vector contains the version change

2577

1

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

2578

1

});

2579

2580

	// Let's ensure talking in v0 works

2581

1

	let dest = Location {

2582

1

		parents: 1,

2583

1

		interior: [

2584

1

			Parachain(2),

2585

1

			AccountKey20 {

2586

1

				network: None,

2587

1

				key: PARAALICE.into(),

2588

1

},

2589

1

2590

1

		.into(),

2591

1

2592

1

	.into();

2593

1

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

2594

1

	ParaA::execute_with(|| {

2595

1

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

2596

		// free execution, full amount received

2597

1

		assert_ok!(PolkadotXcm::transfer_assets(

2598

1

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

2599

1

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

2600

1

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

2601

1

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

2602

0,

2603

1

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

2604

));

2605

		// free execution, full amount received

2606

1

		assert_eq!(

2607

1

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

2608

			INITIAL_BALANCE - 100

2609

);

2610

1

});

2611

2612

1

	ParaB::execute_with(|| {

2613

		// free execution, full amount received

2614

1

		assert_eq!(

2615

1

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

2616

1

			Ok(U256::from(100))

2617

);

2618

1

});

2619

2620

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

2621

	// of the new version change

2622

1

	ParaB::execute_with(|| {

2623

		// Set version

2624

1

		parachain::XcmVersioner::set_version(2);

2625

		// Do runtime upgrade

2626

1

		parachain::on_runtime_upgrade();

2627

		// Initialize block, to call on_initialize and notify targets

2628

1

		parachain::para_roll_to(2);

2629

		// Expect the event in the parachain

2630

1

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

2631

2

e,

2632

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

2633

				result: 2,

2634

..

2635

})

2636

		)));

2637

1

});

2638

2639

	// This event should have been seen in para A

2640

1

	let expected_supported_version_2: parachain::RuntimeEvent =

2641

1

		pallet_xcm::Event::SupportedVersionChanged {

2642

1

			location: Location {

2643

1

				parents: 1,

2644

1

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

2645

1

},

2646

1

			version: 2,

2647

1

2648

1

		.into();

2649

2650

	// Para A should have received the version change

2651

1

	ParaA::execute_with(|| {

2652

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

2653

1

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

2654

1

});

2655

1

2656

2657

#[test]

2658

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2659

1

	MockNet::reset();

2660

2661

1

	let fresh_account = PARABOB;

2662

1

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

2663

1

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

2664

1

	let asset_metadata = parachain::AssetMetadata {

2665

1

		name: b"RelayToken".to_vec(),

2666

1

		symbol: b"Relay".to_vec(),

2667

1

		decimals: 12,

2668

1

};

2669

	// register relay asset in parachain A

2670

1

	ParaA::execute_with(|| {

2671

1

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

2672

1

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

2673

1

			.try_into()

2674

1

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

2675

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2676

1

			source_id,

2677

1

			source_location_latest,

2678

1

			asset_metadata.decimals,

2679

1

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

2680

1

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

2681

));

2682

1

		assert_ok!(add_supported_asset(source_location, 0));

2683

1

});

2684

2685

	// Actually send relay asset to parachain

2686

1

	let dest: Location = AccountKey20 {

2687

1

		network: None,

2688

1

		key: fresh_account,

2689

1

2690

1

	.into();

2691

1

	Relay::execute_with(|| {

2692

1

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

2693

1

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

2694

1

			assets: Wild(All),

2695

1

			beneficiary: dest.clone(),

2696

1

		}]);

2697

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2698

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2699

1

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

2700

1

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

2701

1

			Box::new(TransferType::LocalReserve),

2702

1

			Box::new(fees_id),

2703

1

			Box::new(TransferType::LocalReserve),

2704

1

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

2705

1

			WeightLimit::Unlimited

2706

));

2707

1

});

2708

2709

	// parachain should not have received assets

2710

1

	ParaA::execute_with(|| {

2711

		// free execution, full amount received

2712

1

		assert_eq!(

2713

1

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

2714

1

			Ok(U256::from(123))

2715

);

2716

1

});

2717

1

2718

2719

#[test]

2720

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2721

1

	MockNet::reset();

2722

2723

1

	let fresh_account = [2u8; 20];

2724

1

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

2725

1

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

2726

1

	let asset_metadata = parachain::AssetMetadata {

2727

1

		name: b"RelayToken".to_vec(),

2728

1

		symbol: b"Relay".to_vec(),

2729

1

		decimals: 12,

2730

1

};

2731

	// register relay asset in parachain A

2732

1

	ParaA::execute_with(|| {

2733

1

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

2734

1

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

2735

1

			.try_into()

2736

1

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

2737

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2738

1

			source_id,

2739

1

			source_location_latest,

2740

1

			asset_metadata.decimals,

2741

1

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

2742

1

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

2743

));

2744

1

		assert_ok!(add_supported_asset(source_location, 0));

2745

1

});

2746

2747

	// Actually send relay asset to parachain

2748

1

	let dest: Location = AccountKey20 {

2749

1

		network: None,

2750

1

		key: fresh_account,

2751

1

2752

1

	.into();

2753

1

	Relay::execute_with(|| {

2754

1

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

2755

1

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

2756

1

			assets: Wild(All),

2757

1

			beneficiary: dest.clone(),

2758

1

		}]);

2759

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2760

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2761

1

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

2762

1

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

2763

1

			Box::new(TransferType::LocalReserve),

2764

1

			Box::new(fees_id),

2765

1

			Box::new(TransferType::LocalReserve),

2766

1

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

2767

1

			WeightLimit::Unlimited

2768

));

2769

1

});

2770

2771

	// parachain should have received assets

2772

1

	ParaA::execute_with(|| {

2773

		// free execution, full amount received

2774

1

		assert_eq!(

2775

1

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

2776

1

			Ok(U256::from(123))

2777

);

2778

1

});

2779

1

2780

2781

#[test]

2782

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2783

1

	MockNet::reset();

2784

2785

1

	let mut sufficient_account = [0u8; 20];

2786

1

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

2787

2788

1

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

2789

2790

	// Evm account is self sufficient

2791

1

	ParaA::execute_with(|| {

2792

1

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

2793

1

});

2794

2795

1

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

2796

1

	let asset_metadata = parachain::AssetMetadata {

2797

1

		name: b"RelayToken".to_vec(),

2798

1

		symbol: b"Relay".to_vec(),

2799

1

		decimals: 12,

2800

1

};

2801

	// register relay asset in parachain A

2802

1

	ParaA::execute_with(|| {

2803

1

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

2804

1

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

2805

1

			.try_into()

2806

1

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

2807

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2808

1,

2809

1

			source_location_latest,

2810

1

			asset_metadata.decimals,

2811

1

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

2812

1

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

2813

));

2814

1

		assert_ok!(add_supported_asset(source_location, 0));

2815

1

});

2816

2817

	// Actually send relay asset to parachain

2818

1

	let dest: Location = AccountKey20 {

2819

1

		network: None,

2820

1

		key: sufficient_account,

2821

1

2822

1

	.into();

2823

1

	Relay::execute_with(|| {

2824

1

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

2825

1

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

2826

1

			assets: Wild(All),

2827

1

			beneficiary: dest.clone(),

2828

1

		}]);

2829

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2830

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2831

1

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

2832

1

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

2833

1

			Box::new(TransferType::LocalReserve),

2834

1

			Box::new(fees_id),

2835

1

			Box::new(TransferType::LocalReserve),

2836

1

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

2837

1

			WeightLimit::Unlimited

2838

));

2839

1

});

2840

2841

	// Evm account sufficient ref count increased by 1.

2842

1

	ParaA::execute_with(|| {

2843

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

2844

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

2845

		// remove contract data

2846

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

2847

1

});

2848

2849

1

	ParaA::execute_with(|| {

2850

		// Remove the account from the evm context.

2851

1

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

2852

		// Evm account sufficient ref count decreased by 1.

2853

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

2854

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

2855

		// remove contract data

2856

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

2857

1

});

2858

1

2859

2860

#[test]

2861

1

fn empty_account_should_not_be_reset() {

2862

1

	MockNet::reset();

2863

2864

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

2865

1

	let sufficient_account = PARABOB;

2866

2867

1

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

2868

2869

1

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

2870

1

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

2871

1

	let asset_metadata = parachain::AssetMetadata {

2872

1

		name: b"RelayToken".to_vec(),

2873

1

		symbol: b"Relay".to_vec(),

2874

1

		decimals: 12,

2875

1

};

2876

	// register relay asset in parachain A

2877

1

	ParaA::execute_with(|| {

2878

1

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

2879

1

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

2880

1

			.try_into()

2881

1

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

2882

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2883

1

			source_id,

2884

1

			source_location_latest,

2885

1

			asset_metadata.decimals,

2886

1

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

2887

1

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

2888

));

2889

1

		assert_ok!(add_supported_asset(source_location, 0));

2890

1

});

2891

2892

	// Send native token to evm_account

2893

1

	ParaA::execute_with(|| {

2894

1

		assert_ok!(ParaBalances::transfer_allow_death(

2895

1

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

2896

1

			evm_account_id,

2897

2898

));

2899

1

});

2900

2901

	// Actually send relay asset to parachain

2902

1

	let dest: Location = AccountKey20 {

2903

1

		network: None,

2904

1

		key: sufficient_account,

2905

1

2906

1

	.into();

2907

1

	Relay::execute_with(|| {

2908

1

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

2909

1

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

2910

1

			assets: Wild(All),

2911

1

			beneficiary: dest.clone(),

2912

1

		}]);

2913

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

2914

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2915

1

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

2916

1

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

2917

1

			Box::new(TransferType::LocalReserve),

2918

1

			Box::new(fees_id),

2919

1

			Box::new(TransferType::LocalReserve),

2920

1

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

2921

1

			WeightLimit::Unlimited

2922

));

2923

1

});

2924

2925

1

	ParaA::execute_with(|| {

2926

		// Empty the assets from the account.

2927

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

2928

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

2929

1

		assert_ok!(parachain::EvmForeignAssets::transfer(

2930

1

			source_id,

2931

1

			evm_account_id,

2932

1

			PARAALICE.into(),

2933

1

			U256::from(123)

2934

));

2935

		// Verify account asset balance is Zero.

2936

1

		assert_eq!(

2937

1

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

2938

1

			Ok(U256::from(0))

2939

);

2940

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

2941

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

2942

1

		assert_ok!(ParaBalances::force_set_balance(

2943

1

			parachain::RuntimeOrigin::root(),

2944

1

			evm_account_id,

2945

0,

2946

));

2947

		// Verify account native balance is Zero.

2948

1

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

2949

		// Remove the account from the evm context.

2950

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

2951

1

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

2952

		// Verify reference count.

2953

1

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

2954

1

		assert_eq!(account.sufficients, 0);

2955

1

		assert_eq!(account.consumers, 0);

2956

1

		assert_eq!(account.providers, 1);

2957

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

2958

1

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

2959

1

});

2960

1

2961

2962

#[test]

2963

1

fn test_statemint_like() {

2964

1

	MockNet::reset();

2965

2966

1

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

2967

2968

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2969

1

		polkadot_parachain::primitives::Sibling,

2970

1

		statemint_like::AccountId,

2971

1

	>::convert_location(&dest_para)

2972

1

	.unwrap();

2973

2974

1

	let statemint_asset_a_balances = Location::new(

2975

1,

2976

1

2977

1

			Parachain(1000),

2978

1

			PalletInstance(5),

2979

1

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

2980

1

],

2981

);

2982

1

	let source_location: AssetType = statemint_asset_a_balances

2983

1

		.try_into()

2984

1

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

2985

1

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

2986

2987

1

	let asset_metadata = parachain::AssetMetadata {

2988

1

		name: b"StatemintToken".to_vec(),

2989

1

		symbol: b"StatemintToken".to_vec(),

2990

1

		decimals: 12,

2991

1

};

2992

2993

1

	ParaA::execute_with(|| {

2994

1

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

2995

1

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

2996

1

			.try_into()

2997

1

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

2998

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2999

1

			source_id,

3000

1

			source_location_latest,

3001

1

			asset_metadata.decimals,

3002

1

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

3003

1

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

3004

));

3005

1

		assert_ok!(add_supported_asset(source_location, 0));

3006

1

});

3007

3008

1

	Statemint::execute_with(|| {

3009

		// Set new prefix

3010

1

		statemint_like::PrefixChanger::set_prefix(

3011

1

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

3012

);

3013

1

		assert_ok!(StatemintAssets::create(

3014

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3015

0,

3016

			RELAYALICE,

3017

3018

));

3019

3020

1

		assert_ok!(StatemintAssets::mint(

3021

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3022

0,

3023

			RELAYALICE,

3024

			300000000000000

3025

));

3026

3027

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

3028

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3029

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3030

1

			sov,

3031

			100000000000000

3032

));

3033

3034

		// Actually send relay asset to parachain

3035

1

		let dest: Location = AccountKey20 {

3036

1

			network: None,

3037

1

			key: PARAALICE,

3038

1

3039

1

		.into();

3040

3041

		// Send asset with previous prefix

3042

1

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

3043

1

0,

3044

1

3045

1

				xcm::latest::prelude::PalletInstance(

3046

1

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

3047

1

),

3048

1

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

3049

1

],

3050

1

))

3051

1

		.into();

3052

1

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

3053

1

			assets: Wild(All),

3054

1

			beneficiary: dest.clone(),

3055

1

		}]);

3056

1

		assert_ok!(

3057

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3058

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3059

1

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

3060

1

				Box::new(

3061

1

3062

1

3063

1

							xcm::latest::prelude::PalletInstance(

3064

1

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

3065

1

),

3066

1

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

3067

1

],

3068

1

3069

1

3070

1

						.into()

3071

),

3072

1

				Box::new(TransferType::LocalReserve),

3073

1

				Box::new(fees_id),

3074

1

				Box::new(TransferType::LocalReserve),

3075

1

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

3076

1

				WeightLimit::Unlimited

3077

3078

);

3079

1

});

3080

3081

1

	ParaA::execute_with(|| {

3082

1

		assert_eq!(

3083

1

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

3084

1

			Ok(U256::from(123))

3085

);

3086

1

});

3087

1

3088

3089

#[test]

3090

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

3091

1

	MockNet::reset();

3092

3093

	// Relay asset

3094

1

	let relay_location = Location::parent();

3095

1

	let relay_location_v3 =

3096

1

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

3097

1

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

3098

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

3099

};

3100

1

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

3101

1

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

3102

3103

1

	let relay_asset_metadata = parachain::AssetMetadata {

3104

1

		name: b"RelayToken".to_vec(),

3105

1

		symbol: b"Relay".to_vec(),

3106

1

		decimals: 12,

3107

1

};

3108

3109

	// Statemint asset

3110

1

	let statemint_asset = Location::new(

3111

1,

3112

1

3113

1

			Parachain(1000u32),

3114

1

			PalletInstance(5u8),

3115

1

			GeneralIndex(10u128),

3116

1

],

3117

);

3118

1

	let statemint_location_asset: AssetType = statemint_asset

3119

1

		.clone()

3120

1

		.try_into()

3121

1

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

3122

1

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

3123

3124

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3125

1

		name: b"USDC".to_vec(),

3126

1

		symbol: b"USDC".to_vec(),

3127

1

		decimals: 12,

3128

1

};

3129

3130

1

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

3131

3132

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3133

1

		polkadot_parachain::primitives::Sibling,

3134

1

		statemint_like::AccountId,

3135

1

	>::convert_location(&dest_para)

3136

1

	.unwrap();

3137

3138

1

	ParaA::execute_with(|| {

3139

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3140

1

			source_relay_id,

3141

1

			relay_location.clone(),

3142

1

			relay_asset_metadata.decimals,

3143

1

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

3144

1

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

3145

));

3146

1

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

3147

3148

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3149

1

			source_statemint_asset_id,

3150

1

			statemint_asset.clone(),

3151

1

			asset_metadata_statemint_asset.decimals,

3152

1

			asset_metadata_statemint_asset

3153

1

				.symbol

3154

1

				.try_into()

3155

1

				.expect("too long"),

3156

1

			asset_metadata_statemint_asset

3157

1

				.name

3158

1

				.try_into()

3159

1

				.expect("too long"),

3160

));

3161

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0));

3162

1

});

3163

3164

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

3165

1

		network: None,

3166

1

		key: PARAALICE,

3167

1

3168

1

	.into();

3169

3170

	// Send relay chain asset to Alice in Parachain A

3171

1

	Relay::execute_with(|| {

3172

1

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

3173

1

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

3174

1

			assets: Wild(All),

3175

1

			beneficiary: parachain_beneficiary_from_relay.clone(),

3176

1

		}]);

3177

1

		assert_ok!(RelayChainPalletXcm::transfer_assets_using_type_and_then(

3178

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3179

1

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

3180

1

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

3181

1

			Box::new(TransferType::LocalReserve),

3182

1

			Box::new(fees_id),

3183

1

			Box::new(TransferType::LocalReserve),

3184

1

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

3185

1

			WeightLimit::Unlimited

3186

));

3187

1

});

3188

3189

1

	Statemint::execute_with(|| {

3190

		// Set new prefix

3191

1

		statemint_like::PrefixChanger::set_prefix(

3192

1

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

3193

);

3194

3195

1

		assert_ok!(StatemintAssets::create(

3196

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3197

10,

3198

			RELAYALICE,

3199

3200

));

3201

3202

1

		assert_ok!(StatemintAssets::mint(

3203

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3204

10,

3205

			RELAYALICE,

3206

			300000000000000

3207

));

3208

3209

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

3210

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

3211

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3212

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3213

1

			sov,

3214

			100000000000000

3215

));

3216

3217

		// Send statemint USDC asset to Alice in Parachain A

3218

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

3219

1

			network: None,

3220

1

			key: PARAALICE,

3221

1

3222

1

		.into();

3223

3224

		// Send with new prefix

3225

1

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

3226

1

0,

3227

1

3228

1

				xcm::latest::prelude::PalletInstance(

3229

1

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

3230

1

),

3231

1

				GeneralIndex(10),

3232

1

],

3233

1

))

3234

1

		.into();

3235

1

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

3236

1

			assets: Wild(All),

3237

1

			beneficiary: parachain_beneficiary_from_statemint.clone(),

3238

1

		}]);

3239

1

		assert_ok!(

3240

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3241

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3242

1

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

3243

1

				Box::new(

3244

1

3245

1

3246

1

							xcm::latest::prelude::PalletInstance(

3247

1

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

3248

1

),

3249

1

							GeneralIndex(10),

3250

1

],

3251

1

3252

1

3253

1

						.into()

3254

),

3255

1

				Box::new(TransferType::LocalReserve),

3256

1

				Box::new(fees_id),

3257

1

				Box::new(TransferType::LocalReserve),

3258

1

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

3259

1

				WeightLimit::Unlimited

3260

3261

);

3262

1

});

3263

3264

1

	let statemint_beneficiary = Location {

3265

1

		parents: 1,

3266

1

		interior: [

3267

1

			Parachain(1000),

3268

1

			AccountId32 {

3269

1

				network: None,

3270

1

				id: RELAYBOB.into(),

3271

1

},

3272

1

3273

1

		.into(),

3274

1

};

3275

3276

1

	ParaA::execute_with(|| {

3277

		// Alice has received 125 USDC

3278

1

		assert_eq!(

3279

1

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

3280

1

			Ok(U256::from(125))

3281

);

3282

3283

		// Alice has received 200 Relay assets

3284

1

		assert_eq!(

3285

1

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

3286

1

			Ok(U256::from(200))

3287

);

3288

1

});

3289

3290

1

	Statemint::execute_with(|| {

3291

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

3292

1

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

3293

1

});

3294

3295

1

	let (chain_part, beneficiary) =

3296

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

3297

3298

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

3299

1

	ParaA::execute_with(|| {

3300

1

		let asset = currency_to_asset(

3301

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3302

			100,

3303

);

3304

1

		let asset_fee =

3305

1

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

3306

1

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

3307

1

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

3308

1

			assets: Wild(All),

3309

1

			beneficiary: beneficiary.clone(),

3310

1

		}]);

3311

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3312

1

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

3313

1

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

3314

1

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

3315

1

			Box::new(TransferType::DestinationReserve),

3316

1

			Box::new(fees_id),

3317

1

			Box::new(TransferType::DestinationReserve),

3318

1

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

3319

1

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

3320

));

3321

1

});

3322

3323

1

	ParaA::execute_with(|| {

3324

		// Alice has 100 USDC less

3325

1

		assert_eq!(

3326

1

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

3327

1

			Ok(U256::from(25))

3328

);

3329

3330

		// Alice has 100 relay asset less

3331

1

		assert_eq!(

3332

1

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

3333

1

			Ok(U256::from(100))

3334

);

3335

1

});

3336

3337

1

	Statemint::execute_with(|| {

3338

		// Check that BOB received 100 USDC on statemint

3339

1

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

3340

1

});

3341

1

3342

3343

#[test]

3344

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

3345

1

	MockNet::reset();

3346

3347

	// Relay asset

3348

1

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

3349

1

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

3350

1

	let relay_location_v5 = Location::parent();

3351

1

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

3352

3353

1

	let relay_asset_metadata = parachain::AssetMetadata {

3354

1

		name: b"RelayToken".to_vec(),

3355

1

		symbol: b"Relay".to_vec(),

3356

1

		decimals: 12,

3357

1

};

3358

3359

1

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

3360

3361

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3362

1

		polkadot_parachain::primitives::Sibling,

3363

1

		statemint_like::AccountId,

3364

1

	>::convert_location(&dest_para)

3365

1

	.unwrap();

3366

3367

1

	ParaA::execute_with(|| {

3368

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3369

1

			source_relay_id,

3370

1

			relay_location_v5.clone(),

3371

1

			relay_asset_metadata.decimals,

3372

1

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

3373

1

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

3374

));

3375

1

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

3376

1

});

3377

3378

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3379

1

		network: None,

3380

1

		key: PARAALICE,

3381

1

3382

1

	.into();

3383

3384

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3385

1

		network: None,

3386

1

		id: RELAYALICE.into(),

3387

1

3388

1

	.into();

3389

3390

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

3391

1

	Relay::execute_with(|| {

3392

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3393

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3394

1

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

3395

1

			Box::new(

3396

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3397

1

					.clone()

3398

1

					.into()

3399

),

3400

1

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

3401

0,

3402

1

			WeightLimit::Unlimited

3403

));

3404

1

});

3405

3406

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3407

1

	Statemint::execute_with(|| {

3408

		// Check Alice received 200 tokens on AssetHub

3409

1

		assert_eq!(

3410

1

			StatemintBalances::free_balance(RELAYALICE),

3411

			INITIAL_BALANCE + 200

3412

);

3413

3414

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3415

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3416

1

			sov,

3417

			110000000000000

3418

));

3419

3420

		// Now send those tokens to ParaA

3421

1

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

3422

1

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

3423

1

			assets: Wild(All),

3424

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3425

1

		}]);

3426

1

		assert_ok!(

3427

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3428

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3429

1

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

3430

1

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

3431

1

				Box::new(TransferType::LocalReserve),

3432

1

				Box::new(fees_id),

3433

1

				Box::new(TransferType::LocalReserve),

3434

1

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

3435

1

				WeightLimit::Unlimited

3436

3437

);

3438

1

});

3439

3440

1

	ParaA::execute_with(|| {

3441

		// Alice should have received the DOTs

3442

1

		assert_eq!(

3443

1

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

3444

1

			Ok(U256::from(200))

3445

);

3446

1

});

3447

3448

1

	let dest = Location::new(

3449

1,

3450

1

3451

1

			Parachain(1000),

3452

1

			AccountId32 {

3453

1

				network: None,

3454

1

				id: RELAYBOB.into(),

3455

1

},

3456

1

],

3457

);

3458

1

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

3459

3460

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

3461

1

	ParaA::execute_with(|| {

3462

1

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

3463

1

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

3464

1

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

3465

1

			assets: Wild(All),

3466

1

			beneficiary: beneficiary.clone(),

3467

1

		}]);

3468

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3469

1

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

3470

1

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

3471

1

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

3472

1

			Box::new(TransferType::DestinationReserve),

3473

1

			Box::new(fees_id),

3474

1

			Box::new(TransferType::DestinationReserve),

3475

1

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

3476

1

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

3477

));

3478

3479

1

		assert_eq!(

3480

1

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

3481

1

			Ok(U256::from(100))

3482

);

3483

1

});

3484

3485

1

	Statemint::execute_with(|| {

3486

		// Check that Bob received the tokens back in AssetHub

3487

1

		assert_eq!(

3488

1

			StatemintBalances::free_balance(RELAYBOB),

3489

			INITIAL_BALANCE + 100

3490

);

3491

1

});

3492

3493

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

3494

1

	Statemint::execute_with(|| {

3495

		// Now send those tokens to ParaA

3496

1

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

3497

1

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

3498

1

			assets: Wild(All),

3499

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3500

1

		}]);

3501

1

		assert_ok!(

3502

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3503

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3504

1

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

3505

1

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

3506

1

				Box::new(TransferType::LocalReserve),

3507

1

				Box::new(fees_id),

3508

1

				Box::new(TransferType::LocalReserve),

3509

1

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

3510

1

				WeightLimit::Unlimited

3511

3512

);

3513

3514

		// 100 DOTs were deducted from Bob's account

3515

1

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

3516

1

});

3517

3518

1

	ParaA::execute_with(|| {

3519

		// Alice should have received 100 DOTs

3520

1

		assert_eq!(

3521

1

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

3522

1

			Ok(U256::from(200))

3523

);

3524

1

});

3525

1

3526

3527

#[test]

3528

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3529

1

	MockNet::reset();

3530

3531

	// Relay asset

3532

1

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

3533

1

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

3534

1

	let relay_location_v5 = Location::parent();

3535

1

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

3536

3537

1

	let relay_asset_metadata = parachain::AssetMetadata {

3538

1

		name: b"RelayToken".to_vec(),

3539

1

		symbol: b"Relay".to_vec(),

3540

1

		decimals: 12,

3541

1

};

3542

3543

1

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

3544

3545

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3546

1

		polkadot_parachain::primitives::Sibling,

3547

1

		statemint_like::AccountId,

3548

1

	>::convert_location(&dest_para)

3549

1

	.unwrap();

3550

3551

1

	ParaA::execute_with(|| {

3552

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3553

1

			source_relay_id,

3554

1

			relay_location_v5.clone(),

3555

1

			relay_asset_metadata.decimals,

3556

1

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

3557

1

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

3558

));

3559

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3560

1

});

3561

3562

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3563

1

		network: None,

3564

1

		key: PARAALICE,

3565

1

3566

1

	.into();

3567

3568

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3569

1

		network: None,

3570

1

		id: RELAYALICE.into(),

3571

1

3572

1

	.into();

3573

3574

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3575

1

	Relay::execute_with(|| {

3576

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3577

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3578

1

			Box::new(Parachain(1000).into()),

3579

1

			Box::new(

3580

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3581

1

					.clone()

3582

1

					.into()

3583

),

3584

1

			Box::new(([], 200).into()),

3585

0,

3586

1

			WeightLimit::Unlimited

3587

));

3588

1

});

3589

3590

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3591

1

	Statemint::execute_with(|| {

3592

		// Check Alice received 200 tokens on AssetHub

3593

1

		assert_eq!(

3594

1

			StatemintBalances::free_balance(RELAYALICE),

3595

			INITIAL_BALANCE + 200

3596

);

3597

3598

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3599

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3600

1

			sov,

3601

			110000000000000

3602

));

3603

3604

		// Now send those tokens to ParaA

3605

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3606

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3607

1

			assets: Wild(All),

3608

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3609

1

		}]);

3610

1

		assert_ok!(

3611

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3612

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3613

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3614

1

				Box::new((Location::parent(), 200).into()),

3615

1

				Box::new(TransferType::LocalReserve),

3616

1

				Box::new(fees_id),

3617

1

				Box::new(TransferType::LocalReserve),

3618

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3619

1

				WeightLimit::Unlimited

3620

3621

);

3622

1

});

3623

3624

1

	ParaA::execute_with(|| {

3625

		// Alice should have received the DOTs

3626

1

		assert_eq!(

3627

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3628

1

			Ok(U256::from(200))

3629

);

3630

1

});

3631

3632

1

	let dest = Location::new(

3633

1,

3634

1

3635

1

			Parachain(1000),

3636

1

			AccountId32 {

3637

1

				network: None,

3638

1

				id: RELAYBOB.into(),

3639

1

},

3640

1

],

3641

);

3642

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3643

3644

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3645

1

	ParaA::execute_with(|| {

3646

1

		let asset = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

3647

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3648

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3649

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3650

1

			assets: Wild(All),

3651

1

			beneficiary: beneficiary.clone(),

3652

1

		}]);

3653

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3654

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3655

1

			Box::new(VersionedLocation::from(chain_part)),

3656

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

3657

1

			Box::new(TransferType::DestinationReserve),

3658

1

			Box::new(fees_id),

3659

1

			Box::new(TransferType::DestinationReserve),

3660

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3661

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3662

));

3663

3664

1

		assert_eq!(

3665

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3666

1

			Ok(U256::from(90))

3667

);

3668

1

});

3669

3670

1

	Statemint::execute_with(|| {

3671

		// Free execution: check that Bob received the tokens back in AssetHub

3672

1

		assert_eq!(

3673

1

			StatemintBalances::free_balance(RELAYBOB),

3674

			INITIAL_BALANCE + 110

3675

);

3676

1

});

3677

3678

	// Send back tokens from AH to ParaA from Bob's account

3679

1

	Statemint::execute_with(|| {

3680

		// Now send those tokens to ParaA

3681

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3682

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3683

1

			assets: Wild(All),

3684

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3685

1

		}]);

3686

1

		assert_ok!(

3687

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3688

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3689

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3690

1

				Box::new((Location::parent(), 100).into()),

3691

1

				Box::new(TransferType::LocalReserve),

3692

1

				Box::new(fees_id),

3693

1

				Box::new(TransferType::LocalReserve),

3694

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3695

1

				WeightLimit::Unlimited

3696

3697

);

3698

3699

		// 100 DOTs were deducted from Bob's account

3700

1

		assert_eq!(

3701

1

			StatemintBalances::free_balance(RELAYBOB),

3702

			INITIAL_BALANCE + 10

3703

);

3704

1

});

3705

3706

1

	ParaA::execute_with(|| {

3707

		// Alice should have received 100 DOTs

3708

1

		assert_eq!(

3709

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3710

1

			Ok(U256::from(190))

3711

);

3712

1

});

3713

1

3714

3715

#[test]

3716

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3717

1

	MockNet::reset();

3718

3719

	// Relay asset

3720

1

	let relay_location_v3 = xcm::v3::Location::parent();

3721

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3722

1

	let relay_location_v5 = Location::parent();

3723

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3724

3725

1

	let relay_asset_metadata = parachain::AssetMetadata {

3726

1

		name: b"RelayToken".to_vec(),

3727

1

		symbol: b"Relay".to_vec(),

3728

1

		decimals: 12,

3729

1

};

3730

3731

1

	let dest_para = Location::new(1, [Parachain(1)]);

3732

3733

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3734

1

		polkadot_parachain::primitives::Sibling,

3735

1

		statemint_like::AccountId,

3736

1

	>::convert_location(&dest_para)

3737

1

	.unwrap();

3738

3739

1

	ParaA::execute_with(|| {

3740

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3741

1

			source_relay_id,

3742

1

			relay_location_v5.clone(),

3743

1

			relay_asset_metadata.decimals,

3744

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3745

1

			relay_asset_metadata.name.try_into().expect("too long"),

3746

));

3747

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3748

1

});

3749

3750

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3751

1

		network: None,

3752

1

		key: PARAALICE,

3753

1

3754

1

	.into();

3755

3756

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3757

1

		network: None,

3758

1

		id: RELAYALICE.into(),

3759

1

3760

1

	.into();

3761

3762

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3763

1

	Relay::execute_with(|| {

3764

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3765

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3766

1

			Box::new(Parachain(1000).into()),

3767

1

			Box::new(

3768

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3769

1

					.clone()

3770

1

					.into()

3771

),

3772

1

			Box::new(([], 200).into()),

3773

0,

3774

1

			WeightLimit::Unlimited

3775

));

3776

1

});

3777

3778

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3779

1

	Statemint::execute_with(|| {

3780

		// Check Alice received 200 tokens on AssetHub

3781

1

		assert_eq!(

3782

1

			StatemintBalances::free_balance(RELAYALICE),

3783

			INITIAL_BALANCE + 200

3784

);

3785

3786

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3787

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3788

1

			sov,

3789

			110000000000000

3790

));

3791

3792

		// Now send those tokens to ParaA

3793

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3794

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3795

1

			assets: Wild(All),

3796

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3797

1

		}]);

3798

1

		assert_ok!(

3799

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3800

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

3801

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3802

1

				Box::new((Location::parent(), 200).into()),

3803

1

				Box::new(TransferType::LocalReserve),

3804

1

				Box::new(fees_id),

3805

1

				Box::new(TransferType::LocalReserve),

3806

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3807

1

				WeightLimit::Unlimited

3808

3809

);

3810

1

});

3811

3812

1

	ParaA::execute_with(|| {

3813

		// Alice should have received the DOTs

3814

1

		assert_eq!(

3815

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3816

1

			Ok(U256::from(200))

3817

);

3818

1

});

3819

3820

1

	let dest = Location::new(

3821

1,

3822

1

3823

1

			Parachain(1000),

3824

1

			AccountId32 {

3825

1

				network: None,

3826

1

				id: RELAYBOB.into(),

3827

1

},

3828

1

],

3829

);

3830

3831

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

3832

1

	let asset = Asset {

3833

1

		id: AssetId(Location::parent()),

3834

1

		fun: Fungibility::Fungible(100),

3835

1

};

3836

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

3837

1

	ParaA::execute_with(|| {

3838

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3839

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3840

1

			assets: Wild(All),

3841

1

			beneficiary,

3842

1

		}]);

3843

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

3844

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

3845

1

			Box::new(VersionedLocation::from(chain_part)),

3846

1

			Box::new(VersionedAssets::from(asset)),

3847

1

			Box::new(TransferType::DestinationReserve),

3848

1

			Box::new(fees_id),

3849

1

			Box::new(TransferType::DestinationReserve),

3850

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

3851

1

			WeightLimit::Limited(Weight::from_parts(40000u64, DEFAULT_PROOF_SIZE))

3852

));

3853

3854

1

		assert_eq!(

3855

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3856

1

			Ok(U256::from(100))

3857

);

3858

1

});

3859

3860

1

	Statemint::execute_with(|| {

3861

		// Check that Bob received the tokens back in AssetHub

3862

1

		assert_eq!(

3863

1

			StatemintBalances::free_balance(RELAYBOB),

3864

			INITIAL_BALANCE + 100

3865

);

3866

1

});

3867

3868

	// Send back tokens from AH to ParaA from Bob's account

3869

1

	Statemint::execute_with(|| {

3870

		// Now send those tokens to ParaA

3871

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

3872

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

3873

1

			assets: Wild(All),

3874

1

			beneficiary: parachain_beneficiary_absolute.clone(),

3875

1

		}]);

3876

1

		assert_ok!(

3877

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

3878

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

3879

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

3880

1

				Box::new((Location::parent(), 100).into()),

3881

1

				Box::new(TransferType::LocalReserve),

3882

1

				Box::new(fees_id),

3883

1

				Box::new(TransferType::LocalReserve),

3884

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

3885

1

				WeightLimit::Unlimited

3886

3887

);

3888

3889

		// 100 DOTs were deducted from Bob's account

3890

1

		assert_eq!(StatemintBalances::free_balance(RELAYBOB), INITIAL_BALANCE);

3891

1

});

3892

3893

1

	ParaA::execute_with(|| {

3894

		// Alice should have received 100 DOTs

3895

1

		assert_eq!(

3896

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

3897

1

			Ok(U256::from(200))

3898

);

3899

1

});

3900

1

3901

3902

#[test]

3903

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3904

1

	MockNet::reset();

3905

3906

	// Relay asset

3907

1

	let relay_location_v3 = xcm::v3::Location::parent();

3908

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

3909

1

	let relay_location_v5 = Location::parent();

3910

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

3911

3912

1

	let relay_asset_metadata = parachain::AssetMetadata {

3913

1

		name: b"RelayToken".to_vec(),

3914

1

		symbol: b"Relay".to_vec(),

3915

1

		decimals: 12,

3916

1

};

3917

3918

	// Statemint asset

3919

1

	let statemint_asset = Location::new(

3920

1,

3921

1

3922

1

			Parachain(1000u32),

3923

1

			PalletInstance(5u8),

3924

1

			GeneralIndex(10u128),

3925

1

],

3926

);

3927

1

	let statemint_location_asset: AssetType = statemint_asset

3928

1

		.clone()

3929

1

		.try_into()

3930

1

		.expect("Location convertion to AssetType should succeed");

3931

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

3932

3933

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3934

1

		name: b"USDC".to_vec(),

3935

1

		symbol: b"USDC".to_vec(),

3936

1

		decimals: 12,

3937

1

};

3938

3939

1

	let dest_para = Location::new(1, [Parachain(1)]);

3940

3941

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3942

1

		polkadot_parachain::primitives::Sibling,

3943

1

		statemint_like::AccountId,

3944

1

	>::convert_location(&dest_para)

3945

1

	.unwrap();

3946

3947

1

	ParaA::execute_with(|| {

3948

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3949

1

			source_relay_id,

3950

1

			relay_location_v5.clone(),

3951

1

			relay_asset_metadata.decimals,

3952

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

3953

1

			relay_asset_metadata.name.try_into().expect("too long"),

3954

));

3955

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

3956

3957

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3958

1

			source_statemint_asset_id,

3959

1

			statemint_asset.clone(),

3960

1

			asset_metadata_statemint_asset.decimals,

3961

1

			asset_metadata_statemint_asset

3962

1

				.symbol

3963

1

				.try_into()

3964

1

				.expect("too long"),

3965

1

			asset_metadata_statemint_asset

3966

1

				.name

3967

1

				.try_into()

3968

1

				.expect("too long"),

3969

));

3970

1

		XcmWeightTrader::set_asset_price(statemint_asset, 0u128);

3971

1

});

3972

3973

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3974

1

		network: None,

3975

1

		key: PARAALICE,

3976

1

3977

1

	.into();

3978

3979

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3980

1

		network: None,

3981

1

		id: RELAYALICE.into(),

3982

1

3983

1

	.into();

3984

3985

	// First we send relay chain asset to Alice in AssetHub (via teleport)

3986

1

	Relay::execute_with(|| {

3987

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3988

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3989

1

			Box::new(Parachain(1000).into()),

3990

1

			Box::new(

3991

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3992

1

					.clone()

3993

1

					.into()

3994

),

3995

1

			Box::new(([], 200).into()),

3996

0,

3997

1

			WeightLimit::Unlimited

3998

));

3999

1

});

4000

4001

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4002

1

	Statemint::execute_with(|| {

4003

		// Check Alice received 200 tokens on AssetHub

4004

1

		assert_eq!(

4005

1

			StatemintBalances::free_balance(RELAYALICE),

4006

			INITIAL_BALANCE + 200

4007

);

4008

4009

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4010

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4011

1

			sov,

4012

			110000000000000

4013

));

4014

4015

1

		statemint_like::PrefixChanger::set_prefix(

4016

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4017

);

4018

4019

1

		assert_ok!(StatemintAssets::create(

4020

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4021

10,

4022

			RELAYALICE,

4023

4024

));

4025

4026

1

		assert_ok!(StatemintAssets::mint(

4027

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4028

10,

4029

			RELAYALICE,

4030

			300000000000000

4031

));

4032

4033

		// Now send relay tokens to ParaA

4034

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4035

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4036

1

			assets: Wild(All),

4037

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4038

1

		}]);

4039

1

		assert_ok!(

4040

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4041

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4042

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4043

1

				Box::new((Location::parent(), 200).into()),

4044

1

				Box::new(TransferType::LocalReserve),

4045

1

				Box::new(fees_id),

4046

1

				Box::new(TransferType::LocalReserve),

4047

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4048

1

				WeightLimit::Unlimited

4049

4050

);

4051

4052

		// Send USDC

4053

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4054

1

0,

4055

1

4056

1

				xcm::latest::prelude::PalletInstance(

4057

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4058

1

),

4059

1

				GeneralIndex(10),

4060

1

],

4061

1

))

4062

1

		.into();

4063

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4064

1

			assets: Wild(All),

4065

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4066

1

		}]);

4067

1

		assert_ok!(

4068

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4069

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4070

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4071

1

				Box::new(

4072

1

4073

1

4074

1

							xcm::latest::prelude::PalletInstance(

4075

1

								<StatemintAssets as PalletInfoAccess>::index() as u8

4076

1

),

4077

1

							GeneralIndex(10),

4078

1

],

4079

1

4080

1

4081

1

						.into()

4082

),

4083

1

				Box::new(TransferType::LocalReserve),

4084

1

				Box::new(fees_id),

4085

1

				Box::new(TransferType::LocalReserve),

4086

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4087

1

				WeightLimit::Unlimited

4088

4089

);

4090

1

});

4091

4092

1

	ParaA::execute_with(|| {

4093

		// Alice should have received the DOTs

4094

1

		assert_eq!(

4095

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4096

1

			Ok(U256::from(200))

4097

);

4098

4099

		// Alice has received 125 USDC

4100

1

		assert_eq!(

4101

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4102

1

			Ok(U256::from(125))

4103

);

4104

1

});

4105

4106

1

	let dest = Location::new(

4107

1,

4108

1

4109

1

			Parachain(1000),

4110

1

			AccountId32 {

4111

1

				network: None,

4112

1

				id: RELAYBOB.into(),

4113

1

},

4114

1

],

4115

);

4116

4117

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4118

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4119

1

	ParaA::execute_with(|| {

4120

1

		let asset = currency_to_asset(

4121

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

4122

			100,

4123

);

4124

1

		let asset_fee =

4125

1

			currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 100);

4126

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4127

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4128

1

			assets: Wild(All),

4129

1

			beneficiary: beneficiary.clone(),

4130

1

		}]);

4131

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4132

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4133

1

			Box::new(VersionedLocation::from(chain_part)),

4134

1

			Box::new(VersionedAssets::from(vec![asset_fee, asset])),

4135

1

			Box::new(TransferType::DestinationReserve),

4136

1

			Box::new(fees_id),

4137

1

			Box::new(TransferType::DestinationReserve),

4138

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4139

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4140

));

4141

4142

1

		assert_eq!(

4143

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4144

1

			Ok(U256::from(100))

4145

);

4146

1

});

4147

4148

1

	Statemint::execute_with(|| {

4149

		// Check that Bob received relay tokens back in AssetHub

4150

1

		assert_eq!(

4151

1

			StatemintBalances::free_balance(RELAYBOB),

4152

			INITIAL_BALANCE + 100

4153

);

4154

4155

		// Check that BOB received 100 USDC on AssetHub

4156

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4157

1

});

4158

4159

	// Send back tokens from AH to ParaA from Bob's account

4160

1

	Statemint::execute_with(|| {

4161

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4162

4163

		// Now send those tokens to ParaA

4164

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4165

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4166

1

			assets: Wild(All),

4167

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4168

1

		}]);

4169

1

		assert_ok!(

4170

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4171

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4172

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4173

1

				Box::new((Location::parent(), 100).into()),

4174

1

				Box::new(TransferType::LocalReserve),

4175

1

				Box::new(fees_id),

4176

1

				Box::new(TransferType::LocalReserve),

4177

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4178

1

				WeightLimit::Unlimited

4179

4180

);

4181

4182

		// 100 DOTs were deducted from Bob's account

4183

1

		assert_eq!(

4184

1

			StatemintBalances::free_balance(RELAYBOB),

4185

1

			bob_previous_balance - 100

4186

);

4187

1

});

4188

4189

1

	ParaA::execute_with(|| {

4190

		// Alice should have received 100 DOTs

4191

1

		assert_eq!(

4192

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4193

1

			Ok(U256::from(200))

4194

);

4195

1

});

4196

1

4197

4198

#[test]

4199

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

4200

1

	MockNet::reset();

4201

4202

	// Relay asset

4203

1

	let relay_location_v3 = xcm::v3::Location::parent();

4204

1

	let relay_location = parachain::AssetType::Xcm(relay_location_v3.clone());

4205

1

	let relay_location_v5 = Location::parent();

4206

1

	let source_relay_id: parachain::AssetId = relay_location.clone().into();

4207

4208

1

	let relay_asset_metadata = parachain::AssetMetadata {

4209

1

		name: b"RelayToken".to_vec(),

4210

1

		symbol: b"Relay".to_vec(),

4211

1

		decimals: 12,

4212

1

};

4213

4214

	// Statemint asset

4215

1

	let statemint_asset = Location::new(

4216

1,

4217

1

4218

1

			Parachain(1000u32),

4219

1

			PalletInstance(5u8),

4220

1

			GeneralIndex(10u128),

4221

1

],

4222

);

4223

1

	let statemint_location_asset: AssetType = statemint_asset

4224

1

		.clone()

4225

1

		.try_into()

4226

1

		.expect("Location convertion to AssetType should succeed");

4227

1

	let source_statemint_asset_id: parachain::AssetId = statemint_location_asset.clone().into();

4228

4229

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

4230

1

		name: b"USDC".to_vec(),

4231

1

		symbol: b"USDC".to_vec(),

4232

1

		decimals: 12,

4233

1

};

4234

4235

1

	let dest_para = Location::new(1, [Parachain(1)]);

4236

4237

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

4238

1

		polkadot_parachain::primitives::Sibling,

4239

1

		statemint_like::AccountId,

4240

1

	>::convert_location(&dest_para)

4241

1

	.unwrap();

4242

4243

1

	ParaA::execute_with(|| {

4244

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4245

1

			source_relay_id,

4246

1

			relay_location_v5.clone(),

4247

1

			relay_asset_metadata.decimals,

4248

1

			relay_asset_metadata.symbol.try_into().expect("too long"),

4249

1

			relay_asset_metadata.name.try_into().expect("too long"),

4250

));

4251

1

		XcmWeightTrader::set_asset_price(Location::parent(), 0u128);

4252

4253

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

4254

1

			source_statemint_asset_id,

4255

1

			statemint_asset.clone(),

4256

1

			asset_metadata_statemint_asset.decimals,

4257

1

			asset_metadata_statemint_asset

4258

1

				.symbol

4259

1

				.try_into()

4260

1

				.expect("too long"),

4261

1

			asset_metadata_statemint_asset

4262

1

				.name

4263

1

				.try_into()

4264

1

				.expect("too long"),

4265

));

4266

1

		XcmWeightTrader::set_asset_price(statemint_asset.clone(), 0u128);

4267

1

});

4268

4269

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

4270

1

		network: None,

4271

1

		key: PARAALICE,

4272

1

4273

1

	.into();

4274

4275

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

4276

1

		network: None,

4277

1

		id: RELAYALICE.into(),

4278

1

4279

1

	.into();

4280

4281

	// First we send relay chain asset to Alice in AssetHub (via teleport)

4282

1

	Relay::execute_with(|| {

4283

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

4284

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4285

1

			Box::new(Parachain(1000).into()),

4286

1

			Box::new(

4287

1

				VersionedLocation::from(statemint_beneficiary_absolute)

4288

1

					.clone()

4289

1

					.into()

4290

),

4291

1

			Box::new(([], 200).into()),

4292

0,

4293

1

			WeightLimit::Unlimited

4294

));

4295

1

});

4296

4297

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

4298

1

	Statemint::execute_with(|| {

4299

		// Check Alice received 200 tokens on AssetHub

4300

1

		assert_eq!(

4301

1

			StatemintBalances::free_balance(RELAYALICE),

4302

			INITIAL_BALANCE + 200

4303

);

4304

4305

1

		assert_ok!(StatemintBalances::transfer_allow_death(

4306

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4307

1

			sov,

4308

			110000000000000

4309

));

4310

4311

1

		statemint_like::PrefixChanger::set_prefix(

4312

1

			PalletInstance(<StatemintAssets as PalletInfoAccess>::index() as u8).into(),

4313

);

4314

4315

1

		assert_ok!(StatemintAssets::create(

4316

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4317

10,

4318

			RELAYALICE,

4319

4320

));

4321

4322

1

		assert_ok!(StatemintAssets::mint(

4323

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

4324

10,

4325

			RELAYALICE,

4326

			300000000000000

4327

));

4328

4329

		// Now send relay tokens to ParaA

4330

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4331

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4332

1

			assets: Wild(All),

4333

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4334

1

		}]);

4335

1

		assert_ok!(

4336

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4337

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4338

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4339

1

				Box::new((Location::parent(), 200).into()),

4340

1

				Box::new(TransferType::LocalReserve),

4341

1

				Box::new(fees_id),

4342

1

				Box::new(TransferType::LocalReserve),

4343

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4344

1

				WeightLimit::Unlimited

4345

4346

);

4347

4348

		// Send USDC

4349

1

		let fees_id: VersionedAssetId = AssetId(Location::new(

4350

1

0,

4351

1

4352

1

				xcm::latest::prelude::PalletInstance(

4353

1

					<StatemintAssets as PalletInfoAccess>::index() as u8,

4354

1

),

4355

1

				GeneralIndex(10),

4356

1

],

4357

1

))

4358

1

		.into();

4359

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4360

1

			assets: Wild(All),

4361

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4362

1

		}]);

4363

1

		assert_ok!(

4364

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4365

1

				statemint_like::RuntimeOrigin::signed(RELAYALICE),

4366

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4367

1

				Box::new(

4368

1

4369

1

4370

1

							xcm::latest::prelude::PalletInstance(

4371

1

								<StatemintAssets as PalletInfoAccess>::index() as u8

4372

1

),

4373

1

							GeneralIndex(10),

4374

1

],

4375

1

4376

1

4377

1

						.into()

4378

),

4379

1

				Box::new(TransferType::LocalReserve),

4380

1

				Box::new(fees_id),

4381

1

				Box::new(TransferType::LocalReserve),

4382

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4383

1

				WeightLimit::Unlimited

4384

4385

);

4386

1

});

4387

4388

1

	ParaA::execute_with(|| {

4389

		// Alice should have received the DOTs

4390

1

		assert_eq!(

4391

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4392

1

			Ok(U256::from(200))

4393

);

4394

4395

		// Alice has received 125 USDC

4396

1

		assert_eq!(

4397

1

			EvmForeignAssets::balance(source_statemint_asset_id, PARAALICE.into()),

4398

1

			Ok(U256::from(125))

4399

);

4400

1

});

4401

4402

1

	let dest = Location::new(

4403

1,

4404

1

4405

1

			Parachain(1000),

4406

1

			AccountId32 {

4407

1

				network: None,

4408

1

				id: RELAYBOB.into(),

4409

1

},

4410

1

],

4411

);

4412

4413

1

	let statemint_asset_to_send = Asset {

4414

1

		id: AssetId(statemint_asset),

4415

1

		fun: Fungibility::Fungible(100),

4416

1

};

4417

4418

1

	let relay_asset_to_send = Asset {

4419

1

		id: AssetId(Location::parent()),

4420

1

		fun: Fungibility::Fungible(100),

4421

1

};

4422

4423

1

	let (chain_part, beneficiary) = split_location_into_chain_part_and_beneficiary(dest).unwrap();

4424

1

	let assets_to_send: XcmAssets =

4425

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

4426

4427

	// For some reason the order of the assets is inverted when creating the array above.

4428

	// We need to use relay asset for fees, so we pick index 0.

4429

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

4430

4431

	// Finally we test that we are able to send back the DOTs to AssetHub from the ParaA

4432

1

	ParaA::execute_with(|| {

4433

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4434

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4435

1

			assets: Wild(All),

4436

1

			beneficiary,

4437

1

		}]);

4438

1

		assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

4439

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4440

1

			Box::new(VersionedLocation::from(chain_part)),

4441

1

			Box::new(VersionedAssets::from(assets_to_send)),

4442

1

			Box::new(TransferType::DestinationReserve),

4443

1

			Box::new(fees_id),

4444

1

			Box::new(TransferType::DestinationReserve),

4445

1

			Box::new(VersionedXcm::V5(xcm_on_dest)),

4446

1

			WeightLimit::Limited(Weight::from_parts(80_000_000u64, 100_000u64))

4447

));

4448

4449

1

		assert_eq!(

4450

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4451

1

			Ok(U256::from(100))

4452

);

4453

1

});

4454

4455

1

	Statemint::execute_with(|| {

4456

		// Check that Bob received relay tokens back in AssetHub

4457

1

		assert_eq!(

4458

1

			StatemintBalances::free_balance(RELAYBOB),

4459

			INITIAL_BALANCE + 100

4460

);

4461

4462

		// Check that BOB received 100 USDC on AssetHub

4463

1

		assert_eq!(StatemintAssets::account_balances(RELAYBOB), vec![(10, 100)]);

4464

1

});

4465

4466

	// Send back tokens from AH to ParaA from Bob's account

4467

1

	Statemint::execute_with(|| {

4468

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

4469

4470

		// Now send those tokens to ParaA

4471

1

		let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

4472

1

		let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

4473

1

			assets: Wild(All),

4474

1

			beneficiary: parachain_beneficiary_absolute.clone(),

4475

1

		}]);

4476

1

		assert_ok!(

4477

1

			StatemintChainPalletXcm::transfer_assets_using_type_and_then(

4478

1

				statemint_like::RuntimeOrigin::signed(RELAYBOB),

4479

1

				Box::new(Location::new(1, [Parachain(1)]).into()),

4480

1

				Box::new((Location::parent(), 100).into()),

4481

1

				Box::new(TransferType::LocalReserve),

4482

1

				Box::new(fees_id),

4483

1

				Box::new(TransferType::LocalReserve),

4484

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

4485

1

				WeightLimit::Unlimited

4486

4487

);

4488

4489

		// 100 DOTs were deducted from Bob's account

4490

1

		assert_eq!(

4491

1

			StatemintBalances::free_balance(RELAYBOB),

4492

1

			bob_previous_balance - 100

4493

);

4494

1

});

4495

4496

1

	ParaA::execute_with(|| {

4497

		// Alice should have received 100 DOTs

4498

1

		assert_eq!(

4499

1

			EvmForeignAssets::balance(source_relay_id, PARAALICE.into()),

4500

1

			Ok(U256::from(200))

4501

);

4502

1

});

4503

1

4504

4505

#[test]

4506

1

fn transact_through_signed_multilocation() {

4507

1

	MockNet::reset();

4508

1

	let mut ancestry = Location::parent();

4509

4510

1

	ParaA::execute_with(|| {

4511

		// Root can set transact info

4512

1

		assert_ok!(XcmTransactor::set_transact_info(

4513

1

			parachain::RuntimeOrigin::root(),

4514

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4515

			// Relay charges 1000 for every instruction, and we have 3, so 3000

4516

1

			3000.into(),

4517

1

			20000000000.into(),

4518

			// 4 instructions in transact through signed

4519

1

			Some(4000.into())

4520

));

4521

		// Root can set transact info

4522

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4523

1

		set_fee_per_second_for_location(Location::parent(), WEIGHT_REF_TIME_PER_SECOND as u128)

4524

1

			.expect("must succeed");

4525

1

		ancestry = parachain::UniversalLocation::get().into();

4526

1

});

4527

4528

	// Let's construct the Junction that we will append with DescendOrigin

4529

1

	let signed_origin: Junctions = [AccountKey20 {

4530

1

		network: None,

4531

1

		key: PARAALICE,

4532

1

}]

4533

1

	.into();

4534

4535

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4536

1

	descend_origin_multilocation

4537

1

		.append_with(signed_origin)

4538

1

		.unwrap();

4539

4540

	// To convert it to what the relay will see instead of us

4541

1

	descend_origin_multilocation

4542

1

		.reanchor(&Location::parent(), &ancestry.interior)

4543

1

		.unwrap();

4544

4545

1

	let derived = xcm_builder::Account32Hash::<

4546

1

		relay_chain::KusamaNetwork,

4547

1

		relay_chain::AccountId,

4548

1

	>::convert_location(&descend_origin_multilocation)

4549

1

	.unwrap();

4550

4551

1

	Relay::execute_with(|| {

4552

		// free execution, full amount received

4553

1

		assert_ok!(RelayBalances::transfer_allow_death(

4554

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4555

1

			derived.clone(),

4556

			4000004100u128,

4557

));

4558

		// derived account has all funds

4559

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4560

		// sovereign account has 0 funds

4561

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4562

1

});

4563

4564

	// Encode the call. Balances transact to para_a_account

4565

	// First index

4566

1

	let mut encoded: Vec<u8> = Vec::new();

4567

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4568

1

		relay_chain::Balances,

4569

1

>()

4570

1

	.unwrap() as u8;

4571

4572

1

	encoded.push(index);

4573

4574

	// Then call bytes

4575

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4576

1

		// 100 to sovereign

4577

1

		dest: para_a_account(),

4578

1

		value: 100u32.into(),

4579

1

4580

1

	.encode();

4581

1

	encoded.append(&mut call_bytes);

4582

4583

1

	ParaA::execute_with(|| {

4584

1

		assert_ok!(XcmTransactor::transact_through_signed(

4585

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4586

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4587

1

			CurrencyPayment {

4588

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4589

1

					Location::parent()

4590

1

				))),

4591

1

				fee_amount: None

4592

1

},

4593

1

			encoded,

4594

			// 4000000000 for transfer + 4000 for XCM

4595

1

			TransactWeights {

4596

1

				transact_required_weight_at_most: 4000000000.into(),

4597

1

				overall_weight: None

4598

1

},

4599

			false

4600

));

4601

1

});

4602

4603

1

	Relay::execute_with(|| {

4604

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4605

4606

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4607

1

});

4608

1

4609

4610

#[test]

4611

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4612

1

	MockNet::reset();

4613

1

	let mut ancestry = Location::parent();

4614

4615

1

	ParaA::execute_with(|| {

4616

1

		ancestry = parachain::UniversalLocation::get().into();

4617

1

});

4618

4619

	// Let's construct the Junction that we will append with DescendOrigin

4620

1

	let signed_origin: Junctions = [AccountKey20 {

4621

1

		network: None,

4622

1

		key: PARAALICE,

4623

1

}]

4624

1

	.into();

4625

4626

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4627

1

	descend_origin_multilocation

4628

1

		.append_with(signed_origin)

4629

1

		.unwrap();

4630

4631

	// To convert it to what the relay will see instead of us

4632

1

	descend_origin_multilocation

4633

1

		.reanchor(&Location::parent(), &ancestry.interior)

4634

1

		.unwrap();

4635

4636

1

	let derived = xcm_builder::Account32Hash::<

4637

1

		relay_chain::KusamaNetwork,

4638

1

		relay_chain::AccountId,

4639

1

	>::convert_location(&descend_origin_multilocation)

4640

1

	.unwrap();

4641

4642

1

	Relay::execute_with(|| {

4643

		// free execution, full amount received

4644

1

		assert_ok!(RelayBalances::transfer_allow_death(

4645

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4646

1

			derived.clone(),

4647

			4000004100u128,

4648

));

4649

		// derived account has all funds

4650

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4651

		// sovereign account has 0 funds

4652

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4653

1

});

4654

4655

	// Encode the call. Balances transact to para_a_account

4656

	// First index

4657

1

	let mut encoded: Vec<u8> = Vec::new();

4658

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4659

1

		relay_chain::Balances,

4660

1

>()

4661

1

	.unwrap() as u8;

4662

4663

1

	encoded.push(index);

4664

4665

	// Then call bytes

4666

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4667

1

		// 100 to sovereign

4668

1

		dest: para_a_account(),

4669

1

		value: 100u32.into(),

4670

1

4671

1

	.encode();

4672

1

	encoded.append(&mut call_bytes);

4673

4674

1

	let total_weight = 4000004000u64;

4675

1

	ParaA::execute_with(|| {

4676

1

		assert_ok!(XcmTransactor::transact_through_signed(

4677

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4678

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4679

1

			CurrencyPayment {

4680

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4681

1

					Location::parent()

4682

1

				))),

4683

1

				fee_amount: Some(total_weight as u128)

4684

1

},

4685

1

			encoded,

4686

			// 4000000000 for transfer + 4000 for XCM

4687

1

			TransactWeights {

4688

1

				transact_required_weight_at_most: 4000000000.into(),

4689

1

				overall_weight: Some(Limited(total_weight.into()))

4690

1

},

4691

			false

4692

));

4693

1

});

4694

4695

1

	Relay::execute_with(|| {

4696

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 100);

4697

4698

1

		assert!(RelayBalances::free_balance(&derived) == 0);

4699

1

});

4700

1

4701

4702

#[test]

4703

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4704

1

	MockNet::reset();

4705

1

	let mut ancestry = Location::parent();

4706

4707

1

	ParaA::execute_with(|| {

4708

1

		ancestry = parachain::UniversalLocation::get().into();

4709

1

});

4710

4711

	// Let's construct the Junction that we will append with DescendOrigin

4712

1

	let signed_origin: Junctions = [AccountKey20 {

4713

1

		network: None,

4714

1

		key: PARAALICE,

4715

1

}]

4716

1

	.into();

4717

4718

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4719

1

	descend_origin_multilocation

4720

1

		.append_with(signed_origin)

4721

1

		.unwrap();

4722

4723

	// To convert it to what the relay will see instead of us

4724

1

	descend_origin_multilocation

4725

1

		.reanchor(&Location::parent(), &ancestry.interior)

4726

1

		.unwrap();

4727

4728

1

	let derived = xcm_builder::Account32Hash::<

4729

1

		relay_chain::KusamaNetwork,

4730

1

		relay_chain::AccountId,

4731

1

	>::convert_location(&descend_origin_multilocation)

4732

1

	.unwrap();

4733

4734

1

	Relay::execute_with(|| {

4735

		// free execution, full amount received

4736

1

		assert_ok!(RelayBalances::transfer_allow_death(

4737

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4738

1

			derived.clone(),

4739

			4000009100u128,

4740

));

4741

		// derived account has all funds

4742

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4743

		// sovereign account has 0 funds

4744

1

		assert!(RelayBalances::free_balance(&para_a_account()) == 0);

4745

1

});

4746

4747

	// Encode the call. Balances transact to para_a_account

4748

	// First index

4749

1

	let mut encoded: Vec<u8> = Vec::new();

4750

1

	let index = <relay_chain::Runtime as frame_system::Config>::PalletInfo::index::<

4751

1

		relay_chain::Balances,

4752

1

>()

4753

1

	.unwrap() as u8;

4754

4755

1

	encoded.push(index);

4756

4757

	// Then call bytes

4758

1

	let mut call_bytes = pallet_balances::Call::<relay_chain::Runtime>::transfer_allow_death {

4759

1

		// 100 to sovereign

4760

1

		dest: para_a_account(),

4761

1

		value: 100u32.into(),

4762

1

4763

1

	.encode();

4764

1

	encoded.append(&mut call_bytes);

4765

4766

1

	let total_weight = 4000009000u64;

4767

1

	ParaA::execute_with(|| {

4768

1

		assert_ok!(XcmTransactor::transact_through_signed(

4769

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4770

1

			Box::new(xcm::VersionedLocation::from(Location::parent())),

4771

1

			CurrencyPayment {

4772

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4773

1

					Location::parent()

4774

1

				))),

4775

1

				fee_amount: Some(total_weight as u128)

4776

1

},

4777

1

			encoded,

4778

			// 4000000000 for transfer + 9000 for XCM

4779

1

			TransactWeights {

4780

1

				transact_required_weight_at_most: 4000000000.into(),

4781

1

				overall_weight: Some(Limited(total_weight.into()))

4782

1

},

4783

			true

4784

));

4785

1

});

4786

4787

1

	Relay::execute_with(|| {

4788

		// 100 transferred

4789

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4790

4791

		// 4000009000 refunded

4792

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4793

1

});

4794

1

4795

4796

#[test]

4797

1

fn transact_through_signed_multilocation_para_to_para() {

4798

1

	frame_support::__private::sp_tracing::init_for_tests();

4799

1

	MockNet::reset();

4800

1

	let mut ancestry = Location::parent();

4801

4802

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4803

4804

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4805

4806

1

	ParaA::execute_with(|| {

4807

		// Root can set transact info

4808

1

		assert_ok!(XcmTransactor::set_transact_info(

4809

1

			parachain::RuntimeOrigin::root(),

4810

			// ParaB

4811

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4812

			// Para charges 1000 for every instruction, and we have 3, so 3

4813

1

			3.into(),

4814

1

			20000000000.into(),

4815

			// 4 instructions in transact through signed

4816

1

			Some(4.into())

4817

));

4818

		// Root can set transact info

4819

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4820

1

		set_fee_per_second_for_location(

4821

1

			para_b_balances.clone(),

4822

1

			parachain::ParaTokensPerSecond::get(),

4823

4824

1

		.expect("must succeed");

4825

1

		ancestry = parachain::UniversalLocation::get().into();

4826

1

});

4827

4828

	// Let's construct the Junction that we will append with DescendOrigin

4829

1

	let signed_origin: Junctions = [AccountKey20 {

4830

1

		network: None,

4831

1

		key: PARAALICE,

4832

1

}]

4833

1

	.into();

4834

4835

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4836

1

	descend_origin_multilocation

4837

1

		.append_with(signed_origin)

4838

1

		.unwrap();

4839

4840

	// To convert it to what the paraB will see instead of us

4841

1

	descend_origin_multilocation

4842

1

		.reanchor(&para_b_location, &ancestry.interior)

4843

1

		.unwrap();

4844

4845

1

	let derived = xcm_builder::HashedDescription::<

4846

1

		parachain::AccountId,

4847

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4848

1

	>::convert_location(&descend_origin_multilocation)

4849

1

	.unwrap();

4850

4851

1

	ParaB::execute_with(|| {

4852

		// free execution, full amount received

4853

1

		assert_ok!(ParaBalances::transfer_allow_death(

4854

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4855

1

			derived.clone(),

4856

			4000000104u128,

4857

));

4858

		// derived account has all funds

4859

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4860

		// sovereign account has 0 funds

4861

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4862

1

});

4863

4864

	// Encode the call. Balances transact to para_a_account

4865

	// First index

4866

1

	let mut encoded: Vec<u8> = Vec::new();

4867

1

	let index =

4868

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4869

1

			.unwrap() as u8;

4870

4871

1

	encoded.push(index);

4872

4873

	// Then call bytes

4874

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4875

1

		// 100 to sovereign

4876

1

		dest: para_a_account_20(),

4877

1

		value: 100u32.into(),

4878

1

4879

1

	.encode();

4880

1

	encoded.append(&mut call_bytes);

4881

4882

1

	ParaA::execute_with(|| {

4883

1

		assert_ok!(XcmTransactor::transact_through_signed(

4884

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4885

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4886

1

			CurrencyPayment {

4887

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4888

1

					para_b_balances

4889

1

				))),

4890

1

				fee_amount: None

4891

1

},

4892

1

			encoded,

4893

			// 4000000000 for transfer + 4000 for XCM

4894

			// 1-1 to fee

4895

1

			TransactWeights {

4896

1

				transact_required_weight_at_most: 4000000000.into(),

4897

1

				overall_weight: None

4898

1

},

4899

			false

4900

));

4901

1

});

4902

4903

1

	ParaB::execute_with(|| {

4904

1

		assert_eq!(ParaBalances::free_balance(&derived), 0);

4905

4906

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4907

1

});

4908

1

4909

4910

#[test]

4911

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4912

1

	MockNet::reset();

4913

1

	let mut ancestry = Location::parent();

4914

4915

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4916

4917

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4918

4919

1

	ParaA::execute_with(|| {

4920

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

4921

1

		set_fee_per_second_for_location(

4922

1

			para_b_balances.clone(),

4923

1

			parachain::ParaTokensPerSecond::get(),

4924

4925

1

		.expect("must succeed");

4926

1

		ancestry = parachain::UniversalLocation::get().into();

4927

1

});

4928

4929

	// Let's construct the Junction that we will append with DescendOrigin

4930

1

	let signed_origin: Junctions = [AccountKey20 {

4931

1

		network: None,

4932

1

		key: PARAALICE,

4933

1

}]

4934

1

	.into();

4935

4936

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4937

1

	descend_origin_multilocation

4938

1

		.append_with(signed_origin)

4939

1

		.unwrap();

4940

4941

	// To convert it to what the paraB will see instead of us

4942

1

	descend_origin_multilocation

4943

1

		.reanchor(&para_b_location, &ancestry.interior)

4944

1

		.unwrap();

4945

4946

1

	let derived = xcm_builder::HashedDescription::<

4947

1

		parachain::AccountId,

4948

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4949

1

	>::convert_location(&descend_origin_multilocation)

4950

1

	.unwrap();

4951

4952

1

	ParaB::execute_with(|| {

4953

		// free execution, full amount received

4954

1

		assert_ok!(ParaBalances::transfer_allow_death(

4955

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4956

1

			derived.clone(),

4957

			4000009100u128,

4958

));

4959

		// derived account has all funds

4960

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4961

		// sovereign account has 0 funds

4962

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4963

1

});

4964

4965

	// Encode the call. Balances transact to para_a_account

4966

	// First index

4967

1

	let mut encoded: Vec<u8> = Vec::new();

4968

1

	let index =

4969

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4970

1

			.unwrap() as u8;

4971

4972

1

	encoded.push(index);

4973

4974

	// Then call bytes

4975

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4976

1

		// 100 to sovereign

4977

1

		dest: para_a_account_20(),

4978

1

		value: 100u32.into(),

4979

1

4980

1

	.encode();

4981

1

	encoded.append(&mut call_bytes);

4982

4983

1

	let overall_weight = 4000009000u64;

4984

1

	ParaA::execute_with(|| {

4985

1

		assert_ok!(XcmTransactor::transact_through_signed(

4986

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4987

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4988

1

			CurrencyPayment {

4989

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4990

1

					para_b_balances

4991

1

				))),

4992

1

				fee_amount: Some(overall_weight as u128)

4993

1

},

4994

1

			encoded,

4995

			// 4000000000 for transfer + 9000 for XCM

4996

1

			TransactWeights {

4997

1

				transact_required_weight_at_most: 4000000000.into(),

4998

1

				overall_weight: Some(Limited(overall_weight.into()))

4999

1

},

5000

			true

5001

));

5002

1

});

5003

5004

1

	ParaB::execute_with(|| {

5005

		// Check the derived account was refunded

5006

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

5007

5008

		// Check the transfer was executed

5009

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

5010

1

});

5011

1

5012

5013

#[test]

5014

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

5015

1

	MockNet::reset();

5016

1

	let mut ancestry = Location::parent();

5017

5018

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5019

5020

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5021

5022

1

	ParaA::execute_with(|| {

5023

		// Root can set transact info

5024

1

		assert_ok!(XcmTransactor::set_transact_info(

5025

1

			parachain::RuntimeOrigin::root(),

5026

			// ParaB

5027

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5028

			// Para charges 1000 for every instruction, and we have 3, so 3

5029

1

			3.into(),

5030

1

			20000000000.into(),

5031

			// 4 instructions in transact through signed

5032

1

			Some(4.into())

5033

));

5034

		// Root can set transact info

5035

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5036

1

		set_fee_per_second_for_location(

5037

1

			para_b_balances.clone(),

5038

1

			parachain::ParaTokensPerSecond::get(),

5039

5040

1

		.expect("must succeed");

5041

1

		ancestry = parachain::UniversalLocation::get().into();

5042

1

});

5043

5044

	// Let's construct the Junction that we will append with DescendOrigin

5045

1

	let signed_origin: Junctions = [AccountKey20 {

5046

1

		network: None,

5047

1

		key: PARAALICE,

5048

1

}]

5049

1

	.into();

5050

5051

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5052

1

	descend_origin_multilocation

5053

1

		.append_with(signed_origin)

5054

1

		.unwrap();

5055

5056

	// To convert it to what the paraB will see instead of us

5057

1

	descend_origin_multilocation

5058

1

		.reanchor(&para_b_location, &ancestry.interior)

5059

1

		.unwrap();

5060

5061

1

	let derived = xcm_builder::HashedDescription::<

5062

1

		parachain::AccountId,

5063

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5064

1

	>::convert_location(&descend_origin_multilocation)

5065

1

	.unwrap();

5066

5067

1

	let mut parachain_b_alice_balances_before = 0;

5068

1

	ParaB::execute_with(|| {

5069

1

		assert_ok!(ParaBalances::transfer_allow_death(

5070

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5071

1

			derived.clone(),

5072

			4000000104u128,

5073

));

5074

		// derived account has all funds

5075

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5076

		// sovereign account has 0 funds

5077

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5078

5079

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5080

1

});

5081

5082

	// Encode the call. Balances transact to para_a_account

5083

	// First index

5084

1

	let mut encoded: Vec<u8> = Vec::new();

5085

1

	let index =

5086

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5087

1

			.unwrap() as u8;

5088

5089

1

	encoded.push(index);

5090

5091

	use sp_core::U256;

5092

	// Let's do a EVM transfer

5093

1

	let eth_tx =

5094

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5095

1

			gas_limit: U256::from(21000),

5096

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5097

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5098

1

			value: U256::from(100),

5099

1

			input: BoundedVec::<

5100

1

u8,

5101

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5102

1

			>::try_from(vec![]).unwrap(),

5103

1

			access_list: None,

5104

1

});

5105

5106

	// Then call bytes

5107

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

5108

1

		xcm_transaction: eth_tx,

5109

1

5110

1

	.encode();

5111

1

	encoded.append(&mut call_bytes);

5112

5113

1

	ParaA::execute_with(|| {

5114

1

		assert_ok!(XcmTransactor::transact_through_signed(

5115

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5116

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5117

1

			CurrencyPayment {

5118

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5119

1

					para_b_balances

5120

1

				))),

5121

1

				fee_amount: None

5122

1

},

5123

1

			encoded,

5124

			// 4000000000 for transfer + 4000 for XCM

5125

			// 1-1 to fee

5126

1

			TransactWeights {

5127

1

				transact_required_weight_at_most: 4000000000.into(),

5128

1

				overall_weight: None

5129

1

},

5130

			false

5131

));

5132

1

});

5133

5134

1

	ParaB::execute_with(|| {

5135

		// Make sure the EVM transfer went through

5136

1

		assert!(

5137

1

			ParaBalances::free_balance(&PARAALICE.into())

5138

1

				== parachain_b_alice_balances_before + 100

5139

);

5140

1

});

5141

1

5142

5143

#[test]

5144

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

5145

1

	MockNet::reset();

5146

1

	let mut ancestry = Location::parent();

5147

5148

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5149

5150

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5151

5152

1

	ParaA::execute_with(|| {

5153

		// Root can set transact info

5154

1

		assert_ok!(XcmTransactor::set_transact_info(

5155

1

			parachain::RuntimeOrigin::root(),

5156

			// ParaB

5157

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5158

			// Para charges 1000 for every instruction, and we have 3, so 3

5159

1

			3.into(),

5160

1

			20000000000.into(),

5161

			// 4 instructions in transact through signed

5162

1

			Some(4.into())

5163

));

5164

		// Root can set transact info

5165

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5166

1

		set_fee_per_second_for_location(

5167

1

			para_b_balances.clone(),

5168

1

			parachain::ParaTokensPerSecond::get(),

5169

5170

1

		.expect("must succeed");

5171

1

		ancestry = parachain::UniversalLocation::get().into();

5172

1

});

5173

5174

	// Let's construct the Junction that we will append with DescendOrigin

5175

1

	let signed_origin: Junctions = [AccountKey20 {

5176

1

		network: None,

5177

1

		key: PARAALICE,

5178

1

}]

5179

1

	.into();

5180

5181

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5182

1

	descend_origin_multilocation

5183

1

		.append_with(signed_origin)

5184

1

		.unwrap();

5185

5186

	// To convert it to what the paraB will see instead of us

5187

1

	descend_origin_multilocation

5188

1

		.reanchor(&para_b_location, &ancestry.interior)

5189

1

		.unwrap();

5190

5191

1

	let derived = xcm_builder::HashedDescription::<

5192

1

		parachain::AccountId,

5193

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5194

1

	>::convert_location(&descend_origin_multilocation)

5195

1

	.unwrap();

5196

5197

1

	let mut parachain_b_alice_balances_before = 0;

5198

1

	ParaB::execute_with(|| {

5199

1

		assert_ok!(ParaBalances::transfer_allow_death(

5200

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5201

1

			derived.clone(),

5202

			4000000104u128,

5203

));

5204

		// derived account has all funds

5205

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5206

		// sovereign account has 0 funds

5207

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5208

5209

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

5210

1

});

5211

5212

	// Encode the call. Balances transact to para_a_account

5213

	// First index

5214

1

	let mut encoded: Vec<u8> = Vec::new();

5215

1

	let index =

5216

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5217

1

			.unwrap() as u8;

5218

5219

1

	encoded.push(index);

5220

5221

	use sp_core::U256;

5222

	// Let's do a EVM transfer

5223

1

	let eth_tx =

5224

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

5225

1

			gas_limit: U256::from(21000),

5226

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

5227

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

5228

1

			value: U256::from(100),

5229

1

			input: BoundedVec::<

5230

1

u8,

5231

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5232

1

			>::try_from(vec![]).unwrap(),

5233

1

			access_list: None,

5234

1

});

5235

5236

	// Then call bytes

5237

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5238

1

		transact_as: PARAALICE.into(),

5239

1

		xcm_transaction: eth_tx,

5240

1

5241

1

	.encode();

5242

1

	encoded.append(&mut call_bytes);

5243

5244

1

	ParaA::execute_with(|| {

5245

1

		assert_ok!(XcmTransactor::transact_through_signed(

5246

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5247

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5248

1

			CurrencyPayment {

5249

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5250

1

					para_b_balances

5251

1

				))),

5252

1

				fee_amount: None

5253

1

},

5254

1

			encoded,

5255

1

			TransactWeights {

5256

1

				transact_required_weight_at_most: 4000000000.into(),

5257

1

				overall_weight: None

5258

1

},

5259

			false

5260

));

5261

1

});

5262

5263

1

	ParaB::execute_with(|| {

5264

		// Make sure the EVM transfer wasn't executed

5265

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

5266

1

});

5267

1

5268

5269

#[test]

5270

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

5271

1

	MockNet::reset();

5272

1

	let mut ancestry = Location::parent();

5273

5274

1

	let para_b_location = Location::new(1, [Parachain(2)]);

5275

5276

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

5277

5278

1

	ParaA::execute_with(|| {

5279

		// Root can set transact info

5280

1

		assert_ok!(XcmTransactor::set_transact_info(

5281

1

			parachain::RuntimeOrigin::root(),

5282

			// ParaB

5283

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

5284

			// Para charges 1000 for every instruction, and we have 3, so 3

5285

1

			3.into(),

5286

1

			20000000000.into(),

5287

			// 4 instructions in transact through signed

5288

1

			Some(4.into())

5289

));

5290

		// Root can set transact info

5291

		// Set fee per second using weight-trader (replaces old set_fee_per_second)

5292

1

		set_fee_per_second_for_location(

5293

1

			para_b_balances.clone(),

5294

1

			parachain::ParaTokensPerSecond::get(),

5295

5296

1

		.expect("must succeed");

5297

1

		ancestry = parachain::UniversalLocation::get().into();

5298

1

});

5299

5300

	// Let's construct the Junction that we will append with DescendOrigin

5301

1

	let signed_origin: Junctions = [AccountKey20 {

5302

1

		network: None,

5303

1

		key: PARAALICE,

5304

1

}]

5305

1

	.into();

5306

5307

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

5308

1

	descend_origin_multilocation

5309

1

		.append_with(signed_origin)

5310

1

		.unwrap();

5311

5312

	// To convert it to what the paraB will see instead of us

5313

1

	descend_origin_multilocation

5314

1

		.reanchor(&para_b_location, &ancestry.interior)

5315

1

		.unwrap();

5316

5317

1

	let derived = xcm_builder::HashedDescription::<

5318

1

		parachain::AccountId,

5319

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

5320

1

	>::convert_location(&descend_origin_multilocation)

5321

1

	.unwrap();

5322

5323

1

	let transfer_recipient = evm_account();

5324

1

	let mut transfer_recipient_balance_before = 0;

5325

1

	ParaB::execute_with(|| {

5326

1

		assert_ok!(ParaBalances::transfer_allow_death(

5327

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5328

1

			derived.clone(),

5329

			4000000104u128,

5330

));

5331

		// derived account has all funds

5332

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

5333

		// sovereign account has 0 funds

5334

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

5335

5336

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

5337

5338

		// Add proxy ALICE  -> derived

5339

1

		let _ = parachain::Proxy::add_proxy_delegate(

5340

1

			&PARAALICE.into(),

5341

1

			derived,

5342

1

			parachain::ProxyType::Any,

5343

1

0,

5344

1

);

5345

1

});

5346

5347

	// Encode the call. Balances transact to para_a_account

5348

	// First index

5349

1

	let mut encoded: Vec<u8> = Vec::new();

5350

1

	let index =

5351

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

5352

1

			.unwrap() as u8;

5353

5354

1

	encoded.push(index);

5355

5356

	use sp_core::U256;

5357

	// Let's do a EVM transfer

5358

1

	let eth_tx =

5359

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

5360

1

			gas_limit: U256::from(21000),

5361

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

5362

1

			value: U256::from(100),

5363

1

			input: BoundedVec::<

5364

1

u8,

5365

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

5366

1

			>::try_from(vec![]).unwrap(),

5367

1

			access_list: None,

5368

1

});

5369

5370

	// Then call bytes

5371

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

5372

1

		transact_as: PARAALICE.into(),

5373

1

		xcm_transaction: eth_tx,

5374

1

5375

1

	.encode();

5376

1

	encoded.append(&mut call_bytes);

5377

5378

1

	ParaA::execute_with(|| {

5379

1

		assert_ok!(XcmTransactor::transact_through_signed(

5380

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

5381

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

5382

1

			CurrencyPayment {

5383

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5384

1

					para_b_balances

5385

1

				))),

5386

1

				fee_amount: None

5387

1

},

5388

1

			encoded,

5389

1

			TransactWeights {

5390

1

				transact_required_weight_at_most: 4000000000.into(),

5391

1

				overall_weight: None

5392

1

},

5393

			false

5394

));

5395

1

});

5396

5397

1

	ParaB::execute_with(|| {

5398

		// Make sure the EVM transfer was executed

5399

1

		assert!(

5400

1

			ParaBalances::free_balance(&transfer_recipient.into())

5401

1

				== transfer_recipient_balance_before + 100

5402

);

5403

1

});

5404

1

5405

5406

#[test]

5407

1

fn hrmp_init_accept_through_root() {

5408

1

	MockNet::reset();

5409

5410

1

	Relay::execute_with(|| {

5411

1

		assert_ok!(RelayBalances::transfer_allow_death(

5412

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5413

1

			para_a_account(),

5414

			1000u128

5415

));

5416

1

		assert_ok!(RelayBalances::transfer_allow_death(

5417

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5418

1

			para_b_account(),

5419

			1000u128

5420

));

5421

1

});

5422

5423

1

	ParaA::execute_with(|| {

5424

1

		let total_fee = 1_000u128;

5425

1

		let total_weight: u64 = 1_000_000_000;

5426

1

		let tx_weight: u64 = 500_000_000;

5427

		// Root can send hrmp init channel

5428

1

		assert_ok!(XcmTransactor::hrmp_manage(

5429

1

			parachain::RuntimeOrigin::root(),

5430

1

			HrmpOperation::InitOpen(HrmpInitParams {

5431

1

				para_id: 2u32.into(),

5432

1

				proposed_max_capacity: 1,

5433

1

				proposed_max_message_size: 1

5434

1

}),

5435

1

			CurrencyPayment {

5436

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5437

1

					Location::parent()

5438

1

				))),

5439

1

				fee_amount: Some(total_fee)

5440

1

},

5441

1

			TransactWeights {

5442

1

				transact_required_weight_at_most: tx_weight.into(),

5443

1

				overall_weight: Some(Limited(total_weight.into()))

5444

1

5445

));

5446

1

});

5447

1

	Relay::execute_with(|| {

5448

1

		let expected_event: relay_chain::RuntimeEvent =

5449

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

5450

1

				sender: 1u32.into(),

5451

1

				recipient: 2u32.into(),

5452

1

				proposed_max_capacity: 1u32,

5453

1

				proposed_max_message_size: 1u32,

5454

1

5455

1

			.into();

5456

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5457

1

});

5458

1

	ParaB::execute_with(|| {

5459

1

		let total_fee = 1_000u128;

5460

1

		let total_weight: u64 = 1_000_000_000;

5461

1

		let tx_weight: u64 = 500_000_000;

5462

		// Root can send hrmp accept channel

5463

1

		assert_ok!(XcmTransactor::hrmp_manage(

5464

1

			parachain::RuntimeOrigin::root(),

5465

1

			HrmpOperation::Accept {

5466

1

				para_id: 1u32.into()

5467

1

},

5468

1

			CurrencyPayment {

5469

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5470

1

					Location::parent()

5471

1

				))),

5472

1

				fee_amount: Some(total_fee)

5473

1

},

5474

1

			TransactWeights {

5475

1

				transact_required_weight_at_most: tx_weight.into(),

5476

1

				overall_weight: Some(Limited(total_weight.into()))

5477

1

5478

));

5479

1

});

5480

5481

1

	Relay::execute_with(|| {

5482

1

		let expected_event: relay_chain::RuntimeEvent =

5483

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

5484

1

				sender: 1u32.into(),

5485

1

				recipient: 2u32.into(),

5486

1

5487

1

			.into();

5488

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5489

1

});

5490

1

5491

5492

#[test]

5493

1

fn hrmp_close_works() {

5494

1

	MockNet::reset();

5495

5496

1

	Relay::execute_with(|| {

5497

1

		assert_ok!(RelayBalances::transfer_allow_death(

5498

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

5499

1

			para_a_account(),

5500

			1000u128

5501

));

5502

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

5503

1

			relay_chain::RuntimeOrigin::root(),

5504

1

			1u32.into(),

5505

1

			2u32.into(),

5506

			1u32,

5507

			1u32

5508

));

5509

1

		assert_ok!(Hrmp::force_process_hrmp_open(

5510

1

			relay_chain::RuntimeOrigin::root(),

5511

			1u32

5512

));

5513

1

});

5514

5515

1

	ParaA::execute_with(|| {

5516

1

		let total_fee = 1_000u128;

5517

1

		let total_weight: u64 = 1_000_000_000;

5518

1

		let tx_weight: u64 = 500_000_000;

5519

1

		assert_ok!(XcmTransactor::hrmp_manage(

5520

1

			parachain::RuntimeOrigin::root(),

5521

1

			HrmpOperation::Close(HrmpChannelId {

5522

1

				sender: 1u32.into(),

5523

1

				recipient: 2u32.into()

5524

1

}),

5525

1

			CurrencyPayment {

5526

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

5527

1

					Location::parent()

5528

1

				))),

5529

1

				fee_amount: Some(total_fee)

5530

1

},

5531

1

			TransactWeights {

5532

1

				transact_required_weight_at_most: tx_weight.into(),

5533

1

				overall_weight: Some(Limited(total_weight.into()))

5534

1

5535

));

5536

1

});

5537

1

	Relay::execute_with(|| {

5538

1

		let expected_event: relay_chain::RuntimeEvent =

5539

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

5540

1

				by_parachain: 1u32.into(),

5541

1

				channel_id: HrmpChannelId {

5542

1

					sender: 1u32.into(),

5543

1

					recipient: 2u32.into(),

5544

1

},

5545

1

5546

1

			.into();

5547

1

		assert!(relay_chain::relay_events().contains(&expected_event));

5548

1

});

5549

1

5550

5551

use crate::xcm_mock::parachain::{EvmForeignAssets, MockTransactors, Treasury, XcmWeightTrader};

5552

use parity_scale_codec::{Decode, Encode};

5553

use sp_core::U256;

5554

use sp_io::hashing::blake2_256;

5555

5556

// Helper to derive accountIds

5557

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

5558

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

5559

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

5560

7