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

//! Moonbeam Runtime Xcm Tests

18

19

mod xcm_mock;

20

21

use cumulus_primitives_core::relay_chain::HrmpChannelId;

22

use frame_support::{

23

	assert_ok,

24

	traits::{PalletInfo, PalletInfoAccess},

25

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

26

	BoundedVec,

27

};

28

use moonbeam_runtime::xcm_config::AssetType;

29

use pallet_xcm_transactor::{

30

	Currency, CurrencyPayment, HrmpInitParams, HrmpOperation, TransactWeights,

31

};

32

use sp_core::ConstU32;

33

use sp_core::U256;

34

use sp_runtime::traits::Convert;

35

use xcm::{

36

	latest::{

37

		prelude::{

38

			AccountId32, AccountKey20, Fungible, GeneralIndex, Junction, Junctions, Limited,

39

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

40

			WeightLimit, Xcm,

41

},

42

		Asset, AssetId, Assets as XcmAssets, Fungibility,

43

},

44

	IntoVersion, VersionedAssets, VersionedLocation, WrapVersion,

45

};

46

use xcm_executor::traits::ConvertLocation;

47

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

48

use xcm_mock::relay_chain;

49

use xcm_mock::*;

50

use xcm_primitives::{

51

	split_location_into_chain_part_and_beneficiary, UtilityEncodeCall, DEFAULT_PROOF_SIZE,

52

};

53

use xcm_simulator::TestExt;

54

55

26

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

56

26

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

57

26

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

58

26

		.into_version(xcm::latest::VERSION)

59

26

		.map_err(|_| ())?

60

	else {

61

		return Err(());

62

};

63

	use frame_support::weights::WeightToFee as _;

64

26

	let native_amount_per_second: u128 =

65

26

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

66

26

			&Weight::from_parts(

67

26

				frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,

68

26

0,

69

26

),

70

26

71

26

		.try_into()

72

26

		.map_err(|_| ())?;

73

26

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

74

26

	let relative_price: u128 = if units_per_second > 0u128 {

75

10

		native_amount_per_second

76

10

			.saturating_mul(precision_factor)

77

10

			.saturating_div(units_per_second)

78

	} else {

79

16

		0u128

80

};

81

26

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

82

26

		location_v5,

83

26

		(true, relative_price),

84

26

);

85

26

	Ok(())

86

26

87

88

23

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

89

23

	Asset {

90

23

		id: AssetId(

91

23

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

92

23

				currency_id,

93

23

94

23

			.unwrap(),

95

23

),

96

23

		fun: Fungibility::Fungible(amount),

97

23

98

23

99

100

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

101

#[test]

102

1

fn receive_relay_asset_from_relay() {

103

1

	MockNet::reset();

104

1

105

1

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

106

1

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

107

1

	let asset_metadata = parachain::AssetMetadata {

108

1

		name: b"RelayToken".to_vec(),

109

1

		symbol: b"Relay".to_vec(),

110

1

		decimals: 12,

111

1

};

112

1

113

1

	// Register relay asset in paraA

114

1

	ParaA::execute_with(|| {

115

1

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

116

1

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

117

1

			.try_into()

118

1

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

119

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

120

1

			source_id,

121

1

			source_location_latest,

122

1

			asset_metadata.decimals,

123

1

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

124

1

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

125

1

));

126

1

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

127

1

});

128

1

129

1

	// Actually send relay asset to parachain

130

1

	let dest: Location = AccountKey20 {

131

1

		network: None,

132

1

		key: PARAALICE,

133

1

134

1

	.into();

135

1

136

1

	// First send relay chain asset to Parachain

137

1

	Relay::execute_with(|| {

138

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

139

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

140

1

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

141

1

			Box::new(VersionedLocation::from(dest).clone()),

142

1

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

143

1

0,

144

1

			WeightLimit::Unlimited

145

1

));

146

1

});

147

1

148

1

	// Verify that parachain received the asset

149

1

	ParaA::execute_with(|| {

150

1

		// free execution, full amount received

151

1

		assert_eq!(

152

1

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

153

1

			Ok(U256::from(123))

154

1

);

155

1

});

156

1

157

158

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

159

#[test]

160

1

fn send_relay_asset_to_relay() {

161

1

	MockNet::reset();

162

1

163

1

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

164

1

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

165

1

166

1

	let asset_metadata = parachain::AssetMetadata {

167

1

		name: b"RelayToken".to_vec(),

168

1

		symbol: b"Relay".to_vec(),

169

1

		decimals: 12,

170

1

};

171

1

172

1

	// Register relay asset in paraA

173

1

	ParaA::execute_with(|| {

174

1

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

175

1

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

176

1

			.try_into()

177

1

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

178

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

179

1

			source_id,

180

1

			source_location_latest,

181

1

			asset_metadata.decimals,

182

1

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

183

1

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

184

1

));

185

		// Free execution

186

1

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

187

1

});

188

1

189

1

	let dest: Location = Junction::AccountKey20 {

190

1

		network: None,

191

1

		key: PARAALICE,

192

1

193

1

	.into();

194

1

195

1

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

196

1

	Relay::execute_with(|| {

197

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

198

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

199

1

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

200

1

			Box::new(VersionedLocation::from(dest).clone()),

201

1

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

202

1

0,

203

1

			WeightLimit::Unlimited

204

1

));

205

1

});

206

1

207

1

	ParaA::execute_with(|| {

208

1

		// Free execution, full amount received

209

1

		assert_eq!(

210

1

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

211

1

			Ok(U256::from(123))

212

1

);

213

1

});

214

1

215

1

	// Lets gather the balance before sending back money

216

1

	let mut balance_before_sending = 0;

217

1

	Relay::execute_with(|| {

218

1

		balance_before_sending = RelayBalances::free_balance(&RELAYALICE);

219

1

});

220

1

221

1

	// We now send back some money to the relay

222

1

	let dest = Location {

223

1

		parents: 1,

224

1

		interior: [AccountId32 {

225

1

			network: None,

226

1

			id: RELAYALICE.into(),

227

1

}]

228

1

		.into(),

229

1

};

230

1

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

231

1

	ParaA::execute_with(|| {

232

1

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

233

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

234

1

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

235

1

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

236

1

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

237

1

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

238

1

0,

239

1

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

240

1

));

241

1

});

242

1

243

1

	// The balances in paraAlice should have been substracted

244

1

	ParaA::execute_with(|| {

245

1

		assert_eq!(

246

1

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

247

1

			Ok(U256::from(0))

248

1

);

249

1

});

250

1

251

1

	// Balances in the relay should have been received

252

1

	Relay::execute_with(|| {

253

1

		// free execution,x	 full amount received

254

1

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

255

1

});

256

1

257

258

#[test]

259

1

fn send_relay_asset_to_para_b() {

260

1

	MockNet::reset();

261

1

262

1

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

263

1

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

264

1

265

1

	let asset_metadata = parachain::AssetMetadata {

266

1

		name: b"RelayToken".to_vec(),

267

1

		symbol: b"Relay".to_vec(),

268

1

		decimals: 12,

269

1

};

270

1

271

1

	// Register asset in paraA. Free execution

272

1

	ParaA::execute_with(|| {

273

1

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

274

1

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

275

1

			.try_into()

276

1

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

277

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

278

1

			source_id,

279

1

			source_location_latest,

280

1

			asset_metadata.decimals,

281

1

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

282

1

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

283

1

));

284

1

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

285

1

});

286

1

287

1

	// Register asset in paraB. Free execution

288

1

	ParaB::execute_with(|| {

289

1

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

290

1

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

291

1

			.try_into()

292

1

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

293

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

294

1

			source_id,

295

1

			source_location_latest,

296

1

			asset_metadata.decimals,

297

1

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

298

1

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

299

1

));

300

1

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

301

1

});

302

1

303

1

	let dest: Location = Junction::AccountKey20 {

304

1

		network: None,

305

1

		key: PARAALICE,

306

1

307

1

	.into();

308

1

	Relay::execute_with(|| {

309

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

310

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

311

1

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

312

1

			Box::new(VersionedLocation::from(dest).clone()),

313

1

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

314

1

0,

315

1

			WeightLimit::Unlimited

316

1

));

317

1

});

318

1

319

1

	ParaA::execute_with(|| {

320

1

		// free execution, full amount received

321

1

		assert_eq!(

322

1

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

323

1

			Ok(U256::from(123))

324

1

);

325

1

});

326

1

327

1

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

328

1

	let dest = Location {

329

1

		parents: 1,

330

1

		interior: [

331

1

			Parachain(2),

332

1

			AccountKey20 {

333

1

				network: None,

334

1

				key: PARAALICE.into(),

335

1

},

336

1

337

1

		.into(),

338

1

};

339

1

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

340

1

	ParaA::execute_with(|| {

341

1

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

342

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

343

1

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

344

1

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

345

1

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

346

1

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

347

1

0,

348

1

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

349

1

));

350

1

});

351

1

352

1

	// Para A balances should have been substracted

353

1

	ParaA::execute_with(|| {

354

1

		assert_eq!(

355

1

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

356

1

			Ok(U256::from(23))

357

1

);

358

1

});

359

1

360

1

	// Para B balances should have been credited

361

1

	ParaB::execute_with(|| {

362

1

		assert_eq!(

363

1

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

364

1

			Ok(U256::from(100))

365

1

);

366

1

});

367

1

368

369

#[test]

370

1

fn send_para_a_asset_to_para_b() {

371

1

	MockNet::reset();

372

1

373

1

	// This represents the asset in paraA

374

1

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

375

1

	let source_location: AssetType = para_a_balances

376

1

		.try_into()

377

1

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

378

1

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

379

1

380

1

	let asset_metadata = parachain::AssetMetadata {

381

1

		name: b"ParaAToken".to_vec(),

382

1

		symbol: b"ParaA".to_vec(),

383

1

		decimals: 18,

384

1

};

385

1

386

1

	// Register asset in paraB. Free execution

387

1

	ParaB::execute_with(|| {

388

1

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

389

1

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

390

1

			.try_into()

391

1

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

392

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

393

1

			source_id,

394

1

			source_location_latest,

395

1

			asset_metadata.decimals,

396

1

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

397

1

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

398

1

));

399

1

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

400

1

});

401

1

402

1

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

403

1

	let dest = Location {

404

1

		parents: 1,

405

1

		interior: [

406

1

			Parachain(2),

407

1

			AccountKey20 {

408

1

				network: None,

409

1

				key: PARAALICE.into(),

410

1

},

411

1

412

1

		.into(),

413

1

};

414

1

415

1

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

416

1

	// Native token is substracted in paraA

417

1

	ParaA::execute_with(|| {

418

1

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

419

1

		// Free execution, full amount received

420

1

		assert_ok!(PolkadotXcm::transfer_assets(

421

1

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

422

1

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

423

1

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

424

1

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

425

1

0,

426

1

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

427

1

));

428

1

});

429

1

430

1

	ParaA::execute_with(|| {

431

1

		assert_eq!(

432

1

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

433

1

			INITIAL_BALANCE - 100

434

1

);

435

1

});

436

1

437

1

	// Asset is minted in paraB

438

1

	ParaB::execute_with(|| {

439

1

		// Free execution, full amount received

440

1

		assert_eq!(

441

1

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

442

1

			Ok(U256::from(100))

443

1

);

444

1

});

445

1

446

447

#[test]

448

1

fn send_para_a_asset_from_para_b_to_para_c() {

449

1

	MockNet::reset();

450

1

451

1

	// Represents para A asset

452

1

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

453

1

	let source_location: AssetType = para_a_balances

454

1

		.try_into()

455

1

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

456

1

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

457

1

458

1

	let asset_metadata = parachain::AssetMetadata {

459

1

		name: b"ParaAToken".to_vec(),

460

1

		symbol: b"ParaA".to_vec(),

461

1

		decimals: 18,

462

1

};

463

1

464

1

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

465

1

	ParaB::execute_with(|| {

466

1

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

467

1

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

468

1

			.try_into()

469

1

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

470

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

471

1

			source_id,

472

1

			source_location_latest,

473

1

			asset_metadata.decimals,

474

1

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

475

1

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

476

1

));

477

1

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

478

1

});

479

1

480

1

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

481

1

	ParaC::execute_with(|| {

482

1

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

483

1

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

484

1

			.try_into()

485

1

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

486

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

487

1

			source_id,

488

1

			source_location_latest,

489

1

			asset_metadata.decimals,

490

1

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

491

1

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

492

1

));

493

1

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

494

1

});

495

1

496

1

	let dest = Location {

497

1

		parents: 1,

498

1

		interior: [

499

1

			Parachain(2),

500

1

			AccountKey20 {

501

1

				network: None,

502

1

				key: PARAALICE.into(),

503

1

},

504

1

505

1

		.into(),

506

1

};

507

1

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

508

1

	ParaA::execute_with(|| {

509

1

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

510

1

		assert_ok!(PolkadotXcm::transfer_assets(

511

1

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

512

1

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

513

1

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

514

1

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

515

1

0,

516

1

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

517

1

));

518

1

});

519

1

520

1

	// Para A balances have been substracted

521

1

	ParaA::execute_with(|| {

522

1

		assert_eq!(

523

1

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

524

1

			INITIAL_BALANCE - 100

525

1

);

526

1

});

527

1

528

1

	// Para B balances have been credited

529

1

	ParaB::execute_with(|| {

530

1

		assert_eq!(

531

1

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

532

1

			Ok(U256::from(100))

533

1

);

534

1

});

535

1

536

1

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

537

1

	let dest = Location {

538

1

		parents: 1,

539

1

		interior: [

540

1

			Parachain(3),

541

1

			AccountKey20 {

542

1

				network: None,

543

1

				key: PARAALICE.into(),

544

1

},

545

1

546

1

		.into(),

547

1

};

548

1

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

549

1

	ParaB::execute_with(|| {

550

1

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

551

1

		assert_ok!(PolkadotXcm::transfer_assets(

552

1

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

553

1

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

554

1

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

555

1

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

556

1

0,

557

1

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

558

1

));

559

1

});

560

1

561

1

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

562

1

	ParaC::execute_with(|| {

563

1

		assert_eq!(

564

1

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

565

1

			Ok(U256::from(95))

566

1

);

567

1

});

568

1

569

570

#[test]

571

1

fn send_para_a_asset_to_para_b_and_back_to_para_a() {

572

1

	MockNet::reset();

573

1

574

1

	// para A asset

575

1

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

576

1

	let source_location: AssetType = para_a_balances

577

1

		.try_into()

578

1

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

579

1

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

580

1

581

1

	let asset_metadata = parachain::AssetMetadata {

582

1

		name: b"ParaAToken".to_vec(),

583

1

		symbol: b"ParaA".to_vec(),

584

1

		decimals: 18,

585

1

};

586

1

587

1

	// Register para A asset in para B

588

1

	ParaB::execute_with(|| {

589

1

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

590

1

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

591

1

			.try_into()

592

1

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

593

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

594

1

			source_id,

595

1

			source_location_latest,

596

1

			asset_metadata.decimals,

597

1

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

598

1

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

599

1

));

600

1

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

601

1

});

602

1

603

1

	// Send para A asset to para B

604

1

	let dest = Location {

605

1

		parents: 1,

606

1

		interior: [

607

1

			Parachain(2),

608

1

			AccountKey20 {

609

1

				network: None,

610

1

				key: PARAALICE.into(),

611

1

},

612

1

613

1

		.into(),

614

1

};

615

1

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

616

1

	ParaA::execute_with(|| {

617

1

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

618

1

		assert_ok!(PolkadotXcm::transfer_assets(

619

1

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

620

1

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

621

1

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

622

1

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

623

1

0,

624

1

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

625

1

));

626

1

});

627

1

628

1

	// Balances have been substracted

629

1

	ParaA::execute_with(|| {

630

1

		assert_eq!(

631

1

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

632

1

			INITIAL_BALANCE - 100

633

1

);

634

1

});

635

1

636

1

	// Para B balances have been credited

637

1

	ParaB::execute_with(|| {

638

1

		assert_eq!(

639

1

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

640

1

			Ok(U256::from(100))

641

1

);

642

1

});

643

1

644

1

	// Send back para A asset to para A

645

1

	let dest = Location {

646

1

		parents: 1,

647

1

		interior: [

648

1

			Parachain(1),

649

1

			AccountKey20 {

650

1

				network: None,

651

1

				key: PARAALICE.into(),

652

1

},

653

1

654

1

		.into(),

655

1

};

656

1

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

657

1

	ParaB::execute_with(|| {

658

1

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

659

1

		assert_ok!(PolkadotXcm::transfer_assets(

660

1

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

661

1

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

662

1

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

663

1

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

664

1

0,

665

1

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

666

1

));

667

1

});

668

1

669

1

	ParaA::execute_with(|| {

670

1

		// Weight used is 4

671

1

		assert_eq!(

672

1

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

673

1

			INITIAL_BALANCE - 4

674

1

);

675

1

});

676

1

677

678

#[test]

679

1

fn receive_relay_asset_with_trader() {

680

1

	MockNet::reset();

681

1

682

1

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

683

1

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

684

1

685

1

	let asset_metadata = parachain::AssetMetadata {

686

1

		name: b"RelayToken".to_vec(),

687

1

		symbol: b"Relay".to_vec(),

688

1

		decimals: 12,

689

1

};

690

1

691

1

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

692

1

	// we know later we will divide by 1e12

693

1

	// Lets put 1e6 as units per second

694

1

	ParaA::execute_with(|| {

695

1

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

696

1

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

697

1

			.try_into()

698

1

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

699

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

700

1

			source_id,

701

1

			source_location_latest,

702

1

			asset_metadata.decimals,

703

1

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

704

1

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

705

1

));

706

1

		assert_ok!(add_supported_asset(

707

1

			source_location.clone(),

708

1

			2500000000000u128

709

1

));

710

1

});

711

1

712

1

	let dest: Location = Junction::AccountKey20 {

713

1

		network: None,

714

1

		key: PARAALICE,

715

1

716

1

	.into();

717

1

	// We are sending 100 tokens from relay.

718

1

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

719

1

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

720

1

	// Units per second should be 2_500_000_000_000_000

721

1

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

722

1

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

723

1

	Relay::execute_with(|| {

724

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

725

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

726

1

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

727

1

			Box::new(VersionedLocation::from(dest).clone()),

728

1

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

729

1

0,

730

1

			WeightLimit::Unlimited

731

1

));

732

1

});

733

1

734

1

	ParaA::execute_with(|| {

735

1

		// non-free execution, not full amount received

736

1

		assert_eq!(

737

1

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

738

1

			Ok(U256::from(90))

739

1

);

740

		// Fee should have been received by treasury

741

1

		assert_eq!(

742

1

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

743

1

			Ok(U256::from(10))

744

1

);

745

1

});

746

1

747

748

#[test]

749

1

fn send_para_a_asset_to_para_b_with_trader() {

750

1

	MockNet::reset();

751

1

752

1

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

753

1

	let source_location: AssetType = para_a_balances

754

1

		.try_into()

755

1

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

756

1

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

757

1

758

1

	let asset_metadata = parachain::AssetMetadata {

759

1

		name: b"ParaAToken".to_vec(),

760

1

		symbol: b"ParaA".to_vec(),

761

1

		decimals: 18,

762

1

};

763

1

764

1

	ParaB::execute_with(|| {

765

1

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

766

1

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

767

1

			.try_into()

768

1

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

769

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

770

1

			source_id,

771

1

			source_location_latest,

772

1

			asset_metadata.decimals,

773

1

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

774

1

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

775

1

));

776

1

		assert_ok!(add_supported_asset(

777

1

			source_location.clone(),

778

1

			2500000000000u128

779

1

));

780

1

});

