Grcov report - integration

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 Integration Tests

18

19

#![cfg(test)]

20

21

mod common;

22

23

use common::*;

24

25

use fp_evm::{Context, IsPrecompileResult};

26

use frame_support::{

27

	assert_noop, assert_ok,

28

	dispatch::DispatchClass,

29

	traits::{

30

		Contains, Currency as CurrencyT, EnsureOrigin, OnInitialize, PalletInfo, StorageInfo,

31

		StorageInfoTrait,

32

},

33

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

34

	StorageHasher, Twox128,

35

};

36

use moonbeam_runtime::currency::{GIGAWEI, WEI};

37

use moonbeam_runtime::runtime_params::dynamic_params;

38

use moonbeam_runtime::xcm_config::{AssetHubLocation, XcmExecutor};

39

use moonbeam_runtime::{

40

	currency::GLMR,

41

	moonbeam_xcm_weights,

42

	xcm_config::{CurrencyId, SelfReserve},

43

	AccountId, Balances, EvmForeignAssets, Executive, NormalFilter, OpenTechCommitteeCollective,

44

	ParachainStaking, PolkadotXcm, Precompiles, ProxyType, Runtime, RuntimeBlockWeights,

45

	RuntimeCall, RuntimeEvent, System, TransactionPayment, TransactionPaymentAsGasPrice, Treasury,

46

	TreasuryCouncilCollective, XcmTransactor, WEIGHT_PER_GAS,

47

};

48

use moonbeam_xcm_weights::XcmWeight;

49

use nimbus_primitives::NimbusId;

50

use pallet_evm::PrecompileSet;

51

use pallet_moonbeam_foreign_assets::AssetStatus;

52

use pallet_parachain_staking::InflationDistributionAccount;

53

use pallet_transaction_payment::Multiplier;

54

use pallet_xcm_transactor::{Currency, CurrencyPayment, TransactWeights};

55

use parity_scale_codec::Encode;

56

use polkadot_parachain::primitives::Sibling;

57

use precompile_utils::{

58

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

59

	prelude::*,

60

	testing::*,

61

};

62

use sp_core::{ByteArray, Get, H160, U256};

63

use sp_runtime::{

64

	traits::{Convert, Dispatchable},

65

	BuildStorage, DispatchError, ModuleError, Percent,

66

};

67

use std::str::from_utf8;

68

use xcm::{latest::prelude::*, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm};

69

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

70

use xcm_executor::traits::{ConvertLocation, TransferType};

71

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

72

73

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

74

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

75

	Runtime,

76

	moonbeam_runtime::xcm_config::XcmExecutorConfig,

77

>;

78

type XcmTransactorV2PCall =

79

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

80

81

const BASE_FEE_GENESIS: u128 = 10000 * GIGAWEI;

82

83

3

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

84

3

	Asset {

85

3

		id: AssetId(

86

3

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

87

3

				currency_id,

88

3

89

3

			.unwrap(),

90

3

),

91

3

		fun: Fungibility::Fungible(amount),

92

3

93

3

94

95

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

96

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

97

1

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

98

	use frame_support::weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight, WeightToFee as _};

99

1

	let native_amount_per_second: u128 =

100

1

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

101

1

			&Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, 0),

102

103

1

		.try_into()

104

1

		.map_err(|_| ())?;

105

1

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

106

1

	let relative_price: u128 = if fee_per_second > 0u128 {

107

1

		native_amount_per_second

108

1

			.saturating_mul(precision_factor)

109

1

			.saturating_div(fee_per_second)

110

	} else {

111

		0u128

112

};

113

1

	if pallet_xcm_weight_trader::SupportedAssets::<moonbeam_runtime::Runtime>::contains_key(

114

1

		&location,

115

) {

116

1

		let enabled =

117

1

			pallet_xcm_weight_trader::SupportedAssets::<moonbeam_runtime::Runtime>::get(&location)

118

1

				.ok_or(())?

119

.0;

120

1

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

121

1

			&location,

122

1

			(enabled, relative_price),

123

);

124

	} else {

125

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

126

			&location,

127

			(true, relative_price),

128

);

129

130

1

	Ok(())

131

1

132

#[test]

133

1

