Grcov report - polkadot.rs

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

// We want to avoid including the rococo-runtime here.

18

// TODO: whenever a conclusion is taken from https://github.com/paritytech/substrate/issues/8158

19

20

use cumulus_primitives_core::{relay_chain::HrmpChannelId, ParaId};

21

use pallet_xcm_transactor::chain_indices::RelayChainIndices;

22

use parity_scale_codec::{Decode, Encode};

23

use sp_runtime::traits::{AccountIdLookup, StaticLookup};

24

use sp_runtime::AccountId32;

25

use sp_std::vec::Vec;

26

27

#[derive(Encode, Decode)]

28

pub enum RelayCall {

29

	#[codec(index = 26u8)]

30

	// the index should match the position of the module in `construct_runtime!`

31

	Utility(UtilityCall),

32

33

	#[codec(index = 7u8)]

34

	Stake(StakeCall),

35

	#[codec(index = 60u8)]

36

	// the index should match the position of the module in `construct_runtime!`

37

	Hrmp(HrmpCall),

38

39

40

#[derive(Encode, Decode)]

41

pub enum StakeCall {

42

	#[codec(index = 0u16)]

43

	// the index should match the position of the dispatchable in the target pallet

44

	Bond(

45

		#[codec(compact)] cumulus_primitives_core::relay_chain::Balance,

46

		pallet_staking::RewardDestination<AccountId32>,

47

),

48

	#[codec(index = 1u16)]

49