781

1

782

1

	let dest = Location {

783

1

		parents: 1,

784

1

		interior: [

785

1

			Parachain(2),

786

1

			AccountKey20 {

787

1

				network: None,

788

1

				key: PARAALICE.into(),

789

1

},

790

1

791

1

		.into(),

792

1

};

793

1

794

1

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

795

1

	// In destination chain, we only need 4 weight

796

1

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

797

1

	ParaA::execute_with(|| {

798

1

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

799

1

		assert_ok!(PolkadotXcm::transfer_assets(

800

1

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

801

1

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

802

1

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

803

1

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

804

1

0,

805

1

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

806

1

));

807

1

});

808

1

	ParaA::execute_with(|| {

809

1

		// free execution, full amount received

810

1

		assert_eq!(

811

1

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

812

1

			INITIAL_BALANCE - 100

813

1

);

814

1

});

815

1

816

1

	// We are sending 100 tokens from para A.

817

1

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

818

1

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

819

1

	// Units per second should be 2_500_000_000_000_000

820

1

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

821

1

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

822

1

	// will be 4

823

1

	ParaB::execute_with(|| {

824

1

		assert_eq!(

825

1

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

826

1

			Ok(U256::from(90))

827

1

);

828

		// Fee should have been received by treasury

829

1

		assert_eq!(

830

1

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

831

1

			Ok(U256::from(10))

832

1

);

833

1

});

834

1

835

836

#[test]

837

1

fn send_para_a_asset_to_para_b_with_trader_and_fee() {

838

1

	MockNet::reset();

839

1

840

1

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

841

1

	let source_location: AssetType = para_a_balances

842

1

		.try_into()

843

1

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

844

1

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

845

1

846

1

	let asset_metadata = parachain::AssetMetadata {

847

1

		name: b"ParaAToken".to_vec(),

848

1

		symbol: b"ParaA".to_vec(),

849

1

		decimals: 18,

850

1

};

851

1

852

1

	ParaB::execute_with(|| {

853

1

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

854

1

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

855

1

			.try_into()

856

1

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

857

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

858

1

			source_id,

859

1

			source_location_latest,

860

1

			asset_metadata.decimals,

861

1

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

862

1

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

863

1

));

864

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

865

1

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

866

1

});

867

1

868

1

	let dest = Location {

869

1

		parents: 1,

870

1

		interior: [

871

1

			Parachain(2),

872

1

			AccountKey20 {

873

1

				network: None,

874

1

				key: PARAALICE.into(),

875

1

},

876

1

877

1

		.into(),

878

1

};

879

1

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

880

1

	// we use transfer_with_fee

881

1

	ParaA::execute_with(|| {

882

1

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

883

1

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

884

1

		assert_ok!(PolkadotXcm::transfer_assets(

885

1

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

886

1

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

887

1

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

888

1

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

889

1

0,

890

1

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

891

1

));

892

1

});

893

1

	ParaA::execute_with(|| {

894

1

		// 100 tokens transferred plus 1 taken from fees

895

1

		assert_eq!(

896

1

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

897

1

			INITIAL_BALANCE - 100 - 1

898

1

);

899

1

});

900

1

901

1

	ParaB::execute_with(|| {

902

1

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

903

1

		// what it is specified

904

1

		assert_eq!(

905

1

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

906

1

			Ok(U256::from(101))

907

1

);

908

1

});

909

1

910

911

#[test]

912

1

fn error_when_not_paying_enough() {

913

1

	MockNet::reset();

914

1

915

1

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

916

1

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

917

1

918

1

	let asset_metadata = parachain::AssetMetadata {

919

1

		name: b"RelayToken".to_vec(),

920

1

		symbol: b"Relay".to_vec(),

921

1

		decimals: 12,

922

1

};

923

1

924

1

	let dest: Location = Junction::AccountKey20 {

925

1

		network: None,

926

1

		key: PARAALICE,

927

1

928

1

	.into();

929

1

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

930

1

	// we know later we will divide by 1e12

931

1

	// Lets put 1e6 as units per second

932

1

	ParaA::execute_with(|| {

933

1

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

934

1

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

935

1

			.try_into()

936

1

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

937

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

938

1

			source_id,

939

1

			source_location_latest,

940

1

			asset_metadata.decimals,

941

1

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

942

1

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

943

1

));

944

1

		assert_ok!(add_supported_asset(

945

1

			source_location.clone(),

946

1

			2500000000000u128

947

1

));

948

1

});

949

1

950

1

	// We are sending 100 tokens from relay.

951

1

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

952

1

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

953

1

	Relay::execute_with(|| {

954

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

955

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

956

1

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

957

1

			Box::new(VersionedLocation::from(dest).clone()),

958

1

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

959

1

0,

960

1

			WeightLimit::Unlimited

961

1

));

962

1

});

963

1

964

1

	ParaA::execute_with(|| {

965

1

		// amount not received as it is not paying enough

966

1

		assert_eq!(

967

1

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

968

1

			Ok(U256::from(0))

969

1

);

970

1

});

971

1

972

973

#[test]

974

1

fn transact_through_derivative_multilocation() {

975

1

	MockNet::reset();

976

1

977

1

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

978

1

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

979

1

980

1

	let asset_metadata = parachain::AssetMetadata {

981

1

		name: b"RelayToken".to_vec(),

982

1

		symbol: b"Relay".to_vec(),

983

1

		decimals: 12,

984

1

};

985

1

986

1

	ParaA::execute_with(|| {

987

1

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

988

1

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

989

1

			.try_into()

990

1

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

991

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

992

1

			source_id,

993

1

			source_location_latest,

994

1

			asset_metadata.decimals,

995

1

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

996

1

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

997

1

));

998

1

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

999

1000

		// Root can set transact info

1001

1

		assert_ok!(XcmTransactor::set_transact_info(

1002

1

			parachain::RuntimeOrigin::root(),

1003

1

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

1004

1

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

1005

1

			3000.into(),

1006

1

			20000000000.into(),

1007

1

			None

1008

1

));

1009

		// Root can set transact info

1010

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1011

1

			parachain::RuntimeOrigin::root(),

1012

1

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

1013

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1014

1

));

1015

1

});

1016

1

1017

1

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

1018

1

1019

1

	let dest: Location = AccountKey20 {

1020

1

		network: None,

1021

1

		key: PARAALICE,

1022

1

1023

1

	.into();

1024

1

	Relay::execute_with(|| {

1025

1

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

1026

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1027

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1028

1

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

1029

1

			Box::new(VersionedLocation::from(dest).clone()),

1030

1

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

1031

1

0,

1032

1

			WeightLimit::Unlimited

1033

1

));

1034

1

});

1035

1

1036

1

	ParaA::execute_with(|| {

1037

1

		// free execution, full amount received

1038

1

		assert_eq!(

1039

1

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

1040

1

			Ok(U256::from(4000003100u64))

1041

1

);

1042

1

});

1043

1

1044

1

	// Register address

1045

1

	ParaA::execute_with(|| {

1046

1

		assert_ok!(XcmTransactor::register(

1047

1

			parachain::RuntimeOrigin::root(),

1048

1

			PARAALICE.into(),

1049

1

0,

1050

1

));

1051

1

});

1052

1

1053

1

	// Send to registered address

1054

1

1055

1

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

1056

1

	let dest = Location {

1057

1

		parents: 1,

1058

1

		interior: [AccountId32 {

1059

1

			network: None,

1060

1

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

1061

1

}]

1062

1

		.into(),

1063

1

};

1064

1

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

1065

1

1066

1

	ParaA::execute_with(|| {

1067

1

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

1068

1

		// free execution, full amount received

1069

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1070

1

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

1071

1

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

1072

1

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

1073

1

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

1074

1

0,

1075

1

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

1076

1

));

1077

1

});

1078

1

1079

1

	ParaA::execute_with(|| {

1080

1

		// free execution, full amount received

1081

1

		assert_eq!(

1082

1

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

1083

1

			Ok(U256::from(4000003000u64))

1084

1

);

1085

1

});

1086

1

1087

1

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

1088

1

	// again

1089

1

	Relay::execute_with(|| {

1090

1

		// free execution,x	 full amount received

1091

1

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

1092

1

});

1093

1

1094

1

	// Encode the call. Balances transact to para_a_account

1095

1

	// First index

1096

1

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

1097

1

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

1098

1

		relay_chain::Balances,

1099

1

>()

1100

1

	.unwrap() as u8;

1101

1

1102

1

	encoded.push(index);

1103

1

1104

1

	// Then call bytes

1105

1

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

1106

1

		dest: para_a_account(),

1107

1

		value: 100u32.into(),

1108

1

1109

1

	.encode();

1110

1

	encoded.append(&mut call_bytes);

1111

1

1112

1

	ParaA::execute_with(|| {

1113

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1114

1

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

1115

1

			parachain::MockTransactors::Relay,

1116

1

0,

1117

1

			CurrencyPayment {

1118

1

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

1119

1

					Location::parent()

1120

1

				))),

1121

1

				fee_amount: None

1122

1

},

1123

1

			encoded,

1124

1

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

1125

1

			TransactWeights {

1126

1

				transact_required_weight_at_most: 4000000000.into(),

1127

1

				overall_weight: None

1128

1

},

1129

1

			false

1130

1

));

1131

1

});

1132

1

1133

1

	Relay::execute_with(|| {

1134

1

		// free execution,x	 full amount received

1135

1

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

1136

1137

1

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

1138

1

});

1139

1

1140

1141

#[test]

1142

1

fn transact_through_derivative_with_custom_fee_weight() {

1143

1

	MockNet::reset();

1144

1

1145

1

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

1146

1

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

1147

1

1148

1

	let asset_metadata = parachain::AssetMetadata {

1149

1

		name: b"RelayToken".to_vec(),

1150

1

		symbol: b"Relay".to_vec(),

1151

1

		decimals: 12,

1152

1

};

1153

1

1154

1

	ParaA::execute_with(|| {

1155

1

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

1156

1

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

1157

1

			.try_into()

1158

1

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

1159

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1160

1

			source_id,

1161

1

			source_location_latest,

1162

1

			asset_metadata.decimals,

1163

1

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

1164

1

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

1165

1

));

1166

1

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

1167

1

});

1168

1

1169

1

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

1170

1

1171

1

	let dest: Location = AccountKey20 {

1172

1

		network: None,

1173

1

		key: PARAALICE,

1174

1

1175

1

	.into();

1176

1

	Relay::execute_with(|| {

1177

1

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

1178

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1179

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1180

1

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

1181

1

			Box::new(VersionedLocation::from(dest).clone()),

1182

1

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

1183

1

0,

1184

1

			WeightLimit::Unlimited

1185

1

));

1186

1

});

1187

1

1188

1

	ParaA::execute_with(|| {

1189

1

		// free execution, full amount received

1190

1

		assert_eq!(

1191

1

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

1192

1

			Ok(U256::from(4000003100u64))

1193

1

);

1194

1

});

1195

1

1196

1

	// Register address

1197

1

	ParaA::execute_with(|| {

1198

1

		assert_ok!(XcmTransactor::register(

1199

1

			parachain::RuntimeOrigin::root(),

1200

1

			PARAALICE.into(),

1201

1

0,

1202

1

));

1203

1

});

1204

1

1205

1

	// Send to registered address

1206

1

1207

1

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

1208

1

	let dest = Location {

1209

1

		parents: 1,

1210

1

		interior: [AccountId32 {

1211

1

			network: None,

1212

1

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

1213

1

}]

1214

1

		.into(),

1215

1

};

1216

1

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

1217

1

1218

1

	ParaA::execute_with(|| {

1219

1

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

1220

1

		// free execution, full amount received

1221

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1222

1

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

1223

1

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

1224

1

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

1225

1

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

1226

1

0,

1227

1

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

1228

1

));

1229

1

});

1230

1

1231

1

	ParaA::execute_with(|| {

1232

1

		// free execution, full amount received

1233

1

		assert_eq!(

1234

1

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

1235

1

			Ok(U256::from(4000003000u64))

1236

1

);

1237

1

});

1238

1

1239

1

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

1240

1

	// again

1241

1

	Relay::execute_with(|| {

1242

1

		// free execution,x	 full amount received

1243

1

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

1244

1

});

1245

1

1246

1

	// Encode the call. Balances transact to para_a_account

1247

1

	// First index

1248

1

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

1249

1

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

1250

1

		relay_chain::Balances,

1251

1

>()

1252

1

	.unwrap() as u8;

1253

1

1254

1

	encoded.push(index);

1255

1

1256

1

	// Then call bytes

1257

1

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

1258

1

		dest: para_a_account(),

1259

1

		value: 100u32.into(),

1260

1

1261

1

	.encode();

1262

1

	encoded.append(&mut call_bytes);

1263

1

1264

1

	let overall_weight = 4000003000u64;

1265

1

	ParaA::execute_with(|| {

1266

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1267

1

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

1268

1

			parachain::MockTransactors::Relay,

1269

1

0,

1270

1

			CurrencyPayment {

1271

1

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

1272

1

					Location::parent()

1273

1

				))),

1274

1

				// 1-1 fee weight mapping

1275

1

				fee_amount: Some(overall_weight as u128)

1276

1

},

1277

1

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

1278

1

			encoded,

1279

1

			TransactWeights {

1280

1

				transact_required_weight_at_most: 4000000000.into(),

1281

1

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

1282

1

},

1283

1

			false

1284

1

));

1285

1

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

1286

1

			.iter()

1287

18

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

1288

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

1289

..

1290

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

1291

18

				_ => None,

1292

18

});

1293

1

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

1294

1

		assert!(event_found.is_none());

1295

1

});

1296

1

1297

1

	Relay::execute_with(|| {

1298

1

		// free execution,x	 full amount received

1299

1

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

1300

1301

1

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

1302

1

});

1303

1

1304

1305

#[test]

1306

1

fn transact_through_derivative_with_custom_fee_weight_refund() {

1307

1

	MockNet::reset();

1308

1

1309

1

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

1310

1

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

1311

1

1312

1

	let asset_metadata = parachain::AssetMetadata {

1313

1

		name: b"RelayToken".to_vec(),

1314

1

		symbol: b"Relay".to_vec(),

1315

1

		decimals: 12,

1316

1

};

1317

1

1318

1

	ParaA::execute_with(|| {

1319

1

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

1320

1

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

1321

1

			.try_into()

1322

1

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

1323

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1324

1

			source_id,

1325

1

			source_location_latest,

1326

1

			asset_metadata.decimals,

1327

1

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

1328

1

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

1329

1

));

1330

1

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

1331

1

});

1332

1

1333

1

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

1334

1

1335

1

	let dest: Location = AccountKey20 {

1336

1

		network: None,

1337

1

		key: PARAALICE,

1338

1

1339

1

	.into();

1340

1

	Relay::execute_with(|| {

1341

1

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

1342

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1343

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1344

1

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

1345

1

			Box::new(VersionedLocation::from(dest).clone()),

1346

1

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

1347

1

0,

1348

1

			WeightLimit::Unlimited

1349

1

));

1350

1

});

1351

1

1352

1

	ParaA::execute_with(|| {

1353

1

		// free execution, full amount received

1354

1

		assert_eq!(

1355

1

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

1356

1

			Ok(U256::from(4000009100u64))

1357

1

);

1358

1

});

1359

1

1360

1

	// Register address

1361

1

	ParaA::execute_with(|| {

1362

1

		assert_ok!(XcmTransactor::register(

1363

1

			parachain::RuntimeOrigin::root(),

1364

1

			PARAALICE.into(),

1365

1

0,

1366

1

));

1367

1

});

1368

1

1369

1

	// Send to registered address

1370

1

1371

1

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

1372

1

	let dest = Location {

1373

1

		parents: 1,

1374

1

		interior: [AccountId32 {

1375

1

			network: None,

1376

1

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

1377

1

}]

1378

1

		.into(),

1379

1

};

1380

1

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

1381

1

1382

1

	ParaA::execute_with(|| {

1383

1

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

1384

1

		// free execution, full amount received

1385

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1386

1

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

1387

1

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

1388

1

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

1389

1

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

1390

1

0,

1391

1

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

1392

1

));

1393

1

});

1394

1

1395