fn xcmp_queue_controller_origin_is_root() {

134

	// important for the XcmExecutionManager impl of PauseExecution which uses root origin

135

	// to suspend/resume XCM execution in xcmp_queue::on_idle

136

1

	assert_ok!(

137

1

		<moonbeam_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

138

1

		>::ControllerOrigin::ensure_origin(root_origin())

139

);

140

1

141

142

#[test]

143

1

fn verify_pallet_prefixes() {

144

31

	fn is_pallet_prefix<P: 'static>(name: &str) {

145

		// Compares the unhashed pallet prefix in the `StorageInstance` implementation by every

146

		// storage item in the pallet P. This pallet prefix is used in conjunction with the

147

		// item name to get the unique storage key: hash(PalletPrefix) + hash(StorageName)

148

		// https://github.com/paritytech/substrate/blob/master/frame/support/procedural/src/pallet/

149

		// expand/storage.rs#L389-L401

150

31

		assert_eq!(

151

31

			<moonbeam_runtime::Runtime as frame_system::Config>::PalletInfo::name::<P>(),

152

31

			Some(name)

153

);

154

31

155

	// TODO: use StorageInfoTrait once https://github.com/paritytech/substrate/pull/9246

156

	// is pulled in substrate deps.

157

1

	is_pallet_prefix::<moonbeam_runtime::System>("System");

158

1

	is_pallet_prefix::<moonbeam_runtime::Utility>("Utility");

159

1

	is_pallet_prefix::<moonbeam_runtime::ParachainSystem>("ParachainSystem");

160

1

	is_pallet_prefix::<moonbeam_runtime::TransactionPayment>("TransactionPayment");

161

1

	is_pallet_prefix::<moonbeam_runtime::ParachainInfo>("ParachainInfo");

162

1

	is_pallet_prefix::<moonbeam_runtime::EthereumChainId>("EthereumChainId");

163

1

	is_pallet_prefix::<moonbeam_runtime::EVM>("EVM");

164

1

	is_pallet_prefix::<moonbeam_runtime::Ethereum>("Ethereum");

165

1

	is_pallet_prefix::<moonbeam_runtime::ParachainStaking>("ParachainStaking");

166

1

	is_pallet_prefix::<moonbeam_runtime::Scheduler>("Scheduler");

167

1

	is_pallet_prefix::<moonbeam_runtime::OpenTechCommitteeCollective>(

168

1

		"OpenTechCommitteeCollective",

169

);

170

1

	is_pallet_prefix::<moonbeam_runtime::Treasury>("Treasury");

171

1

	is_pallet_prefix::<moonbeam_runtime::AuthorInherent>("AuthorInherent");

172

1

	is_pallet_prefix::<moonbeam_runtime::AuthorFilter>("AuthorFilter");

173

1

	is_pallet_prefix::<moonbeam_runtime::CrowdloanRewards>("CrowdloanRewards");

174

1

	is_pallet_prefix::<moonbeam_runtime::AuthorMapping>("AuthorMapping");

175

1

	is_pallet_prefix::<moonbeam_runtime::MaintenanceMode>("MaintenanceMode");

176

1

	is_pallet_prefix::<moonbeam_runtime::Identity>("Identity");

177

1

	is_pallet_prefix::<moonbeam_runtime::XcmpQueue>("XcmpQueue");

178

1

	is_pallet_prefix::<moonbeam_runtime::CumulusXcm>("CumulusXcm");

179

1

	is_pallet_prefix::<moonbeam_runtime::PolkadotXcm>("PolkadotXcm");

180

1

	is_pallet_prefix::<moonbeam_runtime::XcmTransactor>("XcmTransactor");

181

1

	is_pallet_prefix::<moonbeam_runtime::ProxyGenesisCompanion>("ProxyGenesisCompanion");

182

1

	is_pallet_prefix::<moonbeam_runtime::MoonbeamOrbiters>("MoonbeamOrbiters");

183

1

	is_pallet_prefix::<moonbeam_runtime::TreasuryCouncilCollective>("TreasuryCouncilCollective");

184

1

	is_pallet_prefix::<moonbeam_runtime::MoonbeamLazyMigrations>("MoonbeamLazyMigrations");

185

1

	is_pallet_prefix::<moonbeam_runtime::RelayStorageRoots>("RelayStorageRoots");

186

1

	is_pallet_prefix::<moonbeam_runtime::BridgeKusamaGrandpa>("BridgeKusamaGrandpa");

187

1

	is_pallet_prefix::<moonbeam_runtime::BridgeKusamaParachains>("BridgeKusamaParachains");

188

1

	is_pallet_prefix::<moonbeam_runtime::BridgeKusamaMessages>("BridgeKusamaMessages");

189

1

	is_pallet_prefix::<moonbeam_runtime::BridgeXcmOverMoonriver>("BridgeXcmOverMoonriver");

190

191

14

	let prefix = |pallet_name, storage_name| {

192

14

		let mut res = [0u8; 32];

193

14

		res[0..16].copy_from_slice(&Twox128::hash(pallet_name));

194

14

		res[16..32].copy_from_slice(&Twox128::hash(storage_name));

195

14

		res.to_vec()

196

14

};

197

1

	assert_eq!(

198

1

		<moonbeam_runtime::Timestamp as StorageInfoTrait>::storage_info(),

199

1

		vec![

200

1

			StorageInfo {

201

1

				pallet_name: b"Timestamp".to_vec(),

202

1

				storage_name: b"Now".to_vec(),

203

1

				prefix: prefix(b"Timestamp", b"Now"),

204

1

				max_values: Some(1),

205

1

				max_size: Some(8),

206

1

},

207

1

			StorageInfo {

208

1

				pallet_name: b"Timestamp".to_vec(),

209

1

				storage_name: b"DidUpdate".to_vec(),

210

1

				prefix: prefix(b"Timestamp", b"DidUpdate"),

211

1

				max_values: Some(1),

212

1

				max_size: Some(1),

213

1

214

215

);

216

1

	assert_eq!(

217

1

		<moonbeam_runtime::Balances as StorageInfoTrait>::storage_info(),

218

1

		vec![

219

1

			StorageInfo {

220

1

				pallet_name: b"Balances".to_vec(),

221

1

				storage_name: b"TotalIssuance".to_vec(),

222

1

				prefix: prefix(b"Balances", b"TotalIssuance"),

223

1

				max_values: Some(1),

224

1

				max_size: Some(16),

225

1

},

226

1

			StorageInfo {

227

1

				pallet_name: b"Balances".to_vec(),

228

1

				storage_name: b"InactiveIssuance".to_vec(),

229

1

				prefix: prefix(b"Balances", b"InactiveIssuance"),

230

1

				max_values: Some(1),

231

1

				max_size: Some(16),

232

1

},

233

1

			StorageInfo {

234

1

				pallet_name: b"Balances".to_vec(),

235

1

				storage_name: b"Account".to_vec(),

236

1

				prefix: prefix(b"Balances", b"Account"),

237

1

				max_values: None,

238

1

				max_size: Some(100),

239

1

},

240

1

			StorageInfo {

241

1

				pallet_name: b"Balances".to_vec(),

242

1

				storage_name: b"Locks".to_vec(),

243

1

				prefix: prefix(b"Balances", b"Locks"),

244

1

				max_values: None,

245

1

				max_size: Some(1287),

246

1

},

247

1

			StorageInfo {

248

1

				pallet_name: b"Balances".to_vec(),

249

1

				storage_name: b"Reserves".to_vec(),

250

1

				prefix: prefix(b"Balances", b"Reserves"),

251

1

				max_values: None,

252

1

				max_size: Some(1037),

253

1

},

254

1

			StorageInfo {

255

1

				pallet_name: b"Balances".to_vec(),

256

1

				storage_name: b"Holds".to_vec(),

257

1

				prefix: prefix(b"Balances", b"Holds"),

258

1

				max_values: None,

259

1

				max_size: Some(91),

260

1

},

261

1

			StorageInfo {

262

1

				pallet_name: b"Balances".to_vec(),

263

1

				storage_name: b"Freezes".to_vec(),

264

1

				prefix: prefix(b"Balances", b"Freezes"),

265

1

				max_values: None,

266

1

				max_size: Some(73),

267

1

},

268

269

);

270

1

	assert_eq!(

271

1

		<moonbeam_runtime::Proxy as StorageInfoTrait>::storage_info(),

272

1

		vec![

273

1

			StorageInfo {

274

1

				pallet_name: b"Proxy".to_vec(),

275

1

				storage_name: b"Proxies".to_vec(),

276

1

				prefix: prefix(b"Proxy", b"Proxies"),

277

1

				max_values: None,

278

1

				max_size: Some(845),

279

1

},

280

1

			StorageInfo {

281

1

				pallet_name: b"Proxy".to_vec(),

282

1

				storage_name: b"Announcements".to_vec(),

283

1

				prefix: prefix(b"Proxy", b"Announcements"),

284

1

				max_values: None,

285

1

				max_size: Some(1837),

286

1

287

288

);

289

1

	assert_eq!(

290

1

		<moonbeam_runtime::MaintenanceMode as StorageInfoTrait>::storage_info(),

291

1

		vec![StorageInfo {

292

1

			pallet_name: b"MaintenanceMode".to_vec(),

293

1

			storage_name: b"MaintenanceMode".to_vec(),

294

1

			prefix: prefix(b"MaintenanceMode", b"MaintenanceMode"),

295

1

			max_values: Some(1),

296

1

			max_size: None,

297

1

},]

298

);

299

1

	assert_eq!(

300

1

		<moonbeam_runtime::RelayStorageRoots as StorageInfoTrait>::storage_info(),

301

1

		vec![

302

1

			StorageInfo {

303

1

				pallet_name: b"RelayStorageRoots".to_vec(),

304

1

				storage_name: b"RelayStorageRoot".to_vec(),

305

1

				prefix: prefix(b"RelayStorageRoots", b"RelayStorageRoot"),

306

1

				max_values: None,

307

1

				max_size: Some(44),

308

1

},

309

1

			StorageInfo {

310

1

				pallet_name: b"RelayStorageRoots".to_vec(),

311

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

312

1

				prefix: prefix(b"RelayStorageRoots", b"RelayStorageRootKeys"),

313

1

				max_values: Some(1),

314

1

				max_size: Some(121),

315

1

},

316

317

);

318

1

319

320

#[test]

321

1

fn test_collectives_storage_item_prefixes() {

322

7

	for StorageInfo { pallet_name, .. } in

323

1

		<moonbeam_runtime::TreasuryCouncilCollective as StorageInfoTrait>::storage_info()

324

325

7

		assert_eq!(pallet_name, b"TreasuryCouncilCollective".to_vec());

326

327

328

7

	for StorageInfo { pallet_name, .. } in

329

1

		<moonbeam_runtime::OpenTechCommitteeCollective as StorageInfoTrait>::storage_info()

330

331

7

		assert_eq!(pallet_name, b"OpenTechCommitteeCollective".to_vec());

332

333

1

334

335

#[test]

336

1

fn collective_set_members_root_origin_works() {

337

1

	ExtBuilder::default().build().execute_with(|| {

338

		// TreasuryCouncilCollective

339

1

		assert_ok!(TreasuryCouncilCollective::set_members(

340

1

			<Runtime as frame_system::Config>::RuntimeOrigin::root(),

341

1

			vec![AccountId::from(ALICE), AccountId::from(BOB)],

342

1

			Some(AccountId::from(ALICE)),

343

344

));

345

		// OpenTechCommitteeCollective

346

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

347

1

			<Runtime as frame_system::Config>::RuntimeOrigin::root(),

348

1

			vec![AccountId::from(ALICE), AccountId::from(BOB)],

349

1

			Some(AccountId::from(ALICE)),

350

351

));

352

1

});

353

1

354

355

#[test]

356

1

fn collective_set_members_general_admin_origin_works() {

357

	use moonbeam_runtime::{

358

		governance::custom_origins::Origin as CustomOrigin, OriginCaller, Utility,

359

};

360

361

1

	ExtBuilder::default().build().execute_with(|| {

362

1

		let root_caller = <Runtime as frame_system::Config>::RuntimeOrigin::root();

363

1

		let alice = AccountId::from(ALICE);

364

365

		// TreasuryCouncilCollective

366

1

		let _ = Utility::dispatch_as(

367

1

			root_caller.clone(),

368

1

			Box::new(OriginCaller::Origins(CustomOrigin::GeneralAdmin)),

369

1

			Box::new(

370

1

				pallet_collective::Call::<Runtime, pallet_collective::Instance3>::set_members {

371

1

					new_members: vec![alice, AccountId::from(BOB)],

372

1

					prime: Some(alice),

373

1

					old_count: 2,

374

1

375

1

				.into(),

376

1

),

377

1

);

378

		// OpenTechCommitteeCollective

379

1

		let _ = Utility::dispatch_as(

380

1

			root_caller,

381

1

			Box::new(OriginCaller::Origins(CustomOrigin::GeneralAdmin)),

382

1

			Box::new(

383

1

				pallet_collective::Call::<Runtime, pallet_collective::Instance4>::set_members {

384

1

					new_members: vec![alice, AccountId::from(BOB)],

385

1

					prime: Some(alice),

386

1

					old_count: 2,

387

1

388

1

				.into(),

389

1

),

390

1

);

391

392

1

		assert_eq!(

393

1

			System::events()

394

1

				.into_iter()

395

2

				.filter_map(|r| {

396

2

					match r.event {

397

2

						RuntimeEvent::Utility(pallet_utility::Event::DispatchedAs { result })

398

2

							if result.is_ok() =>

399

400

2

							Some(true)

401

402

						_ => None,

403

404

2

})

405

1

				.collect::<Vec<_>>()

406

1

				.len(),

407

408

409

1

});

410

1

411

412

#[test]

413

1

fn collective_set_members_signed_origin_does_not_work() {

414

1

	let alice = AccountId::from(ALICE);

415

1

	ExtBuilder::default().build().execute_with(|| {

416

		// TreasuryCouncilCollective

417

1

		assert!(TreasuryCouncilCollective::set_members(

418

1

			<Runtime as frame_system::Config>::RuntimeOrigin::signed(alice),

419

1

			vec![AccountId::from(ALICE), AccountId::from(BOB)],

420

1

			Some(AccountId::from(ALICE)),

421

1

422

1

423

1

		.is_err());

424

		// OpenTechCommitteeCollective

425

1

		assert!(OpenTechCommitteeCollective::set_members(

426

1

			<Runtime as frame_system::Config>::RuntimeOrigin::signed(alice),

427

1

			vec![AccountId::from(ALICE), AccountId::from(BOB)],

428

1

			Some(AccountId::from(ALICE)),

429

1

430

1

431

1

		.is_err());

432

1

});

433

1

434

435

#[test]

436

1

fn verify_pallet_indices() {

437

33

	fn is_pallet_index<P: 'static>(index: usize) {

438

33

		assert_eq!(

439

33

			<moonbeam_runtime::Runtime as frame_system::Config>::PalletInfo::index::<P>(),

440

33

			Some(index)

441

);

442

33

443

444

	// System support

445

1

	is_pallet_index::<moonbeam_runtime::System>(0);

446

1

	is_pallet_index::<moonbeam_runtime::ParachainSystem>(1);

447

1

	is_pallet_index::<moonbeam_runtime::Timestamp>(3);

448

1

	is_pallet_index::<moonbeam_runtime::ParachainInfo>(4);

449

	// Monetary

450

1

	is_pallet_index::<moonbeam_runtime::Balances>(10);

451

1

	is_pallet_index::<moonbeam_runtime::TransactionPayment>(11);

452

	// Consensus support

453

1

	is_pallet_index::<moonbeam_runtime::ParachainStaking>(20);

454

1

	is_pallet_index::<moonbeam_runtime::AuthorInherent>(21);

455

1

	is_pallet_index::<moonbeam_runtime::AuthorFilter>(22);

456

1

	is_pallet_index::<moonbeam_runtime::AuthorMapping>(23);

457

1

	is_pallet_index::<moonbeam_runtime::MoonbeamOrbiters>(24);

458

	// Handy utilities

459

1

	is_pallet_index::<moonbeam_runtime::Utility>(30);

460

1

	is_pallet_index::<moonbeam_runtime::Proxy>(31);

461

1

	is_pallet_index::<moonbeam_runtime::MaintenanceMode>(32);

462

1

	is_pallet_index::<moonbeam_runtime::Identity>(33);

463

1

	is_pallet_index::<moonbeam_runtime::ProxyGenesisCompanion>(35);

464

1

	is_pallet_index::<moonbeam_runtime::MoonbeamLazyMigrations>(37);

465

	// Ethereum compatibility

466

1

	is_pallet_index::<moonbeam_runtime::EthereumChainId>(50);

467

1

	is_pallet_index::<moonbeam_runtime::EVM>(51);

468

1

	is_pallet_index::<moonbeam_runtime::Ethereum>(52);

469

	// Governance

470

1

	is_pallet_index::<moonbeam_runtime::Scheduler>(60);

471

	// is_pallet_index::<moonbeam_runtime::Democracy>(61); Removed

472

	// Council

473

	// is_pallet_index::<moonbeam_runtime::CouncilCollective>(70); Removed

474

	// is_pallet_index::<moonbeam_runtime::TechCommitteeCollective>(71); Removed

475

1

	is_pallet_index::<moonbeam_runtime::TreasuryCouncilCollective>(72);

476

1

	is_pallet_index::<moonbeam_runtime::OpenTechCommitteeCollective>(73);

477

	// Treasury

478

1

	is_pallet_index::<moonbeam_runtime::Treasury>(80);

479

	// Crowdloan

480

1

	is_pallet_index::<moonbeam_runtime::CrowdloanRewards>(90);

481

	// XCM Stuff

482

1

	is_pallet_index::<moonbeam_runtime::XcmpQueue>(100);

483

1

	is_pallet_index::<moonbeam_runtime::CumulusXcm>(101);

484

1

	is_pallet_index::<moonbeam_runtime::PolkadotXcm>(103);

485

	// is_pallet_index::<moonbeam_runtime::Assets>(104); Removed

486

	// is_pallet_index::<moonbeam_runtime::AssetManager>(105); Removed

487

	// is_pallet_index::<moonbeam_runtime::XTokens>(106); Removed

488

1

	is_pallet_index::<moonbeam_runtime::XcmTransactor>(107);

489

1

	is_pallet_index::<moonbeam_runtime::BridgeKusamaGrandpa>(130);

490

1

	is_pallet_index::<moonbeam_runtime::BridgeKusamaParachains>(131);

491

1

	is_pallet_index::<moonbeam_runtime::BridgeKusamaMessages>(132);

492

1

	is_pallet_index::<moonbeam_runtime::BridgeXcmOverMoonriver>(133);

493

1

494

495

#[test]

496

1

fn verify_reserved_indices() {

497

1

	let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

498

1

		.build_storage()

499

1

		.unwrap()

500

1

		.into();

501

502

1

	t.execute_with(|| {

503

		use frame_metadata::*;

504

1

		let metadata = moonbeam_runtime::Runtime::metadata();

505

1

		let metadata = match metadata.1 {

506

1

			RuntimeMetadata::V14(metadata) => metadata,

507

			_ => panic!("metadata has been bumped, test needs to be updated"),

508

};

509

		// 40: Sudo

510

		// 53: BaseFee

511

		// 108: pallet_assets::<Instance1>

512

1

		let reserved = vec![40, 53, 108];

513

1

		let existing = metadata

514

1

			.pallets

515

1

			.iter()

516

1

			.map(|p| p.index)

517

1

			.collect::<Vec<u8>>();

518

3

		assert!(reserved.iter().all(|index| !existing.contains(index)));

519

1

});

520

1

521

522

#[test]

523

1

fn verify_proxy_type_indices() {

524

1

	assert_eq!(moonbeam_runtime::ProxyType::Any as u8, 0);

525

1

	assert_eq!(moonbeam_runtime::ProxyType::NonTransfer as u8, 1);

526

1

	assert_eq!(moonbeam_runtime::ProxyType::Governance as u8, 2);

527

1

	assert_eq!(moonbeam_runtime::ProxyType::Staking as u8, 3);

528

1

	assert_eq!(moonbeam_runtime::ProxyType::CancelProxy as u8, 4);

529

1

	assert_eq!(moonbeam_runtime::ProxyType::Balances as u8, 5);

530

1

	assert_eq!(moonbeam_runtime::ProxyType::AuthorMapping as u8, 6);

531

1

	assert_eq!(moonbeam_runtime::ProxyType::IdentityJudgement as u8, 7);

532

1

533

534

// This test ensure that we not filter out pure proxy calls

535

#[test]

536

1

fn verify_normal_filter_allow_pure_proxy() {

537

1

	ExtBuilder::default().build().execute_with(|| {

538

1

		assert!(NormalFilter::contains(&RuntimeCall::Proxy(

539

1

			pallet_proxy::Call::<Runtime>::create_pure {

540

1

				proxy_type: ProxyType::Any,

541

1

				delay: 0,

542

1

				index: 0,

543

1

544

1

		)));

545

1

		assert!(NormalFilter::contains(&RuntimeCall::Proxy(

546

1

			pallet_proxy::Call::<Runtime>::kill_pure {

547

1

				spawner: AccountId::from(ALICE),

548

1

				proxy_type: ProxyType::Any,

549

1

				index: 0,

550

1

				height: 0,

551

1

				ext_index: 0,

552

1

553

1

		)));

554

1

});

555

1

556

557

#[test]

558

1

fn join_collator_candidates() {

559

1

	ExtBuilder::default()

560

1

		.with_balances(vec![

561

1

			(AccountId::from(ALICE), 10_000_000 * GLMR),

562

1

			(AccountId::from(BOB), 10_000_000 * GLMR),

563

1

			(AccountId::from(CHARLIE), 10_000_000 * GLMR),

564

1

			(AccountId::from(DAVE), 10_000_000 * GLMR),

565

1

])

566

1

		.with_collators(vec![

567

1

			(AccountId::from(ALICE), 2_000_000 * GLMR),

568

1

			(AccountId::from(BOB), 2_000_000 * GLMR),

569

1

])

570

1

		.with_delegations(vec![

571

1

572

1

				AccountId::from(CHARLIE),

573

1

				AccountId::from(ALICE),

574

1

				5_000 * GLMR,

575

1

),

576

1

			(AccountId::from(CHARLIE), AccountId::from(BOB), 5_000 * GLMR),

577

1

])

578

1

		.build()

579

1

		.execute_with(|| {

580

1

			assert_noop!(

581

1

				ParachainStaking::join_candidates(

582

1

					origin_of(AccountId::from(ALICE)),

583

1

					2_000_000 * GLMR,

584

					2u32

585

),

586

1

				pallet_parachain_staking::Error::<Runtime>::CandidateExists

587

);

588

1

			assert_noop!(

589

1

				ParachainStaking::join_candidates(

590

1

					origin_of(AccountId::from(CHARLIE)),

591

1

					2_000_000 * GLMR,

592

					2u32

593

),

594

1

				pallet_parachain_staking::Error::<Runtime>::DelegatorExists

595

);

596

1

			assert!(System::events().is_empty());

597

1

			assert_ok!(ParachainStaking::join_candidates(

598

1

				origin_of(AccountId::from(DAVE)),

599

1

				2_000_000 * GLMR,

600

				2u32

601

));

602

1

			assert_eq!(

603

1

				last_event(),

604

1

				RuntimeEvent::ParachainStaking(

605

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

606

1

						account: AccountId::from(DAVE),

607

1

						amount_locked: 2_000_000 * GLMR,

608

1

						new_total_amt_locked: 6_010_000 * GLMR

609

1

610

1

611

);

612

1

			let candidates = ParachainStaking::candidate_pool();

613

1

			assert_eq!(candidates.0[0].owner, AccountId::from(ALICE));

614

1

			assert_eq!(candidates.0[0].amount, 2_005_000 * GLMR);

615

1

			assert_eq!(candidates.0[1].owner, AccountId::from(BOB));

616

1

			assert_eq!(candidates.0[1].amount, 2_005_000 * GLMR);

617

1

			assert_eq!(candidates.0[2].owner, AccountId::from(DAVE));

618

1

			assert_eq!(candidates.0[2].amount, 2_000_000 * GLMR);

619

1

});

620

1

621

622

#[test]

623

1

fn transfer_through_evm_to_stake() {

624

1

	ExtBuilder::default()

625

1

		.with_balances(vec![(AccountId::from(ALICE), 10_000_000 * GLMR)])

626

1

		.build()

627

1

		.execute_with(|| {

628

			// Charlie has no balance => fails to stake

629

1

			assert_noop!(

630

1

				ParachainStaking::join_candidates(

631

1

					origin_of(AccountId::from(CHARLIE)),

632

1

					2_000_000 * GLMR,

633

					2u32

634

),

635

1

				DispatchError::Module(ModuleError {

636

1

					index: 20,

637

1

					error: [8, 0, 0, 0],

638

1

					message: Some("InsufficientBalance")

639

1

})

640

);

641

			// Alice transfer from free balance 3_000_000 GLMR to Bob

642

1

			assert_ok!(Balances::transfer_allow_death(

643

1

				origin_of(AccountId::from(ALICE)),

644

1

				AccountId::from(BOB),

645

1

				3_000_000 * GLMR,

646

));

647

1

			assert_eq!(

648

1

				Balances::free_balance(AccountId::from(BOB)),

649

				3_000_000 * GLMR

650

);

651

652

1

			let gas_limit = 100000u64;

653

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

654

			// Bob transfers 2_000_000 GLMR to Charlie via EVM

655

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::<Runtime>::call {

656

1

				source: H160::from(BOB),

657

1

				target: H160::from(CHARLIE),

658

1

				input: vec![],

659

1

				value: (2_000_000 * GLMR).into(),

660

1

				gas_limit,

661

1

				max_fee_per_gas: gas_price,

662

1

				max_priority_fee_per_gas: None,

663

1

				nonce: None,

664

1

				access_list: Vec::new(),

665

1

				authorization_list: Vec::new(),

666

1

})

667

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

668

1

			assert_eq!(

669

1

				Balances::free_balance(AccountId::from(CHARLIE)),

670

				2_000_000 * GLMR,

671

);

672

673

			// Charlie can stake now

674

1

			assert_ok!(ParachainStaking::join_candidates(

675

1

				origin_of(AccountId::from(CHARLIE)),

676

1

				2_000_000 * GLMR,

677

				2u32

678

			),);

679

1

			let candidates = ParachainStaking::candidate_pool();

680

1

			assert_eq!(candidates.0[0].owner, AccountId::from(CHARLIE));

681

1

			assert_eq!(candidates.0[0].amount, 2_000_000 * GLMR);

682

1

});

683

1

684

685

#[test]

686

1

fn reward_block_authors() {

687

1

	ExtBuilder::default()

688

1

		.with_balances(vec![

689

1

			// Alice gets 10k extra tokens for her mapping deposit

690

1

			(AccountId::from(ALICE), 10_010_000 * GLMR),

691

1

			(AccountId::from(BOB), 10_000_000 * GLMR),

692

1

])

693

1

		.with_collators(vec![(AccountId::from(ALICE), 2_000_000 * GLMR)])

694

1

		.with_delegations(vec![(

695

1

			AccountId::from(BOB),

696

1

			AccountId::from(ALICE),

697

1

			50_000 * GLMR,

698

1

)])

699

1

		.with_mappings(vec![(

700

1

			NimbusId::from_slice(&ALICE_NIMBUS).unwrap(),

701

1

			AccountId::from(ALICE),

702

1

)])

703

1

		.build()

704

1

		.execute_with(|| {

705

1

			increase_last_relay_slot_number(1);

706

			// Just before round 3

707

1

			run_to_block(7199, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));

708

			// no rewards doled out yet

709

1

			assert_eq!(

710

1

				Balances::usable_balance(AccountId::from(ALICE)),

711

				8_010_000 * GLMR,

712

);

713

1

			assert_eq!(

714

1

				Balances::usable_balance(AccountId::from(BOB)),

715

				9_950_000 * GLMR,

716

);

717

1

			run_to_block(7201, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));

718

			// rewards minted and distributed

719

1

			assert_eq!(

720

1

				Balances::usable_balance(AccountId::from(ALICE)),

721

				8990978048702400000000000,

722

);

723

1

			assert_eq!(

724

1

				Balances::usable_balance(AccountId::from(BOB)),

725

				9969521950497200000000000,

726

);

727

1

});

728

1

729

730

#[test]

731

1

fn reward_block_authors_with_parachain_bond_reserved() {

732

1

	ExtBuilder::default()

733

1

		.with_balances(vec![

734

1

			// Alice gets 10k extra tokens for her mapping deposit

735

1

			(AccountId::from(ALICE), 10_010_000 * GLMR),

736

1

			(AccountId::from(BOB), 10_000_000 * GLMR),

737

1

			(AccountId::from(CHARLIE), 10_000 * GLMR),

738

1

])

739

1

		.with_collators(vec![(AccountId::from(ALICE), 2_000_000 * GLMR)])

740

1

		.with_delegations(vec![(

741

1

			AccountId::from(BOB),

742

1

			AccountId::from(ALICE),

743

1

			50_000 * GLMR,

744

1

)])

745

1

		.with_mappings(vec![(

746

1

			NimbusId::from_slice(&ALICE_NIMBUS).unwrap(),

747

1

			AccountId::from(ALICE),

748

1

)])

749

1

		.build()

750

1

		.execute_with(|| {

751

1

			increase_last_relay_slot_number(1);

752

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

753

1

				root_origin(),

754

1

755

1

					InflationDistributionAccount {

756

1

						account: AccountId::from(CHARLIE),

757

1

						percent: Percent::from_percent(30),

758

1

},

759

1

					InflationDistributionAccount::default(),

760

1

761

1

				.into()

762

));

763

764

			// Stop just before round 3

765

1

			run_to_block(7199, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));

766

			// no collators rewards doled out yet

767

1

			assert_eq!(

768

1

				Balances::usable_balance(AccountId::from(ALICE)),

769

				8_010_000 * GLMR,

770

);

771

1

			assert_eq!(

772

1

				Balances::usable_balance(AccountId::from(BOB)),

773

				9_950_000 * GLMR,

774

);

775

			// 30% reserved for parachain bond

776

1

			assert_eq!(

777

1

				Balances::usable_balance(AccountId::from(CHARLIE)),

778

				310300000000000000000000,

779

);

780

781

			// Go to round 3

782

1

			run_to_block(7201, Some(NimbusId::from_slice(&ALICE_NIMBUS).unwrap()));

783

784

			// collators rewards minted and distributed

785

1

			assert_eq!(

786

1

				Balances::usable_balance(AccountId::from(ALICE)),

787

				8698492682878000000000000,

788

);

789

1

			assert_eq!(

790

1

				Balances::usable_balance(AccountId::from(BOB)),

791

				9962207316621500000000000,

792

);

793

			// 30% reserved for parachain bond again

794

1

			assert_eq!(

795

1

				Balances::usable_balance(AccountId::from(CHARLIE)),

796

				615104500000000000000000,

797

);

798

1

});

799

1

800

801

1

fn run_with_system_weight<F>(w: Weight, mut assertions: F)

802

1

where

803

1

	F: FnMut() -> (),

804

805

1

	let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

806

1

		.build_storage()

807

1

		.unwrap()

808

1

		.into();

809

1

	t.execute_with(|| {

810

1

		System::set_block_consumed_resources(w, 0);

811

1

		assertions()

812

1

});

813

1

814

815

#[test]

816

#[rustfmt::skip]

817

1

fn length_fee_is_sensible() {

818

	use sp_runtime::testing::TestXt;

819

820

	// tests that length fee is sensible for a few hypothetical transactions

821

1

	ExtBuilder::default().build().execute_with(|| {

822

1

		let call = frame_system::Call::remark::<Runtime> { remark: vec![] };

823

1

		let uxt: TestXt<_, ()> = TestXt::new_signed(RuntimeCall::System(call), 1u64, (), ());

824

825

9

		let calc_fee = |len: u32| -> Balance {

826

9

			moonbeam_runtime::TransactionPayment::query_fee_details(uxt.clone(), len)

827

9

				.inclusion_fee

828

9

				.expect("fee should be calculated")

829

9

				.len_fee

830

9

};

831

832

		//                  left: cost of length fee, right: size in bytes

833

		//                             /------------- proportional component: O(N * 1B)

834

		//                             |           /- exponential component: O(N ** 3)

835

		//                             |           |

836

1

		assert_eq!(                    100_000_000_100, calc_fee(1));

837

1

		assert_eq!(                  1_000_000_100_000, calc_fee(10));

838

1

		assert_eq!(                 10_000_100_000_000, calc_fee(100));

839

1

		assert_eq!(                100_100_000_000_000, calc_fee(1_000));

840

1

		assert_eq!(              1_100_000_000_000_000, calc_fee(10_000)); // inflection point

841

1

		assert_eq!(            110_000_000_000_000_000, calc_fee(100_000));

842

1

		assert_eq!(        100_100_000_000_000_000_000, calc_fee(1_000_000)); // 100 GLMR, ~ 1MB

843

1

		assert_eq!(    100_001_000_000_000_000_000_000, calc_fee(10_000_000));

844

1

		assert_eq!(100_000_010_000_000_000_000_000_000, calc_fee(100_000_000));

845

1

});

846

1

847

848

#[test]

849

1

fn multiplier_can_grow_from_zero() {

850

	use frame_support::traits::Get;

851

852

1

	let minimum_multiplier = moonbeam_runtime::MinimumMultiplier::get();

853

1

	let target = moonbeam_runtime::TargetBlockFullness::get()

854

1

		* RuntimeBlockWeights::get()

855

1

			.get(DispatchClass::Normal)

856

1

			.max_total

857

1

			.unwrap();

858

	// if the min is too small, then this will not change, and we are doomed forever.

859

	// the weight is 1/100th bigger than target.

860

1

	run_with_system_weight(target * 101 / 100, || {

861

1

		let next = moonbeam_runtime::SlowAdjustingFeeUpdate::<Runtime>::convert(minimum_multiplier);

862

1

		assert!(

863

1

			next > minimum_multiplier,

864

			"{:?} !>= {:?}",

865

			next,

866

			minimum_multiplier

867

);

868

1

})

869

1

870

871

#[test]

872

1

fn ethereum_invalid_transaction() {

873

1

	ExtBuilder::default().build().execute_with(|| {

874

1

		set_parachain_inherent_data();

875

		// Ensure an extrinsic not containing enough gas limit to store the transaction

876

		// on chain is rejected.

877

1

		assert_eq!(

878

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

879

			Err(

880

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

881

					sp_runtime::transaction_validity::InvalidTransaction::Custom(0u8)

882

883

884

);

885

1

});

886

1

887

888

#[test]

889

1

fn initial_gas_fee_is_correct() {

890

	use fp_evm::FeeCalculator;

891

892

1

	ExtBuilder::default().build().execute_with(|| {

893

1

		let multiplier = TransactionPayment::next_fee_multiplier();

894

1

		assert_eq!(multiplier, Multiplier::from(1u128));

895

896

1

		assert_eq!(

897

1

			TransactionPaymentAsGasPrice::min_gas_price(),

898

1

899

1

				31_250_000_000u128.into(),

900

1

				Weight::from_parts(<Runtime as frame_system::Config>::DbWeight::get().read, 0)

901

1

902

);

903

1

});

904

1

905

906

#[test]

907

1

fn min_gas_fee_is_correct() {

908

	use fp_evm::FeeCalculator;

909

	use frame_support::traits::Hooks;

910

911

1

	ExtBuilder::default().build().execute_with(|| {

912

1

		pallet_transaction_payment::NextFeeMultiplier::<Runtime>::put(Multiplier::from(0));

913

1

		TransactionPayment::on_finalize(System::block_number()); // should trigger min to kick in

914

915

1

		let multiplier = TransactionPayment::next_fee_multiplier();

916

1

		assert_eq!(multiplier, Multiplier::from(1u128));

917

918

1

		assert_eq!(

919

1

			TransactionPaymentAsGasPrice::min_gas_price(),

920

1

921

1

				31_250_000_000u128.into(),

922

1

				Weight::from_parts(<Runtime as frame_system::Config>::DbWeight::get().read, 0)

923

1

924

);

925

1

});

926

1

927

928

#[test]

929

1

fn transfer_ed_0_substrate() {

930

1

	ExtBuilder::default()

931

1

		.with_balances(vec![

932

1

			(AccountId::from(ALICE), (1 * GLMR) + (1 * WEI)),

933

1

			(AccountId::from(BOB), existential_deposit()),

934

1

])

935

1

		.build()

936

1

		.execute_with(|| {

937

			// Substrate transfer

938

1

			assert_ok!(Balances::transfer_allow_death(

939

1

				origin_of(AccountId::from(ALICE)),

940

1

				AccountId::from(BOB),

941

1

				1 * GLMR,

942

));

943

			// 1 WEI is left in the account

944

1

			assert_eq!(Balances::free_balance(AccountId::from(ALICE)), 1 * WEI);

945

1

});

946

1

947

948

#[test]

949

1

fn transfer_ed_0_evm() {

950

1

	ExtBuilder::default()

951

1

		.with_balances(vec![

952

1

953

1

				AccountId::from(ALICE),

954

1

				((1 * GLMR) + (21_000 * BASE_FEE_GENESIS)) + (1 * WEI),

955

1

),

956

1

			(AccountId::from(BOB), existential_deposit()),

957

1

])

958

1

		.build()

959

1

		.execute_with(|| {

960

1

			set_parachain_inherent_data();

961

			// EVM transfer

962

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::<Runtime>::call {

963

1

				source: H160::from(ALICE),

964

1

				target: H160::from(BOB),

965

1

				input: Vec::new(),

966

1

				value: (1 * GLMR).into(),

967

1

				gas_limit: 21_000u64,

968

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

969

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

970

1

				nonce: Some(U256::from(0)),

971

1

				access_list: Vec::new(),

972

1

				authorization_list: Vec::new(),

973

1

})

974

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

975

			// 1 WEI is left in the account

976

1

			assert_eq!(Balances::free_balance(AccountId::from(ALICE)), 1 * WEI,);

977

1

});

978

1

979

980

#[test]

981

1

fn refund_ed_0_evm() {

982

1

	ExtBuilder::default()

983

1

		.with_balances(vec![

984

1

985

1

				AccountId::from(ALICE),

986

1

				((1 * GLMR) + (21_777 * BASE_FEE_GENESIS) + existential_deposit()),

987

1

),

988

1

			(AccountId::from(BOB), existential_deposit()),

989

1

])

990

1

		.build()

991

1

		.execute_with(|| {

992

1

			set_parachain_inherent_data();

993

			// EVM transfer that zeroes ALICE

994

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::<Runtime>::call {

995

1

				source: H160::from(ALICE),

996

1

				target: H160::from(BOB),

997

1

				input: Vec::new(),

998

1

				value: (1 * GLMR).into(),

999

1

				gas_limit: 21_777u64,

1000

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1001

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1002

1

				nonce: Some(U256::from(0)),

1003

1

				access_list: Vec::new(),

1004

1

				authorization_list: Vec::new(),

1005

1

})

1006

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

1007

			// ALICE is refunded

1008

1

			assert_eq!(

1009

1

				Balances::free_balance(AccountId::from(ALICE)),

1010

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

1011

);

1012

1

});

1013

1

1014

1015

#[test]

1016

1

fn author_does_receive_priority_fee() {

1017

1

	ExtBuilder::default()

1018

1

		.with_balances(vec![(

1019

1

			AccountId::from(BOB),

1020

1

			(1 * GLMR) + (21_000 * (500 * GIGAWEI)),

1021

1

)])

1022

1

		.build()

1023

1

		.execute_with(|| {

1024

			// Some block author as seen by pallet-evm.

1025

1

			let author = AccountId::from(<pallet_evm::Pallet<Runtime>>::find_author());

1026

1

			pallet_author_inherent::Author::<Runtime>::put(author);

1027

			// Currently the default impl of the evm uses `deposit_into_existing`.

1028

			// If we were to use this implementation, and for an author to receive eventual tips,

1029

			// the account needs to be somehow initialized, otherwise the deposit would fail.

1030

1

			Balances::make_free_balance_be(&author, 100 * GLMR);

1031

1032

			// EVM transfer.

1033

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::<Runtime>::call {

1034

1

				source: H160::from(BOB),

1035

1

				target: H160::from(ALICE),

1036

1

				input: Vec::new(),

1037

1

				value: (1 * GLMR).into(),

1038

1

				gas_limit: 21_000u64,

1039

1

				max_fee_per_gas: U256::from(300 * GIGAWEI),

1040

1

				max_priority_fee_per_gas: Some(U256::from(200 * GIGAWEI)),

1041

1

				nonce: Some(U256::from(0)),

1042

1

				access_list: Vec::new(),

1043

1

				authorization_list: Vec::new(),

1044

1

})

1045

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

1046

1047

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1048

			// Author free balance increased by priority fee.

1049

1

			assert_eq!(Balances::free_balance(author), 100 * GLMR + priority_fee,);

1050

1

});

1051

1

1052

1053

#[test]

1054

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1055

	use fp_evm::FeeCalculator;

1056

1

	ExtBuilder::default()

1057

1

		.with_balances(vec![

1058

1

1059

1

				AccountId::from(BOB),

1060

1

				(1 * GLMR) + (21_000 * (200 * GIGAWEI) + existential_deposit()),

1061

1

),

1062

1

1063

1

				<pallet_treasury::TreasuryAccountId<Runtime> as sp_core::TypedGet>::get(),

1064

1

				existential_deposit(),

1065

1

),

1066

1

])

1067

1

		.build()

1068

1

		.execute_with(|| {

1069

1

			let issuance_before = <Runtime as pallet_evm::Config>::Currency::total_issuance();

1070

1

			let author = AccountId::from(<pallet_evm::Pallet<Runtime>>::find_author());

1071

1

			pallet_author_inherent::Author::<Runtime>::put(author);

1072

			// EVM transfer.

1073

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::<Runtime>::call {

1074

1

				source: H160::from(BOB),

1075

1

				target: H160::from(ALICE),

1076

1

				input: Vec::new(),

1077

1

				value: (1 * GLMR).into(),

1078

1

				gas_limit: 21_000u64,

1079

1

				max_fee_per_gas: U256::from(125 * GIGAWEI),

1080

1

				max_priority_fee_per_gas: Some(U256::from(100 * GIGAWEI)),

1081

1

				nonce: Some(U256::from(0)),

1082

1

				access_list: Vec::new(),

1083

1

				authorization_list: Vec::new(),

1084

1

})

1085

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

1086

1087

1

			let issuance_after = <Runtime as pallet_evm::Config>::Currency::total_issuance();

1088

1089

1

			let base_fee = TransactionPaymentAsGasPrice::min_gas_price().0.as_u128();

1090

1091

1

			let base_fee: Balance = base_fee * 21_000;

1092

1093

1

			let treasury_proportion = dynamic_params::runtime_config::FeesTreasuryProportion::get();

1094

1095

			// only base fee is split between being burned and sent to treasury

1096

1

			let treasury_base_fee_part: Balance = treasury_proportion.mul_floor(base_fee);

1097

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1098

1099

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1100

1101

1

			assert_eq!(moonbeam_runtime::Treasury::pot(), treasury_base_fee_part);

1102

1

});

1103

1

1104

1105

#[test]

1106

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1107

	use fp_evm::FeeCalculator;

1108

1

	ExtBuilder::default()

1109

1

		.with_balances(vec![

1110

1

1111

1

				AccountId::from(BOB),

1112

1

				(1 * GLMR) + (21_000 * BASE_FEE_GENESIS + existential_deposit()),

1113

1

),

1114

1

1115

1

				<pallet_treasury::TreasuryAccountId<Runtime> as sp_core::TypedGet>::get(),

1116

1

				existential_deposit(),

1117

1

),

1118

1

])

1119

1

		.build()

1120

1

		.execute_with(|| {

1121

1

			set_parachain_inherent_data();

1122

1

			let issuance_before = <Runtime as pallet_evm::Config>::Currency::total_issuance();

1123

			// EVM transfer.

1124

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::<Runtime>::call {

1125

1

				source: H160::from(BOB),

1126

1

				target: H160::from(ALICE),

1127

1

				input: Vec::new(),

1128

1

				value: (1 * GLMR).into(),

1129

1

				gas_limit: 21_000u64,

1130

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1131

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1132

1

				nonce: Some(U256::from(0)),

1133

1

				access_list: Vec::new(),

1134

1

				authorization_list: Vec::new(),

1135

1

})

1136

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

1137

1138

1

			let issuance_after = <Runtime as pallet_evm::Config>::Currency::total_issuance();

1139

1140

1

			let base_fee = TransactionPaymentAsGasPrice::min_gas_price().0.as_u128();

1141

1142

1

			let base_fee: Balance = base_fee * 21_000;

1143

1144

1

			let treasury_proportion = dynamic_params::runtime_config::FeesTreasuryProportion::get();

1145

1146

			// only base fee is split between being burned and sent to treasury

1147

1

			let treasury_base_fee_part: Balance = treasury_proportion.mul_floor(base_fee);

1148

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1149

1150

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1151

1152

1

			assert_eq!(moonbeam_runtime::Treasury::pot(), treasury_base_fee_part);

1153

1

});

1154

1

1155

1156

#[test]

1157

1

fn root_can_change_default_xcm_vers() {

1158

1

	ExtBuilder::default()

1159

1

		.with_balances(vec![

1160

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1161

1

			(AccountId::from(BOB), 1_000 * GLMR),

1162

1

])

1163

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1164

1

			asset_id: 1,

1165

1

			xcm_location: AssetHubLocation::get(),

1166

1

			name: "Dot",

1167

1

			symbol: "Dot",

1168

1

			decimals: 12,

1169

1

			balances: vec![(AccountId::from(ALICE), 1_000_000_000_000_000)],

1170

1

}])

1171

1

		.build()

1172

1

		.execute_with(|| {

1173

1

			let source_id: moonbeam_runtime::AssetId = 1;

1174

1

			let currency_id = moonbeam_runtime::xcm_config::CurrencyId::ForeignAsset(source_id);

1175

1

			let asset = Asset {

1176

1

				id: AssetId(

1177

1

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

1178

1

						currency_id,

1179

1

1180

1

					.unwrap(),

1181

1

),

1182

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1183

1

};

1184

			// Default XCM version is not set yet, so xtokens should fail because it does not

1185

			// know with which version to send

1186

1

			assert_noop!(

1187

1

				PolkadotXcm::transfer_assets(

1188

1

					origin_of(AccountId::from(ALICE)),

1189

1

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

1190

1

					Box::new(VersionedLocation::from(Location {

1191

1

						parents: 0,

1192

1

						interior: [AccountId32 {

1193

1

							network: None,

1194

1

							id: [1u8; 32],

1195

1

}]

1196

1

						.into(),

1197

1

					})),

1198

1

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

1199

0,

1200

1

					WeightLimit::Unlimited,

1201

),

1202

1

				pallet_xcm::Error::<Runtime>::LocalExecutionIncompleteWithError {

1203

1

					index: 2,

1204

1

					error: pallet_xcm::ExecutionError::DestinationUnsupported

1205

1

1206

);

1207

1208

			// Root sets the defaultXcm

1209

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1210

1

				root_origin(),

1211

1

				Some(5)

1212

));

1213

1214

			// Now transferring does not fail

1215

1

			assert_ok!(PolkadotXcm::transfer_assets(

1216

1

				origin_of(AccountId::from(ALICE)),

1217

1

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

1218

1

				Box::new(VersionedLocation::from(Location {

1219

1

					parents: 0,

1220

1

					interior: [AccountId32 {

1221

1

						network: None,

1222

1

						id: [1u8; 32],

1223

1

}]

1224

1

					.into(),

1225

1

				})),

1226

1

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

1227

0,

1228

1

				WeightLimit::Unlimited

1229

));

1230

1

})

1231

1

1232

1233

#[test]

1234

1

fn asset_can_be_registered() {

1235

1

	ExtBuilder::default().build().execute_with(|| {

1236

1

		let source_location = Location::parent();

1237

1

		let source_id = 1;

1238

1239

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1240

1

			moonbeam_runtime::RuntimeOrigin::root(),

1241

1

			source_id,

1242

1

			source_location.clone(),

1243

12,

1244

1

			b"Relay".to_vec().try_into().unwrap(),

1245

1

			b"RelayToken".to_vec().try_into().unwrap(),

1246

));

1247

1248

		// Check that the asset was created

1249

		// First check if the asset ID exists

1250

1

		let location = EvmForeignAssets::assets_by_id(source_id).expect("Asset should exist");

1251

1

		assert_eq!(location.clone(), source_location);

1252

1253

		// Then check the status using AssetsByLocation

1254

1

		let (asset_id, status) =

1255

1

			EvmForeignAssets::assets_by_location(&location).expect("Asset location should exist");

1256

1

		assert_eq!(asset_id, source_id);

1257

1

		assert_eq!(status, AssetStatus::Active);

1258

1

});

1259

1

1260

1261

// The precoompile asset-erc20 is deprecated and not used anymore for new evm foreign assets

1262

// We don't have testing tools in rust test to call real evm smart contract, so we rely on ts tests.

1263

/*

1264

#[test]

1265

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1266

	ExtBuilder::default()

1267

		.with_xcm_assets(vec![XcmAssetInitialization {

1268

			asset_type: AssetType::Xcm(xcm::v3::Location::parent()),

1269

			metadata: AssetRegistrarMetadata {

1270

				name: b"RelayToken".to_vec(),

1271

				symbol: b"Relay".to_vec(),

1272

				decimals: 12,

1273

				is_frozen: false,

1274

},

1275

			balances: vec![(AccountId::from(ALICE), 1_000 * GLMR)],

1276

			is_sufficient: true,

1277

}])

1278

		.with_balances(vec![

1279

			(AccountId::from(ALICE), 2_000 * GLMR),

1280

			(AccountId::from(BOB), 1_000 * GLMR),

1281

])

1282

		.build()

1283

		.execute_with(|| {

1284

			// We have the assetId that corresponds to the relay chain registered

1285

			let relay_asset_id: moonbeam_runtime::AssetId =

1286

				AssetType::Xcm(xcm::v3::Location::parent()).into();

1287

1288

			// Its address is

1289

			let asset_precompile_address = Runtime::asset_id_to_account(

1290

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1291

				relay_asset_id,

1292

);

1293

1294

			// Assert the asset has been created with the correct supply

1295

			assert_eq!(

1296

				moonbeam_runtime::Assets::total_supply(relay_asset_id),

1297

				1_000 * GLMR

1298

);

1299

1300

			// Access totalSupply through precompile. Important that the context is correct

1301

			Precompiles::new()

1302

				.prepare_test(

1303

					ALICE,

1304

					asset_precompile_address,

1305

					ForeignAssetsPCall::total_supply {},

1306

1307

				.expect_cost(5007)

1308

				.expect_no_logs()

1309

				.execute_returns(U256::from(1000 * GLMR));

1310

1311

			// Access balanceOf through precompile

1312

			Precompiles::new()

1313

				.prepare_test(

1314

					ALICE,

1315

					asset_precompile_address,

1316

					ForeignAssetsPCall::balance_of {

1317

						who: Address(ALICE.into()),

1318

},

1319

1320

				.expect_cost(5007)

1321

				.expect_no_logs()

1322

				.execute_returns(U256::from(1000 * GLMR));

1323

});

1324

1325

1326

#[test]

1327

fn xcm_asset_erc20_precompiles_transfer() {

1328

	ExtBuilder::default()

1329

		.with_xcm_assets(vec![XcmAssetInitialization {

1330

			asset_type: AssetType::Xcm(xcm::v3::Location::parent()),

1331

			metadata: AssetRegistrarMetadata {

1332

				name: b"RelayToken".to_vec(),

1333

				symbol: b"Relay".to_vec(),

1334

				decimals: 12,

1335

				is_frozen: false,

1336

},

1337

			balances: vec![(AccountId::from(ALICE), 1_000 * GLMR)],

1338

			is_sufficient: true,

1339

}])

1340

		.with_balances(vec![

1341

			(AccountId::from(ALICE), 2_000 * GLMR),

1342

			(AccountId::from(BOB), 1_000 * GLMR),

1343

])

1344

		.build()

1345

		.execute_with(|| {

1346

			// We have the assetId that corresponds to the relay chain registered

1347

			let relay_asset_id: moonbeam_runtime::AssetId =

1348

				AssetType::Xcm(xcm::v3::Location::parent()).into();

1349

1350

			// Its address is

1351

			let asset_precompile_address = Runtime::asset_id_to_account(

1352

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1353

				relay_asset_id,

1354

);

1355

1356

			// Transfer tokens from Aice to Bob, 400 GLMR.

1357

			Precompiles::new()

1358

				.prepare_test(

1359

					ALICE,

1360

					asset_precompile_address,

1361

					ForeignAssetsPCall::transfer {

1362

						to: Address(BOB.into()),

1363

						value: { 400 * GLMR }.into(),

1364

},

1365

1366

				.expect_cost(26580)

1367

				.expect_log(log3(

1368

					asset_precompile_address,

1369

					SELECTOR_LOG_TRANSFER,

1370

					H160::from(ALICE),

1371

					H160::from(BOB),

1372

					solidity::encode_event_data(U256::from(400 * GLMR)),

1373

))

1374

				.execute_returns(true);

1375

1376

			// Make sure BOB has 400 GLMR

1377

			Precompiles::new()

1378

				.prepare_test(

1379

					BOB,

1380

					asset_precompile_address,

1381

					ForeignAssetsPCall::balance_of {

1382

						who: Address(BOB.into()),

1383

},

1384

1385

				.expect_cost(5007)

1386

				.expect_no_logs()

1387

				.execute_returns(U256::from(400 * GLMR));

1388

});

1389

1390

1391

#[test]

1392

fn xcm_asset_erc20_precompiles_approve() {

1393

	ExtBuilder::default()

1394

		.with_xcm_assets(vec![XcmAssetInitialization {

1395

			asset_type: AssetType::Xcm(xcm::v3::Location::parent()),

1396

			metadata: AssetRegistrarMetadata {

1397

				name: b"RelayToken".to_vec(),

1398

				symbol: b"Relay".to_vec(),

1399

				decimals: 12,

1400

				is_frozen: false,

1401

},

1402

			balances: vec![(AccountId::from(ALICE), 1_000 * GLMR)],

1403

			is_sufficient: true,

1404

}])

1405

		.with_balances(vec![

1406

			(AccountId::from(ALICE), 2_000 * GLMR),

1407

			(AccountId::from(BOB), 1_000 * GLMR),

1408

])

1409

		.build()

1410

		.execute_with(|| {

1411

			// We have the assetId that corresponds to the relay chain registered

1412

			let relay_asset_id: moonbeam_runtime::AssetId =

1413

				AssetType::Xcm(xcm::v3::Location::parent()).into();

1414

1415

			// Its address is

1416

			let asset_precompile_address = Runtime::asset_id_to_account(

1417

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1418

				relay_asset_id,

1419

);

1420

1421

			// Aprove Bob for spending 400 GLMR from Alice

1422

			Precompiles::new()

1423

				.prepare_test(

1424

					ALICE,

1425

					asset_precompile_address,

1426

					ForeignAssetsPCall::approve {

1427

						spender: Address(BOB.into()),

1428

						value: { 400 * GLMR }.into(),

1429

},

1430

1431

				.expect_cost(17323)

1432

				.expect_log(log3(

1433

					asset_precompile_address,

1434

					SELECTOR_LOG_APPROVAL,

1435

					H160::from(ALICE),

1436

					H160::from(BOB),

1437

					solidity::encode_event_data(U256::from(400 * GLMR)),

1438

))

1439

				.execute_returns(true);

1440

1441

			// Transfer tokens from Alice to Charlie by using BOB as origin

1442

			Precompiles::new()

1443

				.prepare_test(

1444

					BOB,

1445

					asset_precompile_address,

1446

					ForeignAssetsPCall::transfer_from {

1447

						from: Address(ALICE.into()),

1448

						to: Address(CHARLIE.into()),

1449

						value: { 400 * GLMR }.into(),

1450

},

1451

1452

				.expect_cost(31887)

1453

				.expect_log(log3(

1454

					asset_precompile_address,

1455

					SELECTOR_LOG_TRANSFER,

1456

					H160::from(ALICE),

1457

					H160::from(CHARLIE),

1458

					solidity::encode_event_data(U256::from(400 * GLMR)),

1459

))

1460

				.execute_returns(true);

1461

1462

			// Make sure CHARLIE has 400 GLMR

1463

			Precompiles::new()

1464

				.prepare_test(

1465

					CHARLIE,

1466

					asset_precompile_address,

1467

					ForeignAssetsPCall::balance_of {

1468

						who: Address(CHARLIE.into()),

1469

},

1470

1471

				.expect_cost(5007)

1472

				.expect_no_logs()

1473

				.execute_returns(U256::from(400 * GLMR));

1474

});

1475

}*/

1476

1477

#[test]

1478

1

fn make_sure_glmr_can_be_transferred_precompile() {

1479

1

	ExtBuilder::default()

1480

1

		.with_balances(vec![

1481

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1482

1

			(AccountId::from(BOB), 1_000 * GLMR),

1483

1

])

1484

1

		.with_collators(vec![(AccountId::from(ALICE), 1_000 * GLMR)])

1485

1

		.with_mappings(vec![(

1486

1

			NimbusId::from_slice(&ALICE_NIMBUS).unwrap(),

1487

1

			AccountId::from(ALICE),

1488

1

)])

1489

1

		.with_safe_xcm_version(3)

1490

1

		.build()

1491

1

		.execute_with(|| {

1492

1

			assert_ok!(PolkadotXcm::transfer_assets(

1493

1

				origin_of(AccountId::from(ALICE)),

1494

1

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

1495

1

				Box::new(VersionedLocation::from(Location {

1496

1

					parents: 0,

1497

1

					interior: [AccountId32 {

1498

1

						network: None,

1499

1

						id: [1u8; 32],

1500

1

}]

1501

1

					.into(),

1502

1

				})),

1503

1

				Box::new(VersionedAssets::from(Asset {

1504

1

					id: AssetId(moonbeam_runtime::xcm_config::SelfReserve::get()),

1505

1

					fun: Fungible(1000)

1506

1

				})),

1507

0,

1508

1

				WeightLimit::Limited(40000.into())

1509

));

1510

1

});

1511

1

1512

1513

#[test]

1514

1

fn make_sure_glmr_can_be_transferred() {

1515

1

	ExtBuilder::default()

1516

1

		.with_balances(vec![

1517

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1518

1

			(AccountId::from(BOB), 1_000 * GLMR),

1519

1

])

1520

1

		.with_collators(vec![(AccountId::from(ALICE), 1_000 * GLMR)])

1521

1

		.with_mappings(vec![(

1522

1

			NimbusId::from_slice(&ALICE_NIMBUS).unwrap(),

1523

1

			AccountId::from(ALICE),

1524

1

)])

1525

1

		.with_safe_xcm_version(3)

1526

1

		.build()

1527

1

		.execute_with(|| {

1528

1

			let dest = Location {

1529

1

				parents: 1,

1530

1

				interior: [AccountId32 {

1531

1

					network: None,

1532

1

					id: [1u8; 32],

1533

1

}]

1534

1

				.into(),

1535

1

};

1536

1

			assert_ok!(PolkadotXcm::transfer_assets(

1537

1

				origin_of(AccountId::from(ALICE)),

1538

1

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

1539

1

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

1540

1

				Box::new(VersionedAssets::from(Asset {

1541

1

					id: AssetId(moonbeam_runtime::xcm_config::SelfReserve::get()),

1542

1

					fun: Fungible(100)

1543

1

				})),

1544

0,

1545

1

				WeightLimit::Limited(40000.into())

1546

));

1547

1

});

1548

1

1549

1550

#[test]

1551

1

fn make_sure_polkadot_xcm_cannot_be_called() {

1552

1

	ExtBuilder::default()

1553

1

		.with_balances(vec![

1554

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1555

1

			(AccountId::from(BOB), 1_000 * GLMR),

1556

1

])

1557

1

		.with_collators(vec![(AccountId::from(ALICE), 1_000 * GLMR)])

1558

1

		.with_mappings(vec![(

1559

1

			NimbusId::from_slice(&ALICE_NIMBUS).unwrap(),

1560

1

			AccountId::from(ALICE),

1561

1

)])

1562

1

		.build()

1563

1

		.execute_with(|| {

1564

1

			let dest = Location {

1565

1

				parents: 1,

1566

1

				interior: [AccountId32 {

1567

1

					network: None,

1568

1

					id: [1u8; 32],

1569

1

}]

1570

1

				.into(),

1571

1

};

1572

1

			let assets: Assets = [Asset {

1573

1

				id: AssetId(moonbeam_runtime::xcm_config::SelfLocation::get()),

1574

1

				fun: Fungible(1000),

1575

1

}]

1576

1

			.to_vec()

1577

1

			.into();

1578

1

			assert_noop!(

1579

1

				RuntimeCall::PolkadotXcm(pallet_xcm::Call::<Runtime>::reserve_transfer_assets {

1580

1

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

1581

1

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

1582

1

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

1583

1

					fee_asset_item: 0,

1584

1

})

1585

1

				.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::signed(

1586

1

					AccountId::from(ALICE)

1587

)),

1588

1

				frame_system::Error::<Runtime>::CallFiltered

1589

);

1590

1

});

1591

1

1592

1593

#[test]

1594

1

fn transact_through_signed_precompile_works_v2() {

1595

1

	ExtBuilder::default()

1596

1

		.with_balances(vec![

1597

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1598

1

			(AccountId::from(BOB), 1_000 * GLMR),

1599

1

])

1600

1

		.with_safe_xcm_version(3)

1601

1

		.build()

1602

1

		.execute_with(|| {

1603

			// Destination

1604

1

			let dest = Location::parent();

1605

1606

1

			let fee_payer_asset = Location::parent();

1607

1608

1

			let bytes = vec![1u8, 2u8, 3u8];

1609

1610

1

			let total_weight = 1_000_000_000u64;

1611

1612

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1613

1614

1

			Precompiles::new()

1615

1

				.prepare_test(

1616

					ALICE,

1617

1

					xcm_transactor_v2_precompile_address,

1618

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1619

1

						dest,

1620

1

						fee_asset: fee_payer_asset,

1621

1

						weight: 4_000_000,

1622

1

						call: bytes.into(),

1623

1

						fee_amount: u128::from(total_weight).into(),

1624

1

						overall_weight: total_weight,

1625

1

},

1626

1627

1

				.expect_cost(31331)

1628

1

				.expect_no_logs()

1629

1

				.execute_returns(());

1630

1

});

1631

1

1632

1633

#[test]

1634

1

fn transact_through_signed_cannot_send_to_local_chain() {

1635

1

	ExtBuilder::default()

1636

1

		.with_balances(vec![

1637

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1638

1

			(AccountId::from(BOB), 1_000 * GLMR),

1639

1

])

1640

1

		.with_safe_xcm_version(3)

1641

1

		.build()

1642

1

		.execute_with(|| {

1643

			// Destination

1644

1

			let dest = Location::here();

1645

1646

1

			let fee_payer_asset = Location::parent();

1647

1648

1

			let bytes = vec![1u8, 2u8, 3u8];

1649

1650

1

			let total_weight = 1_000_000_000u64;

1651

1652

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1653

1654

1

			Precompiles::new()

1655

1

				.prepare_test(

1656

					ALICE,

1657

1

					xcm_transactor_v2_precompile_address,

1658

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1659

1

						dest,

1660

1

						fee_asset: fee_payer_asset,

1661

1

						weight: 4_000_000,

1662

1

						call: bytes.into(),

1663

1

						fee_amount: u128::from(total_weight).into(),

1664

1

						overall_weight: total_weight,

1665

1

},

1666

1667

1

				.execute_reverts(|output| {

1668

1

					from_utf8(&output)

1669

1

						.unwrap()

1670

1

						.contains("Dispatched call failed with error:")

1671

1

						&& from_utf8(&output).unwrap().contains("ErrorValidating")

1672

1

});

1673

1

});

1674

1

1675

1676

#[test]

1677

1

fn transactor_cannot_use_more_than_max_weight() {

1678

1

	ExtBuilder::default()

1679

1

		.with_balances(vec![

1680

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1681

1

			(AccountId::from(BOB), 1_000 * GLMR),

1682

1

])

1683

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1684

1

			asset_id: 1,

1685

1

			xcm_location: xcm::v5::Location::parent(),

1686

1

			name: "RelayToken",

1687

1

			symbol: "Relay",

1688

1

			decimals: 12,

1689

1

			balances: vec![(AccountId::from(ALICE), 1_000_000_000_000_000)],

1690

1

}])

1691

1

		.build()

1692

1

		.execute_with(|| {

1693

1

			let source_id: moonbeam_runtime::AssetId = 1;

1694

1

			assert_ok!(XcmTransactor::register(

1695

1

				root_origin(),

1696

1

				AccountId::from(ALICE),

1697

0,

1698

));

1699

1700

			// Root can set transact info

1701

1

			assert_ok!(XcmTransactor::set_transact_info(

1702

1

				root_origin(),

1703

1

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

1704

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

1705

1

				3000.into(),

1706

1

				20000.into(),

1707

1

				None

1708

));

1709

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

1710

1

			set_fee_per_second_for_location(Location::parent(), 1).expect("must succeed");

1711

1712

1

			assert_noop!(

1713

1

				XcmTransactor::transact_through_derivative(

1714

1

					origin_of(AccountId::from(ALICE)),

1715

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

1716

0,

1717

1

					CurrencyPayment {

1718

1

						currency: Currency::AsMultiLocation(Box::new(

1719

1

							xcm::VersionedLocation::from(Location::parent())

1720

1

)),

1721

1

						fee_amount: None

1722

1

},

1723

1

					vec![],

1724

					// 20000 is the max

1725

1

					TransactWeights {

1726

1

						transact_required_weight_at_most: 17001.into(),

1727

1

						overall_weight: None

1728

1

},

1729

					false

1730

),

1731

1

				pallet_xcm_transactor::Error::<Runtime>::MaxWeightTransactReached

1732

);

1733

1

			assert_noop!(

1734

1

				XcmTransactor::transact_through_derivative(

1735

1

					origin_of(AccountId::from(ALICE)),

1736

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

1737

0,

1738

1

					CurrencyPayment {

1739

1

						currency: Currency::AsCurrencyId(

1740

1

							moonbeam_runtime::xcm_config::CurrencyId::ForeignAsset(source_id)

1741

1

),

1742

1

						fee_amount: None

1743

1

},

1744

1

					vec![],

1745

					// 20000 is the max

1746

1

					TransactWeights {

1747

1

						transact_required_weight_at_most: 17001.into(),

1748

1

						overall_weight: None

1749

1

},

1750

					false

1751

),

1752

1

				pallet_xcm_transactor::Error::<Runtime>::MaxWeightTransactReached

1753

);

1754

1

})

1755

1

1756

1757

#[test]

1758

1

fn call_pallet_xcm_with_fee() {

1759

1

	let asset_id = 1;

1760

1

	ExtBuilder::default()

1761

1

		.with_balances(vec![

1762

1

			(AccountId::from(ALICE), 2_000 * GLMR),

1763

1

			(AccountId::from(BOB), 1_000 * GLMR),

1764

1

])

1765

1

		.with_safe_xcm_version(3)

1766

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1767

1

			asset_id,

1768

1

			xcm_location: Location::parent(),

1769

1

			name: "RelayToken",

1770

1

			symbol: "Relay",

1771

1

			decimals: 12,

1772

1

			balances: vec![(AccountId::from(ALICE), 1_000_000_000_000_000)],

1773

1

}])

1774

1

		.build()

1775

1

		.execute_with(|| {

1776

1

			let dest = Location {

1777

1

				parents: 1,

1778

1

				interior: [AccountId32 {

1779

1

					network: None,

1780

1

					id: [1u8; 32],

1781

1

}]

1782

1

				.into(),

1783

1

};

1784

1785

1

			let before_balance =

1786

1

				EvmForeignAssets::balance(asset_id, AccountId::from(ALICE)).unwrap();

1787

1

			let (chain_part, beneficiary) =

1788

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1789

1

			let asset = currency_to_asset(CurrencyId::ForeignAsset(asset_id), 100_000_000_000_000);

1790

1

			let asset_fee = currency_to_asset(CurrencyId::ForeignAsset(asset_id), 100);

1791

1

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

1792

1

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

1793

1

				assets: Wild(All),

1794

1

				beneficiary: beneficiary.clone(),

1795

1

			}]);

1796

1

			assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1797

1

				origin_of(AccountId::from(ALICE)),

1798

1

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

1799

1

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

1800

1

				Box::new(TransferType::DestinationReserve),

1801

1

				Box::new(fees_id),

1802

1

				Box::new(TransferType::DestinationReserve),

1803

1

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

1804

1

				WeightLimit::Limited(4000000000.into())

1805

));

1806

1807

1

			let after_balance =

1808

1

				EvmForeignAssets::balance(asset_id, AccountId::from(ALICE)).unwrap();

1809

			// Balance should have been reduced by the transfer amount plus fees

1810

1

			assert!(after_balance < before_balance);

1811

1

});

1812

1

1813

1814

#[test]

1815

1

fn test_xcm_utils_ml_tp_account() {

1816

1

	ExtBuilder::default().build().execute_with(|| {

1817

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1818

1

		let expected_address_parent: H160 =

1819

1

			ParentIsPreset::<AccountId>::convert_location(&Location::parent())

1820

1

				.unwrap()

1821

1

				.into();

1822

1823

1

		Precompiles::new()

1824

1

			.prepare_test(

1825

				ALICE,

1826

1

				xcm_utils_precompile_address,

1827

1

				XcmUtilsPCall::multilocation_to_address {

1828

1

					location: Location::parent(),

1829

1

},

1830

1831

1

			.expect_cost(

1832

1

				<Runtime as frame_system::Config>::DbWeight::get()

1833

1

					.read

1834

1

					.saturating_div(WEIGHT_PER_GAS)

1835

1

					.saturating_mul(2),

1836

1837

1

			.expect_no_logs()

1838

1

			.execute_returns(Address(expected_address_parent));

1839

1840

1

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

1841

1

		let expected_address_parachain: H160 =

1842

1

			SiblingParachainConvertsVia::<Sibling, AccountId>::convert_location(

1843

1

				&parachain_2000_location,

1844

1845

1

			.unwrap()

1846

1

			.into();

1847

1848

1

		Precompiles::new()

1849

1

			.prepare_test(

1850

				ALICE,

1851

1

				xcm_utils_precompile_address,

1852

1

				XcmUtilsPCall::multilocation_to_address {

1853

1

					location: parachain_2000_location,

1854

1

},

1855

1856

1

			.expect_cost(

1857

1

				<Runtime as frame_system::Config>::DbWeight::get()

1858

1

					.read

1859

1

					.saturating_div(WEIGHT_PER_GAS)

1860

1

					.saturating_mul(2),

1861

1862

1

			.expect_no_logs()

1863

1

			.execute_returns(Address(expected_address_parachain));

1864

1865

1

		let alice_in_parachain_2000_location = Location::new(

1866

1,

1867

1

1868

1

				Parachain(2000),

1869

1

				AccountKey20 {

1870

1

					network: None,

1871

1

					key: ALICE,

1872

1

},

1873

1

],

1874

);

1875

1

		let expected_address_alice_in_parachain_2000 =

1876

1

			xcm_builder::HashedDescription::<

1877

1

				AccountId,

1878

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

1879

1

			>::convert_location(&alice_in_parachain_2000_location)

1880

1

			.unwrap()

1881

1

			.into();

1882

1883

1

		Precompiles::new()

1884

1

			.prepare_test(

1885

				ALICE,

1886

1

				xcm_utils_precompile_address,

1887

1

				XcmUtilsPCall::multilocation_to_address {

1888

1

					location: alice_in_parachain_2000_location,

1889

1

},

1890

1891

1

			.expect_cost(

1892

1

				<Runtime as frame_system::Config>::DbWeight::get()

1893

1

					.read

1894

1

					.saturating_div(WEIGHT_PER_GAS)

1895

1

					.saturating_mul(2),

1896

1897

1

			.expect_no_logs()

1898

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

1899

1

});

1900

1

1901

1902

#[test]

1903

1

fn test_xcm_utils_weight_message() {

1904

1

	ExtBuilder::default().build().execute_with(|| {

1905

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1906

1

		let expected_weight =

1907

1

			XcmWeight::<moonbeam_runtime::Runtime, RuntimeCall>::clear_origin().ref_time();

1908

1909

1

		let message: Vec<u8> = xcm::VersionedXcm::<()>::V5(Xcm(vec![ClearOrigin])).encode();

1910

1911

1

		let input = XcmUtilsPCall::weight_message {

1912

1

			message: message.into(),

1913

1

};

1914

1915

1

		Precompiles::new()

1916

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1917

1

			.expect_cost(

1918

1

				<Runtime as frame_system::Config>::DbWeight::get()

1919

1

					.read

1920

1

					.saturating_div(WEIGHT_PER_GAS),

1921

1922

1

			.expect_no_logs()

1923

1

			.execute_returns(expected_weight);

1924

1

});

1925

1

1926

1927

#[test]

1928

1

fn test_nested_batch_calls_from_xcm_transact() {

1929

1

	ExtBuilder::default().build().execute_with(|| {

1930

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

1931

		// in a future polkadot-sdk version

1932

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

1933

1934

1

		let mut valid_nested_calls =

1935

1

			RuntimeCall::System(frame_system::Call::remark { remark: vec![] });

1936

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

1937

8

			valid_nested_calls = RuntimeCall::Utility(pallet_utility::Call::batch {

1938

8

				calls: vec![valid_nested_calls],

1939

8

});

1940

8

1941

1942

1

		let valid_message = Xcm(vec![Transact {

1943

1

			origin_kind: OriginKind::SovereignAccount,

1944

1

			fallback_max_weight: None,

1945

1

			call: valid_nested_calls.encode().into(),

1946

1

		}]);

1947

1948

1

		assert!(XcmExecutor::prepare(valid_message, Weight::MAX).is_ok());

1949

1950

1

		let excessive_nested_calls = RuntimeCall::Utility(pallet_utility::Call::batch {

1951

1

			calls: vec![valid_nested_calls],

1952

1

});

1953

1954

1

		let invalid_message = Xcm(vec![Transact {

1955

1

			origin_kind: OriginKind::SovereignAccount,

1956

1

			fallback_max_weight: None,

1957

1

			call: excessive_nested_calls.encode().into(),

1958

1

		}]);

1959

		// Expect to fail because we have too many nested calls

1960

1

		assert!(XcmExecutor::prepare(invalid_message, Weight::MAX).is_err());

1961

1

});

1962

1

1963

1964

#[test]

1965

1

fn test_xcm_utils_get_units_per_second() {

1966

1

	ExtBuilder::default().build().execute_with(|| {

1967

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1968

1

		let location = SelfReserve::get();

1969

1970

1

		let input = XcmUtilsPCall::get_units_per_second { location };

1971

1972

1

		let expected_units =

1973

1

			WEIGHT_REF_TIME_PER_SECOND as u128 * moonbeam_runtime::currency::WEIGHT_FEE;

1974

1975

1

		Precompiles::new()

1976

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1977

1

			.expect_cost(

1978

1

				<Runtime as frame_system::Config>::DbWeight::get()

1979

1

					.read

1980

1

					.saturating_div(WEIGHT_PER_GAS)

1981

1

					.saturating_mul(2),

1982

1983

1

			.expect_no_logs()

1984

1

			.execute_returns(expected_units);

1985

1

});

1986

1

1987

1988

#[test]

1989

1

fn precompile_existence() {

1990

1

	ExtBuilder::default().build().execute_with(|| {

1991

1

		let precompiles = Precompiles::new();

1992

1

		let precompile_addresses: std::collections::BTreeSet<_> = vec![

1993

			1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 256, 1024, 1025, 1026, 2048,

1994

			2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062,

1995

			2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074,

1996

1997

1

		.into_iter()

1998

1

		.map(H160::from_low_u64_be)

1999

1

		.collect();

2000

2001

3001

		for i in 0..3000 {

2002

3000

			let address = H160::from_low_u64_be(i);

2003

2004

3000

			if precompile_addresses.contains(&address) {

2005

47

				assert!(

2006

47

					is_precompile_or_fail::<Runtime>(address, 100_000u64).expect("to be ok"),

2007

					"is_precompile({}) should return true",

2008

2009

);

2010

2011

47

				assert!(

2012

47

					precompiles

2013

47

						.execute(&mut MockHandle::new(

2014

47

							address,

2015

47

							Context {

2016

47

								address,

2017

47

								caller: H160::zero(),

2018

47

								apparent_value: U256::zero()

2019

47

2020

47

),)

2021

47

						.is_some(),

2022

					"execute({},..) should return Some(_)",

2023

2024

);

2025

			} else {

2026

2953

				assert!(

2027

2953

					!is_precompile_or_fail::<Runtime>(address, 100_000u64).expect("to be ok"),

2028

					"is_precompile({}) should return false",

2029

2030

);

2031

2032

2953

				assert!(

2033

2953

					precompiles

2034

2953

						.execute(&mut MockHandle::new(

2035

2953

							address,

2036

2953

							Context {

2037

2953

								address,

2038

2953

								caller: H160::zero(),

2039

2953

								apparent_value: U256::zero()

2040

2953

2041

2953

),)

2042

2953

						.is_none(),

2043

					"execute({},..) should return None",

2044

2045

);

2046

2047

2048

1

});

2049

1

2050

2051

#[test]

2052

1

fn removed_precompiles() {

2053

1

	ExtBuilder::default().build().execute_with(|| {

2054

1

		let precompiles = Precompiles::new();

2055

1

		let removed_precompiles = [1025, 1027, 2051, 2062, 2063];

2056

2057

3000

		for i in 1..3000 {

2058

2999

			let address = H160::from_low_u64_be(i);

2059

2060

2999

			if !is_precompile_or_fail::<Runtime>(address, 100_000u64).expect("to be ok") {

2061

2952

				continue;

2062

47

2063

2064

47

			if !removed_precompiles.contains(&i) {

2065

43

				assert!(

2066

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2067

43

						IsPrecompileResult::Answer { is_precompile, .. } => is_precompile,

2068

						_ => false,

2069

},

2070

					"{i} should be an active precompile"

2071

);

2072

43

				continue;

2073

4

2074

2075

4

			assert!(

2076

4

				!match precompiles.is_active_precompile(address, 100_000u64) {

2077

4

					IsPrecompileResult::Answer { is_precompile, .. } => is_precompile,

2078

					_ => false,

2079

},

2080

				"{i} shouldn't be an active precompile"

2081

);

2082

2083

4

			precompiles

2084

4

				.prepare_test(Alice, address, [])

2085

4

				.execute_reverts(|out| out == b"Removed precompile");

2086

2087

1

})

2088

1

2089

2090

#[test]

2091

1

fn deal_with_fees_handles_tip() {

2092

	use frame_support::traits::OnUnbalanced;

2093

	use moonbeam_runtime::Treasury;

2094

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2095

2096

1

	ExtBuilder::default().build().execute_with(|| {

2097

1

		set_parachain_inherent_data();

2098

		// This test validates the functionality of the `DealWithSubstrateFeesAndTip` trait implementation

2099

		// in the Moonbeam runtime. It verifies that:

2100

		// - The correct proportion of the fee is sent to the treasury.

2101

		// - The remaining fee is burned (removed from the total supply).

2102

		// - The entire tip is sent to the block author.

2103

2104

		// The test details:

2105

		// 1. Simulate issuing a `fee` of 100 and a `tip` of 1000.

2106

		// 2. Confirm the initial total supply is 1,100 (equal to the sum of the issued fee and tip).

2107

		// 3. Confirm the treasury's balance is initially 0.

2108

		// 4. Execute the `DealWithSubstrateFeesAndTip::on_unbalanceds` function with the `fee` and `tip`.

2109

		// 5. Validate that the treasury's balance has increased by 20% of the fee (based on FeesTreasuryProportion).

2110

		// 6. Validate that 80% of the fee is burned, and the total supply decreases accordingly.

2111

		// 7. Validate that the entire tip (100%) is sent to the block author (collator).

2112

2113

		// Step 1: Issue the fee and tip amounts.

2114

1

		let fee = <pallet_balances::Pallet<Runtime> as frame_support::traits::fungible::Balanced<

2115

1

			AccountId,

2116

1

		>>::issue(100);

2117

1

		let tip = <pallet_balances::Pallet<Runtime> as frame_support::traits::fungible::Balanced<

2118

1

			AccountId,

2119

1

		>>::issue(1000);

2120

2121

		// Step 2: Validate the initial supply and balances.

2122

1

		let total_supply_before = Balances::total_issuance();

2123

1

		let block_author = pallet_author_inherent::Pallet::<Runtime>::get();

2124

1

		let block_author_balance_before = Balances::free_balance(&block_author);

2125

1

		assert_eq!(total_supply_before, 1_100);

2126

1

		assert_eq!(Balances::free_balance(&Treasury::account_id()), 0);

2127

2128

		// Step 3: Execute the fees handling logic.

2129

1

		DealWithSubstrateFeesAndTip::<

2130

1

			Runtime,

2131

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2132

1

		>::on_unbalanceds(vec![fee, tip].into_iter());

2133

2134

		// Step 4: Compute the split between treasury and burned fees based on FeesTreasuryProportion (20%).

2135

1

		let treasury_proportion = dynamic_params::runtime_config::FeesTreasuryProportion::get();

2136

2137

1

		let treasury_fee_part: Balance = treasury_proportion.mul_floor(100);

2138

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2139

2140

		// Step 5: Validate the treasury received 20% of the fee.

2141

1

		assert_eq!(

2142

1

			Balances::free_balance(&Treasury::account_id()),

2143

			treasury_fee_part,

2144

);

2145

2146

		// Step 6: Verify that 80% of the fee was burned (removed from the total supply).

2147

1

		let total_supply_after = Balances::total_issuance();

2148

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2149

2150

		// Step 7: Validate that the block author (collator) received 100% of the tip.

2151

1

		let block_author_balance_after = Balances::free_balance(&block_author);

2152

1

		assert_eq!(

2153

1

			block_author_balance_after - block_author_balance_before,

2154

			1000,

2155

);

2156

1

});

2157

1

2158

2159

#[test]

2160

1

fn evm_revert_substrate_events() {

2161

1

	ExtBuilder::default()

2162

1

		.with_balances(vec![(AccountId::from(ALICE), 100_000 * GLMR)])

2163

1

		.build()

2164

1

		.execute_with(|| {

2165

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2166

2167

			// Batch a transfer followed by an invalid call to batch.

2168

			// Thus BatchAll will revert the transfer.

2169

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::call {

2170

1

				source: ALICE.into(),

2171

1

				target: batch_precompile_address,

2172

1

2173

1

				input: BatchPCall::batch_all {

2174

1

					to: vec![Address(BOB.into()), Address(batch_precompile_address)].into(),

2175

1

					value: vec![U256::from(1 * GLMR), U256::zero()].into(),

2176

1

					call_data: vec![].into(),

2177

1

					gas_limit: vec![].into()

2178

1

2179

1

				.into(),

2180

1

				value: U256::zero(), // No value sent in EVM

2181

1

				gas_limit: 500_000,

2182

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2183

1

				max_priority_fee_per_gas: None,

2184

1

				nonce: Some(U256::from(0)),

2185

1

				access_list: Vec::new(),

2186

1

				authorization_list: Vec::new(),

2187

1

})

2188

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

2189

2190

1

			let transfer_count = System::events()

2191

1

				.iter()

2192

4

				.filter(|r| match r.event {

2193

					RuntimeEvent::Balances(pallet_balances::Event::Transfer { .. }) => true,

2194

6

					_ => false,

2195

6

})

2196

1

				.count();

2197

2198

1

			assert_eq!(transfer_count, 0, "there should be no transfer event");

2199

1

});

2200

1

2201

2202

#[test]

2203

1

fn evm_success_keeps_substrate_events() {

2204

1

	ExtBuilder::default()

2205

1

		.with_balances(vec![(AccountId::from(ALICE), 100_000 * GLMR)])

2206

1

		.build()

2207

1

		.execute_with(|| {

2208

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2209

2210

1

			assert_ok!(RuntimeCall::EVM(pallet_evm::Call::call {

2211

1

				source: ALICE.into(),

2212

1

				target: batch_precompile_address,

2213

1

				input: BatchPCall::batch_all {

2214

1

					to: vec![Address(BOB.into())].into(),

2215

1

					value: vec![U256::from(1 * GLMR)].into(),

2216

1

					call_data: vec![].into(),

2217

1

					gas_limit: vec![].into()

2218

1

2219

1

				.into(),

2220

1

				value: U256::zero(), // No value sent in EVM

2221

1

				gas_limit: 500_000,

2222

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2223

1

				max_priority_fee_per_gas: None,

2224

1

				nonce: Some(U256::from(0)),

2225

1

				access_list: Vec::new(),

2226

1

				authorization_list: Vec::new(),

2227

1

})

2228

1

			.dispatch(<Runtime as frame_system::Config>::RuntimeOrigin::root()));

2229

2230

1

			let transfer_count = System::events()

2231

1

				.iter()

2232

6

				.filter(|r| match r.event {

2233

1

					RuntimeEvent::Balances(pallet_balances::Event::Transfer { .. }) => true,

2234

9

					_ => false,

2235

10

})

2236

1

				.count();

2237

2238

1

			assert_eq!(transfer_count, 1, "there should be 1 transfer event");

2239

1

});

2240

1

2241

2242

#[cfg(test)]

2243

mod bridge_tests {

2244

	use crate::common::{origin_of, root_origin, ExtBuilder, XcmAssetInitialization, ALICE, BOB};

2245

	use crate::currency_to_asset;

2246

	use bp_messages::target_chain::DispatchMessageData;

2247

	use bp_messages::ReceptionResult;

2248

	use bp_runtime::messages::MessageDispatchResult;

2249

	use cumulus_primitives_core::AggregateMessageOrigin;

2250

	use frame_support::assert_ok;

2251

	use frame_support::pallet_prelude::{Hooks, PalletInfoAccess};

2252

	use moonbeam_core_primitives::AccountId;

2253

	use moonbeam_runtime::bridge_config::{

2254

		KusamaGlobalConsensusNetwork, WithKusamaMessagesInstance,

2255

};

2256

	use moonbeam_runtime::currency::GLMR;

2257

	use moonbeam_runtime::xcm_config::CurrencyId;

2258

	use moonbeam_runtime::{

2259

		Balances, BridgeKusamaMessages, BridgeXcmOverMoonriver, MessageQueue, PolkadotXcm, Runtime,

2260

		RuntimeEvent, System,

2261

};

2262

	use pallet_bridge_messages::{LanesManager, StoredMessagePayload};

2263

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

2264

	use parity_scale_codec::{Decode, Encode};

2265

	use sp_core::H256;

2266

	use xcm::latest::Junctions::X1;

2267

	use xcm::latest::{Junctions, Location, NetworkId, WeightLimit, Xcm};

2268

	use xcm::prelude::{

2269

		AccountKey20, Asset, AssetFilter, AssetId, BuyExecution, ClearOrigin, DepositAsset,

2270

		DescendOrigin, Fungible, GlobalConsensus, PalletInstance, Parachain, ReserveAssetDeposited,

2271

		SetTopic, UniversalOrigin, XCM_VERSION,

2272

};

2273

	use xcm::v5::WildAsset;

2274

	use xcm::{VersionedAssets, VersionedInteriorLocation, VersionedLocation, VersionedXcm};

2275

	use xcm_builder::BridgeMessage;

2276

2277

1

	fn next_block() {

2278

1

		System::reset_events();

2279

1

		System::set_block_number(System::block_number() + 1u32);

2280

1

		System::on_initialize(System::block_number());

2281

1

		MessageQueue::on_initialize(System::block_number());

2282

1

2283

2284

	#[test]

2285

1

	fn transfer_asset_moonbeam_to_moonriver() {

2286

1

		frame_support::__private::sp_tracing::init_for_tests();

2287

2288

1

		ExtBuilder::default()

2289

1

			.with_balances(vec![

2290

1

				(AccountId::from(ALICE), 2_000 * GLMR),

2291

1

				(AccountId::from(BOB), 1_000 * GLMR),

2292

1

])

2293

1

			.with_safe_xcm_version(XCM_VERSION)

2294

1

			.with_open_bridges(vec![(

2295

1

				Location::new(

2296

1

1,

2297

1

					[Parachain(

2298

1

						<bp_moonbeam::Moonbeam as bp_runtime::Parachain>::PARACHAIN_ID,

2299

1

)],

2300

1

),

2301

1

				Junctions::from([

2302

1

					NetworkId::Kusama.into(),

2303

1

					Parachain(<bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID),

2304

1

]),

2305

1

				Some(bp_moonbeam::LaneId::from_inner(H256([0u8; 32])))

2306

1

)])

2307

1

			.build()

2308

1

			.execute_with(|| {

2309

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2310

1

					root_origin(),

2311

1

					Box::new(bp_moonriver::GlobalConsensusLocation::get()),

2312

					XCM_VERSION

2313

));

2314

2315

1

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

2316

2317

1

				let message_data = BridgeKusamaMessages::outbound_message_data(

2318

1

					bp_moonriver::LaneId::from_inner(H256([0u8; 32])),

2319

					1u64,

2320

);

2321

1

				assert!(message_data.is_none());

2322

2323

1

				assert_ok!(PolkadotXcm::transfer_assets(

2324

1

					origin_of(AccountId::from(ALICE)),

2325

1

					Box::new(VersionedLocation::V5(bp_moonriver::GlobalConsensusLocation::get())),

2326

1

					Box::new(VersionedLocation::V5(Location {

2327

1

						parents: 0,

2328

1

						interior: [AccountKey20 {

2329

1

							network: None,

2330

1

							key: ALICE,

2331

1

}]

2332

1

						.into(),

2333

1

					})),

2334

1

					Box::new(VersionedAssets::V5(asset.into())),

2335

0,

2336

1

					WeightLimit::Unlimited

2337

));

2338

2339

1

				let message_data = BridgeKusamaMessages::outbound_message_data(

2340

1

					bp_moonriver::LaneId::from_inner(H256([0u8; 32])),

2341

					1u64,

2342

1

				).unwrap();

2343

1

				let decoded: StoredMessagePayload::<Runtime, WithKusamaMessagesInstance> = Decode::decode(&mut &message_data[..]).unwrap();

2344

2345

1

				let BridgeMessage { universal_dest, message } =

2346

1

					Decode::decode(&mut &decoded[..]).unwrap();

2347

2348

1

				let expected_universal_dest: VersionedInteriorLocation = bp_moonriver::GlobalConsensusLocation::get().interior.into();

2349

1

				assert_eq!(universal_dest, expected_universal_dest);

2350

2351

1

				assert_eq!(

2352

					message,

2353

1

					VersionedXcm::V5(

2354

1

						Xcm(

2355

1

2356

1

								UniversalOrigin(GlobalConsensus(NetworkId::Polkadot)),

2357

1

								DescendOrigin(X1([Parachain(<bp_moonbeam::Moonbeam as bp_runtime::Parachain>::PARACHAIN_ID)].into())),

2358

1

								ReserveAssetDeposited(

2359

1

									vec![

2360

1

										Asset {

2361

1

											id: AssetId(

2362

1

												Location::new(

2363

1

2,

2364

1

2365

1

														GlobalConsensus(NetworkId::Polkadot),

2366

1

														Parachain(<bp_moonbeam::Moonbeam as bp_runtime::Parachain>::PARACHAIN_ID),

2367

1

														PalletInstance(<Balances as PalletInfoAccess>::index() as u8)

2368

1

2369

1

2370

1

),

2371

1

											fun: Fungible(100_000_000_000_000_000_000)

2372

1

2373

1

									].into()

2374

1

),

2375

1

								ClearOrigin,

2376

1

								BuyExecution {

2377

1

									fees: Asset {

2378

1

										id: AssetId(

2379

1

											Location::new(

2380

1

2,

2381

1

2382

1

													GlobalConsensus(NetworkId::Polkadot),

2383

1

													Parachain(<bp_moonbeam::Moonbeam as bp_runtime::Parachain>::PARACHAIN_ID),

2384

1

													PalletInstance(<Balances as PalletInfoAccess>::index() as u8)

2385

1

2386

1

2387

1

),

2388

1

										fun: Fungible(100_000_000_000_000_000_000)

2389

1

},

2390

1

									weight_limit: WeightLimit::Unlimited

2391

1

},

2392

1

								DepositAsset {

2393

1

									assets: AssetFilter::Wild(WildAsset::AllCounted(1)),

2394

1

									beneficiary: Location::new(0, [AccountKey20 { network: None, key: ALICE}]),

2395

1

},

2396

1

								SetTopic([24, 73, 92, 41, 231, 15, 196, 44, 136, 120, 145, 143, 224, 187, 112, 187, 47, 89, 154, 44, 193, 175, 174, 249, 30, 194, 97, 183, 171, 39, 87, 147])

2397

1

							].into()

2398

1

2399

1

2400

);

2401

1

})

2402

1

2403

2404

	#[test]

2405

1

	fn receive_message_from_moonriver() {

2406

1

		frame_support::__private::sp_tracing::init_for_tests();

2407

2408

1

		ExtBuilder::default()

2409

1

			.with_balances(vec![

2410

1

				(AccountId::from(ALICE), 2_000 * GLMR),

2411

1

				(AccountId::from(BOB), 1_000 * GLMR),

2412

1

])

2413

1

			.with_xcm_assets(vec![XcmAssetInitialization {

2414

1

				asset_id: 1,

2415

1

				xcm_location: Location::new(

2416

1

2,

2417

1

2418

1

						GlobalConsensus(KusamaGlobalConsensusNetwork::get()),

2419

1

						Parachain(<bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID),

2420

1

						PalletInstance(<Balances as PalletInfoAccess>::index() as u8)

2421

1

2422

1

),

2423

1

				name: "xcMOVR",

2424

1

				symbol: "xcMOVR",

2425

1

				decimals: 18,

2426

1

				balances: vec![(AccountId::from(ALICE), 1_000_000_000_000_000)],

2427

1

}])

2428

1

			.with_safe_xcm_version(XCM_VERSION)

2429

1

			.with_open_bridges(vec![(

2430

1

				Location::new(

2431

1

1,

2432

1

					[Parachain(

2433

1

						<bp_moonbeam::Moonbeam as bp_runtime::Parachain>::PARACHAIN_ID,

2434

1

)],

2435

1

),

2436

1

				Junctions::from([

2437

1

					NetworkId::Kusama.into(),

2438

1

					Parachain(<bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID),

2439

1

]),

2440

1

				Some(bp_moonriver::LaneId::from_inner(H256([0u8; 32]))),

2441

1

)])

2442

1

			.build()

2443

1

			.execute_with(|| {

2444

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2445

1

					root_origin(),

2446

1

					Box::new(bp_moonriver::GlobalConsensusLocation::get()),

2447

					XCM_VERSION

2448

));

2449

2450

1

				let bridge_message: BridgeMessage = BridgeMessage {

2451

1

					universal_dest: VersionedInteriorLocation::V5(

2452

1

2453

1

							GlobalConsensus(NetworkId::Polkadot),

2454

1

							Parachain(<bp_moonbeam::Moonbeam as bp_runtime::Parachain>::PARACHAIN_ID)

2455

1

						].into()

2456

1

),

2457

1

					message: VersionedXcm::V5(

2458

1

						Xcm(

2459

1

2460

1

								UniversalOrigin(GlobalConsensus(NetworkId::Kusama)),

2461

1

								DescendOrigin(X1([Parachain(<bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID)].into())),

2462

1

								ReserveAssetDeposited(

2463

1

									vec![

2464

1

										Asset {

2465

1

											id: AssetId(

2466

1

												Location::new(

2467

1

2,

2468

1

2469

1

														GlobalConsensus(NetworkId::Kusama),

2470

1

														Parachain(<bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID),

2471

1

														PalletInstance(<Balances as PalletInfoAccess>::index() as u8)

2472

1

2473

1

2474

1

),

2475

1

											fun: Fungible(10_000_000_000_000_000_000_000_000_000_000_000)

2476

1

2477

1

									].into()

2478

1

),

2479

1

								ClearOrigin,

2480

1

								BuyExecution {

2481

1

									fees: Asset {

2482

1

										id: AssetId(

2483

1

											Location::new(

2484

1

2,

2485

1

2486

1

													GlobalConsensus(NetworkId::Kusama),

2487

1

													Parachain(<bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID),

2488

1

													PalletInstance(<Balances as PalletInfoAccess>::index() as u8)

2489

1

2490

1

2491

1

),

2492

1

										fun: Fungible(6_000_000_000_000_000_000_000_000_000_000_000)

2493

1

},

2494

1

									weight_limit: WeightLimit::Unlimited

2495

1

},

2496

1

								DepositAsset {

2497

1

									assets: AssetFilter::Wild(WildAsset::AllCounted(1)),

2498

1

									beneficiary: Location::new(0, [AccountKey20 { network: None, key: ALICE }]),

2499

1

},

2500

1

								SetTopic([24, 73, 92, 41, 231, 15, 196, 44, 136, 120, 145, 143, 224, 187, 112, 187, 47, 89, 154, 44, 193, 175, 174, 249, 30, 194, 97, 183, 171, 39, 87, 147])

2501

1

							].into()

2502

1

2503

1

2504

1

};

2505

2506

1

				let mut inbound_lane = LanesManager::<Runtime, WithKusamaMessagesInstance>::new()

2507

1

					.active_inbound_lane(Default::default())

2508

1

					.unwrap();

2509

2510

1

				let msg = DispatchMessageData { payload: Ok(bridge_message.encode()) };

2511

1

	 			let result = inbound_lane.receive_message::<BridgeXcmOverMoonriver>(&AccountId::from(ALICE),

2512

1,

2513

1

					msg,

2514

);

2515

2516

1

				assert_eq!(result, ReceptionResult::Dispatched(MessageDispatchResult { unspent_weight: Default::default(), dispatch_level_result: Dispatched }));

2517

2518

				// Produce next block

2519

1

				next_block();

2520

				// Confirm that the xcm message was successfully processed

2521

7

				assert!(System::events().iter().any(|evt| {

2522

1

					matches!(

2523

1

						evt.event,

2524

						RuntimeEvent::MessageQueue(

2525

							pallet_message_queue::Event::Processed {

2526

								origin: AggregateMessageOrigin::Here,

2527

								success: true,

2528

..

2529

2530

2531

2532

7

				}));

2533

1

});

2534

1

2535

2536

2537

#[cfg(test)]

2538

mod treasury_tests {

2539

	use super::*;

2540

	use frame_support::traits::fungible::NativeOrWithId;

2541

	use moonbeam_runtime::XcmWeightTrader;

2542

	use sp_core::bounded_vec;

2543

	use sp_runtime::traits::Hash;

2544

2545

4

	fn expect_events(events: Vec<RuntimeEvent>) {

2546

4

		let block_events: Vec<RuntimeEvent> =

2547

4

			System::events().into_iter().map(|r| r.event).collect();

2548

2549

7

		assert!(events.iter().all(|evt| block_events.contains(evt)))

2550

4

2551

2552

7

	fn next_block() {

2553

7

		System::reset_events();

2554

7

		System::set_block_number(System::block_number() + 1u32);

2555

7

		System::on_initialize(System::block_number());

2556

7

		Treasury::on_initialize(System::block_number());

2557

7

2558

2559

3

	fn get_asset_balance(id: &u128, account: &AccountId) -> U256 {

2560

3

		pallet_moonbeam_foreign_assets::Pallet::<Runtime>::balance(id.clone(), account.clone())

2561

3

			.expect("failed to get account balance")

2562

3

2563

2564

	#[test]

2565

1

	fn test_treasury_spend_local_with_council_origin() {

2566

1

		let initial_treasury_balance = 1_000 * GLMR;

2567

1

		ExtBuilder::default()

2568

1

			.with_balances(vec![

2569

1

				(AccountId::from(ALICE), 2_000 * GLMR),

2570

1

				(Treasury::account_id(), initial_treasury_balance),

2571

1

])

2572

1

			.build()

2573

1

			.execute_with(|| {

2574

1

				let spend_amount = 100u128 * GLMR;

2575

1

				let spend_beneficiary = AccountId::from(BOB);

2576

2577

1

				next_block();

2578

2579

				// TreasuryCouncilCollective

2580

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2581

1

					root_origin(),

2582

1

					vec![AccountId::from(ALICE)],

2583

1

					Some(AccountId::from(ALICE)),

2584

2585

));

2586

2587

1

				next_block();

2588

2589

				// Perform treasury spending

2590

1

				let valid_from = System::block_number() + 5u32;

2591

1

				let proposal = RuntimeCall::Treasury(pallet_treasury::Call::spend {

2592

1

					amount: spend_amount,

2593

1

					asset_kind: Box::new(NativeOrWithId::Native),

2594

1

					beneficiary: Box::new(AccountId::from(BOB)),

2595

1

					valid_from: Some(valid_from),

2596

1

});

2597

1

				assert_ok!(TreasuryCouncilCollective::propose(

2598

1

					origin_of(AccountId::from(ALICE)),

2599

1,

2600

1

					Box::new(proposal.clone()),

2601

					1_000

2602

));

2603

2604

1

				let payout_period =

2605

1

					<<Runtime as pallet_treasury::Config>::PayoutPeriod as Get<u32>>::get();

2606

1

				let expected_events = [

2607

1

					RuntimeEvent::Treasury(pallet_treasury::Event::AssetSpendApproved {

2608

1

						index: 0,

2609

1

						asset_kind: NativeOrWithId::Native,

2610

1

						amount: spend_amount,

2611

1

						beneficiary: spend_beneficiary,

2612

1

						valid_from,

2613

1

						expire_at: payout_period + valid_from,

2614

1

}),

2615

1

					RuntimeEvent::TreasuryCouncilCollective(pallet_collective::Event::Executed {

2616

1

						proposal_hash: sp_runtime::traits::BlakeTwo256::hash_of(&proposal),

2617

1

						result: Ok(()),

2618

1

}),

2619

1

2620

1

				.to_vec();

2621

1

				expect_events(expected_events);

2622

2623

6

				while System::block_number() < valid_from {

2624

5

					next_block();

2625

5

2626

2627

1

				assert_ok!(Treasury::payout(origin_of(spend_beneficiary), 0));

2628

2629

1

				let expected_events = [

2630

1

					RuntimeEvent::Treasury(pallet_treasury::Event::Paid {

2631

1

						index: 0,

2632

1

						payment_id: (),

2633

1

}),

2634

1

					RuntimeEvent::Balances(pallet_balances::Event::Transfer {

2635

1

						from: Treasury::account_id(),

2636

1

						to: spend_beneficiary,

2637

1

						amount: spend_amount,

2638

1

}),

2639

1

2640

1

				.to_vec();

2641

1

				expect_events(expected_events);

2642

1

});

2643

1

2644

2645

	#[test]

2646

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2647

1

		let initial_treasury_balance = 1_000 * GLMR;

2648

1

		let asset_id = 1000100010001000u128;

2649

1

		ExtBuilder::default()

2650

1

			.with_balances(vec![(AccountId::from(ALICE), 2_000 * GLMR)])

2651

1

			.build()

2652

1

			.execute_with(|| {

2653

1

				let spend_amount = 100u128 * GLMR;

2654

1

				let spend_beneficiary = AccountId::from(BOB);

2655

2656

1

				let asset_location: Location = Location {

2657

1

					parents: 1,

2658

1

					interior: Junctions::Here,

2659

1

};

2660

2661

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2662

1

					root_origin(),

2663

1

					asset_id,

2664

1

					asset_location.clone(),

2665

12,

2666

1

					bounded_vec![b'M', b'T'],

2667

1

					bounded_vec![b'M', b'y', b'T', b'o', b'k'],

2668

));

2669

2670

1

				assert_ok!(XcmWeightTrader::add_asset(

2671

1

					root_origin(),

2672

1

					asset_location,

2673

					1u128

2674

));

2675

2676

1

				assert_ok!(EvmForeignAssets::mint_into(

2677

1

					asset_id,

2678

1

					Treasury::account_id(),

2679

1

					initial_treasury_balance.into()

2680

));

2681

2682

1

				assert_eq!(

2683

1

					get_asset_balance(&asset_id, &Treasury::account_id()),

2684

1

					initial_treasury_balance.into(),

2685

					"Treasury balance not updated"

2686

);

2687

2688

				// TreasuryCouncilCollective

2689

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2690

1

					root_origin(),

2691

1

					vec![AccountId::from(ALICE)],

2692

1

					Some(AccountId::from(ALICE)),

2693

2694

));

2695

2696

				// Perform treasury spending

2697

1

				let proposal = RuntimeCall::Treasury(pallet_treasury::Call::spend {

2698

1

					amount: spend_amount,

2699

1

					asset_kind: Box::new(NativeOrWithId::WithId(asset_id)),

2700

1

					beneficiary: Box::new(spend_beneficiary),

2701

1

					valid_from: None,

2702

1

});

2703

1

				assert_ok!(TreasuryCouncilCollective::propose(

2704

1

					origin_of(AccountId::from(ALICE)),

2705

1,

2706

1

					Box::new(proposal.clone()),

2707

					1_000

2708

));

2709

2710

1

				let payout_period =

2711

1

					<<Runtime as pallet_treasury::Config>::PayoutPeriod as Get<u32>>::get();

2712

2713

1

				let current_block = System::block_number();

2714

1

				let expected_events = [

2715

1

					RuntimeEvent::Treasury(pallet_treasury::Event::AssetSpendApproved {

2716

1

						index: 0,

2717

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2718

1

						amount: spend_amount,

2719

1

						beneficiary: spend_beneficiary,

2720

1

						valid_from: current_block,

2721

1

						expire_at: current_block + payout_period,

2722

1

}),

2723

1

					RuntimeEvent::TreasuryCouncilCollective(pallet_collective::Event::Executed {

2724

1

						proposal_hash: sp_runtime::traits::BlakeTwo256::hash_of(&proposal),

2725

1

						result: Ok(()),

2726

1

}),

2727

1

2728

1

				.to_vec();

2729

1

				expect_events(expected_events);

2730

2731

1

				assert_ok!(Treasury::payout(origin_of(spend_beneficiary), 0));

2732

2733

1

				expect_events(vec![RuntimeEvent::Treasury(pallet_treasury::Event::Paid {

2734

1

					index: 0,

2735

1

					payment_id: (),

2736

1

				})]);

2737

2738

1

				assert_eq!(

2739

1

					get_asset_balance(&asset_id, &Treasury::account_id()),

2740

1

					(initial_treasury_balance - spend_amount).into(),

2741

					"Treasury balance not updated"

2742

);

2743

2744

1

				assert_eq!(

2745

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2746

1

					spend_amount.into(),

2747

					"Treasury payout failed"

2748

);

2749

1

});

2750

1

2751

2752

2753

#[cfg(test)]

2754

mod fee_tests {

2755

	use super::*;

2756

	use fp_evm::FeeCalculator;

2757

	use frame_support::{

2758

		traits::{ConstU128, OnFinalize},

2759

		weights::{ConstantMultiplier, WeightToFee},

2760

};

2761

	use moonbeam_runtime::{

2762

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2763

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2764

};

2765

	use sp_core::Get;

2766

	use sp_runtime::{BuildStorage, FixedPointNumber, Perbill};

2767

2768

1

	fn run_with_system_weight<F>(w: Weight, mut assertions: F)

2769

1

	where

2770

1

		F: FnMut() -> (),

2771

2772

1

		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

2773

1

			.build_storage()

2774

1

			.unwrap()

2775

1

			.into();

2776

1

		t.execute_with(|| {

2777

1

			System::set_block_consumed_resources(w, 0);

2778

1

			assertions()

2779

1

});

2780

1

2781

2782

	#[test]

2783

1

	fn test_multiplier_can_grow_from_zero() {

2784

1

		let minimum_multiplier = MinimumMultiplier::get();

2785

1

		let target = TargetBlockFullness::get()

2786

1

			* RuntimeBlockWeights::get()

2787

1

				.get(DispatchClass::Normal)

2788

1

				.max_total

2789

1

				.unwrap();

2790

		// if the min is too small, then this will not change, and we are doomed forever.

2791

		// the weight is 1/100th bigger than target.

2792

1

		run_with_system_weight(target * 101 / 100, || {

2793

1

			let next = SlowAdjustingFeeUpdate::<Runtime>::convert(minimum_multiplier);

2794

1

			assert!(

2795

1

				next > minimum_multiplier,

2796

				"{:?} !>= {:?}",

2797

				next,

2798

				minimum_multiplier

2799

);

2800

1

})

2801

1

2802

2803

	#[test]

2804

1

	fn test_fee_calculation() {

2805

1

		let base_extrinsic = RuntimeBlockWeights::get()

2806

1

			.get(DispatchClass::Normal)

2807

1

			.base_extrinsic;

2808

1

		let multiplier = sp_runtime::FixedU128::from_float(0.999000000000000000);

2809

1

		let extrinsic_len = 100u32;

2810

1

		let extrinsic_weight = 5_000u64;

2811

1

		let tip = 42u128;

2812

		type WeightToFeeImpl = ConstantMultiplier<u128, ConstU128<{ currency::WEIGHT_FEE }>>;

2813

		type LengthToFeeImpl = LengthToFee;

2814

2815

		// base_fee + (multiplier * extrinsic_weight_fee) + extrinsic_length_fee + tip

2816

1

		let expected_fee =

2817

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

2818

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

2819

1

					&Weight::from_parts(extrinsic_weight, 1),

2820

1

				)) + LengthToFeeImpl::weight_to_fee(&Weight::from_parts(extrinsic_len as u64, 1))

2821

1

				+ tip;

2822

2823

1

		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

2824

1

			.build_storage()

2825

1

			.unwrap()

2826

1

			.into();

2827

1

		t.execute_with(|| {

2828

1

			pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(multiplier);

2829

1

			let actual_fee = TransactionPayment::compute_fee(

2830

1

				extrinsic_len,

2831

1

				&frame_support::dispatch::DispatchInfo {

2832

1

					class: DispatchClass::Normal,

2833

1

					pays_fee: frame_support::dispatch::Pays::Yes,

2834

1

					call_weight: Weight::from_parts(extrinsic_weight, 1),

2835

1

					extension_weight: Weight::zero(),

2836

1

},

2837

1

				tip,

2838

);

2839

2840

1

			assert_eq!(

2841

				expected_fee,

2842

				actual_fee,

2843

				"The actual fee did not match the expected fee, diff {}",

2844

				actual_fee - expected_fee

2845

);

2846

1

});

2847

1

2848

2849

	#[test]

2850

1

	fn test_min_gas_price_is_deterministic() {

2851

1

		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

2852

1

			.build_storage()

2853

1

			.unwrap()

2854

1

			.into();

2855

1

		t.execute_with(|| {

2856

1

			let multiplier = sp_runtime::FixedU128::from_u32(1);

2857

1

			pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(multiplier);

2858

1

			let actual = TransactionPaymentAsGasPrice::min_gas_price().0;

2859

1

			let expected: U256 = multiplier

2860

1

				.saturating_mul_int(currency::WEIGHT_FEE.saturating_mul(WEIGHT_PER_GAS as u128))

2861

1

				.into();

2862

2863

1

			assert_eq!(expected, actual);

2864

1

});

2865

1

2866

2867

	#[test]

2868

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

2869

1

		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

2870

1

			.build_storage()

2871

1

			.unwrap()

2872

1

			.into();

2873

1

		t.execute_with(|| {

2874

1

			let multiplier_1 = sp_runtime::FixedU128::from_float(0.999593900000000000);

2875

1

			let multiplier_2 = sp_runtime::FixedU128::from_float(0.999593200000000000);

2876

2877

1

			pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(multiplier_1);

2878

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

2879

1

			pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(multiplier_2);

2880

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

2881

2882

1

			assert_ne!(

2883

				a, b,

2884

				"both gas prices were equal, unexpected precision loss incurred"

2885

);

2886

1

});

2887

1

2888

2889

	#[test]

2890

1

	fn test_fee_scenarios() {

2891

		use sp_runtime::FixedU128;

2892

1

		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()

2893

1

			.build_storage()

2894

1

			.unwrap()

2895

1

			.into();

2896

1

		t.execute_with(|| {

2897

1

			let weight_fee_per_gas = (currency::WEIGHT_FEE).saturating_mul(WEIGHT_PER_GAS as u128);

2898

12

			let sim = |start_gas_price: u128, fullness: Perbill, num_blocks: u64| -> U256 {

2899

12

				let start_multiplier =

2900

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

2901

12

				pallet_transaction_payment::NextFeeMultiplier::<Runtime>::set(start_multiplier);

2902

2903

12

				let block_weight = NORMAL_WEIGHT * fullness;

2904

2905

60004

				for i in 0..num_blocks {

2906

60004

					System::set_block_number(i as u32);

2907

60004

					System::set_block_consumed_resources(block_weight, 0);

2908

60004

					TransactionPayment::on_finalize(i as u32);

2909

60004

2910

2911

12

				TransactionPaymentAsGasPrice::min_gas_price().0

2912

12

};

2913

2914

			// The expected values are the ones observed during test execution,

2915

			// they are expected to change when parameters that influence

2916

			// the fee calculation are changed, and should be updated accordingly.

2917

			// If a test fails when nothing specific to fees has changed,

2918

			// it may indicate an unexpected collateral effect and should be investigated

2919

2920

1

			assert_eq!(

2921

1

				sim(1_000_000_000, Perbill::from_percent(0), 1),

2922

1

				U256::from(31_250_000_000u128), // lower bound enforced

2923

);

2924

1

			assert_eq!(

2925

1

				sim(1_000_000_000, Perbill::from_percent(25), 1),

2926

1

				U256::from(31_250_000_000u128),

2927

);

2928

1

			assert_eq!(

2929

1

				sim(1_000_000_000, Perbill::from_percent(50), 1),

2930

1

				U256::from(31_268_755_625u128), // slightly higher than lower bound

2931

);

2932

1

			assert_eq!(

2933

1

				sim(1_000_000_000, Perbill::from_percent(100), 1),

2934

1

				U256::from(31_331_355_625u128), // a bit higher than before

2935

);

2936

2937

			// 1 "real" hour (at 12-second blocks)

2938

1

			assert_eq!(

2939

1

				sim(1_000_000_000, Perbill::from_percent(0), 600),

2940

1

				U256::from(31_250_000_000u128), // lower bound enforced

2941

);

2942

1

			assert_eq!(

2943

1

				sim(1_000_000_000, Perbill::from_percent(25), 600),

2944

1

				U256::from(31_250_000_000u128),

2945

);

2946

1

			assert_eq!(

2947

1

				sim(1_000_000_000, Perbill::from_percent(50), 600),

2948

1

				U256::from(44_791_543_237u128), // a bit higher than lower bound

2949

);

2950

1

			assert_eq!(

2951

1

				sim(1_000_000_000, Perbill::from_percent(100), 600),

2952

1

				U256::from(148_712_903_041u128), // a lot more

2953

);

2954

2955

			// 1 "real" day (at 12-second blocks)

2956

1

			assert_eq!(

2957

1

				sim(1_000_000_000, Perbill::from_percent(0), 14400),

2958

1

				U256::from(31_250_000_000u128), // lower bound enforced

2959

);

2960

1

			assert_eq!(

2961

1

				sim(1_000_000_000, Perbill::from_percent(25), 14400),

2962

1

				U256::from(31_250_000_000u128),

2963

);

2964

1

			assert_eq!(

2965

1

				sim(1_000_000_000, Perbill::from_percent(50), 14400),

2966

1

				U256::from(176_666_465_470_908u128), // significantly higher

2967

);

2968

1

			assert_eq!(

2969

1

				sim(1_000_000_000, Perbill::from_percent(100), 14400),

2970

1

				U256::from(3_125_000_000_000_000u128), // upper bound enforced

2971

);

2972

1

});

2973

1

2974

2975

2976

#[cfg(test)]

2977

mod balance_tests {

2978

	use crate::common::{ExtBuilder, ALICE};

2979

	use frame_support::assert_ok;

2980

	use frame_support::traits::LockableCurrency;

2981

	use frame_support::traits::{LockIdentifier, ReservableCurrency, WithdrawReasons};

2982

	use moonbeam_core_primitives::AccountId;

2983

	use moonbeam_runtime::{Balances, Runtime, System};

2984

2985

	#[test]

2986

1

	fn reserve_should_work_for_frozen_balance() {

2987

1

		let alice = AccountId::from(ALICE);

2988

		const ID_1: LockIdentifier = *b"1       ";

2989

2990

1

		ExtBuilder::default()

2991

1

			.with_balances(vec![(alice, 10)])

2992

1

			.build()

2993

1

			.execute_with(|| {

2994

				// Check balances

2995

1

				let account = System::account(&alice).data;

2996

1

				assert_eq!(account.free, 10);

2997

1

				assert_eq!(account.frozen, 0);

2998

1

				assert_eq!(account.reserved, 0);

2999

3000

1

				Balances::set_lock(ID_1, &alice, 9, WithdrawReasons::RESERVE);

3001

3002

1

				let account = System::account(&alice).data;

3003

1

				assert_eq!(account.free, 10);

3004

1

				assert_eq!(account.frozen, 9);

3005

1

				assert_eq!(account.reserved, 0);

3006

3007

1

				assert_ok!(Balances::reserve(&alice, 5));

3008

3009

1

				let account = System::account(&alice).data;

3010

1

				assert_eq!(account.free, 5);

3011

1

				assert_eq!(account.frozen, 9);

3012

1

				assert_eq!(account.reserved, 5);

3013

3014

1

				let previous_reserved_amount = account.reserved;

3015

1

				let ed: u128 = <Runtime as pallet_balances::Config>::ExistentialDeposit::get();

3016

1

				let next_reserve = account.free.saturating_sub(ed);

3017

1

				assert_ok!(Balances::reserve(&alice, next_reserve));

3018

3019

1

				let account = System::account(&alice).data;

3020

1

				assert_eq!(account.free, ed);

3021

1

				assert_eq!(account.frozen, 9);

3022

1

				assert_eq!(

3023

					account.reserved,

3024

1

					previous_reserved_amount.saturating_add(next_reserve)

3025

);

3026

1

});

3027

1

3028

3029

3030

moonbeam_runtime_common::generate_common_xcm_tests!(moonbeam_runtime);