	BondExtra(#[codec(compact)] cumulus_primitives_core::relay_chain::Balance),

50

	#[codec(index = 2u16)]

51

	Unbond(#[codec(compact)] cumulus_primitives_core::relay_chain::Balance),

52

	#[codec(index = 3u16)]

53

	WithdrawUnbonded(u32),

54

	#[codec(index = 4u16)]

55

	Validate(pallet_staking::ValidatorPrefs),

56

	#[codec(index = 5u16)]

57

	Nominate(Vec<<AccountIdLookup<AccountId32, ()> as StaticLookup>::Source>),

58

	#[codec(index = 6u16)]

59

	Chill,

60

	#[codec(index = 7u16)]

61

	SetPayee(pallet_staking::RewardDestination<AccountId32>),

62

	#[codec(index = 8u16)]

63

	SetController,

64

	#[codec(index = 19u16)]

65

	Rebond(#[codec(compact)] cumulus_primitives_core::relay_chain::Balance),

66

67

68

// Utility call encoding, needed for xcm transactor pallet

69

#[derive(Encode, Decode)]

70

pub enum UtilityCall {

71

	#[codec(index = 1u8)]

72

	AsDerivative(u16),

73

74

75

// HRMP call encoding, needed for xcm transactor pallet

76

#[derive(Encode, Decode)]

77

pub enum HrmpCall {

78

	#[codec(index = 0u8)]

79

	InitOpenChannel(ParaId, u32, u32),

80

	#[codec(index = 1u8)]

81

	AcceptOpenChannel(ParaId),

82

	#[codec(index = 2u8)]

83

	CloseChannel(HrmpChannelId),

84

	#[codec(index = 6u8)]

85

	CancelOpenRequest(HrmpChannelId, u32),

86

87

88

pub struct PolkadotEncoder;

89

90

impl xcm_primitives::UtilityEncodeCall for PolkadotEncoder {

91

	fn encode_call(self, call: xcm_primitives::UtilityAvailableCalls) -> Vec<u8> {

92

		match call {

93

			xcm_primitives::UtilityAvailableCalls::AsDerivative(a, b) => {

94

				let mut call = RelayCall::Utility(UtilityCall::AsDerivative(a.clone())).encode();

95

				// If we encode directly we inject the call length,

96

				// so we just append the inner call after encoding the outer

97

				call.append(&mut b.clone());

98

				call

99

100

101

102

103

104

impl xcm_primitives::HrmpEncodeCall for PolkadotEncoder {

105

	fn hrmp_encode_call(

106

		call: xcm_primitives::HrmpAvailableCalls,

107

	) -> Result<Vec<u8>, xcm::latest::Error> {

108

		match call {

109

			xcm_primitives::HrmpAvailableCalls::InitOpenChannel(a, b, c) => Ok(RelayCall::Hrmp(

110

				HrmpCall::InitOpenChannel(a.clone(), b.clone(), c.clone()),

111

112

			.encode()),

113

			xcm_primitives::HrmpAvailableCalls::AcceptOpenChannel(a) => {

114

				Ok(RelayCall::Hrmp(HrmpCall::AcceptOpenChannel(a.clone())).encode())

115

116

			xcm_primitives::HrmpAvailableCalls::CloseChannel(a) => {

117

				Ok(RelayCall::Hrmp(HrmpCall::CloseChannel(a.clone())).encode())

118

119

			xcm_primitives::HrmpAvailableCalls::CancelOpenRequest(a, b) => {

120

				Ok(RelayCall::Hrmp(HrmpCall::CancelOpenRequest(a.clone(), b.clone())).encode())

121

122

123

124

125

126

impl xcm_primitives::StakeEncodeCall<()> for PolkadotEncoder {

127

	fn encode_call(_transactor: (), call: xcm_primitives::AvailableStakeCalls) -> Vec<u8> {

128

		match call {

129

			xcm_primitives::AvailableStakeCalls::Bond(b, c) => {

130

				RelayCall::Stake(StakeCall::Bond(b, c)).encode()

131

132

133

			xcm_primitives::AvailableStakeCalls::BondExtra(a) => {

134

				RelayCall::Stake(StakeCall::BondExtra(a)).encode()

135

136

137

			xcm_primitives::AvailableStakeCalls::Unbond(a) => {

138

				RelayCall::Stake(StakeCall::Unbond(a)).encode()

139

140

141

			xcm_primitives::AvailableStakeCalls::WithdrawUnbonded(a) => {

142

				RelayCall::Stake(StakeCall::WithdrawUnbonded(a)).encode()

143

144

145

			xcm_primitives::AvailableStakeCalls::Validate(a) => {

146

				RelayCall::Stake(StakeCall::Validate(a)).encode()

147

148

149

			xcm_primitives::AvailableStakeCalls::Chill => {

150

				RelayCall::Stake(StakeCall::Chill).encode()

151

152

153

			xcm_primitives::AvailableStakeCalls::SetPayee(a) => {

154

				RelayCall::Stake(StakeCall::SetPayee(a.into())).encode()

155

156

157

			xcm_primitives::AvailableStakeCalls::SetController => {

158

				RelayCall::Stake(StakeCall::SetController).encode()

159

160

161

			xcm_primitives::AvailableStakeCalls::Rebond(a) => {

162

				RelayCall::Stake(StakeCall::Rebond(a.into())).encode()

163

164

165

			xcm_primitives::AvailableStakeCalls::Nominate(a) => {

166

				let nominated: Vec<<AccountIdLookup<AccountId32, ()> as StaticLookup>::Source> =

167

					a.iter().map(|add| (*add).clone().into()).collect();

168

169

				RelayCall::Stake(StakeCall::Nominate(nominated)).encode()

170

171

172

173

174

175

/// Polkadot pallet and extrinsic indices

176

pub const POLKADOT_RELAY_INDICES: RelayChainIndices = RelayChainIndices {

177

	staking: 7u8,

178

	utility: 26u8,

179

	hrmp: 60u8,

180

	bond: 0u8,

181

	bond_extra: 1u8,

182

	unbond: 2u8,

183

	withdraw_unbonded: 3u8,

184

	validate: 4u8,

185

	nominate: 5u8,

186

	chill: 6u8,

187

	set_payee: 7u8,

188

	set_controller: 8u8,

189

	rebond: 19u8,

190

	as_derivative: 1u8,

191

	init_open_channel: 0u8,

192

	accept_open_channel: 1u8,

193

	close_channel: 2u8,

194

	cancel_open_request: 6u8,

195

};

196

197

// #[cfg(test)]

198

// mod tests {

199

// 	use super::*;

200

// 	use crate::polkadot::PolkadotEncoder;

201

// 	use frame_support::traits::PalletInfo;

202

// 	use sp_runtime::Perbill;

203

// 	use xcm_primitives::{StakeEncodeCall, UtilityEncodeCall};

204

//

205

// 	#[test]

206

// 	fn test_as_derivative() {

207

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

208

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

209

// 			polkadot_runtime::Utility,

210

// 		>()

211

// 		.unwrap() as u8;

212

// 		expected_encoded.push(index);

213

//

214

// 		let mut expected = pallet_utility::Call::<polkadot_runtime::Runtime>::as_derivative {

215

// 			index: 1,

216

// 			call: polkadot_runtime::RuntimeCall::Staking(pallet_staking::Call::<

217

// 				polkadot_runtime::Runtime,

218

// 			>::chill {})

219

// 			.into(),

220

// 		}

221

// 		.encode();

222

// 		expected_encoded.append(&mut expected);

223

//

224

// 		let call_bytes = <PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

225

// 			xcm_primitives::AvailableStakeCalls::Chill,

226

// 		);

227

//

228

// 		expected_encoded.append(&mut expected);

229

//

230

// 		assert_eq!(

231

// 			xcm_primitives::UtilityEncodeCall::encode_call(

232

// 				PolkadotEncoder,

233

// 				xcm_primitives::UtilityAvailableCalls::AsDerivative(1, call_bytes.clone())

234

// 			),

235

// 			expected_encoded.clone()

236

// 		);

237

// 		sp_io::TestExternalities::default().execute_with(|| {

238

// 			// Pallet-xcm-transactor default encoder returns same result

239

// 			// insert storage item as per migration to set the storage item

240

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

241

// 				POLKADOT_RELAY_INDICES,

242

// 			);

243

// 			assert_eq!(

244

// 				<pallet_xcm_transactor::Pallet::<

245

// 					moonbeam_runtime::Runtime> as UtilityEncodeCall

246

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

247

// 					pallet_xcm_transactor::Pallet(

248

// 						sp_std::marker::PhantomData::<moonbeam_runtime::Runtime>::default()

249

// 					),

250

// 					xcm_primitives::UtilityAvailableCalls::AsDerivative(1, call_bytes)

251

// 				),

252

// 				expected_encoded

253

// 			);

254

// 		});

255

// 	}

256

//

257

// 	#[test]

258

// 	fn test_stake_bond() {

259

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

260

//

261

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

262

// 			polkadot_runtime::Staking,

263

// 		>()

264

// 		.unwrap() as u8;

265

// 		expected_encoded.push(index);

266

//

267

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::bond {

268

// 			value: 100u32.into(),

269

// 			payee: pallet_staking::RewardDestination::Controller,

270

// 		}

271

// 		.encode();

272

// 		expected_encoded.append(&mut expected);

273

//

274

// 		assert_eq!(

275

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

276

// 				xcm_primitives::AvailableStakeCalls::Bond(

277

// 					100u32.into(),

278

// 					pallet_staking::RewardDestination::Controller

279

// 				)

280

// 			),

281

// 			expected_encoded.clone()

282

// 		);

283

// 		sp_io::TestExternalities::default().execute_with(|| {

284

// 			// Pallet-xcm-transactor default encoder returns same result

285

// 			// insert storage item as per migration to set the storage item

286

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

287

// 				POLKADOT_RELAY_INDICES,

288

// 			);

289

// 			assert_eq!(

290

// 				<pallet_xcm_transactor::Pallet::<

291

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

292

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

293

// 					xcm_primitives::AvailableStakeCalls::Bond(

294

// 						100u32.into(),

295

// 						pallet_staking::RewardDestination::Controller

296

// 					)

297

// 				),

298

// 				expected_encoded

299

// 			);

300

// 		});

301

// 	}

302

// 	#[test]

303

// 	fn test_stake_bond_extra() {

304

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

305

//

306

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

307

// 			polkadot_runtime::Staking,

308

// 		>()

309

// 		.unwrap() as u8;

310

// 		expected_encoded.push(index);

311

//

312

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::bond_extra {

313

// 			max_additional: 100u32.into(),

314

// 		}

315

// 		.encode();

316

// 		expected_encoded.append(&mut expected);

317

//

318

// 		assert_eq!(

319

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

320

// 				xcm_primitives::AvailableStakeCalls::BondExtra(100u32.into(),)

321

// 			),

322

// 			expected_encoded.clone()

323

// 		);

324

// 		sp_io::TestExternalities::default().execute_with(|| {

325

// 			// Pallet-xcm-transactor default encoder returns same result

326

// 			// insert storage item as per migration to set the storage item

327

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

328

// 				POLKADOT_RELAY_INDICES,

329

// 			);

330

// 			assert_eq!(

331

// 				<pallet_xcm_transactor::Pallet::<

332

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

333

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

334

// 					xcm_primitives::AvailableStakeCalls::BondExtra(100u32.into(),)

335

// 				),

336

// 				expected_encoded

337

// 			);

338

// 		});

339

// 	}

340

// 	#[test]

341

// 	fn test_stake_unbond() {

342

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

343

//

344

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

345

// 			polkadot_runtime::Staking,

346

// 		>()

347

// 		.unwrap() as u8;

348

// 		expected_encoded.push(index);

349

//

350

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::unbond {

351

// 			value: 100u32.into(),

352

// 		}

353

// 		.encode();

354

// 		expected_encoded.append(&mut expected);

355

//

356

// 		assert_eq!(

357

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

358

// 				xcm_primitives::AvailableStakeCalls::Unbond(100u32.into(),)

359

// 			),

360

// 			expected_encoded.clone()

361

// 		);

362

// 		sp_io::TestExternalities::default().execute_with(|| {

363

// 			// Pallet-xcm-transactor default encoder returns same result

364

// 			// insert storage item as per migration to set the storage item

365

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

366

// 				POLKADOT_RELAY_INDICES,

367

// 			);

368

// 			assert_eq!(

369

// 				<pallet_xcm_transactor::Pallet::<

370

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

371

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

372

// 					xcm_primitives::AvailableStakeCalls::Unbond(100u32.into(),)

373

// 				),

374

// 				expected_encoded

375

// 			);

376

// 		});

377

// 	}

378

// 	#[test]

379

// 	fn test_stake_withdraw_unbonded() {

380

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

381

//

382

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

383

// 			polkadot_runtime::Staking,

384

// 		>()

385

// 		.unwrap() as u8;

386

// 		expected_encoded.push(index);

387

//

388

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::withdraw_unbonded {

389

// 			num_slashing_spans: 100u32,

390

// 		}

391

// 		.encode();

392

// 		expected_encoded.append(&mut expected);

393

//

394

// 		assert_eq!(

395

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

396

// 				xcm_primitives::AvailableStakeCalls::WithdrawUnbonded(100u32,)

397

// 			),

398

// 			expected_encoded.clone()

399

// 		);

400

// 		sp_io::TestExternalities::default().execute_with(|| {

401

// 			// Pallet-xcm-transactor default encoder returns same result

402

// 			// insert storage item as per migration to set the storage item

403

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

404

// 				POLKADOT_RELAY_INDICES,

405

// 			);

406

// 			assert_eq!(

407

// 				<pallet_xcm_transactor::Pallet::<

408

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

409

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

410

// 					xcm_primitives::AvailableStakeCalls::WithdrawUnbonded(100u32,)

411

// 				),

412

// 				expected_encoded

413

// 			);

414

// 		});

415

// 	}

416

// 	#[test]

417

// 	fn test_stake_validate() {

418

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

419

//

420

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

421

// 			polkadot_runtime::Staking,

422

// 		>()

423

// 		.unwrap() as u8;

424

// 		expected_encoded.push(index);

425

//

426

// 		let validator_prefs = pallet_staking::ValidatorPrefs {

427

// 			commission: Perbill::from_percent(5),

428

// 			blocked: true,

429

// 		};

430

//

431

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::validate {

432

// 			prefs: validator_prefs.clone(),

433

// 		}

434

// 		.encode();

435

// 		expected_encoded.append(&mut expected);

436

//

437

// 		assert_eq!(

438

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

439

// 				xcm_primitives::AvailableStakeCalls::Validate(validator_prefs.clone())

440

// 			),

441

// 			expected_encoded.clone()

442

// 		);

443

// 		sp_io::TestExternalities::default().execute_with(|| {

444

// 			// Pallet-xcm-transactor default encoder returns same result

445

// 			// insert storage item as per migration to set the storage item

446

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

447

// 				POLKADOT_RELAY_INDICES,

448

// 			);

449

// 			assert_eq!(

450

// 				<pallet_xcm_transactor::Pallet::<

451

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

452

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

453

// 					xcm_primitives::AvailableStakeCalls::Validate(validator_prefs)

454

// 				),

455

// 				expected_encoded

456

// 			);

457

// 		});

458

// 	}

459

// 	#[test]

460

// 	fn test_stake_nominate() {

461

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

462

// 		let relay_account: AccountId32 = [1u8; 32].into();

463

//

464

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

465

// 			polkadot_runtime::Staking,

466

// 		>()

467

// 		.unwrap() as u8;

468

// 		expected_encoded.push(index);

469

//

470

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::nominate {

471

// 			targets: vec![relay_account.clone().into()],

472

// 		}

473

// 		.encode();

474

// 		expected_encoded.append(&mut expected);

475

//

476

// 		assert_eq!(

477

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

478

// 				xcm_primitives::AvailableStakeCalls::Nominate(vec![relay_account.clone().into()])

479

// 			),

480

// 			expected_encoded.clone()

481

// 		);

482

// 		sp_io::TestExternalities::default().execute_with(|| {

483

// 			// Pallet-xcm-transactor default encoder returns same result

484

// 			// insert storage item as per migration to set the storage item

485

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

486

// 				POLKADOT_RELAY_INDICES,

487

// 			);

488

// 			assert_eq!(

489

// 				<pallet_xcm_transactor::Pallet::<

490

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

491

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

492

// 					xcm_primitives::AvailableStakeCalls::Nominate(vec![

493

// 						relay_account.into()

494

// 					])

495

// 				),

496

// 				expected_encoded

497

// 			);

498

// 		});

499

// 	}

500

// 	#[test]

501

// 	fn test_stake_chill() {

502

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

503

//

504

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

505

// 			polkadot_runtime::Staking,

506

// 		>()

507

// 		.unwrap() as u8;

508

// 		expected_encoded.push(index);

509

//

510

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::chill {}.encode();

511

// 		expected_encoded.append(&mut expected);

512

//

513

// 		assert_eq!(

514

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

515

// 				xcm_primitives::AvailableStakeCalls::Chill

516

// 			),

517

// 			expected_encoded.clone()

518

// 		);

519

// 		sp_io::TestExternalities::default().execute_with(|| {

520

// 			// Pallet-xcm-transactor default encoder returns same result

521

// 			// insert storage item as per migration to set the storage item

522

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

523

// 				POLKADOT_RELAY_INDICES,

524

// 			);

525

// 			assert_eq!(

526

// 				<pallet_xcm_transactor::Pallet::<

527

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

528

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

529

// 					xcm_primitives::AvailableStakeCalls::Chill

530

// 				),

531

// 				expected_encoded

532

// 			);

533

// 		});

534

// 	}

535

//

536

// 	#[test]

537

// 	fn test_set_payee() {

538

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

539

//

540

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

541

// 			polkadot_runtime::Staking,

542

// 		>()

543

// 		.unwrap() as u8;

544

// 		expected_encoded.push(index);

545

//

546

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::set_payee {

547

// 			payee: pallet_staking::RewardDestination::Controller,

548

// 		}

549

// 		.encode();

550

// 		expected_encoded.append(&mut expected);

551

//

552

// 		assert_eq!(

553

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

554

// 				xcm_primitives::AvailableStakeCalls::SetPayee(

555

// 					pallet_staking::RewardDestination::Controller

556

// 				)

557

// 			),

558

// 			expected_encoded.clone()

559

// 		);

560

// 		sp_io::TestExternalities::default().execute_with(|| {

561

// 			// Pallet-xcm-transactor default encoder returns same result

562

// 			// insert storage item as per migration to set the storage item

563

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

564

// 				POLKADOT_RELAY_INDICES,

565

// 			);

566

// 			assert_eq!(

567

// 				<pallet_xcm_transactor::Pallet::<

568

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

569

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

570

// 					xcm_primitives::AvailableStakeCalls::SetPayee(

571

// 						pallet_staking::RewardDestination::Controller

572

// 					)

573

// 				),

574

// 				expected_encoded

575

// 			);

576

// 		});

577

// 	}

578

//

579

// 	#[test]

580

// 	fn test_set_controller() {

581

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

582

//

583

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

584

// 			polkadot_runtime::Staking,

585

// 		>()

586

// 		.unwrap() as u8;

587

// 		expected_encoded.push(index);

588

//

589

// 		let mut expected =

590

// 			pallet_staking::Call::<polkadot_runtime::Runtime>::set_controller {}.encode();

591

// 		expected_encoded.append(&mut expected);

592

//

593

// 		assert_eq!(

594

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

595

// 				xcm_primitives::AvailableStakeCalls::SetController

596

// 			),

597

// 			expected_encoded.clone()

598

// 		);

599

// 		sp_io::TestExternalities::default().execute_with(|| {

600

// 			// Pallet-xcm-transactor default encoder returns same result

601

// 			// insert storage item as per migration to set the storage item

602

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

603

// 				POLKADOT_RELAY_INDICES,

604

// 			);

605

// 			assert_eq!(

606

// 				<pallet_xcm_transactor::Pallet::<

607

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

608

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

609

// 					xcm_primitives::AvailableStakeCalls::SetController

610

// 				),

611

// 				expected_encoded

612

// 			);

613

// 		});

614

// 	}

615

// 	#[test]

616

// 	fn test_rebond() {

617

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

618

//

619

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

620

// 			polkadot_runtime::Staking,

621

// 		>()

622

// 		.unwrap() as u8;

623

// 		expected_encoded.push(index);

624

//

625

// 		let mut expected = pallet_staking::Call::<polkadot_runtime::Runtime>::rebond {

626

// 			value: 100u32.into(),

627

// 		}

628

// 		.encode();

629

// 		expected_encoded.append(&mut expected);

630

//

631

// 		assert_eq!(

632

// 			<PolkadotEncoder as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

633

// 				xcm_primitives::AvailableStakeCalls::Rebond(100u32.into())

634

// 			),

635

// 			expected_encoded.clone()

636

// 		);

637

// 		sp_io::TestExternalities::default().execute_with(|| {

638

// 			// Pallet-xcm-transactor default encoder returns same result

639

// 			// insert storage item as per migration to set the storage item

640

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

641

// 				POLKADOT_RELAY_INDICES,

642

// 			);

643

// 			assert_eq!(

644

// 				<pallet_xcm_transactor::Pallet::<

645

// 					moonbeam_runtime::Runtime> as StakeEncodeCall<moonbeam_runtime::xcm_config::Transactors>

646

// 				>::encode_call(moonbeam_runtime::xcm_config::Transactors::Relay,

647

// 					xcm_primitives::AvailableStakeCalls::Rebond(100u32.into())

648

// 				),

649

// 				expected_encoded

650

// 			);

651

// 		});

652

// 	}

653

//

654

// 	#[test]

655

// 	fn test_hrmp_init() {

656

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

657

//

658

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

659

// 			polkadot_runtime::Hrmp,

660

// 		>()

661

// 		.unwrap() as u8;

662

// 		expected_encoded.push(index);

663

//

664

// 		let mut expected = polkadot_runtime_parachains::hrmp::Call::<

665

// 			polkadot_runtime::Runtime

666

// 		>::hrmp_init_open_channel {

667

// 			recipient: 1000u32.into(),

668

// 			proposed_max_capacity: 100u32,

669

// 			proposed_max_message_size: 100u32,

670

// 		}

671

// 		.encode();

672

// 		expected_encoded.append(&mut expected);

673

//

674

// 		assert_eq!(

675

// 			<PolkadotEncoder as xcm_primitives::HrmpEncodeCall>::hrmp_encode_call(

676

// 				xcm_primitives::HrmpAvailableCalls::InitOpenChannel(

677

// 					1000u32.into(),

678

// 					100u32.into(),

679

// 					100u32.into()

680

// 				)

681

// 			),

682

// 			Ok(expected_encoded.clone())

683

// 		);

684

// 		sp_io::TestExternalities::default().execute_with(|| {

685

// 			// Pallet-xcm-transactor default encoder returns same result

686

// 			// insert storage item as per migration to set the storage item

687

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

688

// 				POLKADOT_RELAY_INDICES,

689

// 			);

690

// 			assert_eq!(

691

// 				<pallet_xcm_transactor::Pallet::<

692

// 					moonbeam_runtime::Runtime> as xcm_primitives::HrmpEncodeCall

693

// 				>::hrmp_encode_call(

694

// 					xcm_primitives::HrmpAvailableCalls::InitOpenChannel(

695

// 						1000u32.into(),

696

// 						100u32.into(),

697

// 						100u32.into()

698

// 					)

699

// 				),

700

// 				Ok(expected_encoded)

701

// 			);

702

// 		});

703

// 	}

704

//

705

// 	#[test]

706

// 	fn test_hrmp_accept() {

707

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

708

//

709

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

710

// 			polkadot_runtime::Hrmp,

711

// 		>()

712

// 		.unwrap() as u8;

713

// 		expected_encoded.push(index);

714

//

715

// 		let mut expected = polkadot_runtime_parachains::hrmp::Call::<

716

// 			polkadot_runtime::Runtime

717

// 		>::hrmp_accept_open_channel {

718

// 			sender: 1000u32.into()

719

// 		}

720

// 		.encode();

721

// 		expected_encoded.append(&mut expected);

722

//

723

// 		assert_eq!(

724

// 			<PolkadotEncoder as xcm_primitives::HrmpEncodeCall>::hrmp_encode_call(

725

// 				xcm_primitives::HrmpAvailableCalls::AcceptOpenChannel(1000u32.into(),)

726

// 			),

727

// 			Ok(expected_encoded.clone())

728

// 		);

729

// 		sp_io::TestExternalities::default().execute_with(|| {

730

// 			// Pallet-xcm-transactor default encoder returns same result

731

// 			// insert storage item as per migration to set the storage item

732

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

733

// 				POLKADOT_RELAY_INDICES,

734

// 			);

735

// 			assert_eq!(

736

// 				<pallet_xcm_transactor::Pallet::<

737

// 					moonbeam_runtime::Runtime> as xcm_primitives::HrmpEncodeCall

738

// 				>::hrmp_encode_call(

739

// 					xcm_primitives::HrmpAvailableCalls::AcceptOpenChannel(1000u32.into(),)

740

// 				),

741

// 				Ok(expected_encoded)

742

// 			);

743

// 		});

744

// 	}

745

//

746

// 	#[test]

747

// 	fn test_hrmp_close() {

748

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

749

//

750

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

751

// 			polkadot_runtime::Hrmp,

752

// 		>()

753

// 		.unwrap() as u8;

754

// 		expected_encoded.push(index);

755

//

756

// 		let mut expected = polkadot_runtime_parachains::hrmp::Call::<

757

// 			polkadot_runtime::Runtime

758

// 		>::hrmp_close_channel {

759

// 			channel_id: HrmpChannelId {

760

// 				sender: 1000u32.into(),

761

// 				recipient: 1001u32.into()

762

// 			}

763

// 		}

764

// 		.encode();

765

// 		expected_encoded.append(&mut expected);

766

//

767

// 		assert_eq!(

768

// 			<PolkadotEncoder as xcm_primitives::HrmpEncodeCall>::hrmp_encode_call(

769

// 				xcm_primitives::HrmpAvailableCalls::CloseChannel(HrmpChannelId {

770

// 					sender: 1000u32.into(),

771

// 					recipient: 1001u32.into()

772

// 				})

773

// 			),

774

// 			Ok(expected_encoded.clone())

775

// 		);

776

// 		sp_io::TestExternalities::default().execute_with(|| {

777

// 			// Pallet-xcm-transactor default encoder returns same result

778

// 			// insert storage item as per migration to set the storage item

779

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

780

// 				POLKADOT_RELAY_INDICES,

781

// 			);

782

// 			assert_eq!(

783

// 				<pallet_xcm_transactor::Pallet::<

784

// 					moonbeam_runtime::Runtime> as xcm_primitives::HrmpEncodeCall

785

// 				>::hrmp_encode_call(

786

// 					xcm_primitives::HrmpAvailableCalls::CloseChannel(HrmpChannelId {

787

// 						sender: 1000u32.into(),

788

// 						recipient: 1001u32.into()

789

// 					})

790

// 				),

791

// 				Ok(expected_encoded)

792

// 			);

793

// 		});

794

// 	}

795

//

796

// 	#[test]

797

// 	fn test_hrmp_cancel() {

798

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

799

//

800

// 		let index = <polkadot_runtime::Runtime as frame_system::Config>::PalletInfo::index::<

801

// 			polkadot_runtime::Hrmp,

802

// 		>()

803

// 		.unwrap() as u8;

804

// 		expected_encoded.push(index);

805

//

806

// 		let channel_id = HrmpChannelId {

807

// 			sender: 1u32.into(),

808

// 			recipient: 1u32.into(),

809

// 		};

810

// 		let open_requests: u32 = 1;

811

//

812

// 		let mut expected = polkadot_runtime_parachains::hrmp::Call::<

813

// 			polkadot_runtime::Runtime

814

// 		>::hrmp_cancel_open_request {

815

// 			channel_id: channel_id.clone(),

816

// 			open_requests

817

// 		}

818

// 		.encode();

819

// 		expected_encoded.append(&mut expected);

820

//

821

// 		assert_eq!(

822

// 			<PolkadotEncoder as xcm_primitives::HrmpEncodeCall>::hrmp_encode_call(

823

// 				xcm_primitives::HrmpAvailableCalls::CancelOpenRequest(

824

// 					channel_id.clone(),

825

// 					open_requests

826

// 				)

827

// 			),

828

// 			Ok(expected_encoded.clone())

829

// 		);

830

// 		sp_io::TestExternalities::default().execute_with(|| {

831

// 			// Pallet-xcm-transactor default encoder returns same result

832

// 			// insert storage item as per migration to set the storage item

833

// 			pallet_xcm_transactor::RelayIndices::<moonbeam_runtime::Runtime>::put(

834

// 				POLKADOT_RELAY_INDICES,

835

// 			);

836

// 			assert_eq!(

837

// 				<pallet_xcm_transactor::Pallet::<

838

// 					moonbeam_runtime::Runtime> as xcm_primitives::HrmpEncodeCall

839

// 				>::hrmp_encode_call(

840

// 					xcm_primitives::HrmpAvailableCalls::CancelOpenRequest(

841

// 						channel_id.clone(),

842

// 						open_requests

843

// 					)

844

// 				),

845

// 				Ok(expected_encoded)

846

// 			);

847

// 		});

848

// 	}

849

// }