1

	ParaA::execute_with(|| {

1396

1

		// free execution, full amount received

1397

1

		assert_eq!(

1398

1

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

1399

1

			Ok(U256::from(4000009000u64))

1400

1

);

1401

1

});

1402

1

1403

1

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

1404

1

	// again

1405

1

	Relay::execute_with(|| {

1406

1

		// free execution,x	 full amount received

1407

1

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

1408

1

});

1409

1

1410

1

	// Encode the call. Balances transact to para_a_account

1411

1

	// First index

1412

1

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

1413

1

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

1414

1

		relay_chain::Balances,

1415

1

>()

1416

1

	.unwrap() as u8;

1417

1

1418

1

	encoded.push(index);

1419

1

1420

1

	// Then call bytes

1421

1

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

1422

1

		dest: para_a_account(),

1423

1

		value: 100u32.into(),

1424

1

1425

1

	.encode();

1426

1

	encoded.append(&mut call_bytes);

1427

1

1428

1

	let overall_weight = 4000009000u64;

1429

1

	ParaA::execute_with(|| {

1430

1

		assert_ok!(XcmTransactor::transact_through_derivative(

1431

1

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

1432

1

			parachain::MockTransactors::Relay,

1433

1

0,

1434

1

			CurrencyPayment {

1435

1

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

1436

1

					Location::parent()

1437

1

				))),

1438

1

				// 1-1 fee weight mapping

1439

1

				fee_amount: Some(overall_weight as u128)

1440

1

},

1441

1

			encoded,

1442

1

			TransactWeights {

1443

1

				transact_required_weight_at_most: 4000000000.into(),

1444

1

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

1445

1

},

1446

1

			true

1447

1

));

1448

1

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

1449

1

			.iter()

1450

18

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

1451

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

1452

..

1453

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

1454

18

				_ => None,

1455

18

});

1456

1

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

1457

1

		assert!(event_found.is_none());

1458

1

});

1459

1

1460

1

	Relay::execute_with(|| {

1461

1

		// free execution,x	 full amount received

1462

1

		// 4000009000 refunded + 100 transferred = 4000009100

1463

1

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

1464

1

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

1465

1

});

1466

1

1467

1468

#[test]

1469

1

fn transact_through_sovereign() {

1470

1

	MockNet::reset();

1471

1

1472

1

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

1473

1

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

1474

1

1475

1

	let asset_metadata = parachain::AssetMetadata {

1476

1

		name: b"RelayToken".to_vec(),

1477

1

		symbol: b"Relay".to_vec(),

1478

1

		decimals: 12,

1479

1

};

1480

1

1481

1

	ParaA::execute_with(|| {

1482

1

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

1483

1

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

1484

1

			.try_into()

1485

1

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

1486

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1487

1

			source_id,

1488

1

			source_location_latest,

1489

1

			asset_metadata.decimals,

1490

1

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

1491

1

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

1492

1

));

1493

1

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

1494

1495

		// Root can set transact info

1496

1

		assert_ok!(XcmTransactor::set_transact_info(

1497

1

			parachain::RuntimeOrigin::root(),

1498

1

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

1499

1

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

1500

1

			3000.into(),

1501

1

			20000000000.into(),

1502

1

			None

1503

1

));

1504

		// Root can set transact info

1505

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1506

1

			parachain::RuntimeOrigin::root(),

1507

1

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

1508

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1509

1

));

1510

1

});

1511

1

1512

1

	let dest: Location = AccountKey20 {

1513

1

		network: None,

1514

1

		key: PARAALICE,

1515

1

1516

1

	.into();

1517

1

	Relay::execute_with(|| {

1518

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1519

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1520

1

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

1521

1

			Box::new(VersionedLocation::from(dest).clone()),

1522

1

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

1523

1

0,

1524

1

			WeightLimit::Unlimited

1525

1

));

1526

1

});

1527

1

1528

1

	ParaA::execute_with(|| {

1529

1

		// free execution, full amount received

1530

1

		assert_eq!(

1531

1

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

1532

1

			Ok(U256::from(4000003100u64))

1533

1

);

1534

1

});

1535

1

1536

1

	// Register address

1537

1

	ParaA::execute_with(|| {

1538

1

		assert_ok!(XcmTransactor::register(

1539

1

			parachain::RuntimeOrigin::root(),

1540

1

			PARAALICE.into(),

1541

1

0,

1542

1

));

1543

1

});

1544

1

1545

1

	// Send to registered address

1546

1

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

1547

1

	let dest = Location {

1548

1

		parents: 1,

1549

1

		interior: [AccountId32 {

1550

1

			network: None,

1551

1

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

1552

1

}]

1553

1

		.into(),

1554

1

};

1555

1

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

1556

1

1557

1

	ParaA::execute_with(|| {

1558

1

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

1559

1

		// free execution, full amount received

1560

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1561

1

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

1562

1

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

1563

1

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

1564

1

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

1565

1

0,

1566

1

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

1567

1

));

1568

1

});

1569

1

1570

1

	ParaA::execute_with(|| {

1571

1

		// free execution, full amount received

1572

1

		assert_eq!(

1573

1

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

1574

1

			Ok(U256::from(4000003000u64))

1575

1

);

1576

1

});

1577

1

1578

1

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

1579

1

	// again

1580

1

	Relay::execute_with(|| {

1581

1

		// free execution,x	 full amount received

1582

1

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

1583

1

1584

1

});

1585

1

1586

1

	// We send the xcm transact operation to parent

1587

1

	let dest = Location {

1588

1

		parents: 1,

1589

1

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

1590

1

};

1591

1

1592

1

	// Encode the call. Balances transact to para_a_account

1593

1

	// First index

1594

1

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

1595

1

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

1596

1

		relay_chain::Balances,

1597

1

>()

1598

1

	.unwrap() as u8;

1599

1

1600

1

	encoded.push(index);

1601

1

1602

1

	// Then call bytes

1603

1

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

1604

1

		dest: para_a_account(),

1605

1

		value: 100u32.into(),

1606

1

1607

1

	.encode();

1608

1

	encoded.append(&mut call_bytes);

1609

1

1610

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1611

1

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

1612

1

);

1613

1

1614

1

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

1615

1

	ParaA::execute_with(|| {

1616

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1617

1

			parachain::RuntimeOrigin::root(),

1618

1

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

1619

1

			Some(PARAALICE.into()),

1620

1

			CurrencyPayment {

1621

1

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

1622

1

					Location::parent()

1623

1

				))),

1624

1

				fee_amount: None

1625

1

},

1626

1

			utility_bytes,

1627

1

			OriginKind::SovereignAccount,

1628

1

			TransactWeights {

1629

1

				transact_required_weight_at_most: 4000000000.into(),

1630

1

				overall_weight: None

1631

1

},

1632

1

			false

1633

1

));

1634

1

});

1635

1

1636

1

	Relay::execute_with(|| {

1637

1

		// free execution,x	 full amount received

1638

1

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

1639

1640

1

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

1641

1

});

1642

1

1643

1644

#[test]

1645

1

fn transact_through_sovereign_fee_payer_none() {

1646

1

	MockNet::reset();

1647

1

1648

1

	ParaA::execute_with(|| {

1649

1

		// Root can set transact info

1650

1

		assert_ok!(XcmTransactor::set_transact_info(

1651

1

			parachain::RuntimeOrigin::root(),

1652

1

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

1653

1

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

1654

1

			3000.into(),

1655

1

			20000000000.into(),

1656

1

			None

1657

1

));

1658

		// Root can set transact info

1659

1

		assert_ok!(XcmTransactor::set_fee_per_second(

1660

1

			parachain::RuntimeOrigin::root(),

1661

1

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

1662

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

1663

1

));

1664

1

});

1665

1

1666

1

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

1667

1

1668

1

	Relay::execute_with(|| {

1669

1

		// Transfer 100 tokens to derivative_address on the relay

1670

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1671

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1672

1

			derivative_address.clone(),

1673

1

			100u128

1674

1

));

1675

1676

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

1677

1

		assert_ok!(RelayBalances::transfer_keep_alive(

1678

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1679

1

			para_a_account(),

1680

1

			4000003000u128

1681

1

));

1682

1

});

1683

1

1684

1

	// Check balances before the transact call

1685

1

	Relay::execute_with(|| {

1686

1

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

1687

1

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

1688

1

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

1689

1

});

1690

1

1691

1

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

1692

1

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

1693

1

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

1694

1

		relay_chain::Balances,

1695

1

>()

1696

1

	.unwrap() as u8;

1697

1

1698

1

	encoded.push(index);

1699

1

1700

1

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

1701

1

		dest: RELAYBOB,

1702

1

		value: 100u32.into(),

1703

1

1704

1

	.encode();

1705

1

	encoded.append(&mut call_bytes);

1706

1

1707

1

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

1708

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1709

1

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

1710

1

);

1711

1

1712

1

	// We send the xcm transact operation to parent

1713

1

	let dest = Location {

1714

1

		parents: 1,

1715

1

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

1716

1

};

1717

1

1718

1

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

1719

1

	ParaA::execute_with(|| {

1720

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1721

1

			parachain::RuntimeOrigin::root(),

1722

1

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

1723

1

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

1724

1

			None,

1725

1

			CurrencyPayment {

1726

1

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

1727

1

					Location::parent()

1728

1

				))),

1729

1

				fee_amount: None

1730

1

},

1731

1

			utility_bytes,

1732

1

			OriginKind::SovereignAccount,

1733

1

			TransactWeights {

1734

1

				transact_required_weight_at_most: 4000000000.into(),

1735

1

				overall_weight: None

1736

1

},

1737

1

			false

1738

1

));

1739

1

});

1740

1

1741

1

	// Check balances after the transact call are correct

1742

1

	Relay::execute_with(|| {

1743

1

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

1744

1

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

1745

1

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

1746

1

});

1747

1

1748

1749

#[test]

1750

1

fn transact_through_sovereign_with_custom_fee_weight() {

1751

1

	MockNet::reset();

1752

1

1753

1

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

1754

1

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

1755

1

1756

1

	let asset_metadata = parachain::AssetMetadata {

1757

1

		name: b"RelayToken".to_vec(),

1758

1

		symbol: b"Relay".to_vec(),

1759

1

		decimals: 12,

1760

1

};

1761

1

1762

1

	ParaA::execute_with(|| {

1763

1

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

1764

1

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

1765

1

			.try_into()

1766

1

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

1767

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1768

1

			source_id,

1769

1

			source_location_latest,

1770

1

			asset_metadata.decimals,

1771

1

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

1772

1

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

1773

1

));

1774

1

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

1775

1

});

1776

1

1777

1

	let dest: Location = AccountKey20 {

1778

1

		network: None,

1779

1

		key: PARAALICE,

1780

1

1781

1

	.into();

1782

1

	Relay::execute_with(|| {

1783

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1784

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1785

1

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

1786

1

			Box::new(VersionedLocation::from(dest).clone()),

1787

1

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

1788

1

0,

1789

1

			WeightLimit::Unlimited

1790

1

));

1791

1

});

1792

1

1793

1

	ParaA::execute_with(|| {

1794

1

		// free execution, full amount received

1795

1

		assert_eq!(

1796

1

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

1797

1

			Ok(U256::from(4000003100u64))

1798

1

);

1799

1

});

1800

1

1801

1

	// Register address

1802

1

	ParaA::execute_with(|| {

1803

1

		assert_ok!(XcmTransactor::register(

1804

1

			parachain::RuntimeOrigin::root(),

1805

1

			PARAALICE.into(),

1806

1

0,

1807

1

));

1808

1

});

1809

1

1810

1

	// Send to registered address

1811

1

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

1812

1

	let dest = Location {

1813

1

		parents: 1,

1814

1

		interior: [AccountId32 {

1815

1

			network: None,

1816

1

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

1817

1

}]

1818

1

		.into(),

1819

1

};

1820

1

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

1821

1

1822

1

	ParaA::execute_with(|| {

1823

1

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

1824

1

		// free execution, full amount received

1825

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1826

1

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

1827

1

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

1828

1

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

1829

1

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

1830

1

0,

1831

1

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

1832

1

));

1833

1

});

1834

1

1835

1

	ParaA::execute_with(|| {

1836

1

		// free execution, full amount received

1837

1

		assert_eq!(

1838

1

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

1839

1

			Ok(U256::from(4000003000u64))

1840

1

);

1841

1

});

1842

1

1843

1

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

1844

1

	// again

1845

1

	Relay::execute_with(|| {

1846

1

		// free execution,x	 full amount received

1847

1

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

1848

1

1849

1

});

1850

1

1851

1

	// We send the xcm transact operation to parent

1852

1

	let dest = Location {

1853

1

		parents: 1,

1854

1

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

1855

1

};

1856

1

1857

1

	// Encode the call. Balances transact to para_a_account

1858

1

	// First index

1859

1

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

1860

1

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

1861

1

		relay_chain::Balances,

1862

1

>()

1863

1

	.unwrap() as u8;

1864

1

1865

1

	encoded.push(index);

1866

1

1867

1

	// Then call bytes

1868

1

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

1869

1

		dest: para_a_account(),

1870

1

		value: 100u32.into(),

1871

1

1872

1

	.encode();

1873

1

	encoded.append(&mut call_bytes);

1874

1

1875

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

1876

1

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

1877

1

);

1878

1

1879

1

	let total_weight = 4000003000u64;

1880

1

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

1881

1

	ParaA::execute_with(|| {

1882

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

1883

1

			parachain::RuntimeOrigin::root(),

1884

1

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

1885

1

			Some(PARAALICE.into()),

1886

1

			CurrencyPayment {

1887

1

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

1888

1

					Location::parent()

1889

1

				))),

1890

1

				// 1-1 fee-weight mapping

1891

1

				fee_amount: Some(total_weight as u128)

1892

1

},

1893

1

			utility_bytes,

1894

1

			OriginKind::SovereignAccount,

1895

1

			TransactWeights {

1896

1

				transact_required_weight_at_most: 4000000000.into(),

1897

1

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

1898

1

},

1899

1

			false

1900

1

));

1901

1

});

1902

1

1903

1

	Relay::execute_with(|| {

1904

1

		// free execution,x	 full amount received

1905

1

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

1906

1907

1

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

1908

1

});

1909

1

1910

1911

#[test]

1912

1

fn transact_through_sovereign_with_custom_fee_weight_refund() {

1913

1

	MockNet::reset();

1914

1

1915

1

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

1916

1

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

1917

1

1918

1

	let asset_metadata = parachain::AssetMetadata {

1919

1

		name: b"RelayToken".to_vec(),

1920

1

		symbol: b"Relay".to_vec(),

1921

1

		decimals: 12,

1922

1

};

1923

1

1924

1

	ParaA::execute_with(|| {

1925

1

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

1926

1

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

1927

1

			.try_into()

1928

1

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

1929

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

1930

1

			source_id,

1931

1

			source_location_latest,

1932

1

			asset_metadata.decimals,

1933

1

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

1934

1

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

1935

1

));

1936

1

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

1937

1

});

1938

1

1939

1

	let dest: Location = AccountKey20 {

1940

1

		network: None,

1941

1

		key: PARAALICE,

1942

1

1943

1

	.into();

1944

1

	Relay::execute_with(|| {

1945

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

1946

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

1947

1

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

1948

1

			Box::new(VersionedLocation::from(dest).clone()),

1949

1

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

1950

1

0,

1951

1

			WeightLimit::Unlimited

1952

1

));

1953

1

});

1954

1

1955

1

	ParaA::execute_with(|| {

1956

1

		// free execution, full amount received

1957

1

		assert_eq!(

1958

1

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

1959

1

			Ok(U256::from(4000009100u64))

1960

1

);

1961

1

});

1962

1

1963

1

	// Register address

1964

1

	ParaA::execute_with(|| {

1965

1

		assert_ok!(XcmTransactor::register(

1966

1

			parachain::RuntimeOrigin::root(),

1967

1

			PARAALICE.into(),

1968

1

0,

1969

1

));

1970

1

});

1971

1

1972

1

	// Send to registered address

1973

1

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

1974

1

	let dest = Location {

1975

1

		parents: 1,

1976

1

		interior: [AccountId32 {

1977

1

			network: None,

1978

1

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

1979

1

}]

1980

1

		.into(),

1981

1

};

1982

1

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

1983

1

1984

1

	ParaA::execute_with(|| {

1985

1

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

1986

1

		// free execution, full amount received

1987

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

1988

1

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

1989

1

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

1990

1

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

1991

1

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

1992

1

0,

1993

1

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

1994

1

));

1995

1

});

1996

1

1997

1

	ParaA::execute_with(|| {

1998

1

		// free execution, full amount received

1999

1

		assert_eq!(

2000

1

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

2001

1

			Ok(U256::from(4000009000u64))

2002

1

);

2003

1

});

2004

1

2005

1

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

2006

1

	// again

2007

1

	Relay::execute_with(|| {

2008

1

		// free execution,x	 full amount received

2009

1

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

2010

1

2011

1

});

2012

1

2013

1

	// We send the xcm transact operation to parent

2014

1

	let dest = Location {

2015

1

		parents: 1,

2016

1

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

2017

1

};

2018

1

2019

1

	// Encode the call. Balances transact to para_a_account

2020

1

	// First index

2021

1

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

2022

1

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

2023

1

		relay_chain::Balances,

2024

1

>()

2025

1

	.unwrap() as u8;

2026

1

2027

1

	encoded.push(index);

2028

1

2029

1

	// Then call bytes

2030

1

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

2031

1

		dest: para_a_account(),

2032

1

		value: 100u32.into(),

2033

1

2034

1

	.encode();

2035

1

	encoded.append(&mut call_bytes);

2036

1

2037

1

	let utility_bytes = parachain::MockTransactors::Relay.encode_call(

2038

1

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

2039

1

);

2040

1

2041

1

	let total_weight = 4000009000u64;

2042

1

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

2043

1

	ParaA::execute_with(|| {

2044

1

		assert_ok!(XcmTransactor::transact_through_sovereign(

2045

1

			parachain::RuntimeOrigin::root(),

2046

1

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

2047

1

			Some(PARAALICE.into()),

2048

1

			CurrencyPayment {

2049

1

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

2050

1

					Location::parent()

2051

1

				))),

2052

1

				// 1-1 fee-weight mapping

2053

1

				fee_amount: Some(total_weight as u128)

2054

1

},

2055

1

			utility_bytes,

2056

1

			OriginKind::SovereignAccount,

2057

1

			TransactWeights {

2058

1

				transact_required_weight_at_most: 4000000000.into(),

2059

1

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

2060

1

},

2061

1

			true

2062

1

));

2063

1

});

2064

1

2065

1

	Relay::execute_with(|| {

2066

1

		// free execution, full amount received

2067

1

		// 4000009000 refunded + 100 transferred = 4000009100

2068

1

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

2069

2070

1

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

2071

1

});

2072

1

2073

2074

#[test]

2075

1

fn test_automatic_versioning_on_runtime_upgrade_with_relay() {

2076

1

	MockNet::reset();

2077

1

2078

1

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

2079

1

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

2080

1

	let asset_metadata = parachain::AssetMetadata {

2081

1

		name: b"RelayToken".to_vec(),

2082

1

		symbol: b"Relay".to_vec(),

2083

1

		decimals: 12,

2084

1

};

2085

1

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

2086

1

	ParaA::execute_with(|| {

2087

1

		parachain::XcmVersioner::set_version(1);

2088

1

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

2089

1

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

2090

1

			.try_into()

2091

1

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

2092

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2093

1

			source_id,

2094

1

			source_location_latest,

2095

1

			asset_metadata.decimals,

2096

1

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

2097

1

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

2098

1

));

2099

1

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

2100

1

});

2101

1

2102

1

	let response = Response::Version(2);

2103

1

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

2104

1

2105

1

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

2106

1

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

2107

1

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

2108

1

		query_id: 0,

2109

1

		response,

2110

1

		max_weight: Weight::zero(),

2111

1

		querier: Some(querier),

2112

1

	}]);

2113

1

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

2114

1

	// it directly here

2115

1

	// Actually send relay asset to parachain

2116

1

	let dest: Location = AccountKey20 {

2117

1

		network: None,

2118

1

		key: PARAALICE,

2119

1

2120

1

	.into();

2121

1

2122

1

	Relay::execute_with(|| {

2123

1

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

2124

1

		assert_ok!(RelayChainPalletXcm::force_default_xcm_version(

2125

1

			relay_chain::RuntimeOrigin::root(),

2126

1

			Some(3)

2127

1

));

2128

2129

		// Wrap version, which sets VersionedStorage

2130

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

2131

		// this is not necessary in prod

2132

1

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

2133

1

			&Parachain(1).into(),

2134

1

			mock_message

2135

1

));

2136

2137

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

2138

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2139

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2140

1

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

2141

1

			Box::new(VersionedLocation::from(dest).clone()),

2142

1

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

2143

1

0,

2144

1

			WeightLimit::Unlimited

2145

1

));

2146

2147

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

2148

1

		relay_chain::relay_roll_to(2);

2149

1

2150

1

		// queries should have been updated

2151

1

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

2152

1

});

2153

1

2154

1

	let expected_supported_version: relay_chain::RuntimeEvent =

2155

1

		pallet_xcm::Event::SupportedVersionChanged {

2156

1

			location: Location {

2157

1

				parents: 0,

2158

1

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

2159

1

},

2160

1

			version: 1,

2161

1

2162

1

		.into();

2163

1

2164

1

	Relay::execute_with(|| {

2165

1

		// Assert that the events vector contains the version change

2166

1

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

2167

1

});

2168

1

2169

1

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

2170

1

	// of the new version change

2171

1

	ParaA::execute_with(|| {

2172

1

		// Set version

2173

1

		parachain::XcmVersioner::set_version(2);

2174

1

		// Do runtime upgrade

2175

1

		parachain::on_runtime_upgrade();

2176

1

		// Initialize block, to call on_initialize and notify targets

2177

1

		parachain::para_roll_to(2);

2178

1

		// Expect the event in the parachain

2179

1

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

2180

2

e,

2181

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

2182

				result: 2,

2183

..

2184

})

2185

1

		)));

2186

1

});

2187

1

2188

1

	// This event should have been seen in the relay

2189

1

	let expected_supported_version_2: relay_chain::RuntimeEvent =

2190

1

		pallet_xcm::Event::SupportedVersionChanged {

2191

1

			location: Location {

2192

1

				parents: 0,

2193

1

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

2194

1

},

2195

1

			version: 2,

2196

1

2197

1

		.into();

2198

1

2199

1

	Relay::execute_with(|| {

2200

1

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

2201

1

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

2202

1

});

2203

1

2204

2205

#[test]

2206

1

fn receive_asset_with_no_sufficients_is_possible_for_non_existent_account() {

2207

1

	MockNet::reset();

2208

1

2209

1

	let fresh_account = PARABOB;

2210

1

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

2211

1

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

2212

1

	let asset_metadata = parachain::AssetMetadata {

2213

1

		name: b"RelayToken".to_vec(),

2214

1

		symbol: b"Relay".to_vec(),

2215

1

		decimals: 12,

2216

1

};

2217

1

	// register relay asset in parachain A

2218

1

	ParaA::execute_with(|| {

2219

1

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

2220

1

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

2221

1

			.try_into()

2222

1

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

2223

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2224

1

			source_id,

2225

1

			source_location_latest,

2226

1

			asset_metadata.decimals,

2227

1

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

2228

1

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

2229

1

));

2230

1

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

2231

1

});

2232

1

2233

1

	// Actually send relay asset to parachain

2234

1

	let dest: Location = AccountKey20 {

2235

1

		network: None,

2236

1

		key: fresh_account,

2237

1

2238

1

	.into();

2239

1

	Relay::execute_with(|| {

2240

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2241

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2242

1

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

2243

1

			Box::new(VersionedLocation::from(dest.clone()).clone().into()),

2244

1

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

2245

1

0,

2246

1

			WeightLimit::Unlimited

2247

1

));

2248

1

});

2249

1

2250

1

	// parachain should have received assets

2251

1

	ParaA::execute_with(|| {

2252

1

		// free execution, full amount received

2253

1

		assert_eq!(

2254

1

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

2255

1

			Ok(U256::from(123))

2256

1

);

2257

1

});

2258

1

2259

2260

#[test]

2261

1

fn receive_assets_with_sufficients_true_allows_non_funded_account_to_receive_assets() {

2262

1

	MockNet::reset();

2263

1

2264

1

	let fresh_account = [2u8; 20];

2265

1

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

2266

1

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

2267

1

	let asset_metadata = parachain::AssetMetadata {

2268

1

		name: b"RelayToken".to_vec(),

2269

1

		symbol: b"Relay".to_vec(),

2270

1

		decimals: 12,

2271

1

};

2272

1

	// register relay asset in parachain A

2273

1

	ParaA::execute_with(|| {

2274

1

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

2275

1

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

2276

1

			.try_into()

2277

1

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

2278

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2279

1

			source_id,

2280

1

			source_location_latest,

2281

1

			asset_metadata.decimals,

2282

1

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

2283

1

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

2284

1

));

2285

1

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

2286

1

});

2287

1

2288

1

	// Actually send relay asset to parachain

2289

1

	let dest: Location = AccountKey20 {

2290

1

		network: None,

2291

1

		key: fresh_account,

2292

1

2293

1

	.into();

2294

1

	Relay::execute_with(|| {

2295

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2296

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2297

1

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

2298

1

			Box::new(VersionedLocation::from(dest.clone()).clone().into()),

2299

1

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

2300

1

0,

2301

1

			WeightLimit::Unlimited

2302

1

));

2303

1

});

2304

1

2305

1

	// parachain should have received assets

2306

1

	ParaA::execute_with(|| {

2307

1

		// free execution, full amount received

2308

1

		assert_eq!(

2309

1

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

2310

1

			Ok(U256::from(123))

2311

1

);

2312

1

});

2313

1

2314

2315

#[test]

2316

1

fn evm_account_receiving_assets_should_handle_sufficients_ref_count() {

2317

1

	MockNet::reset();

2318

1

2319

1

	let mut sufficient_account = [0u8; 20];

2320

1

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

2321

1

2322

1

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

2323

1

2324

1

	// Evm account is self sufficient

2325

1

	ParaA::execute_with(|| {

2326

1

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

2327

1

});

2328

1

2329

1

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

2330

1

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

2331

1

	let asset_metadata = parachain::AssetMetadata {

2332

1

		name: b"RelayToken".to_vec(),

2333

1

		symbol: b"Relay".to_vec(),

2334

1

		decimals: 12,

2335

1

};

2336

1

	// register relay asset in parachain A

2337

1

	ParaA::execute_with(|| {

2338

1

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

2339

1

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

2340

1

			.try_into()

2341

1

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

2342

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2343

1

			source_id,

2344

1

			source_location_latest,

2345

1

			asset_metadata.decimals,

2346

1

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

2347

1

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

2348

1

));

2349

1

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

2350

1

});

2351

1

2352

1

	// Actually send relay asset to parachain

2353

1

	let dest: Location = AccountKey20 {

2354

1

		network: None,

2355

1

		key: sufficient_account,

2356

1

2357

1

	.into();

2358

1

	Relay::execute_with(|| {

2359

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2360

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2361

1

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

2362

1

			Box::new(VersionedLocation::from(dest.clone()).clone().into()),

2363

1

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

2364

1

0,

2365

1

			WeightLimit::Unlimited

2366

1

));

2367

1

});

2368

1

2369

1

	// Evm account sufficient ref count increased by 1.

2370

1

	ParaA::execute_with(|| {

2371

1

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

2372

1

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

2373

1

		// will be implemented in a future release

2374

1

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

2375

1

});

2376

1

2377

1

	ParaA::execute_with(|| {

2378

1

		// Remove the account from the evm context.

2379

1

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

2380

1

		// Evm account sufficient ref count decreased by 1.

2381

1

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

2382

1

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

2383

1

		// will be implemented in a future release

2384

1

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

2385

1

});

2386

1

2387

2388

#[test]

2389

1

fn empty_account_should_not_be_reset() {

2390

1

	MockNet::reset();

2391

1

2392

1

	// Test account has nonce 1 on genesis.

2393

1

	let sufficient_account = PARABOB;

2394

1

2395

1

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

2396

1

2397

1

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

2398

1

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

2399

1

	let asset_metadata = parachain::AssetMetadata {

2400

1

		name: b"RelayToken".to_vec(),

2401

1

		symbol: b"Relay".to_vec(),

2402

1

		decimals: 12,

2403

1

};

2404

1

	// register relay asset in parachain A

2405

1

	ParaA::execute_with(|| {

2406

1

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

2407

1

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

2408

1

			.try_into()

2409

1

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

2410

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2411

1

			source_id,

2412

1

			source_location_latest,

2413

1

			asset_metadata.decimals,

2414

1

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

2415

1

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

2416

1

));

2417

1

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

2418

1

});

2419

1

2420

1

	// Send native token to evm_account

2421

1

	ParaA::execute_with(|| {

2422

1

		assert_ok!(ParaBalances::transfer_allow_death(

2423

1

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

2424

1

			evm_account_id,

2425

1

2426

1

));

2427

1

});

2428

1

2429

1

	// Actually send relay asset to parachain

2430

1

	let dest: Location = AccountKey20 {

2431

1

		network: None,

2432

1

		key: sufficient_account,

2433

1

2434

1

	.into();

2435

1

	Relay::execute_with(|| {

2436

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2437

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2438

1

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

2439

1

			Box::new(VersionedLocation::from(dest.clone()).clone().into()),

2440

1

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

2441

1

0,

2442

1

			WeightLimit::Unlimited

2443

1

));

2444

1

});

2445

1

2446

1

	ParaA::execute_with(|| {

2447

1

		// Empty the assets from the account.

2448

1

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

2449

1

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

2450

1

		// Transfer using EvmForeignAssets

2451

1

		assert_ok!(EvmForeignAssets::transfer(

2452

1

			source_id,

2453

1

			evm_account_id,

2454

1

			PARAALICE.into(),

2455

1

			U256::from(123)

2456

1

));

2457

		// Verify account asset balance is Zero.

2458

1

		assert_eq!(

2459

1

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

2460

1

			Ok(U256::from(0))

2461

1

);

2462

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

2463

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

2464

1

		assert_ok!(ParaBalances::force_set_balance(

2465

1

			parachain::RuntimeOrigin::root(),

2466

1

			evm_account_id,

2467

1

0,

2468

1

));

2469

		// Verify account native balance is Zero.

2470

1

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

2471

		// Remove the account from the evm context.

2472

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

2473

1

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

2474

1

		// Verify reference count.

2475

1

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

2476

1

		assert_eq!(account.sufficients, 0);

2477

1

		assert_eq!(account.consumers, 0);

2478

1

		assert_eq!(account.providers, 1);

2479

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

2480

1

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

2481

1

});

2482

1

2483

2484

#[test]

2485

1

fn test_statemint_like() {

2486

1

	MockNet::reset();

2487

1

2488

1

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

2489

1

2490

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2491

1

		polkadot_parachain::primitives::Sibling,

2492

1

		statemint_like::AccountId,

2493

1

	>::convert_location(&dest_para)

2494

1

	.unwrap();

2495

1

2496

1

	let statemint_asset_a_balances = Location::new(

2497

1

1,

2498

1

2499

1

			Parachain(1000),

2500

1

			PalletInstance(5),

2501

1

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

2502

1

],

2503

1

);

2504

1

	let source_location: AssetType = statemint_asset_a_balances

2505

1

		.try_into()

2506

1

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

2507

1

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

2508

1

2509

1

	let asset_metadata = parachain::AssetMetadata {

2510

1

		name: b"StatemintToken".to_vec(),

2511

1

		symbol: b"StatemintToken".to_vec(),

2512

1

		decimals: 12,

2513

1

};

2514

1

2515

1

	ParaA::execute_with(|| {

2516

1

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

2517

1

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

2518

1

			.try_into()

2519

1

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

2520

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2521

1

			source_id,

2522

1

			source_location_latest,

2523

1

			asset_metadata.decimals,

2524

1

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

2525

1

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

2526

1

));

2527

1

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

2528

1

});

2529

1

2530

1

	Statemint::execute_with(|| {

2531

1

		// Set new prefix

2532

1

		statemint_like::PrefixChanger::set_prefix(

2533

1

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

2534

1

);

2535

1

2536

1

		assert_ok!(StatemintAssets::create(

2537

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2538

1

0,

2539

1

			RELAYALICE,

2540

1

2541

1

));

2542

2543

1

		assert_ok!(StatemintAssets::mint(

2544

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2545

1

0,

2546

1

			RELAYALICE,

2547

1

			300000000000000

2548

1

));

2549

2550

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

2551

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2552

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2553

1

			sov,

2554

1

			100000000000000

2555

1

));

2556

2557

		// Actually send relay asset to parachain

2558

1

		let dest: Location = AccountKey20 {

2559

1

			network: None,

2560

1

			key: PARAALICE,

2561

1

2562

1

		.into();

2563

1

2564

1

		// Send with new prefix

2565

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2566

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2567

1

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

2568

1

			Box::new(VersionedLocation::from(dest).clone()),

2569

1

			Box::new(

2570

1

2571

1

2572

1

						xcm::latest::prelude::PalletInstance(

2573

1

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

2574

1

),

2575

1

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

2576

1

],

2577

1

2578

1

2579

1

					.into()

2580

1

),

2581

1

0,

2582

1

			WeightLimit::Unlimited

2583

1

));

2584

1

});

2585

1

2586

1

	ParaA::execute_with(|| {

2587

1

		assert_eq!(

2588

1

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

2589

1

			Ok(U256::from(123))

2590

1

);

2591

1

});

2592

1

2593

2594

#[test]

2595

2596

1

fn send_statemint_asset_from_para_a_to_statemint_with_relay_fee() {

2597

1

	MockNet::reset();

2598

1

2599

1

	// Relay asset

2600

1

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

2601

1

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

2602

1

2603

1

	let relay_asset_metadata = parachain::AssetMetadata {

2604

1

		name: b"RelayToken".to_vec(),

2605

1

		symbol: b"Relay".to_vec(),

2606

1

		decimals: 12,

2607

1

};

2608

1

2609

1

	// Statemint asset

2610

1

	let statemint_asset = Location::new(

2611

1

1,

2612

1

2613

1

			Parachain(1000u32),

2614

1

			PalletInstance(5u8),

2615

1

			GeneralIndex(10u128),

2616

1

],

2617

1

);

2618

1

	let statemint_location_asset: AssetType = statemint_asset

2619

1

		.clone()

2620

1

		.try_into()

2621

1

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

2622

1

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

2623

1

2624

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

2625

1

		name: b"USDC".to_vec(),

2626

1

		symbol: b"USDC".to_vec(),

2627

1

		decimals: 12,

2628

1

};

2629

1

2630

1

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

2631

1

2632

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2633

1

		polkadot_parachain::primitives::Sibling,

2634

1

		statemint_like::AccountId,

2635

1

	>::convert_location(&dest_para)

2636

1

	.unwrap();

2637

1

2638

1

	ParaA::execute_with(|| {

2639

1

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

2640

1

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

2641

1

			.try_into()

2642

1

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

2643

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2644

1

			source_relay_id,

2645

1

			source_location_latest,

2646

1

			relay_asset_metadata.decimals,

2647

1

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

2648

1

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

2649

1

));

2650

1

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

2651

2652

1

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

2653

1

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

2654

1

			.try_into()

2655

1

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

2656

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2657

1

			source_statemint_asset_id,

2658

1

			source_location_latest,

2659

1

			asset_metadata_statemint_asset.decimals,

2660

1

			asset_metadata_statemint_asset

2661

1

				.symbol

2662

1

				.try_into()

2663

1

				.expect("too long"),

2664

1

			asset_metadata_statemint_asset

2665

1

				.name

2666

1

				.try_into()

2667

1

				.expect("too long"),

2668

1

));

2669

1

		assert_ok!(add_supported_asset(statemint_location_asset, 0u128));

2670

1

});

2671

1

2672

1

	let parachain_beneficiary_from_relay: Location = Junction::AccountKey20 {

2673

1

		network: None,

2674

1

		key: PARAALICE,

2675

1

2676

1

	.into();

2677

1

2678

1

	// Send relay chain asset to Alice in Parachain A

2679

1

	Relay::execute_with(|| {

2680

1

		assert_ok!(RelayChainPalletXcm::limited_reserve_transfer_assets(

2681

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2682

1

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

2683

1

			Box::new(

2684

1

				VersionedLocation::from(parachain_beneficiary_from_relay)

2685

1

					.clone()

2686

1

					.into()

2687

1

),

2688

1

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

2689

1

0,

2690

1

			WeightLimit::Unlimited

2691

1

));

2692

1

});

2693

1

2694

1

	Statemint::execute_with(|| {

2695

1

		// Set new prefix

2696

1

		statemint_like::PrefixChanger::set_prefix(

2697

1

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

2698

1

);

2699

1

2700

1

		assert_ok!(StatemintAssets::create(

2701

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2702

1

10,

2703

1

			RELAYALICE,

2704

1

2705

1

));

2706

2707

1

		assert_ok!(StatemintAssets::mint(

2708

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2709

1

10,

2710

1

			RELAYALICE,

2711

1

			300000000000000

2712

1

));

2713

2714

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

2715

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

2716

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2717

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2718

1

			sov,

2719

1

			100000000000000

2720

1

));

2721

2722

		// Send statemint USDC asset to Alice in Parachain A

2723

1

		let parachain_beneficiary_from_statemint: Location = AccountKey20 {

2724

1

			network: None,

2725

1

			key: PARAALICE,

2726

1

2727

1

		.into();

2728

1

2729

1

		// Send with new prefix

2730

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2731

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2732

1

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

2733

1

			Box::new(

2734

1

				VersionedLocation::from(parachain_beneficiary_from_statemint)

2735

1

					.clone()

2736

1

					.into()

2737

1

),

2738

1

			Box::new(

2739

1

2740

1

2741

1

						xcm::latest::prelude::PalletInstance(

2742

1

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

2743

1

),

2744

1

						GeneralIndex(10),

2745

1

],

2746

1

2747

1

2748

1

					.into()

2749

1

),

2750

1

0,

2751

1

			WeightLimit::Unlimited

2752

1

));

2753

1

});

2754

1

2755

1

	let statemint_beneficiary = Location {

2756

1

		parents: 1,

2757

1

		interior: [

2758

1

			Parachain(1000),

2759

1

			AccountId32 {

2760

1

				network: None,

2761

1

				id: RELAYBOB.into(),

2762

1

},

2763

1

2764

1

		.into(),

2765

1

};

2766

1

2767

1

	ParaA::execute_with(|| {

2768

1

		// Alice has received 125 USDC

2769

1

		assert_eq!(

2770

1

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

2771

1

			Ok(U256::from(125))

2772

1

);

2773

2774

		// Alice has received 200 Relay assets

2775

1

		assert_eq!(

2776

1

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

2777

1

			Ok(U256::from(200))

2778

1

);

2779

1

});

2780

1

2781

1

	Statemint::execute_with(|| {

2782

1

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

2783

1

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

2784

1

});

2785

1

	let (chain_part, beneficiary) =

2786

1

		split_location_into_chain_part_and_beneficiary(statemint_beneficiary).unwrap();

2787

1

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

2788

1

	ParaA::execute_with(|| {

2789

1

		let asset = currency_to_asset(

2790

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

2791

1

			100,

2792

1

);

2793

1

		let asset_fee =

2794

1

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

2795

1

		let assets_to_send: XcmAssets = XcmAssets::from(vec![asset, asset_fee.clone()]);

2796

1

		assert_eq!(assets_to_send.get(0).unwrap(), &asset_fee);

2797

2798

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

2799

1

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

2800

1

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

2801

1

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

2802

1

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

2803

1

0,

2804

1

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

2805

1

));

2806

1

});

2807

1

2808

1

	ParaA::execute_with(|| {

2809

1

		// Alice has 100 USDC less

2810

1

		assert_eq!(

2811

1

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

2812

1

			Ok(U256::from(25))

2813

1

);

2814

2815

		// Alice has 100 relay asset less

2816

1

		assert_eq!(

2817

1

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

2818

1

			Ok(U256::from(100))

2819

1

);

2820

1

});

2821

1

2822

1

	Statemint::execute_with(|| {

2823

1

		println!("STATEMINT EVENTS: {:?}", parachain::para_events());

2824

1

		// Check that BOB received 100 USDC on statemint

2825

1

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

2826

1

});

2827

1

2828

2829

#[test]

2830

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer() {

2831

1

	MockNet::reset();

2832

1

2833

1

	// Relay asset

2834

1

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

2835

1

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

2836

1

2837

1

	let relay_asset_metadata = parachain::AssetMetadata {

2838

1

		name: b"RelayToken".to_vec(),

2839

1

		symbol: b"Relay".to_vec(),

2840

1

		decimals: 12,

2841

1

};

2842

1

2843

1

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

2844

1

2845

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

2846

1

		polkadot_parachain::primitives::Sibling,

2847

1

		statemint_like::AccountId,

2848

1

	>::convert_location(&dest_para)

2849

1

	.unwrap();

2850

1

2851

1

	ParaA::execute_with(|| {

2852

1

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

2853

1

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

2854

1

			.try_into()

2855

1

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

2856

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

2857

1

			source_relay_id,

2858

1

			source_location_latest,

2859

1

			relay_asset_metadata.decimals,

2860

1

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

2861

1

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

2862

1

));

2863

1

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

2864

1

});

2865

1

2866

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

2867

1

		network: None,

2868

1

		key: PARAALICE,

2869

1

2870

1

	.into();

2871

1

2872

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

2873

1

		network: None,

2874

1

		id: RELAYALICE.into(),

2875

1

2876

1

	.into();

2877

1

2878

1

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

2879

1

	Relay::execute_with(|| {

2880

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

2881

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

2882

1

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

2883

1

			Box::new(

2884

1

				VersionedLocation::from(statemint_beneficiary_absolute)

2885

1

					.clone()

2886

1

					.into()

2887

1

),

2888

1

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

2889

1

0,

2890

1

			WeightLimit::Unlimited

2891

1

));

2892

1

});

2893

1

2894

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

2895

1

	Statemint::execute_with(|| {

2896

1

		// Check Alice received 200 tokens on AssetHub

2897

1

		assert_eq!(

2898

1

			StatemintBalances::free_balance(RELAYALICE),

2899

1

			INITIAL_BALANCE + 200

2900

1

);

2901

2902

1

		assert_ok!(StatemintBalances::transfer_allow_death(

2903

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2904

1

			sov,

2905

1

			110000000000000

2906

1

));

2907

2908

		// Now send those tokens to ParaA

2909

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2910

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

2911

1

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

2912

1

			Box::new(

2913

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

2914

1

					.clone()

2915

1

					.into()

2916

1

),

2917

1

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

2918

1

0,

2919

1

			WeightLimit::Unlimited

2920

1

));

2921

1

});

2922

1

2923

1

	ParaA::execute_with(|| {

2924

1

		// Alice should have received the DOTs

2925

1

		assert_eq!(

2926

1

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

2927

1

			Ok(U256::from(200))

2928

1

);

2929

1

});

2930

1

2931

1

	let dest = Location::new(

2932

1

1,

2933

1

2934

1

			Parachain(1000),

2935

1

			AccountId32 {

2936

1

				network: None,

2937

1

				id: RELAYBOB.into(),

2938

1

},

2939

1

],

2940

1

);

2941

1

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

2942

1

2943

1

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

2944

1

	ParaA::execute_with(|| {

2945

1

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

2946

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

2947

1

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

2948

1

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

2949

1

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

2950

1

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

2951

1

0,

2952

1

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

2953

1

));

2954

2955

1

		assert_eq!(

2956

1

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

2957

1

			Ok(U256::from(100))

2958

1

);

2959

1

});

2960

1

2961

1

	Statemint::execute_with(|| {

2962

1

		// Check that Bob received the tokens back in AssetHub

2963

1

		assert_eq!(

2964

1

			StatemintBalances::free_balance(RELAYBOB),

2965

1

			INITIAL_BALANCE + 100

2966

1

);

2967

1

});

2968

1

2969

1

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

2970

1

	Statemint::execute_with(|| {

2971

1

		// Now send those tokens to ParaA

2972

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

2973

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

2974

1

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

2975

1

			Box::new(

2976

1

				VersionedLocation::from(parachain_beneficiary_absolute)

2977

1

					.clone()

2978

1

					.into()

2979

1

),

2980

1

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

2981

1

0,

2982

1

			WeightLimit::Unlimited

2983

1

));

2984

2985

		// 100 DOTs were deducted from Bob's account

2986

1

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

2987

1

});

2988

1

2989

1

	ParaA::execute_with(|| {

2990

1

		// Alice should have received 100 DOTs

2991

1

		assert_eq!(

2992

1

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

2993

1

			Ok(U256::from(200))

2994

1

);

2995

1

});

2996

1

2997

2998

#[test]

2999

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_with_fee() {

3000

1

	MockNet::reset();

3001

1

3002

1

	// Relay asset

3003

1

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

3004

1

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

3005

1

3006

1

	let relay_asset_metadata = parachain::AssetMetadata {

3007

1

		name: b"RelayToken".to_vec(),

3008

1

		symbol: b"Relay".to_vec(),

3009

1

		decimals: 12,

3010

1

};

3011

1

3012

1

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

3013

1

3014

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3015

1

		polkadot_parachain::primitives::Sibling,

3016

1

		statemint_like::AccountId,

3017

1

	>::convert_location(&dest_para)

3018

1

	.unwrap();

3019

1

3020

1

	ParaA::execute_with(|| {

3021

1

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

3022

1

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

3023

1

			.try_into()

3024

1

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

3025

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3026

1

			source_relay_id,

3027

1

			source_location_latest,

3028

1

			relay_asset_metadata.decimals,

3029

1

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

3030

1

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

3031

1

));

3032

1

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

3033

1

});

3034

1

3035

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3036

1

		network: None,

3037

1

		key: PARAALICE,

3038

1

3039

1

	.into();

3040

1

3041

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3042

1

		network: None,

3043

1

		id: RELAYALICE.into(),

3044

1

3045

1

	.into();

3046

1

3047

1

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

3048

1

	Relay::execute_with(|| {

3049

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3050

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3051

1

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

3052

1

			Box::new(

3053

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3054

1

					.clone()

3055

1

					.into()

3056

1

),

3057

1

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

3058

1

0,

3059

1

			WeightLimit::Unlimited

3060

1

));

3061

1

});

3062

1

3063

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3064

1

	Statemint::execute_with(|| {

3065

1

		// Check Alice received 200 tokens on AssetHub

3066

1

		assert_eq!(

3067

1

			StatemintBalances::free_balance(RELAYALICE),

3068

1

			INITIAL_BALANCE + 200

3069

1

);

3070

3071

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3072

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3073

1

			sov,

3074

1

			110000000000000

3075

1

));

3076

3077

		// Now send those tokens to ParaA

3078

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3079

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3080

1

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

3081

1

			Box::new(

3082

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3083

1

					.clone()

3084

1

					.into()

3085

1

),

3086

1

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

3087

1

0,

3088

1

			WeightLimit::Unlimited

3089

1

));

3090

1

});

3091

1

3092

1

	ParaA::execute_with(|| {

3093

1

		// Alice should have received the DOTs

3094

1

		assert_eq!(

3095

1

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

3096

1

			Ok(U256::from(200))

3097

1

);

3098

1

});

3099

1

3100

1

	let dest = Location::new(

3101

1

1,

3102

1

3103

1

			Parachain(1000),

3104

1

			AccountId32 {

3105

1

				network: None,

3106

1

				id: RELAYBOB.into(),

3107

1

},

3108

1

],

3109

1

);

3110

1

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

3111

1

3112

1

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

3113

1

	ParaA::execute_with(|| {

3114

1

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

3115

1

		let asset_fee = currency_to_asset(parachain::CurrencyId::ForeignAsset(source_relay_id), 10);

3116

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3117

1

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

3118

1

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

3119

1

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

3120

1

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

3121

1

0,

3122

1

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

3123

1

));

3124

3125

1

		assert_eq!(

3126

1

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

3127

1

			Ok(U256::from(90))

3128

1

);

3129

1

});

3130

1

3131

1

	Statemint::execute_with(|| {

3132

1

		// Free execution: check that Bob received the tokens back in AssetHub

3133

1

		assert_eq!(

3134

1

			StatemintBalances::free_balance(RELAYBOB),

3135

1

			INITIAL_BALANCE + 110

3136

1

);

3137

1

});

3138

1

3139

1

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

3140

1

	Statemint::execute_with(|| {

3141

1

		// Now send those tokens to ParaA

3142

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3143

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3144

1

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

3145

1

			Box::new(

3146

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3147

1

					.clone()

3148

1

					.into()

3149

1

),

3150

1

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

3151

1

0,

3152

1

			WeightLimit::Unlimited

3153

1

));

3154

3155

		// 100 DOTs were deducted from Bob's account

3156

1

		assert_eq!(

3157

1

			StatemintBalances::free_balance(RELAYBOB),

3158

1

			INITIAL_BALANCE + 10

3159

1

);

3160

1

});

3161

1

3162

1

	ParaA::execute_with(|| {

3163

1

		// Alice should have received 100 DOTs

3164

1

		assert_eq!(

3165

1

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

3166

1

			Ok(U256::from(190))

3167

1

);

3168

1

});

3169

1

3170

3171

#[test]

3172

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiasset() {

3173

1

	MockNet::reset();

3174

1

3175

1

	// Relay asset

3176

1

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

3177

1

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

3178

1

3179

1

	let relay_asset_metadata = parachain::AssetMetadata {

3180

1

		name: b"RelayToken".to_vec(),

3181

1

		symbol: b"Relay".to_vec(),

3182

1

		decimals: 12,

3183

1

};

3184

1

3185

1

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

3186

1

3187

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3188

1

		polkadot_parachain::primitives::Sibling,

3189

1

		statemint_like::AccountId,

3190

1

	>::convert_location(&dest_para)

3191

1

	.unwrap();

3192

1

3193

1

	ParaA::execute_with(|| {

3194

1

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

3195

1

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

3196

1

			.try_into()

3197

1

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

3198

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3199

1

			source_relay_id,

3200

1

			source_location_latest,

3201

1

			relay_asset_metadata.decimals,

3202

1

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

3203

1

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

3204

1

));

3205

1

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

3206

1

});

3207

1

3208

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3209

1

		network: None,

3210

1

		key: PARAALICE,

3211

1

3212

1

	.into();

3213

1

3214

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3215

1

		network: None,

3216

1

		id: RELAYALICE.into(),

3217

1

3218

1

	.into();

3219

1

3220

1

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

3221

1

	Relay::execute_with(|| {

3222

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3223

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3224

1

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

3225

1

			Box::new(

3226

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3227

1

					.clone()

3228

1

					.into()

3229

1

),

3230

1

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

3231

1

0,

3232

1

			WeightLimit::Unlimited

3233

1

));

3234

1

});

3235

1

3236

1

	// Send DOTs from AssetHub to ParaA (Moonbeam)

3237

1

	Statemint::execute_with(|| {

3238

1

		// Check Alice received 200 tokens on AssetHub

3239

1

		assert_eq!(

3240

1

			StatemintBalances::free_balance(RELAYALICE),

3241

1

			INITIAL_BALANCE + 200

3242

1

);

3243

3244

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3245

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3246

1

			sov,

3247

1

			110000000000000

3248

1

));

3249

3250

		// Now send those tokens to ParaA

3251

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3252

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3253

1

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

3254

1

			Box::new(

3255

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3256

1

					.clone()

3257

1

					.into()

3258

1

),

3259

1

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

3260

1

0,

3261

1

			WeightLimit::Unlimited

3262

1

));

3263

1

});

3264

1

3265

1

	ParaA::execute_with(|| {

3266

1

		// Alice should have received the DOTs

3267

1

		assert_eq!(

3268

1

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

3269

1

			Ok(U256::from(200))

3270

1

);

3271

1

});

3272

1

3273

1

	let dest = Location::new(

3274

1

1,

3275

1

3276

1

			Parachain(1000),

3277

1

			AccountId32 {

3278

1

				network: None,

3279

1

				id: RELAYBOB.into(),

3280

1

},

3281

1

],

3282

1

);

3283

1

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

3284

1

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

3285

1

	ParaA::execute_with(|| {

3286

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3287

1

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

3288

1

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

3289

1

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

3290

1

			Box::new(VersionedAssets::from((Location::parent(), 100))),

3291

1

0,

3292

1

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

3293

1

));

3294

3295

1

		assert_eq!(

3296

1

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

3297

1

			Ok(U256::from(100))

3298

1

);

3299

1

});

3300

1

3301

1

	Statemint::execute_with(|| {

3302

1

		// Check that Bob received the tokens back in AssetHub

3303

1

		assert_eq!(

3304

1

			StatemintBalances::free_balance(RELAYBOB),

3305

1

			INITIAL_BALANCE + 100

3306

1

);

3307

1

});

3308

1

3309

1

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

3310

1

	Statemint::execute_with(|| {

3311

1

		// Now send those tokens to ParaA

3312

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3313

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3314

1

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

3315

1

			Box::new(

3316

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3317

1

					.clone()

3318

1

					.into()

3319

1

),

3320

1

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

3321

1

0,

3322

1

			WeightLimit::Unlimited

3323

1

));

3324

3325

		// 100 DOTs were deducted from Bob's account

3326

1

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

3327

1

});

3328

1

3329

1

	ParaA::execute_with(|| {

3330

1

		// Alice should have received 100 DOTs

3331

1

		assert_eq!(

3332

1

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

3333

1

			Ok(U256::from(200))

3334

1

);

3335

1

});

3336

1

3337

3338

#[test]

3339

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multicurrencies() {

3340

1

	MockNet::reset();

3341

1

3342

1

	// Relay asset

3343

1

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

3344

1

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

3345

1

3346

1

	let relay_asset_metadata = parachain::AssetMetadata {

3347

1

		name: b"RelayToken".to_vec(),

3348

1

		symbol: b"Relay".to_vec(),

3349

1

		decimals: 12,

3350

1

};

3351

1

3352

1

	// Statemint asset

3353

1

	let statemint_asset = Location::new(

3354

1

1,

3355

1

3356

1

			Parachain(1000u32),

3357

1

			PalletInstance(5u8),

3358

1

			GeneralIndex(10u128),

3359

1

],

3360

1

);

3361

1

	let statemint_location_asset: AssetType = statemint_asset

3362

1

		.clone()

3363

1

		.try_into()

3364

1

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

3365

1

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

3366

1

3367

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3368

1

		name: b"USDC".to_vec(),

3369

1

		symbol: b"USDC".to_vec(),

3370

1

		decimals: 12,

3371

1

};

3372

1

3373

1

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

3374

1

3375

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3376

1

		polkadot_parachain::primitives::Sibling,

3377

1

		statemint_like::AccountId,

3378

1

	>::convert_location(&dest_para)

3379

1

	.unwrap();

3380

1

3381

1

	ParaA::execute_with(|| {

3382

1

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

3383

1

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

3384

1

			.try_into()

3385

1

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

3386

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3387

1

			source_relay_id,

3388

1

			source_location_latest,

3389

1

			relay_asset_metadata.decimals,

3390

1

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

3391

1

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

3392

1

));

3393

1

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

3394

1

3395

1

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

3396

1

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

3397

1

			.try_into()

3398

1

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

3399

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3400

1

			source_statemint_asset_id,

3401

1

			source_location_latest,

3402

1

			asset_metadata_statemint_asset.decimals,

3403

1

			asset_metadata_statemint_asset

3404

1

				.symbol

3405

1

				.try_into()

3406

1

				.expect("too long"),

3407

1

			asset_metadata_statemint_asset

3408

1

				.name

3409

1

				.try_into()

3410

1

				.expect("too long"),

3411

1

));

3412

1

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

3413

1

});

3414

1

3415

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3416

1

		network: None,

3417

1

		key: PARAALICE,

3418

1

3419

1

	.into();

3420

1

3421

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3422

1

		network: None,

3423

1

		id: RELAYALICE.into(),

3424

1

3425

1

	.into();

3426

1

3427

1

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

3428

1

	Relay::execute_with(|| {

3429

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3430

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3431

1

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

3432

1

			Box::new(

3433

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3434

1

					.clone()

3435

1

					.into()

3436

1

),

3437

1

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

3438

1

0,

3439

1

			WeightLimit::Unlimited

3440

1

));

3441

1

});

3442

1

3443

1

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3444

1

	Statemint::execute_with(|| {

3445

1

		// Check Alice received 200 tokens on AssetHub

3446

1

		assert_eq!(

3447

1

			StatemintBalances::free_balance(RELAYALICE),

3448

1

			INITIAL_BALANCE + 200

3449

1

);

3450

3451

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3452

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3453

1

			sov,

3454

1

			110000000000000

3455

1

));

3456

3457

1

		statemint_like::PrefixChanger::set_prefix(

3458

1

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

3459

1

);

3460

1

3461

1

		assert_ok!(StatemintAssets::create(

3462

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3463

1

10,

3464

1

			RELAYALICE,

3465

1

3466

1

));

3467

3468

1

		assert_ok!(StatemintAssets::mint(

3469

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3470

1

10,

3471

1

			RELAYALICE,

3472

1

			300000000000000

3473

1

));

3474

3475

		// Now send relay tokens to ParaA

3476

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3477

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3478

1

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

3479

1

			Box::new(

3480

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3481

1

					.clone()

3482

1

					.into()

3483

1

),

3484

1

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

3485

1

0,

3486

1

			WeightLimit::Unlimited

3487

1

));

3488

3489

		// Send USDC

3490

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3491

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3492

1

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

3493

1

			Box::new(

3494

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3495

1

					.clone()

3496

1

					.into()

3497

1

),

3498

1

			Box::new(

3499

1

3500

1

3501

1

						xcm::latest::prelude::PalletInstance(

3502

1

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

3503

1

),

3504

1

						GeneralIndex(10),

3505

1

],

3506

1

3507

1

3508

1

					.into()

3509

1

),

3510

1

0,

3511

1

			WeightLimit::Unlimited

3512

1

));

3513

1

});

3514

1

3515

1

	ParaA::execute_with(|| {

3516

1

		// Alice should have received the DOTs

3517

1

		assert_eq!(

3518

1

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

3519

1

			Ok(U256::from(200))

3520

1

);

3521

3522

		// Alice has received 125 USDC

3523

1

		assert_eq!(

3524

1

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

3525

1

			Ok(U256::from(125))

3526

1

);

3527

1

});

3528

1

3529

1

	let dest = Location::new(

3530

1

1,

3531

1

3532

1

			Parachain(1000),

3533

1

			AccountId32 {

3534

1

				network: None,

3535

1

				id: RELAYBOB.into(),

3536

1

},

3537

1

],

3538

1

);

3539

1

3540

1

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

3541

1

3542

1

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

3543

1

	ParaA::execute_with(|| {

3544

1

		let asset_1 = currency_to_asset(

3545

1

			parachain::CurrencyId::ForeignAsset(source_statemint_asset_id),

3546

1

			100,

3547

1

);

3548

1

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

3549

1

		let assets_to_send = vec![asset_1, asset_2];

3550

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3551

1

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

3552

1

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

3553

1

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

3554

1

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

3555

1

1,

3556

1

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

3557

1

));

3558

3559

1

		assert_eq!(

3560

1

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

3561

1

			Ok(U256::from(100))

3562

1

);

3563

1

});

3564

1

3565

1

	Statemint::execute_with(|| {

3566

1

		// Check that Bob received relay tokens back in AssetHub

3567

1

		assert_eq!(

3568

1

			StatemintBalances::free_balance(RELAYBOB),

3569

1

			INITIAL_BALANCE + 100

3570

1

);

3571

3572

		// Check that BOB received 100 USDC on AssetHub

3573

1

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

3574

1

});

3575

1

3576

1

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

3577

1

	Statemint::execute_with(|| {

3578

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3579

1

3580

1

		// Now send those tokens to ParaA

3581

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3582

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3583

1

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

3584

1

			Box::new(

3585

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3586

1

					.clone()

3587

1

					.into()

3588

1

),

3589

1

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

3590

1

0,

3591

1

			WeightLimit::Unlimited

3592

1

));

3593

3594

		// 100 DOTs were deducted from Bob's account

3595

1

		assert_eq!(

3596

1

			StatemintBalances::free_balance(RELAYBOB),

3597

1

			bob_previous_balance - 100

3598

1

);

3599

1

});

3600

1

3601

1

	ParaA::execute_with(|| {

3602

1

		// Alice should have received 100 DOTs

3603

1

		assert_eq!(

3604

1

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

3605

1

			Ok(U256::from(200))

3606

1

);

3607

1

});

3608

1

3609

3610

#[test]

3611

1

fn send_dot_from_moonbeam_to_statemint_via_xtokens_transfer_multiassets() {

3612

1

	MockNet::reset();

3613

1

3614

1

	// Relay asset

3615

1

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

3616

1

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

3617

1

3618

1

	let relay_asset_metadata = parachain::AssetMetadata {

3619

1

		name: b"RelayToken".to_vec(),

3620

1

		symbol: b"Relay".to_vec(),

3621

1

		decimals: 12,

3622

1

};

3623

1

3624

1

	// Statemint asset

3625

1

	let statemint_asset = Location::new(

3626

1

1,

3627

1

3628

1

			Parachain(1000u32),

3629

1

			PalletInstance(5u8),

3630

1

			GeneralIndex(10u128),

3631

1

],

3632

1

);

3633

1

	let statemint_location_asset: AssetType = statemint_asset

3634

1

		.clone()

3635

1

		.try_into()

3636

1

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

3637

1

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

3638

1

3639

1

	let asset_metadata_statemint_asset = parachain::AssetMetadata {

3640

1

		name: b"USDC".to_vec(),

3641

1

		symbol: b"USDC".to_vec(),

3642

1

		decimals: 12,

3643

1

};

3644

1

3645

1

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

3646

1

3647

1

	let sov = xcm_builder::SiblingParachainConvertsVia::<

3648

1

		polkadot_parachain::primitives::Sibling,

3649

1

		statemint_like::AccountId,

3650

1

	>::convert_location(&dest_para)

3651

1

	.unwrap();

3652

1

3653

1

	ParaA::execute_with(|| {

3654

1

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

3655

1

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

3656

1

			.try_into()

3657

1

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

3658

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3659

1

			source_relay_id,

3660

1

			source_location_latest,

3661

1

			relay_asset_metadata.decimals,

3662

1

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

3663

1

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

3664

1

));

3665

1

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

3666

1

3667

1

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

3668

1

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

3669

1

			.try_into()

3670

1

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

3671

1

		assert_ok!(EvmForeignAssets::register_foreign_asset(

3672

1

			source_statemint_asset_id,

3673

1

			source_location_latest,

3674

1

			asset_metadata_statemint_asset.decimals,

3675

1

			asset_metadata_statemint_asset

3676

1

				.symbol

3677

1

				.try_into()

3678

1

				.expect("too long"),

3679

1

			asset_metadata_statemint_asset

3680

1

				.name

3681

1

				.try_into()

3682

1

				.expect("too long"),

3683

1

));

3684

1

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

3685

1

});

3686

1

3687

1

	let parachain_beneficiary_absolute: Location = Junction::AccountKey20 {

3688

1

		network: None,

3689

1

		key: PARAALICE,

3690

1

3691

1

	.into();

3692

1

3693

1

	let statemint_beneficiary_absolute: Location = Junction::AccountId32 {

3694

1

		network: None,

3695

1

		id: RELAYALICE.into(),

3696

1

3697

1

	.into();

3698

1

3699

1

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

3700

1

	Relay::execute_with(|| {

3701

1

		assert_ok!(RelayChainPalletXcm::limited_teleport_assets(

3702

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3703

1

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

3704

1

			Box::new(

3705

1

				VersionedLocation::from(statemint_beneficiary_absolute)

3706

1

					.clone()

3707

1

					.into()

3708

1

),

3709

1

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

3710

1

0,

3711

1

			WeightLimit::Unlimited

3712

1

));

3713

1

});

3714

1

3715

1

	// Send DOTs and USDC from AssetHub to ParaA (Moonbeam)

3716

1

	Statemint::execute_with(|| {

3717

1

		// Check Alice received 200 tokens on AssetHub

3718

1

		assert_eq!(

3719

1

			StatemintBalances::free_balance(RELAYALICE),

3720

1

			INITIAL_BALANCE + 200

3721

1

);

3722

3723

1

		assert_ok!(StatemintBalances::transfer_allow_death(

3724

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3725

1

			sov,

3726

1

			110000000000000

3727

1

));

3728

3729

1

		statemint_like::PrefixChanger::set_prefix(

3730

1

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

3731

1

);

3732

1

3733

1

		assert_ok!(StatemintAssets::create(

3734

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3735

1

10,

3736

1

			RELAYALICE,

3737

1

3738

1

));

3739

3740

1

		assert_ok!(StatemintAssets::mint(

3741

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3742

1

10,

3743

1

			RELAYALICE,

3744

1

			300000000000000

3745

1

));

3746

3747

		// Now send relay tokens to ParaA

3748

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3749

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3750

1

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

3751

1

			Box::new(

3752

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3753

1

					.clone()

3754

1

					.into()

3755

1

),

3756

1

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

3757

1

0,

3758

1

			WeightLimit::Unlimited

3759

1

));

3760

3761

		// Send USDC

3762

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3763

1

			statemint_like::RuntimeOrigin::signed(RELAYALICE),

3764

1

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

3765

1

			Box::new(

3766

1

				VersionedLocation::from(parachain_beneficiary_absolute.clone())

3767

1

					.clone()

3768

1

					.into()

3769

1

),

3770

1

			Box::new(

3771

1

3772

1

3773

1

						xcm::latest::prelude::PalletInstance(

3774

1

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

3775

1

),

3776

1

						GeneralIndex(10),

3777

1

],

3778

1

3779

1

3780

1

					.into()

3781

1

),

3782

1

0,

3783

1

			WeightLimit::Unlimited

3784

1

));

3785

1

});

3786

1

3787

1

	ParaA::execute_with(|| {

3788

1

		// Alice should have received the DOTs

3789

1

		assert_eq!(

3790

1

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

3791

1

			Ok(U256::from(200))

3792

1

);

3793

3794

		// Alice has received 125 USDC

3795

1

		assert_eq!(

3796

1

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

3797

1

			Ok(U256::from(125))

3798

1

);

3799

1

});

3800

1

3801

1

	let dest = Location::new(

3802

1

1,

3803

1

3804

1

			Parachain(1000),

3805

1

			AccountId32 {

3806

1

				network: None,

3807

1

				id: RELAYBOB.into(),

3808

1

},

3809

1

],

3810

1

);

3811

1

3812

1

	let statemint_asset_to_send = Asset {

3813

1

		id: AssetId(statemint_asset),

3814

1

		fun: Fungible(100),

3815

1

};

3816

1

3817

1

	let relay_asset_to_send = Asset {

3818

1

		id: AssetId(Location::parent()),

3819

1

		fun: Fungible(100),

3820

1

};

3821

1

3822

1

	let assets_to_send: XcmAssets =

3823

1

		XcmAssets::from(vec![statemint_asset_to_send, relay_asset_to_send.clone()]);

3824

1

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

3825

1

	// For some reason the order of the assets is inverted when creating the array above.

3826

1

	// We need to use relay asset for fees, so we pick index 0.

3827

1

	assert_eq!(assets_to_send.get(0).unwrap(), &relay_asset_to_send);

3828

3829

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

3830

1

	ParaA::execute_with(|| {

3831

1

		assert_ok!(PolkadotXcm::limited_reserve_transfer_assets(

3832

1

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

3833

1

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

3834

1

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

3835

1

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

3836

1

0,

3837

1

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

3838

1

));

3839

3840

1

		assert_eq!(

3841

1

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

3842

1

			Ok(U256::from(100))

3843

1

);

3844

1

});

3845

1

3846

1

	Statemint::execute_with(|| {

3847

1

		// Check that Bob received relay tokens back in AssetHub

3848

1

		assert_eq!(

3849

1

			StatemintBalances::free_balance(RELAYBOB),

3850

1

			INITIAL_BALANCE + 100

3851

1

);

3852

3853

		// Check that BOB received 100 USDC on AssetHub

3854

1

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

3855

1

});

3856

1

3857

1

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

3858

1

	Statemint::execute_with(|| {

3859

1

		let bob_previous_balance = StatemintBalances::free_balance(RELAYBOB);

3860

1

3861

1

		// Now send those tokens to ParaA

3862

1

		assert_ok!(StatemintChainPalletXcm::limited_reserve_transfer_assets(

3863

1

			statemint_like::RuntimeOrigin::signed(RELAYBOB),

3864

1

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

3865

1

			Box::new(

3866

1

				VersionedLocation::from(parachain_beneficiary_absolute)

3867

1

					.clone()

3868

1

					.into()

3869

1

),

3870

1

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

3871

1

0,

3872

1

			WeightLimit::Unlimited

3873

1

));

3874

3875

		// 100 DOTs were deducted from Bob's account

3876

1

		assert_eq!(

3877

1

			StatemintBalances::free_balance(RELAYBOB),

3878

1

			bob_previous_balance - 100

3879

1

);

3880

1

});

3881

1

3882

1

	ParaA::execute_with(|| {

3883

1

		// Alice should have received 100 DOTs

3884

1

		assert_eq!(

3885

1

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

3886

1

			Ok(U256::from(200))

3887

1

);

3888

1

});

3889

1

3890

3891

#[test]

3892

1

fn transact_through_signed_multilocation() {

3893

1

	MockNet::reset();

3894

1

	let mut ancestry = Location::parent();

3895

1

3896

1

	ParaA::execute_with(|| {

3897

1

		// Root can set transact info

3898

1

		assert_ok!(XcmTransactor::set_transact_info(

3899

1

			parachain::RuntimeOrigin::root(),

3900

1

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

3901

1

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

3902

1

			3000.into(),

3903

1

			20000000000.into(),

3904

1

			// 4 instructions in transact through signed

3905

1

			Some(4000.into())

3906

1

));

3907

		// Root can set transact info

3908

1

		assert_ok!(XcmTransactor::set_fee_per_second(

3909

1

			parachain::RuntimeOrigin::root(),

3910

1

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

3911

1

			WEIGHT_REF_TIME_PER_SECOND as u128,

3912

1

));

3913

1

		ancestry = parachain::UniversalLocation::get().into();

3914

1

});

3915

1

3916

1

	// Let's construct the Junction that we will append with DescendOrigin

3917

1

	let signed_origin: Junctions = [AccountKey20 {

3918

1

		network: None,

3919

1

		key: PARAALICE,

3920

1

}]

3921

1

	.into();

3922

1

3923

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

3924

1

	descend_origin_multilocation

3925

1

		.append_with(signed_origin)

3926

1

		.unwrap();

3927

1

3928

1

	// To convert it to what the relay will see instead of us

3929

1

	descend_origin_multilocation

3930

1

		.reanchor(&Location::parent(), &ancestry.interior)

3931

1

		.unwrap();

3932

1

3933

1

	let derived = xcm_builder::Account32Hash::<

3934

1

		relay_chain::KusamaNetwork,

3935

1

		relay_chain::AccountId,

3936

1

	>::convert_location(&descend_origin_multilocation)

3937

1

	.unwrap();

3938

1

3939

1

	Relay::execute_with(|| {

3940

1

		// free execution, full amount received

3941

1

		assert_ok!(RelayBalances::transfer_allow_death(

3942

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

3943

1

			derived.clone(),

3944

1

			4000004100u128,

3945

1

));

3946

		// derived account has all funds

3947

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

3948

		// sovereign account has 0 funds

3949

1

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

3950

1

});

3951

1

3952

1

	// Encode the call. Balances transact to para_a_account

3953

1

	// First index

3954

1

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

3955

1

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

3956

1

		relay_chain::Balances,

3957

1

>()

3958

1

	.unwrap() as u8;

3959

1

3960

1

	encoded.push(index);

3961

1

3962

1

	// Then call bytes

3963

1

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

3964

1

		// 100 to sovereign

3965

1

		dest: para_a_account(),

3966

1

		value: 100u32.into(),

3967

1

3968

1

	.encode();

3969

1

	encoded.append(&mut call_bytes);

3970

1

3971

1

	ParaA::execute_with(|| {

3972

1

		assert_ok!(XcmTransactor::transact_through_signed(

3973

1

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

3974

1

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

3975

1

			CurrencyPayment {

3976

1

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

3977

1

					Location::parent()

3978

1

				))),

3979

1

				fee_amount: None

3980

1

},

3981

1

			encoded,

3982

1

			// 4000000000 for transfer + 4000 for XCM

3983

1

			TransactWeights {

3984

1

				transact_required_weight_at_most: 4000000000.into(),

3985

1

				overall_weight: None

3986

1

},

3987

1

			false

3988

1

));

3989

1

});

3990

1

3991

1

	Relay::execute_with(|| {

3992

1

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

3993

3994

1

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

3995

1

});

3996

1

3997

3998

#[test]

3999

1

fn transact_through_signed_multilocation_custom_fee_and_weight() {

4000

1

	MockNet::reset();

4001

1

	let mut ancestry = Location::parent();

4002

1

4003

1

	ParaA::execute_with(|| {

4004

1

		ancestry = parachain::UniversalLocation::get().into();

4005

1

});

4006

1

4007

1

	// Let's construct the Junction that we will append with DescendOrigin

4008

1

	let signed_origin: Junctions = [AccountKey20 {

4009

1

		network: None,

4010

1

		key: PARAALICE,

4011

1

}]

4012

1

	.into();

4013

1

4014

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4015

1

	descend_origin_multilocation

4016

1

		.append_with(signed_origin)

4017

1

		.unwrap();

4018

1

4019

1

	// To convert it to what the relay will see instead of us

4020

1

	descend_origin_multilocation

4021

1

		.reanchor(&Location::parent(), &ancestry.interior)

4022

1

		.unwrap();

4023

1

4024

1

	let derived = xcm_builder::Account32Hash::<

4025

1

		relay_chain::KusamaNetwork,

4026

1

		relay_chain::AccountId,

4027

1

	>::convert_location(&descend_origin_multilocation)

4028

1

	.unwrap();

4029

1

4030

1

	Relay::execute_with(|| {

4031

1

		// free execution, full amount received

4032

1

		assert_ok!(RelayBalances::transfer_allow_death(

4033

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4034

1

			derived.clone(),

4035

1

			4000004100u128,

4036

1

));

4037

		// derived account has all funds

4038

1

		assert!(RelayBalances::free_balance(&derived) == 4000004100);

4039

		// sovereign account has 0 funds

4040

1

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

4041

1

});

4042

1

4043

1

	// Encode the call. Balances transact to para_a_account

4044

1

	// First index

4045

1

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

4046

1

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

4047

1

		relay_chain::Balances,

4048

1

>()

4049

1

	.unwrap() as u8;

4050

1

4051

1

	encoded.push(index);

4052

1

4053

1

	// Then call bytes

4054

1

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

4055

1

		// 100 to sovereign

4056

1

		dest: para_a_account(),

4057

1

		value: 100u32.into(),

4058

1

4059

1

	.encode();

4060

1

	encoded.append(&mut call_bytes);

4061

1

4062

1

	let total_weight = 4000004000u64;

4063

1

	ParaA::execute_with(|| {

4064

1

		assert_ok!(XcmTransactor::transact_through_signed(

4065

1

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

4066

1

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

4067

1

			CurrencyPayment {

4068

1

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

4069

1

					Location::parent()

4070

1

				))),

4071

1

				fee_amount: Some(total_weight as u128)

4072

1

},

4073

1

			encoded,

4074

1

			// 4000000000 for transfer + 4000 for XCM

4075

1

			TransactWeights {

4076

1

				transact_required_weight_at_most: 4000000000.into(),

4077

1

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

4078

1

},

4079

1

			false

4080

1

));

4081

1

});

4082

1

4083

1

	Relay::execute_with(|| {

4084

1

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

4085

4086

1

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

4087

1

});

4088

1

4089

4090

#[test]

4091

1

fn transact_through_signed_multilocation_custom_fee_and_weight_refund() {

4092

1

	MockNet::reset();

4093

1

	let mut ancestry = Location::parent();

4094

1

4095

1

	ParaA::execute_with(|| {

4096

1

		ancestry = parachain::UniversalLocation::get().into();

4097

1

});

4098

1

4099

1

	// Let's construct the Junction that we will append with DescendOrigin

4100

1

	let signed_origin: Junctions = [AccountKey20 {

4101

1

		network: None,

4102

1

		key: PARAALICE,

4103

1

}]

4104

1

	.into();

4105

1

4106

1

	let mut descend_origin_multilocation = parachain::SelfLocation::get();

4107

1

	descend_origin_multilocation

4108

1

		.append_with(signed_origin)

4109

1

		.unwrap();

4110

1

4111

1

	// To convert it to what the relay will see instead of us

4112

1

	descend_origin_multilocation

4113

1

		.reanchor(&Location::parent(), &ancestry.interior)

4114

1

		.unwrap();

4115

1

4116

1

	let derived = xcm_builder::Account32Hash::<

4117

1

		relay_chain::KusamaNetwork,

4118

1

		relay_chain::AccountId,

4119

1

	>::convert_location(&descend_origin_multilocation)

4120

1

	.unwrap();

4121

1

4122

1

	Relay::execute_with(|| {

4123

1

		// free execution, full amount received

4124

1

		assert_ok!(RelayBalances::transfer_allow_death(

4125

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4126

1

			derived.clone(),

4127

1

			4000009100u128,

4128

1

));

4129

		// derived account has all funds

4130

1

		assert!(RelayBalances::free_balance(&derived) == 4000009100);

4131

		// sovereign account has 0 funds

4132

1

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

4133

1

});

4134

1

4135

1

	// Encode the call. Balances transact to para_a_account

4136

1

	// First index

4137

1

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

4138

1

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

4139

1

		relay_chain::Balances,

4140

1

>()

4141

1

	.unwrap() as u8;

4142

1

4143

1

	encoded.push(index);

4144

1

4145

1

	// Then call bytes

4146

1

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

4147

1

		// 100 to sovereign

4148

1

		dest: para_a_account(),

4149

1

		value: 100u32.into(),

4150

1

4151

1

	.encode();

4152

1

	encoded.append(&mut call_bytes);

4153

1

4154

1

	let total_weight = 4000009000u64;

4155

1

	ParaA::execute_with(|| {

4156

1

		assert_ok!(XcmTransactor::transact_through_signed(

4157

1

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

4158

1

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

4159

1

			CurrencyPayment {

4160

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4161

1

					Location::parent()

4162

1

				))),

4163

1

				fee_amount: Some(total_weight as u128)

4164

1

},

4165

1

			encoded,

4166

1

			// 4000000000 for transfer + 9000 for XCM

4167

1

			TransactWeights {

4168

1

				transact_required_weight_at_most: 4000000000.into(),

4169

1

				overall_weight: Some(Limited(total_weight.into()))

4170

1

},

4171

1

			true

4172

1

));

4173

1

});

4174

1

4175

1

	Relay::execute_with(|| {

4176

1

		// 100 transferred

4177

1

		assert_eq!(RelayBalances::free_balance(&para_a_account()), 100);

4178

4179

		// 4000009000 refunded

4180

1

		assert_eq!(RelayBalances::free_balance(&derived), 4000009000);

4181

1

});

4182

1

4183

4184

#[test]

4185

1

fn transact_through_signed_multilocation_para_to_para() {

4186

1

	MockNet::reset();

4187

1

	let mut ancestry = Location::parent();

4188

1

4189

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4190

1

4191

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4192

1

4193

1

	ParaA::execute_with(|| {

4194

1

		// Root can set transact info

4195

1

		assert_ok!(XcmTransactor::set_transact_info(

4196

1

			parachain::RuntimeOrigin::root(),

4197

1

			// ParaB

4198

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4199

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4200

1

			3.into(),

4201

1

			20000000000.into(),

4202

1

			// 4 instructions in transact through signed

4203

1

			Some(4.into())

4204

1

));

4205

		// Root can set transact info

4206

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4207

1

			parachain::RuntimeOrigin::root(),

4208

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4209

1

			parachain::ParaTokensPerSecond::get(),

4210

1

));

4211

1

		ancestry = parachain::UniversalLocation::get().into();

4212

1

});

4213

1

4214

1

	// Let's construct the Junction that we will append with DescendOrigin

4215

1

	let signed_origin: Junctions = [AccountKey20 {

4216

1

		network: None,

4217

1

		key: PARAALICE,

4218

1

}]

4219

1

	.into();

4220

1

4221

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4222

1

	descend_origin_location.append_with(signed_origin).unwrap();

4223

1

4224

1

	// To convert it to what the paraB will see instead of us

4225

1

	descend_origin_location

4226

1

		.reanchor(&para_b_location, &ancestry.interior)

4227

1

		.unwrap();

4228

1

4229

1

	let derived = xcm_builder::HashedDescription::<

4230

1

		parachain::AccountId,

4231

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4232

1

	>::convert_location(&descend_origin_location)

4233

1

	.unwrap();

4234

1

4235

1

	ParaB::execute_with(|| {

4236

1

		// free execution, full amount received

4237

1

		assert_ok!(ParaBalances::transfer_allow_death(

4238

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4239

1

			derived.clone(),

4240

1

			4000000104u128,

4241

1

));

4242

		// derived account has all funds

4243

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4244

		// sovereign account has 0 funds

4245

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4246

1

});

4247

1

4248

1

	// Encode the call. Balances transact to para_a_account

4249

1

	// First index

4250

1

	let mut encoded: Vec<u8> = Vec::new();

4251

1

	let index =

4252

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4253

1

			.unwrap() as u8;

4254

1

4255

1

	encoded.push(index);

4256

1

4257

1

	// Then call bytes

4258

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4259

1

		// 100 to sovereign

4260

1

		dest: para_a_account_20(),

4261

1

		value: 100u32.into(),

4262

1

4263

1

	.encode();

4264

1

	encoded.append(&mut call_bytes);

4265

1

4266

1

	ParaA::execute_with(|| {

4267

1

		assert_ok!(XcmTransactor::transact_through_signed(

4268

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4269

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4270

1

			CurrencyPayment {

4271

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4272

1

					para_b_balances

4273

1

				))),

4274

1

				fee_amount: None

4275

1

},

4276

1

			encoded,

4277

1

			// 4000000000 for transfer + 4000 for XCM

4278

1

			// 1-1 to fee

4279

1

			TransactWeights {

4280

1

				transact_required_weight_at_most: 4000000000.into(),

4281

1

				overall_weight: None

4282

1

},

4283

1

			false

4284

1

));

4285

1

});

4286

1

4287

1

	ParaB::execute_with(|| {

4288

1

		assert!(ParaBalances::free_balance(&derived) == 0);

4289

4290

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 100);

4291

1

});

4292

1

4293

4294

#[test]

4295

1

fn transact_through_signed_multilocation_para_to_para_refund() {

4296

1

	MockNet::reset();

4297

1

	let mut ancestry = Location::parent();

4298

1

4299

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4300

1

4301

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4302

1

4303

1

	ParaA::execute_with(|| {

4304

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4305

1

			parachain::RuntimeOrigin::root(),

4306

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4307

1

			parachain::ParaTokensPerSecond::get(),

4308

1

));

4309

1

		ancestry = parachain::UniversalLocation::get().into();

4310

1

});

4311

1

4312

1

	// Let's construct the Junction that we will append with DescendOrigin

4313

1

	let signed_origin: Junctions = [AccountKey20 {

4314

1

		network: None,

4315

1

		key: PARAALICE,

4316

1

}]

4317

1

	.into();

4318

1

4319

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4320

1

	descend_origin_location.append_with(signed_origin).unwrap();

4321

1

4322

1

	// To convert it to what the paraB will see instead of us

4323

1

	descend_origin_location

4324

1

		.reanchor(&para_b_location, &ancestry.interior)

4325

1

		.unwrap();

4326

1

4327

1

	let derived = xcm_builder::HashedDescription::<

4328

1

		parachain::AccountId,

4329

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4330

1

	>::convert_location(&descend_origin_location)

4331

1

	.unwrap();

4332

1

4333

1

	ParaB::execute_with(|| {

4334

1

		// free execution, full amount received

4335

1

		assert_ok!(ParaBalances::transfer_allow_death(

4336

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4337

1

			derived.clone(),

4338

1

			4000009100u128,

4339

1

));

4340

		// derived account has all funds

4341

1

		assert!(ParaBalances::free_balance(&derived) == 4000009100);

4342

		// sovereign account has 0 funds

4343

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4344

1

});

4345

1

4346

1

	// Encode the call. Balances transact to para_a_account

4347

1

	// First index

4348

1

	let mut encoded: Vec<u8> = Vec::new();

4349

1

	let index =

4350

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::Balances>()

4351

1

			.unwrap() as u8;

4352

1

4353

1

	encoded.push(index);

4354

1

4355

1

	// Then call bytes

4356

1

	let mut call_bytes = pallet_balances::Call::<parachain::Runtime>::transfer_allow_death {

4357

1

		// 100 to sovereign

4358

1

		dest: para_a_account_20(),

4359

1

		value: 100u32.into(),

4360

1

4361

1

	.encode();

4362

1

	encoded.append(&mut call_bytes);

4363

1

4364

1

	let overall_weight = 4000009000u64;

4365

1

	ParaA::execute_with(|| {

4366

1

		assert_ok!(XcmTransactor::transact_through_signed(

4367

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4368

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4369

1

			CurrencyPayment {

4370

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4371

1

					para_b_balances

4372

1

				))),

4373

1

				fee_amount: Some(overall_weight as u128)

4374

1

},

4375

1

			encoded,

4376

1

			// 4000000000 for transfer + 9000 for XCM

4377

1

			TransactWeights {

4378

1

				transact_required_weight_at_most: 4000000000.into(),

4379

1

				overall_weight: Some(Limited(overall_weight.into()))

4380

1

},

4381

1

			true

4382

1

));

4383

1

});

4384

1

4385

1

	ParaB::execute_with(|| {

4386

1

		// Check the derived account was refunded

4387

1

		assert_eq!(ParaBalances::free_balance(&derived), 3826174993);

4388

4389

		// Check the transfer was executed

4390

1

		assert_eq!(ParaBalances::free_balance(&para_a_account_20()), 100);

4391

1

});

4392

1

4393

4394

#[test]

4395

1

fn transact_through_signed_multilocation_para_to_para_ethereum() {

4396

1

	MockNet::reset();

4397

1

	let mut ancestry = Location::parent();

4398

1

4399

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4400

1

4401

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4402

1

4403

1

	ParaA::execute_with(|| {

4404

1

		// Root can set transact info

4405

1

		assert_ok!(XcmTransactor::set_transact_info(

4406

1

			parachain::RuntimeOrigin::root(),

4407

1

			// ParaB

4408

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4409

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4410

1

			3.into(),

4411

1

			20000000000.into(),

4412

1

			// 4 instructions in transact through signed

4413

1

			Some(4.into())

4414

1

));

4415

		// Root can set transact info

4416

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4417

1

			parachain::RuntimeOrigin::root(),

4418

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4419

1

			parachain::ParaTokensPerSecond::get(),

4420

1

));

4421

1

		ancestry = parachain::UniversalLocation::get().into();

4422

1

});

4423

1

4424

1

	// Let's construct the Junction that we will append with DescendOrigin

4425

1

	let signed_origin: Junctions = [AccountKey20 {

4426

1

		network: None,

4427

1

		key: PARAALICE,

4428

1

}]

4429

1

	.into();

4430

1

4431

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4432

1

	descend_origin_location.append_with(signed_origin).unwrap();

4433

1

4434

1

	// To convert it to what the paraB will see instead of us

4435

1

	descend_origin_location

4436

1

		.reanchor(&para_b_location, &ancestry.interior)

4437

1

		.unwrap();

4438

1

4439

1

	let derived = xcm_builder::HashedDescription::<

4440

1

		parachain::AccountId,

4441

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4442

1

	>::convert_location(&descend_origin_location)

4443

1

	.unwrap();

4444

1

4445

1

	let mut parachain_b_alice_balances_before = 0;

4446

1

	ParaB::execute_with(|| {

4447

1

		assert_ok!(ParaBalances::transfer_allow_death(

4448

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4449

1

			derived.clone(),

4450

1

			4000000104u128,

4451

1

));

4452

		// derived account has all funds

4453

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4454

		// sovereign account has 0 funds

4455

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4456

4457

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4458

1

});

4459

1

4460

1

	// Encode the call. Balances transact to para_a_account

4461

1

	// First index

4462

1

	let mut encoded: Vec<u8> = Vec::new();

4463

1

	let index =

4464

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4465

1

			.unwrap() as u8;

4466

1

4467

1

	encoded.push(index);

4468

4469

	use sp_core::U256;

4470

	// Let's do a EVM transfer

4471

1

	let eth_tx =

4472

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4473

1

			gas_limit: U256::from(21000),

4474

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4475

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4476

1

			value: U256::from(100),

4477

1

			input: BoundedVec::<

4478

1

u8,

4479

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4480

1

			>::try_from(vec![]).unwrap(),

4481

1

			access_list: None,

4482

1

});

4483

1

4484

1

	// Then call bytes

4485

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact {

4486

1

		xcm_transaction: eth_tx,

4487

1

4488

1

	.encode();

4489

1

	encoded.append(&mut call_bytes);

4490

1

4491

1

	ParaA::execute_with(|| {

4492

1

		assert_ok!(XcmTransactor::transact_through_signed(

4493

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4494

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4495

1

			CurrencyPayment {

4496

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4497

1

					para_b_balances

4498

1

				))),

4499

1

				fee_amount: None

4500

1

},

4501

1

			encoded,

4502

1

			// 4000000000 for transfer + 4000 for XCM

4503

1

			// 1-1 to fee

4504

1

			TransactWeights {

4505

1

				transact_required_weight_at_most: 4000000000.into(),

4506

1

				overall_weight: None

4507

1

},

4508

1

			false

4509

1

));

4510

1

});

4511

1

4512

1

	ParaB::execute_with(|| {

4513

1

		// Make sure the EVM transfer went through

4514

1

		assert!(

4515

1

			ParaBalances::free_balance(&PARAALICE.into())

4516

1

				== parachain_b_alice_balances_before + 100

4517

1

);

4518

1

});

4519

1

4520

4521

#[test]

4522

1

fn transact_through_signed_multilocation_para_to_para_ethereum_no_proxy_fails() {

4523

1

	MockNet::reset();

4524

1

	let mut ancestry = Location::parent();

4525

1

4526

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4527

1

4528

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4529

1

4530

1

	ParaA::execute_with(|| {

4531

1

		// Root can set transact info

4532

1

		assert_ok!(XcmTransactor::set_transact_info(

4533

1

			parachain::RuntimeOrigin::root(),

4534

1

			// ParaB

4535

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4536

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4537

1

			3.into(),

4538

1

			20000000000.into(),

4539

1

			// 4 instructions in transact through signed

4540

1

			Some(4.into())

4541

1

));

4542

		// Root can set transact info

4543

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4544

1

			parachain::RuntimeOrigin::root(),

4545

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4546

1

			parachain::ParaTokensPerSecond::get(),

4547

1

));

4548

1

		ancestry = parachain::UniversalLocation::get().into();

4549

1

});

4550

1

4551

1

	// Let's construct the Junction that we will append with DescendOrigin

4552

1

	let signed_origin: Junctions = [AccountKey20 {

4553

1

		network: None,

4554

1

		key: PARAALICE,

4555

1

}]

4556

1

	.into();

4557

1

4558

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4559

1

	descend_origin_location.append_with(signed_origin).unwrap();

4560

1

4561

1

	// To convert it to what the paraB will see instead of us

4562

1

	descend_origin_location

4563

1

		.reanchor(&para_b_location, &ancestry.interior)

4564

1

		.unwrap();

4565

1

4566

1

	let derived = xcm_builder::HashedDescription::<

4567

1

		parachain::AccountId,

4568

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4569

1

	>::convert_location(&descend_origin_location)

4570

1

	.unwrap();

4571

1

4572

1

	let mut parachain_b_alice_balances_before = 0;

4573

1

	ParaB::execute_with(|| {

4574

1

		assert_ok!(ParaBalances::transfer_allow_death(

4575

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4576

1

			derived.clone(),

4577

1

			4000000104u128,

4578

1

));

4579

		// derived account has all funds

4580

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4581

		// sovereign account has 0 funds

4582

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4583

4584

1

		parachain_b_alice_balances_before = ParaBalances::free_balance(&PARAALICE.into())

4585

1

});

4586

1

4587

1

	// Encode the call. Balances transact to para_a_account

4588

1

	// First index

4589

1

	let mut encoded: Vec<u8> = Vec::new();

4590

1

	let index =

4591

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4592

1

			.unwrap() as u8;

4593

1

4594

1

	encoded.push(index);

4595

4596

	use sp_core::U256;

4597

	// Let's do a EVM transfer

4598

1

	let eth_tx =

4599

1

		xcm_primitives::EthereumXcmTransaction::V1(xcm_primitives::EthereumXcmTransactionV1 {

4600

1

			gas_limit: U256::from(21000),

4601

1

			fee_payment: xcm_primitives::EthereumXcmFee::Auto,

4602

1

			action: pallet_ethereum::TransactionAction::Call(PARAALICE.into()),

4603

1

			value: U256::from(100),

4604

1

			input: BoundedVec::<

4605

1

u8,

4606

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4607

1

			>::try_from(vec![]).unwrap(),

4608

1

			access_list: None,

4609

1

});

4610

1

4611

1

	// Then call bytes

4612

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4613

1

		transact_as: PARAALICE.into(),

4614

1

		xcm_transaction: eth_tx,

4615

1

4616

1

	.encode();

4617

1

	encoded.append(&mut call_bytes);

4618

1

4619

1

	ParaA::execute_with(|| {

4620

1

		assert_ok!(XcmTransactor::transact_through_signed(

4621

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4622

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4623

1

			CurrencyPayment {

4624

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4625

1

					para_b_balances

4626

1

				))),

4627

1

				fee_amount: None

4628

1

},

4629

1

			encoded,

4630

1

			TransactWeights {

4631

1

				transact_required_weight_at_most: 4000000000.into(),

4632

1

				overall_weight: None

4633

1

},

4634

1

			false

4635

1

));

4636

1

});

4637

1

4638

1

	ParaB::execute_with(|| {

4639

1

		// Make sure the EVM transfer wasn't executed

4640

1

		assert!(ParaBalances::free_balance(&PARAALICE.into()) == parachain_b_alice_balances_before);

4641

1

});

4642

1

4643

4644

#[test]

4645

1

fn transact_through_signed_multilocation_para_to_para_ethereum_proxy_succeeds() {

4646

1

	MockNet::reset();

4647

1

	let mut ancestry = Location::parent();

4648

1

4649

1

	let para_b_location = Location::new(1, [Parachain(2)]);

4650

1

4651

1

	let para_b_balances = Location::new(1, [Parachain(2), PalletInstance(1u8)]);

4652

1

4653

1

	ParaA::execute_with(|| {

4654

1

		// Root can set transact info

4655

1

		assert_ok!(XcmTransactor::set_transact_info(

4656

1

			parachain::RuntimeOrigin::root(),

4657

1

			// ParaB

4658

1

			Box::new(xcm::VersionedLocation::from(para_b_location.clone())),

4659

1

			// Para charges 1000 for every instruction, and we have 3, so 3

4660

1

			3.into(),

4661

1

			20000000000.into(),

4662

1

			// 4 instructions in transact through signed

4663

1

			Some(4.into())

4664

1

));

4665

		// Root can set transact info

4666

1

		assert_ok!(XcmTransactor::set_fee_per_second(

4667

1

			parachain::RuntimeOrigin::root(),

4668

1

			Box::new(xcm::VersionedLocation::from(para_b_balances.clone())),

4669

1

			parachain::ParaTokensPerSecond::get(),

4670

1

));

4671

1

		ancestry = parachain::UniversalLocation::get().into();

4672

1

});

4673

1

4674

1

	// Let's construct the Junction that we will append with DescendOrigin

4675

1

	let signed_origin: Junctions = [AccountKey20 {

4676

1

		network: None,

4677

1

		key: PARAALICE,

4678

1

}]

4679

1

	.into();

4680

1

4681

1

	let mut descend_origin_location = parachain::SelfLocation::get();

4682

1

	descend_origin_location.append_with(signed_origin).unwrap();

4683

1

4684

1

	// To convert it to what the paraB will see instead of us

4685

1

	descend_origin_location

4686

1

		.reanchor(&para_b_location, &ancestry.interior)

4687

1

		.unwrap();

4688

1

4689

1

	let derived = xcm_builder::HashedDescription::<

4690

1

		parachain::AccountId,

4691

1

		xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

4692

1

	>::convert_location(&descend_origin_location)

4693

1

	.unwrap();

4694

1

4695

1

	let transfer_recipient = evm_account();

4696

1

	let mut transfer_recipient_balance_before = 0;

4697

1

	ParaB::execute_with(|| {

4698

1

		assert_ok!(ParaBalances::transfer_allow_death(

4699

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4700

1

			derived.clone(),

4701

1

			4000000104u128,

4702

1

));

4703

		// derived account has all funds

4704

1

		assert!(ParaBalances::free_balance(&derived) == 4000000104);

4705

		// sovereign account has 0 funds

4706

1

		assert!(ParaBalances::free_balance(&para_a_account_20()) == 0);

4707

4708

1

		transfer_recipient_balance_before = ParaBalances::free_balance(&transfer_recipient.into());

4709

1

4710

1

		// Add proxy ALICE  -> derived

4711

1

		let _ = parachain::Proxy::add_proxy_delegate(

4712

1

			&PARAALICE.into(),

4713

1

			derived,

4714

1

			parachain::ProxyType::Any,

4715

1

0,

4716

1

);

4717

1

});

4718

1

4719

1

	// Encode the call. Balances transact to para_a_account

4720

1

	// First index

4721

1

	let mut encoded: Vec<u8> = Vec::new();

4722

1

	let index =

4723

1

		<parachain::Runtime as frame_system::Config>::PalletInfo::index::<parachain::EthereumXcm>()

4724

1

			.unwrap() as u8;

4725

1

4726

1

	encoded.push(index);

4727

4728

	use sp_core::U256;

4729

	// Let's do a EVM transfer

4730

1

	let eth_tx =

4731

1

		xcm_primitives::EthereumXcmTransaction::V2(xcm_primitives::EthereumXcmTransactionV2 {

4732

1

			gas_limit: U256::from(21000),

4733

1

			action: pallet_ethereum::TransactionAction::Call(transfer_recipient.into()),

4734

1

			value: U256::from(100),

4735

1

			input: BoundedVec::<

4736

1

u8,

4737

1

				ConstU32<{ xcm_primitives::MAX_ETHEREUM_XCM_INPUT_SIZE }>

4738

1

			>::try_from(vec![]).unwrap(),

4739

1

			access_list: None,

4740

1

});

4741

1

4742

1

	// Then call bytes

4743

1

	let mut call_bytes = pallet_ethereum_xcm::Call::<parachain::Runtime>::transact_through_proxy {

4744

1

		transact_as: PARAALICE.into(),

4745

1

		xcm_transaction: eth_tx,

4746

1

4747

1

	.encode();

4748

1

	encoded.append(&mut call_bytes);

4749

1

4750

1

	ParaA::execute_with(|| {

4751

1

		assert_ok!(XcmTransactor::transact_through_signed(

4752

1

			parachain::RuntimeOrigin::signed(PARAALICE.into()),

4753

1

			Box::new(xcm::VersionedLocation::from(para_b_location)),

4754

1

			CurrencyPayment {

4755

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4756

1

					para_b_balances

4757

1

				))),

4758

1

				fee_amount: None

4759

1

},

4760

1

			encoded,

4761

1

			TransactWeights {

4762

1

				transact_required_weight_at_most: 4000000000.into(),

4763

1

				overall_weight: None

4764

1

},

4765

1

			false

4766

1

));

4767

1

});

4768

1

4769

1

	ParaB::execute_with(|| {

4770

1

		// Make sure the EVM transfer was executed

4771

1

		assert!(

4772

1

			ParaBalances::free_balance(&transfer_recipient.into())

4773

1

				== transfer_recipient_balance_before + 100

4774

1

);

4775

1

});

4776

1

4777

4778

#[test]

4779

1

fn hrmp_init_accept_through_root() {

4780

1

	MockNet::reset();

4781

1

4782

1

	Relay::execute_with(|| {

4783

1

		assert_ok!(RelayBalances::transfer_allow_death(

4784

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4785

1

			para_a_account(),

4786

1

			1000u128

4787

1

));

4788

1

		assert_ok!(RelayBalances::transfer_allow_death(

4789

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4790

1

			para_b_account(),

4791

1

			1000u128

4792

1

));

4793

1

});

4794

1

4795

1

	ParaA::execute_with(|| {

4796

1

		let total_fee = 1_000u128;

4797

1

		let total_weight: u64 = 1_000_000_000;

4798

1

		let tx_weight: u64 = 500_000_000;

4799

1

		// Root can send hrmp init channel

4800

1

		assert_ok!(XcmTransactor::hrmp_manage(

4801

1

			parachain::RuntimeOrigin::root(),

4802

1

			HrmpOperation::InitOpen(HrmpInitParams {

4803

1

				para_id: 2u32.into(),

4804

1

				proposed_max_capacity: 1,

4805

1

				proposed_max_message_size: 1

4806

1

}),

4807

1

			CurrencyPayment {

4808

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4809

1

					Location::parent()

4810

1

				))),

4811

1

				fee_amount: Some(total_fee)

4812

1

},

4813

1

			TransactWeights {

4814

1

				transact_required_weight_at_most: tx_weight.into(),

4815

1

				overall_weight: Some(Limited(total_weight.into()))

4816

1

4817

1

));

4818

1

});

4819

1

	Relay::execute_with(|| {

4820

1

		let expected_event: relay_chain::RuntimeEvent =

4821

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelRequested {

4822

1

				sender: 1u32.into(),

4823

1

				recipient: 2u32.into(),

4824

1

				proposed_max_capacity: 1u32,

4825

1

				proposed_max_message_size: 1u32,

4826

1

4827

1

			.into();

4828

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4829

1

});

4830

1

	ParaB::execute_with(|| {

4831

1

		let total_fee = 1_000u128;

4832

1

		let total_weight: u64 = 1_000_000_000;

4833

1

		let tx_weight: u64 = 500_000_000;

4834

1

		// Root can send hrmp accept channel

4835

1

		assert_ok!(XcmTransactor::hrmp_manage(

4836

1

			parachain::RuntimeOrigin::root(),

4837

1

			HrmpOperation::Accept {

4838

1

				para_id: 1u32.into()

4839

1

},

4840

1

			CurrencyPayment {

4841

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4842

1

					Location::parent()

4843

1

				))),

4844

1

				fee_amount: Some(total_fee)

4845

1

},

4846

1

			TransactWeights {

4847

1

				transact_required_weight_at_most: tx_weight.into(),

4848

1

				overall_weight: Some(Limited(total_weight.into()))

4849

1

4850

1

));

4851

1

});

4852

1

4853

1

	Relay::execute_with(|| {

4854

1

		let expected_event: relay_chain::RuntimeEvent =

4855

1

			polkadot_runtime_parachains::hrmp::Event::OpenChannelAccepted {

4856

1

				sender: 1u32.into(),

4857

1

				recipient: 2u32.into(),

4858

1

4859

1

			.into();

4860

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4861

1

});

4862

1

4863

4864

#[test]

4865

1

fn hrmp_close_works() {

4866

1

	MockNet::reset();

4867

1

4868

1

	Relay::execute_with(|| {

4869

1

		assert_ok!(RelayBalances::transfer_allow_death(

4870

1

			relay_chain::RuntimeOrigin::signed(RELAYALICE),

4871

1

			para_a_account(),

4872

1

			1000u128

4873

1

));

4874

1

		assert_ok!(Hrmp::force_open_hrmp_channel(

4875

1

			relay_chain::RuntimeOrigin::root(),

4876

1

			1u32.into(),

4877

1

			2u32.into(),

4878

1

			1u32,

4879

1

			1u32

4880

1

));

4881

1

		assert_ok!(Hrmp::force_process_hrmp_open(

4882

1

			relay_chain::RuntimeOrigin::root(),

4883

1

			1u32

4884

1

));

4885

1

});

4886

1

4887

1

	ParaA::execute_with(|| {

4888

1

		let total_fee = 1_000u128;

4889

1

		let total_weight: u64 = 1_000_000_000;

4890

1

		let tx_weight: u64 = 500_000_000;

4891

1

		// Root can send hrmp close

4892

1

		assert_ok!(XcmTransactor::hrmp_manage(

4893

1

			parachain::RuntimeOrigin::root(),

4894

1

			HrmpOperation::Close(HrmpChannelId {

4895

1

				sender: 1u32.into(),

4896

1

				recipient: 2u32.into()

4897

1

}),

4898

1

			CurrencyPayment {

4899

1

				currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::from(

4900

1

					Location::parent()

4901

1

				))),

4902

1

				fee_amount: Some(total_fee)

4903

1

},

4904

1

			TransactWeights {

4905

1

				transact_required_weight_at_most: tx_weight.into(),

4906

1

				overall_weight: Some(Limited(total_weight.into()))

4907

1

4908

1

));

4909

1

});

4910

1

	Relay::execute_with(|| {

4911

1

		let expected_event: relay_chain::RuntimeEvent =

4912

1

			polkadot_runtime_parachains::hrmp::Event::ChannelClosed {

4913

1

				by_parachain: 1u32.into(),

4914

1

				channel_id: HrmpChannelId {

4915

1

					sender: 1u32.into(),

4916

1

					recipient: 2u32.into(),

4917

1

},

4918

1

4919

1

			.into();

4920

1

		assert!(relay_chain::relay_events().contains(&expected_event));

4921

1

});

4922

1

4923

4924

use crate::xcm_mock::parachain::XcmWeightTrader;

4925

use parity_scale_codec::{Decode, Encode};

4926

use sp_io::hashing::blake2_256;

4927

4928

// Helper to derive accountIds

4929

7

pub fn derivative_account_id(who: sp_runtime::AccountId32, index: u16) -> sp_runtime::AccountId32 {

4930

7

	let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);

4931

7

	sp_runtime::AccountId32::decode(&mut &entropy[..]).expect("valid account id")

4932

7