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::*, VersionedAssets, VersionedLocation};

69

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

70

use xcm_executor::traits::ConvertLocation;

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

7

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

84

7

	Asset {

85

7

		id: AssetId(

86

7

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

87

7

				currency_id,

88

7

89

7

			.unwrap(),

90

7

),

91

7

		fun: Fungibility::Fungible(amount),

92

7

93

7

94

#[test]

95

1

fn xcmp_queue_controller_origin_is_root() {

96

1

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

97

1

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

98

1

	assert_ok!(

99

1

		<moonbeam_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

100

1

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

101

1

);

102

1

103

104

#[test]

105

1

fn verify_pallet_prefixes() {

106

31

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

107

31

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

108

31

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

109

31

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

110

31

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

111

31

		// expand/storage.rs#L389-L401

112

31

		assert_eq!(

113

31

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

114

31

			Some(name)

115

31

);

116

31

117

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

118

	// is pulled in substrate deps.

119

1

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

120

1

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

121

1

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

122

1

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

123

1

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

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

	is_pallet_prefix::<moonbeam_runtime::OpenTechCommitteeCollective>(

130

1

		"OpenTechCommitteeCollective",

131

1

);

132

1

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

133

1

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

134

1

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

135

1

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

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

153

14

	let prefix = |pallet_name, storage_name| {

154

14

		let mut res = [0u8; 32];

155

14

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

156

14

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

157

14

		res.to_vec()

158

14

};

159

1

	assert_eq!(

160

1

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

161

1

		vec![

162

1

			StorageInfo {

163

1

				pallet_name: b"Timestamp".to_vec(),

164

1

				storage_name: b"Now".to_vec(),

165

1

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

166

1

				max_values: Some(1),

167

1

				max_size: Some(8),

168

1

},

169

1

			StorageInfo {

170

1

				pallet_name: b"Timestamp".to_vec(),

171

1

				storage_name: b"DidUpdate".to_vec(),

172

1

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

173

1

				max_values: Some(1),

174

1

				max_size: Some(1),

175

1

176

1

177

1

);

178

1

	assert_eq!(

179

1

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

180

1

		vec![

181

1

			StorageInfo {

182

1

				pallet_name: b"Balances".to_vec(),

183

1

				storage_name: b"TotalIssuance".to_vec(),

184

1

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

185

1

				max_values: Some(1),

186

1

				max_size: Some(16),

187

1

},

188

1

			StorageInfo {

189

1

				pallet_name: b"Balances".to_vec(),

190

1

				storage_name: b"InactiveIssuance".to_vec(),

191

1

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

192

1

				max_values: Some(1),

193

1

				max_size: Some(16),

194

1

},

195

1

			StorageInfo {

196

1

				pallet_name: b"Balances".to_vec(),

197

1

				storage_name: b"Account".to_vec(),

198

1

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

199

1

				max_values: None,

200

1

				max_size: Some(100),

201

1

},

202

1

			StorageInfo {

203

1

				pallet_name: b"Balances".to_vec(),

204

1

				storage_name: b"Locks".to_vec(),

205

1

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

206

1

				max_values: None,

207

1

				max_size: Some(1287),

208

1

},

209

1

			StorageInfo {

210

1

				pallet_name: b"Balances".to_vec(),

211

1

				storage_name: b"Reserves".to_vec(),

212

1

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

213

1

				max_values: None,

214

1

				max_size: Some(1037),

215

1

},

216

1

			StorageInfo {

217

1

				pallet_name: b"Balances".to_vec(),

218

1

				storage_name: b"Holds".to_vec(),

219

1

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

220

1

				max_values: None,

221

1

				max_size: Some(91),

222

1

},

223

1

			StorageInfo {

224

1

				pallet_name: b"Balances".to_vec(),

225

1

				storage_name: b"Freezes".to_vec(),

226

1

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

227

1

				max_values: None,

228

1

				max_size: Some(73),

229

1

},

230

1

231

1

);

232

1

	assert_eq!(

233

1

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

234

1

		vec![

235

1

			StorageInfo {

236

1

				pallet_name: b"Proxy".to_vec(),

237

1

				storage_name: b"Proxies".to_vec(),

238

1

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

239

1

				max_values: None,

240

1

				max_size: Some(845),

241

1

},

242

1

			StorageInfo {

243

1

				pallet_name: b"Proxy".to_vec(),

244

1

				storage_name: b"Announcements".to_vec(),

245

1

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

246

1

				max_values: None,

247

1

				max_size: Some(1837),

248

1

249

1

250

1

);

251

1

	assert_eq!(

252

1

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

253

1

		vec![StorageInfo {

254

1

			pallet_name: b"MaintenanceMode".to_vec(),

255

1

			storage_name: b"MaintenanceMode".to_vec(),

256

1

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

257

1

			max_values: Some(1),

258

1

			max_size: None,

259

1

},]

260

1

);

261

1

	assert_eq!(

262

1

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

263

1

		vec![

264

1

			StorageInfo {

265

1

				pallet_name: b"RelayStorageRoots".to_vec(),

266

1

				storage_name: b"RelayStorageRoot".to_vec(),

267

1

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

268

1

				max_values: None,

269

1

				max_size: Some(44),

270

1

},

271

1

			StorageInfo {

272

1

				pallet_name: b"RelayStorageRoots".to_vec(),

273

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

274

1

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

275

1

				max_values: Some(1),

276

1

				max_size: Some(121),

277

1

},

278

1

279

1

);

280

1

281

282

#[test]

283

1

fn test_collectives_storage_item_prefixes() {

284

7

	for StorageInfo { pallet_name, .. } in

285

8

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

286

287

7

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

288

289

290

7

	for StorageInfo { pallet_name, .. } in

291

8

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

292

293

7

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

294

295

1

296

297

#[test]

298

1

fn collective_set_members_root_origin_works() {

299

1

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

300

1

		// TreasuryCouncilCollective

301

1

		assert_ok!(TreasuryCouncilCollective::set_members(

302

1

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

303

1

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

304

1

			Some(AccountId::from(ALICE)),

305

1

306

1

));

307

		// OpenTechCommitteeCollective

308

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

309

1

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

310

1

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

311

1

			Some(AccountId::from(ALICE)),

312

1

313

1

));

314

1

});

315

1

316

317

#[test]

318

1

fn collective_set_members_general_admin_origin_works() {

319

	use moonbeam_runtime::{

320

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

321

};

322

323

1

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

324

1

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

325

1

		let alice = AccountId::from(ALICE);

326

1

327

1

		// TreasuryCouncilCollective

328

1

		let _ = Utility::dispatch_as(

329

1

			root_caller.clone(),

330

1

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

331

1

			Box::new(

332

1

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

333

1

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

334

1

					prime: Some(alice),

335

1

					old_count: 2,

336

1

337

1

				.into(),

338

1

),

339

1

);

340

1

		// OpenTechCommitteeCollective

341

1

		let _ = Utility::dispatch_as(

342

1

			root_caller,

343

1

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

344

1

			Box::new(

345

1

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

346

1

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

347

1

					prime: Some(alice),

348

1

					old_count: 2,

349

1

350

1

				.into(),

351

1

),

352

1

);

353

1

354

1

		assert_eq!(

355

1

			System::events()

356

1

				.into_iter()

357

2

				.filter_map(|r| {

358

2

					match r.event {

359

2

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

360

2

							if result.is_ok() =>

361

2

362

2

							Some(true)

363

364

						_ => None,

365

366

2

})

367

1

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

368

1

				.len(),

369

1

370

1

371

1

});

372

1

373

374

#[test]

375

1

fn collective_set_members_signed_origin_does_not_work() {

376

1

	let alice = AccountId::from(ALICE);

377

1

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

378

1

		// TreasuryCouncilCollective

379

1

		assert!(TreasuryCouncilCollective::set_members(

380

1

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

381

1

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

382

1

			Some(AccountId::from(ALICE)),

383

1

384

1

385

1

		.is_err());

386

		// OpenTechCommitteeCollective

387

1

		assert!(OpenTechCommitteeCollective::set_members(

388

1

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

389

1

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

390

1

			Some(AccountId::from(ALICE)),

391

1

392

1

393

1

		.is_err());

394

1

});

395

1

396

397

#[test]

398

1

fn verify_pallet_indices() {

399

33

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

400

33

		assert_eq!(

401

33

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

402

33

			Some(index)

403

33

);

404

33

405

406

	// System support

407

1

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

408

1

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

409

1

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

410

1

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

411

1

	// Monetary

412

1

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

413

1

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

414

1

	// Consensus support

415

1

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

416

1

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

417

1

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

418

1

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

419

1

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

420

1

	// Handy utilities

421

1

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

422

1

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

423

1

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

424

1

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

425

1

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

426

1

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

427

1

	// Ethereum compatibility

428

1

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

429

1

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

430

1

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

431

1

	// Governance

432

1

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

433

1

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

434

1

	// Council

435

1

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

436

1

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

437

1

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

438

1

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

439

1

	// Treasury

440

1

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

441

1

	// Crowdloan

442

1

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

443

1

	// XCM Stuff

444

1

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

445

1

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

446

1

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

447

1

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

448

1

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

449

1

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

450

1

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

451

1

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

452

1

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

453

1

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

454

1

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

455

1

456

457

#[test]

458

1

fn verify_reserved_indices() {

459

1

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

460

1

		.build_storage()

461

1

		.unwrap()

462

1

		.into();

463

1

464

1

	t.execute_with(|| {

465

		use frame_metadata::*;

466

1

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

467

1

		let metadata = match metadata.1 {

468

1

			RuntimeMetadata::V14(metadata) => metadata,

469

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

470

};

471

		// 40: Sudo

472

		// 53: BaseFee

473

		// 108: pallet_assets::<Instance1>

474

1

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

475

1

		let existing = metadata

476

1

			.pallets

477

1

			.iter()

478

51

			.map(|p| p.index)

479

1

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

480

3

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

481

1

});

482

1

483

484

#[test]

485

1

fn verify_proxy_type_indices() {

486

1

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

487

1

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

488

1

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

489

1

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

490

1

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

491

1

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

492

1

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

493

1

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

494

1

495

496

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

497

#[test]

498

1

fn verify_normal_filter_allow_pure_proxy() {

499

1

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

500

1

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

501

1

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

502

1

				proxy_type: ProxyType::Any,

503

1

				delay: 0,

504

1

				index: 0,

505

1

506

1

		)));

507

1

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

508

1

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

509

1

				spawner: AccountId::from(ALICE),

510

1

				proxy_type: ProxyType::Any,

511

1

				index: 0,

512

1

				height: 0,

513

1

				ext_index: 0,

514

1

515

1

		)));

516

1

});

517

1

518

519

#[test]

520

1

fn join_collator_candidates() {

521

1

	ExtBuilder::default()

522

1

		.with_balances(vec![

523

1

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

524

1

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

525

1

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

526

1

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

527

1

])

528

1

		.with_collators(vec![

529

1

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

530

1

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

531

1

])

532

1

		.with_delegations(vec![

533

1

534

1

				AccountId::from(CHARLIE),

535

1

				AccountId::from(ALICE),

536

1

				5_000 * GLMR,

537

1

),

538

1

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

539

1

])

540

1

		.build()

541

1

		.execute_with(|| {

542

1

			assert_noop!(

543

1

				ParachainStaking::join_candidates(

544

1

					origin_of(AccountId::from(ALICE)),

545

1

					2_000_000 * GLMR,

546

1

					2u32

547

1

),

548

1

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

549

1

);

550

1

			assert_noop!(

551

1

				ParachainStaking::join_candidates(

552

1

					origin_of(AccountId::from(CHARLIE)),

553

1

					2_000_000 * GLMR,

554

1

					2u32

555

1

),

556

1

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

557

1

);

558

1

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

559

1

			assert_ok!(ParachainStaking::join_candidates(

560

1

				origin_of(AccountId::from(DAVE)),

561

1

				2_000_000 * GLMR,

562

1

				2u32

563

1

));

564

1

			assert_eq!(

565

1

				last_event(),

566

1

				RuntimeEvent::ParachainStaking(

567

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

568

1

						account: AccountId::from(DAVE),

569

1

						amount_locked: 2_000_000 * GLMR,

570

1

						new_total_amt_locked: 6_010_000 * GLMR

571

1

572

1

573

1

);

574

1

			let candidates = ParachainStaking::candidate_pool();

575

1

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

576

1

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

577

1

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

578

1

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

579

1

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

580

1

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

581

1

});

582

1

583

584

#[test]

585

1

fn transfer_through_evm_to_stake() {

586

1

	ExtBuilder::default()

587

1

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

588

1

		.build()

589

1

		.execute_with(|| {

590

1

			// Charlie has no balance => fails to stake

591

1

			assert_noop!(

592

1

				ParachainStaking::join_candidates(

593

1

					origin_of(AccountId::from(CHARLIE)),

594

1

					2_000_000 * GLMR,

595

1

					2u32

596

1

),

597

1

				DispatchError::Module(ModuleError {

598

1

					index: 20,

599

1

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

600

1

					message: Some("InsufficientBalance")

601

1

})

602

1

);

603

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

604

1

			assert_ok!(Balances::transfer_allow_death(

605

1

				origin_of(AccountId::from(ALICE)),

606

1

				AccountId::from(BOB),

607

1

				3_000_000 * GLMR,

608

1

));

609

1

			assert_eq!(

610

1

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

611

1

				3_000_000 * GLMR

612

1

);

613

614

1

			let gas_limit = 100000u64;

615

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

616

1

			// Bob transfers 2_000_000 GLMR to Charlie via EVM

617

1

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

618

1

				source: H160::from(BOB),

619

1

				target: H160::from(CHARLIE),

620

1

				input: vec![],

621

1

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

622

1

				gas_limit,

623

1

				max_fee_per_gas: gas_price,

624

1

				max_priority_fee_per_gas: None,

625

1

				nonce: None,

626

1

				access_list: Vec::new(),

627

1

				authorization_list: Vec::new(),

628

1

})

629

1

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

630

1

			assert_eq!(

631

1

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

632

1

				2_000_000 * GLMR,

633

1

);

634

635

			// Charlie can stake now

636

1

			assert_ok!(ParachainStaking::join_candidates(

637

1

				origin_of(AccountId::from(CHARLIE)),

638

1

				2_000_000 * GLMR,

639

1

				2u32

640

1

			),);

641

1

			let candidates = ParachainStaking::candidate_pool();

642

1

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

643

1

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

644

1

});

645

1

646

647

#[test]

648

1

fn reward_block_authors() {

649

1

	ExtBuilder::default()

650

1

		.with_balances(vec![

651

1

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

652

1

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

653

1

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

654

1

])

655

1

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

656

1

		.with_delegations(vec![(

657

1

			AccountId::from(BOB),

658

1

			AccountId::from(ALICE),

659

1

			50_000 * GLMR,

660

1

)])

661

1

		.with_mappings(vec![(

662

1

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

663

1

			AccountId::from(ALICE),

664

1

)])

665

1

		.build()

666

1

		.execute_with(|| {

667

1

			increase_last_relay_slot_number(1);

668

1

			// Just before round 3

669

1

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

670

1

			// no rewards doled out yet

671

1

			assert_eq!(

672

1

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

673

1

				8_010_000 * GLMR,

674

1

);

675

1

			assert_eq!(

676

1

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

677

1

				9_950_000 * GLMR,

678

1

);

679

1

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

680

1

			// rewards minted and distributed

681

1

			assert_eq!(

682

1

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

683

1

				8990978048702400000000000,

684

1

);

685

1

			assert_eq!(

686

1

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

687

1

				9969521950497200000000000,

688

1

);

689

1

});

690

1

691

692

#[test]

693

1

fn reward_block_authors_with_parachain_bond_reserved() {

694

1

	ExtBuilder::default()

695

1

		.with_balances(vec![

696

1

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

697

1

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

698

1

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

699

1

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

700

1

])

701

1

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

702

1

		.with_delegations(vec![(

703

1

			AccountId::from(BOB),

704

1

			AccountId::from(ALICE),

705

1

			50_000 * GLMR,

706

1

)])

707

1

		.with_mappings(vec![(

708

1

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

709

1

			AccountId::from(ALICE),

710

1

)])

711

1

		.build()

712

1

		.execute_with(|| {

713

1

			increase_last_relay_slot_number(1);

714

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

715

1

				root_origin(),

716

1

717

1

					InflationDistributionAccount {

718

1

						account: AccountId::from(CHARLIE),

719

1

						percent: Percent::from_percent(30),

720

1

},

721

1

					InflationDistributionAccount::default(),

722

1

723

1

				.into()

724

1

));

725

726

			// Stop just before round 3

727

1

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

728

1

			// no collators rewards doled out yet

729

1

			assert_eq!(

730

1

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

731

1

				8_010_000 * GLMR,

732

1

);

733

1

			assert_eq!(

734

1

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

735

1

				9_950_000 * GLMR,

736

1

);

737

			// 30% reserved for parachain bond

738

1

			assert_eq!(

739

1

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

740

1

				310300000000000000000000,

741

1

);

742

743

			// Go to round 3

744

1

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

745

1

746

1

			// collators rewards minted and distributed

747

1

			assert_eq!(

748

1

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

749

1

				8698492682878000000000000,

750

1

);

751

1

			assert_eq!(

752

1

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

753

1

				9962207316621500000000000,

754

1

);

755

			// 30% reserved for parachain bond again

756

1

			assert_eq!(

757

1

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

758

1

				615104500000000000000000,

759

1

);

760

1

});

761

1

762

763

1

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

764

1

where

765

1

	F: FnMut() -> (),

766

1

767

1

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

768

1

		.build_storage()

769

1

		.unwrap()

770

1

		.into();

771

1

	t.execute_with(|| {

772

1

		System::set_block_consumed_resources(w, 0);

773

1

		assertions()

774

1

});

775

1

776

777

#[test]

778

#[rustfmt::skip]

779

1

fn length_fee_is_sensible() {

780

	use sp_runtime::testing::TestXt;

781

782

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

783

1

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

784

1

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

785

1

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

786

1

787

9

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

788

9

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

789

9

				.inclusion_fee

790

9

				.expect("fee should be calculated")

791

9

				.len_fee

792

9

};

793

794

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

795

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

796

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

797

		//                             |           |

798

1

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

799

1

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

800

1

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

801

1

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

802

1

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

803

1

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

804

1

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

805

1

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

806

1

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

807

1

});

808

1

809

810

#[test]

811

1

fn multiplier_can_grow_from_zero() {

812

	use frame_support::traits::Get;

813

814

1

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

815

1

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

816

1

		* RuntimeBlockWeights::get()

817

1

			.get(DispatchClass::Normal)

818

1

			.max_total

819

1

			.unwrap();

820

1

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

821

1

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

822

1

	run_with_system_weight(target * 101 / 100, || {

823

1

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

824

1

		assert!(

825

1

			next > minimum_multiplier,

826

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

827

			next,

828

			minimum_multiplier

829

);

830

1

})

831

1

832

833

#[test]

834

1

fn ethereum_invalid_transaction() {

835

1

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

836

1

		set_parachain_inherent_data();

837

1

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

838

1

		// on chain is rejected.

839

1

		assert_eq!(

840

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

841

1

			Err(

842

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

843

1

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

844

1

845

1

846

1

);

847

1

});

848

1

849

850

#[test]

851

1

fn initial_gas_fee_is_correct() {

852

	use fp_evm::FeeCalculator;

853

854

1

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

855

1

		let multiplier = TransactionPayment::next_fee_multiplier();

856

1

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

857

858

1

		assert_eq!(

859

1

			TransactionPaymentAsGasPrice::min_gas_price(),

860

1

861

1

				31_250_000_000u128.into(),

862

1

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

863

1

864

1

);

865

1

});

866

1

867

868

#[test]

869

1

fn min_gas_fee_is_correct() {

870

	use fp_evm::FeeCalculator;

871

	use frame_support::traits::Hooks;

872

873

1

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

874

1

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

875

1

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

876

1

877

1

		let multiplier = TransactionPayment::next_fee_multiplier();

878

1

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

879

880

1

		assert_eq!(

881

1

			TransactionPaymentAsGasPrice::min_gas_price(),

882

1

883

1

				31_250_000_000u128.into(),

884

1

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

885

1

886

1

);

887

1

});

888

1

889

890

#[test]

891

1

fn transfer_ed_0_substrate() {

892

1

	ExtBuilder::default()

893

1

		.with_balances(vec![

894

1

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

895

1

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

896

1

])

897

1

		.build()

898

1

		.execute_with(|| {

899

1

			// Substrate transfer

900

1

			assert_ok!(Balances::transfer_allow_death(

901

1

				origin_of(AccountId::from(ALICE)),

902

1

				AccountId::from(BOB),

903

1

				1 * GLMR,

904

1

));

905

			// 1 WEI is left in the account

906

1

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

907

1

});

908

1

909

910

#[test]

911

1

fn transfer_ed_0_evm() {

912

1

	ExtBuilder::default()

913

1

		.with_balances(vec![

914

1

915

1

				AccountId::from(ALICE),

916

1

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

917

1

),

918

1

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

919

1

])

920

1

		.build()

921

1

		.execute_with(|| {

922

1

			set_parachain_inherent_data();

923

1

			// EVM transfer

924

1

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

925

1

				source: H160::from(ALICE),

926

1

				target: H160::from(BOB),

927

1

				input: Vec::new(),

928

1

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

929

1

				gas_limit: 21_000u64,

930

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

931

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

932

1

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

933

1

				access_list: Vec::new(),

934

1

				authorization_list: Vec::new(),

935

1

})

936

1

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

937

			// 1 WEI is left in the account

938

1

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

939

1

});

940

1

941

942

#[test]

943

1

fn refund_ed_0_evm() {

944

1

	ExtBuilder::default()

945

1

		.with_balances(vec![

946

1

947

1

				AccountId::from(ALICE),

948

1

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

949

1

),

950

1

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

951

1

])

952

1

		.build()

953

1

		.execute_with(|| {

954

1

			set_parachain_inherent_data();

955

1

			// EVM transfer that zeroes ALICE

956

1

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

957

1

				source: H160::from(ALICE),

958

1

				target: H160::from(BOB),

959

1

				input: Vec::new(),

960

1

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

961

1

				gas_limit: 21_777u64,

962

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

963

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

964

1

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

965

1

				access_list: Vec::new(),

966

1

				authorization_list: Vec::new(),

967

1

})

968

1

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

969

			// ALICE is refunded

970

1

			assert_eq!(

971

1

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

972

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

973

1

);

974

1

});

975

1

976

977

#[test]

978

1

fn author_does_receive_priority_fee() {

979

1

	ExtBuilder::default()

980

1

		.with_balances(vec![(

981

1

			AccountId::from(BOB),

982

1

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

983

1

)])

984

1

		.build()

985

1

		.execute_with(|| {

986

1

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

987

1

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

988

1

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

989

1

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

990

1

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

991

1

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

992

1

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

993

1

994

1

			// EVM transfer.

995

1

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

996

1

				source: H160::from(BOB),

997

1

				target: H160::from(ALICE),

998

1

				input: Vec::new(),

999

1

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

1000

1

				gas_limit: 21_000u64,

1001

1

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

1002

1

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

1003

1

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

1004

1

				access_list: Vec::new(),

1005

1

				authorization_list: Vec::new(),

1006

1

})

1007

1

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

1008

1009

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1010

1

			// Author free balance increased by priority fee.

1011

1

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

1012

1

});

1013

1

1014

1015

#[test]

1016

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1017

	use fp_evm::FeeCalculator;

1018

1

	ExtBuilder::default()

1019

1

		.with_balances(vec![

1020

1

1021

1

				AccountId::from(BOB),

1022

1

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

1023

1

),

1024

1

1025

1

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

1026

1

				existential_deposit(),

1027

1

),

1028

1

])

1029

1

		.build()

1030

1

		.execute_with(|| {

1031

1

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

1032

1

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

1033

1

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

1034

1

			// EVM transfer.

1035

1

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

1036

1

				source: H160::from(BOB),

1037

1

				target: H160::from(ALICE),

1038

1

				input: Vec::new(),

1039

1

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

1040

1

				gas_limit: 21_000u64,

1041

1

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

1042

1

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

1043

1

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

1044

1

				access_list: Vec::new(),

1045

1

				authorization_list: Vec::new(),

1046

1

})

1047

1

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

1048

1049

1

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

1050

1

1051

1

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

1052

1

1053

1

			let base_fee: Balance = base_fee * 21_000;

1054

1

1055

1

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

1056

1

1057

1

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

1058

1

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

1059

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1060

1

1061

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1062

1063

1

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

1064

1

});

1065

1

1066

1067

#[test]

1068

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1069

	use fp_evm::FeeCalculator;

1070

1

	ExtBuilder::default()

1071

1

		.with_balances(vec![

1072

1

1073

1

				AccountId::from(BOB),

1074

1

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

1075

1

),

1076

1

1077

1

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

1078

1

				existential_deposit(),

1079

1

),

1080

1

])

1081

1

		.build()

1082

1

		.execute_with(|| {

1083

1

			set_parachain_inherent_data();

1084

1

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

1085

1

			// EVM transfer.

1086

1

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

1087

1

				source: H160::from(BOB),

1088

1

				target: H160::from(ALICE),

1089

1

				input: Vec::new(),

1090

1

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

1091

1

				gas_limit: 21_000u64,

1092

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1093

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1094

1

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

1095

1

				access_list: Vec::new(),

1096

1

				authorization_list: Vec::new(),

1097

1

})

1098

1

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

1099

1100

1

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

1101

1

1102

1

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

1103

1

1104

1

			let base_fee: Balance = base_fee * 21_000;

1105

1

1106

1

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

1107

1

1108

1

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

1109

1

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

1110

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1111

1

1112

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1113

1114

1

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

1115

1

});

1116

1

1117

1118

#[test]

1119

1

fn root_can_change_default_xcm_vers() {

1120

1

	ExtBuilder::default()

1121

1

		.with_balances(vec![

1122

1

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

1123

1

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

1124

1

])

1125

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1126

1

			asset_id: 1,

1127

1

			xcm_location: AssetHubLocation::get(),

1128

1

			name: "Dot",

1129

1

			symbol: "Dot",

1130

1

			decimals: 12,

1131

1

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

1132

1

}])

1133

1

		.build()

1134

1

		.execute_with(|| {

1135

1

			let source_id: moonbeam_runtime::AssetId = 1;

1136

1

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

1137

1

			let asset = Asset {

1138

1

				id: AssetId(

1139

1

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

1140

1

						currency_id,

1141

1

1142

1

					.unwrap(),

1143

1

),

1144

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1145

1

};

1146

1

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

1147

1

			// know with which version to send

1148

1

			assert_noop!(

1149

1

				PolkadotXcm::transfer_assets(

1150

1

					origin_of(AccountId::from(ALICE)),

1151

1

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

1152

1

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

1153

1

						parents: 0,

1154

1

						interior: [AccountId32 {

1155

1

							network: None,

1156

1

							id: [1u8; 32],

1157

1

}]

1158

1

						.into(),

1159

1

					})),

1160

1

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

1161

1

0,

1162

1

					WeightLimit::Unlimited

1163

1

),

1164

1

				pallet_xcm::Error::<Runtime>::LocalExecutionIncomplete

1165

1

);

1166

1167

			// Root sets the defaultXcm

1168

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1169

1

				root_origin(),

1170

1

				Some(5)

1171

1

));

1172

1173

			// Now transferring does not fail

1174

1

			assert_ok!(PolkadotXcm::transfer_assets(

1175

1

				origin_of(AccountId::from(ALICE)),

1176

1

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

1177

1

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

1178

1

					parents: 0,

1179

1

					interior: [AccountId32 {

1180

1

						network: None,

1181

1

						id: [1u8; 32],

1182

1

}]

1183

1

					.into(),

1184

1

				})),

1185

1

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

1186

1

0,

1187

1

				WeightLimit::Unlimited

1188

1

));

1189

1

})

1190

1

1191

1192

#[test]

1193

1

fn asset_can_be_registered() {

1194

1

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

1195

1

		let source_location = Location::parent();

1196

1

		let source_id = 1;

1197

1

1198

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1199

1

			moonbeam_runtime::RuntimeOrigin::root(),

1200

1

			source_id,

1201

1

			source_location.clone(),

1202

1

12,

1203

1

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

1204

1

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

1205

1

));

1206

1207

		// Check that the asset was created

1208

		// First check if the asset ID exists

1209

1

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

1210

1

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

1211

1212

		// Then check the status using AssetsByLocation

1213

1

		let (asset_id, status) =

1214

1

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

1215

1

		assert_eq!(asset_id, source_id);

1216

1

		assert_eq!(status, AssetStatus::Active);

1217

1

});

1218

1

1219

1220

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

1221

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

1222

/*

1223

#[test]

1224

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1225

	ExtBuilder::default()

1226

		.with_xcm_assets(vec![XcmAssetInitialization {

1227

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

1228

			metadata: AssetRegistrarMetadata {

1229

				name: b"RelayToken".to_vec(),

1230

				symbol: b"Relay".to_vec(),

1231

				decimals: 12,

1232

				is_frozen: false,

1233

},

1234

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

1235

			is_sufficient: true,

1236

}])

1237

		.with_balances(vec![

1238

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

1239

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

1240

])

1241

		.build()

1242

		.execute_with(|| {

1243

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

1244

			let relay_asset_id: moonbeam_runtime::AssetId =

1245

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

1246

1247

			// Its address is

1248

			let asset_precompile_address = Runtime::asset_id_to_account(

1249

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1250

				relay_asset_id,

1251

);

1252

1253

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

1254

			assert_eq!(

1255

				moonbeam_runtime::Assets::total_supply(relay_asset_id),

1256

				1_000 * GLMR

1257

);

1258

1259

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

1260

			Precompiles::new()

1261

				.prepare_test(

1262

					ALICE,

1263

					asset_precompile_address,

1264

					ForeignAssetsPCall::total_supply {},

1265

1266

				.expect_cost(5007)

1267

				.expect_no_logs()

1268

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

1269

1270

			// Access balanceOf through precompile

1271

			Precompiles::new()

1272

				.prepare_test(

1273

					ALICE,

1274

					asset_precompile_address,

1275

					ForeignAssetsPCall::balance_of {

1276

						who: Address(ALICE.into()),

1277

},

1278

1279

				.expect_cost(5007)

1280

				.expect_no_logs()

1281

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

1282

});

1283

1284

1285

#[test]

1286

fn xcm_asset_erc20_precompiles_transfer() {

1287

	ExtBuilder::default()

1288

		.with_xcm_assets(vec![XcmAssetInitialization {

1289

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

1290

			metadata: AssetRegistrarMetadata {

1291

				name: b"RelayToken".to_vec(),

1292

				symbol: b"Relay".to_vec(),

1293

				decimals: 12,

1294

				is_frozen: false,

1295

},

1296

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

1297

			is_sufficient: true,

1298

}])

1299

		.with_balances(vec![

1300

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

1301

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

1302

])

1303

		.build()

1304

		.execute_with(|| {

1305

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

1306

			let relay_asset_id: moonbeam_runtime::AssetId =

1307

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

1308

1309

			// Its address is

1310

			let asset_precompile_address = Runtime::asset_id_to_account(

1311

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1312

				relay_asset_id,

1313

);

1314

1315

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

1316

			Precompiles::new()

1317

				.prepare_test(

1318

					ALICE,

1319

					asset_precompile_address,

1320

					ForeignAssetsPCall::transfer {

1321

						to: Address(BOB.into()),

1322

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

1323

},

1324

1325

				.expect_cost(26580)

1326

				.expect_log(log3(

1327

					asset_precompile_address,

1328

					SELECTOR_LOG_TRANSFER,

1329

					H160::from(ALICE),

1330

					H160::from(BOB),

1331

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

1332

))

1333

				.execute_returns(true);

1334

1335

			// Make sure BOB has 400 GLMR

1336

			Precompiles::new()

1337

				.prepare_test(

1338

					BOB,

1339

					asset_precompile_address,

1340

					ForeignAssetsPCall::balance_of {

1341

						who: Address(BOB.into()),

1342

},

1343

1344

				.expect_cost(5007)

1345

				.expect_no_logs()

1346

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

1347

});

1348

1349

1350

#[test]

1351

fn xcm_asset_erc20_precompiles_approve() {

1352

	ExtBuilder::default()

1353

		.with_xcm_assets(vec![XcmAssetInitialization {

1354

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

1355

			metadata: AssetRegistrarMetadata {

1356

				name: b"RelayToken".to_vec(),

1357

				symbol: b"Relay".to_vec(),

1358

				decimals: 12,

1359

				is_frozen: false,

1360

},

1361

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

1362

			is_sufficient: true,

1363

}])

1364

		.with_balances(vec![

1365

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

1366

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

1367

])

1368

		.build()

1369

		.execute_with(|| {

1370

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

1371

			let relay_asset_id: moonbeam_runtime::AssetId =

1372

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

1373

1374

			// Its address is

1375

			let asset_precompile_address = Runtime::asset_id_to_account(

1376

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1377

				relay_asset_id,

1378

);

1379

1380

			// Aprove Bob for spending 400 GLMR from Alice

1381

			Precompiles::new()

1382

				.prepare_test(

1383

					ALICE,

1384

					asset_precompile_address,

1385

					ForeignAssetsPCall::approve {

1386

						spender: Address(BOB.into()),

1387

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

1388

},

1389

1390

				.expect_cost(17323)

1391

				.expect_log(log3(

1392

					asset_precompile_address,

1393

					SELECTOR_LOG_APPROVAL,

1394

					H160::from(ALICE),

1395

					H160::from(BOB),

1396

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

1397

))

1398

				.execute_returns(true);

1399

1400

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

1401

			Precompiles::new()

1402

				.prepare_test(

1403

					BOB,

1404

					asset_precompile_address,

1405

					ForeignAssetsPCall::transfer_from {

1406

						from: Address(ALICE.into()),

1407

						to: Address(CHARLIE.into()),

1408

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

1409

},

1410

1411

				.expect_cost(31887)

1412

				.expect_log(log3(

1413

					asset_precompile_address,

1414

					SELECTOR_LOG_TRANSFER,

1415

					H160::from(ALICE),

1416

					H160::from(CHARLIE),

1417

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

1418

))

1419

				.execute_returns(true);

1420

1421

			// Make sure CHARLIE has 400 GLMR

1422

			Precompiles::new()

1423

				.prepare_test(

1424

					CHARLIE,

1425

					asset_precompile_address,

1426

					ForeignAssetsPCall::balance_of {

1427

						who: Address(CHARLIE.into()),

1428

},

1429

1430

				.expect_cost(5007)

1431

				.expect_no_logs()

1432

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

1433

});

1434

}*/

1435

1436

#[test]

1437

1

fn make_sure_glmr_can_be_transferred_precompile() {

1438

1

	ExtBuilder::default()

1439

1

		.with_balances(vec![

1440

1

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

1441

1

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

1442

1

])

1443

1

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

1444

1

		.with_mappings(vec![(

1445

1

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

1446

1

			AccountId::from(ALICE),

1447

1

)])

1448

1

		.with_safe_xcm_version(3)

1449

1

		.build()

1450

1

		.execute_with(|| {

1451

1

			assert_ok!(PolkadotXcm::transfer_assets(

1452

1

				origin_of(AccountId::from(ALICE)),

1453

1

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

1454

1

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

1455

1

					parents: 0,

1456

1

					interior: [AccountId32 {

1457

1

						network: None,

1458

1

						id: [1u8; 32],

1459

1

}]

1460

1

					.into(),

1461

1

				})),

1462

1

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

1463

1

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

1464

1

					fun: Fungible(1000)

1465

1

				})),

1466

1

0,

1467

1

				WeightLimit::Limited(40000.into())

1468

1

));

1469

1

});

1470

1

1471

1472

#[test]

1473

1

fn make_sure_glmr_can_be_transferred() {

1474

1

	ExtBuilder::default()

1475

1

		.with_balances(vec![

1476

1

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

1477

1

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

1478

1

])

1479

1

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

1480

1

		.with_mappings(vec![(

1481

1

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

1482

1

			AccountId::from(ALICE),

1483

1

)])

1484

1

		.with_safe_xcm_version(3)

1485

1

		.build()

1486

1

		.execute_with(|| {

1487

1

			let dest = Location {

1488

1

				parents: 1,

1489

1

				interior: [AccountId32 {

1490

1

					network: None,

1491

1

					id: [1u8; 32],

1492

1

}]

1493

1

				.into(),

1494

1

};

1495

1

			assert_ok!(PolkadotXcm::transfer_assets(

1496

1

				origin_of(AccountId::from(ALICE)),

1497

1

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

1498

1

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

1499

1

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

1500

1

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

1501

1

					fun: Fungible(100)

1502

1

				})),

1503

1

0,

1504

1

				WeightLimit::Limited(40000.into())

1505

1

));

1506

1

});

1507

1

1508

1509

#[test]

1510

1

fn make_sure_polkadot_xcm_cannot_be_called() {

1511

1

	ExtBuilder::default()

1512

1

		.with_balances(vec![

1513

1

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

1514

1

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

1515

1

])

1516

1

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

1517

1

		.with_mappings(vec![(

1518

1

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

1519

1

			AccountId::from(ALICE),

1520

1

)])

1521

1

		.build()

1522

1

		.execute_with(|| {

1523

1

			let dest = Location {

1524

1

				parents: 1,

1525

1

				interior: [AccountId32 {

1526

1

					network: None,

1527

1

					id: [1u8; 32],

1528

1

}]

1529

1

				.into(),

1530

1

};

1531

1

			let assets: Assets = [Asset {

1532

1

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

1533

1

				fun: Fungible(1000),

1534

1

}]

1535

1

			.to_vec()

1536

1

			.into();

1537

1

			assert_noop!(

1538

1

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

1539

1

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

1540

1

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

1541

1

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

1542

1

					fee_asset_item: 0,

1543

1

})

1544

1

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

1545

1

					AccountId::from(ALICE)

1546

1

)),

1547

1

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

1548

1

);

1549

1

});

1550

1

1551

1552

#[test]

1553

1

fn transact_through_signed_precompile_works_v2() {

1554

1

	ExtBuilder::default()

1555

1

		.with_balances(vec![

1556

1

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

1557

1

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

1558

1

])

1559

1

		.with_safe_xcm_version(3)

1560

1

		.build()

1561

1

		.execute_with(|| {

1562

1

			// Destination

1563

1

			let dest = Location::parent();

1564

1

1565

1

			let fee_payer_asset = Location::parent();

1566

1

1567

1

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

1568

1

1569

1

			let total_weight = 1_000_000_000u64;

1570

1

1571

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1572

1

1573

1

			Precompiles::new()

1574

1

				.prepare_test(

1575

1

					ALICE,

1576

1

					xcm_transactor_v2_precompile_address,

1577

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1578

1

						dest,

1579

1

						fee_asset: fee_payer_asset,

1580

1

						weight: 4_000_000,

1581

1

						call: bytes.into(),

1582

1

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

1583

1

						overall_weight: total_weight,

1584

1

},

1585

1

1586

1

				.expect_cost(31045)

1587

1

				.expect_no_logs()

1588

1

				.execute_returns(());

1589

1

});

1590

1

1591

1592

#[test]

1593

1

fn transact_through_signed_cannot_send_to_local_chain() {

1594

1

	ExtBuilder::default()

1595

1

		.with_balances(vec![

1596

1

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

1597

1

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

1598

1

])

1599

1

		.with_safe_xcm_version(3)

1600

1

		.build()

1601

1

		.execute_with(|| {

1602

1

			// Destination

1603

1

			let dest = Location::here();

1604

1

1605

1

			let fee_payer_asset = Location::parent();

1606

1

1607

1

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

1608

1

1609

1

			let total_weight = 1_000_000_000u64;

1610

1

1611

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1612

1

1613

1

			Precompiles::new()

1614

1

				.prepare_test(

1615

1

					ALICE,

1616

1

					xcm_transactor_v2_precompile_address,

1617

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1618

1

						dest,

1619

1

						fee_asset: fee_payer_asset,

1620

1

						weight: 4_000_000,

1621

1

						call: bytes.into(),

1622

1

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

1623

1

						overall_weight: total_weight,

1624

1

},

1625

1

1626

1

				.execute_reverts(|output| {

1627

1

					from_utf8(&output)

1628

1

						.unwrap()

1629

1

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

1630

1

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

1631

1

});

1632

1

});

1633

1

1634

1635

#[test]

1636

1

fn transactor_cannot_use_more_than_max_weight() {

1637

1

	ExtBuilder::default()

1638

1

		.with_balances(vec![

1639

1

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

1640

1

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

1641

1

])

1642

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1643

1

			asset_id: 1,

1644

1

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

1645

1

			name: "RelayToken",

1646

1

			symbol: "Relay",

1647

1

			decimals: 12,

1648

1

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

1649

1

}])

1650

1

		.build()

1651

1

		.execute_with(|| {

1652

1

			let source_id: moonbeam_runtime::AssetId = 1;

1653

1

			assert_ok!(XcmTransactor::register(

1654

1

				root_origin(),

1655

1

				AccountId::from(ALICE),

1656

1

0,

1657

1

));

1658

1659

			// Root can set transact info

1660

1

			assert_ok!(XcmTransactor::set_transact_info(

1661

1

				root_origin(),

1662

1

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

1663

1

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

1664

1

				3000.into(),

1665

1

				20000.into(),

1666

1

				None

1667

1

));

1668

			// Root can set transact info

1669

1

			assert_ok!(XcmTransactor::set_fee_per_second(

1670

1

				root_origin(),

1671

1

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

1672

1

1,

1673

1

));

1674

1675

1

			assert_noop!(

1676

1

				XcmTransactor::transact_through_derivative(

1677

1

					origin_of(AccountId::from(ALICE)),

1678

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

1679

1

0,

1680

1

					CurrencyPayment {

1681

1

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

1682

1

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

1683

1

)),

1684

1

						fee_amount: None

1685

1

},

1686

1

					vec![],

1687

1

					// 20000 is the max

1688

1

					TransactWeights {

1689

1

						transact_required_weight_at_most: 17001.into(),

1690

1

						overall_weight: None

1691

1

},

1692

1

					false

1693

1

),

1694

1

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

1695

1

);

1696

1

			assert_noop!(

1697

1

				XcmTransactor::transact_through_derivative(

1698

1

					origin_of(AccountId::from(ALICE)),

1699

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

1700

1

0,

1701

1

					CurrencyPayment {

1702

1

						currency: Currency::AsCurrencyId(

1703

1

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

1704

1

),

1705

1

						fee_amount: None

1706

1

},

1707

1

					vec![],

1708

1

					// 20000 is the max

1709

1

					TransactWeights {

1710

1

						transact_required_weight_at_most: 17001.into(),

1711

1

						overall_weight: None

1712

1

},

1713

1

					false

1714

1

),

1715

1

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

1716

1

);

1717

1

})

1718

1

1719

1720

// TODO: Unify all "call_pallet_xcm_with_fee" prefixed tests after the asset hub migration

1721

#[test]

1722

1

fn call_pallet_xcm_with_fee() {

1723

1

	let asset_id = 1;

1724

1

1725

1

	ExtBuilder::default()

1726

1

		.with_balances(vec![

1727

1

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

1728

1

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

1729

1

])

1730

1

		.with_safe_xcm_version(3)

1731

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1732

1

			asset_id,

1733

1

			xcm_location: Location::parent(),

1734

1

			name: "RelayToken",

1735

1

			symbol: "Relay",

1736

1

			decimals: 12,

1737

1

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

1738

1

}])

1739

1

		.build()

1740

1

		.execute_with(|| {

1741

1

			let dest = Location {

1742

1

				parents: 1,

1743

1

				interior: [AccountId32 {

1744

1

					network: None,

1745

1

					id: [1u8; 32],

1746

1

}]

1747

1

				.into(),

1748

1

};

1749

1

1750

1

			let before_balance =

1751

1

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

1752

1

			let (chain_part, beneficiary) =

1753

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1754

1

			let asset_amount = 100_000_000_000_000u128;

1755

1

			let asset_fee_amount = 100u128;

1756

1

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

1757

1

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

1758

1

			// We are able to transfer with fee

1759

1

			assert_ok!(PolkadotXcm::transfer_assets(

1760

1

				origin_of(AccountId::from(ALICE)),

1761

1

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

1762

1

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

1763

1

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

1764

1

0,

1765

1

				WeightLimit::Limited(4000000000.into())

1766

1

));

1767

1768

1

			let after_balance =

1769

1

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

1770

1

			// At least these much (plus fees) should have been charged

1771

1

			assert_eq!(

1772

1

				before_balance

1773

1

					.saturating_sub(asset_amount.into())

1774

1

					.saturating_sub(asset_fee_amount.into()),

1775

1

				after_balance

1776

1

);

1777

1

});

1778

1

1779

1780

// TODO: Unify all "call_pallet_xcm_with_fee" prefixed tests after the asset hub migration

1781

#[test]

1782

1

fn call_pallet_xcm_with_fee_after_ahm() {

1783

1

	let asset_id = 1;

1784

1

	ExtBuilder::default()

1785

1

		.asset_hub_migration_has_started()

1786

1

		.with_balances(vec![

1787

1

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

1788

1

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

1789

1

])

1790

1

		.with_safe_xcm_version(3)

1791

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1792

1

			asset_id,

1793

1

			xcm_location: Location::parent(),

1794

1

			name: "RelayToken",

1795

1

			symbol: "Relay",

1796

1

			decimals: 12,

1797

1

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

1798

1

}])

1799

1

		.build()

1800

1

		.execute_with(|| {

1801

1

			let dest = Location {

1802

1

				parents: 1,

1803

1

				interior: [AccountId32 {

1804

1

					network: None,

1805

1

					id: [1u8; 32],

1806

1

}]

1807

1

				.into(),

1808

1

};

1809

1

1810

1

			let before_balance =

1811

1

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

1812

1

			let (chain_part, beneficiary) =

1813

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1814

1

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

1815

1

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

1816

1

1817

1

			// Once the AH migration starts, we should no longer be able to use the parent location as reserve.

1818

1

			assert_noop!(

1819

1

				PolkadotXcm::transfer_assets(

1820

1

					origin_of(AccountId::from(ALICE)),

1821

1

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

1822

1

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

1823

1

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

1824

1

0,

1825

1

					WeightLimit::Limited(4000000000.into())

1826

1

),

1827

1

				pallet_xcm::Error::<Runtime>::InvalidAssetUnknownReserve

1828

1

);

1829

1830

1

			let after_balance =

1831

1

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

1832

1

			// At least these much (plus fees) should have been charged

1833

1

			assert_eq!(before_balance, after_balance);

1834

1

});

1835

1

1836

1837

// TODO: Unify all "call_pallet_xcm_with_fee" prefixed tests after the asset hub migration

1838

#[test]

1839

1

fn call_pallet_xcm_with_fee_before_ahm() {

1840

1

	let asset_id = 1;

1841

1

	ExtBuilder::default()

1842

1

		.with_balances(vec![

1843

1

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

1844

1

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

1845

1

])

1846

1

		.with_safe_xcm_version(3)

1847

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1848

1

			asset_id,

1849

1

			xcm_location: Location::parent(),

1850

1

			name: "RelayToken",

1851

1

			symbol: "Relay",

1852

1

			decimals: 12,

1853

1

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

1854

1

}])

1855

1

		.build()

1856

1

		.execute_with(|| {

1857

1

			let dest = Location {

1858

1

				parents: 1,

1859

1

				interior: [AccountId32 {

1860

1

					network: None,

1861

1

					id: [1u8; 32],

1862

1

}]

1863

1

				.into(),

1864

1

};

1865

1

			let before_balance =

1866

1

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

1867

1

			let (chain_part, beneficiary) =

1868

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1869

1

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

1870

1

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

1871

1

			// We are able to transfer with fee

1872

1

			assert_ok!(PolkadotXcm::transfer_assets(

1873

1

				origin_of(AccountId::from(ALICE)),

1874

1

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

1875

1

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

1876

1

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

1877

1

0,

1878

1

				WeightLimit::Limited(4000000000.into())

1879

1

));

1880

1881

1

			let after_balance =

1882

1

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

1883

1

			// At least these much (plus fees) should have been charged

1884

1

			assert_eq!(

1885

1

				before_balance - 100_000_000_000_000u128 - 100u128,

1886

1

				after_balance

1887

1

);

1888

1

});

1889

1

1890

1891

#[test]

1892

1

fn test_xcm_utils_ml_tp_account() {

1893

1

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

1894

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1895

1

		let expected_address_parent: H160 =

1896

1

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

1897

1

				.unwrap()

1898

1

				.into();

1899

1

1900

1

		Precompiles::new()

1901

1

			.prepare_test(

1902

1

				ALICE,

1903

1

				xcm_utils_precompile_address,

1904

1

				XcmUtilsPCall::multilocation_to_address {

1905

1

					location: Location::parent(),

1906

1

},

1907

1

1908

1

			.expect_cost(

1909

1

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

1910

1

					.read

1911

1

					.saturating_div(WEIGHT_PER_GAS)

1912

1

					.saturating_mul(2),

1913

1

1914

1

			.expect_no_logs()

1915

1

			.execute_returns(Address(expected_address_parent));

1916

1

1917

1

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

1918

1

		let expected_address_parachain: H160 =

1919

1

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

1920

1

				&parachain_2000_location,

1921

1

1922

1

			.unwrap()

1923

1

			.into();

1924

1

1925

1

		Precompiles::new()

1926

1

			.prepare_test(

1927

1

				ALICE,

1928

1

				xcm_utils_precompile_address,

1929

1

				XcmUtilsPCall::multilocation_to_address {

1930

1

					location: parachain_2000_location,

1931

1

},

1932

1

1933

1

			.expect_cost(

1934

1

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

1935

1

					.read

1936

1

					.saturating_div(WEIGHT_PER_GAS)

1937

1

					.saturating_mul(2),

1938

1

1939

1

			.expect_no_logs()

1940

1

			.execute_returns(Address(expected_address_parachain));

1941

1

1942

1

		let alice_in_parachain_2000_location = Location::new(

1943

1

1,

1944

1

1945

1

				Parachain(2000),

1946

1

				AccountKey20 {

1947

1

					network: None,

1948

1

					key: ALICE,

1949

1

},

1950

1

],

1951

1

);

1952

1

		let expected_address_alice_in_parachain_2000 =

1953

1

			xcm_builder::HashedDescription::<

1954

1

				AccountId,

1955

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

1956

1

			>::convert_location(&alice_in_parachain_2000_location)

1957

1

			.unwrap()

1958

1

			.into();

1959

1

1960

1

		Precompiles::new()

1961

1

			.prepare_test(

1962

1

				ALICE,

1963

1

				xcm_utils_precompile_address,

1964

1

				XcmUtilsPCall::multilocation_to_address {

1965

1

					location: alice_in_parachain_2000_location,

1966

1

},

1967

1

1968

1

			.expect_cost(

1969

1

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

1970

1

					.read

1971

1

					.saturating_div(WEIGHT_PER_GAS)

1972

1

					.saturating_mul(2),

1973

1

1974

1

			.expect_no_logs()

1975

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

1976

1

});

1977

1

1978

1979

#[test]

1980

1

fn test_xcm_utils_weight_message() {

1981

1

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

1982

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1983

1

		let expected_weight =

1984

1

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

1985

1

1986

1

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

1987

1

1988

1

		let input = XcmUtilsPCall::weight_message {

1989

1

			message: message.into(),

1990

1

};

1991

1

1992

1

		Precompiles::new()

1993

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1994

1

			.expect_cost(

1995

1

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

1996

1

					.read

1997

1

					.saturating_div(WEIGHT_PER_GAS),

1998

1

1999

1

			.expect_no_logs()

2000

1

			.execute_returns(expected_weight);

2001

1

});

2002

1

2003

2004

#[test]

2005

1

fn test_nested_batch_calls_from_xcm_transact() {

2006

1

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

2007

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2008

1

		// in a future polkadot-sdk version

2009

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2010

2011

1

		let mut valid_nested_calls =

2012

1

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

2013

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2014

8

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

2015

8

				calls: vec![valid_nested_calls],

2016

8

});

2017

8

2018

2019

1

		let valid_message = Xcm(vec![Transact {

2020

1

			origin_kind: OriginKind::SovereignAccount,

2021

1

			fallback_max_weight: None,

2022

1

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

2023

1

		}]);

2024

1

2025

1

		assert!(XcmExecutor::prepare(valid_message).is_ok());

2026

2027

1

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

2028

1

			calls: vec![valid_nested_calls],

2029

1

});

2030

1

2031

1

		let invalid_message = Xcm(vec![Transact {

2032

1

			origin_kind: OriginKind::SovereignAccount,

2033

1

			fallback_max_weight: None,

2034

1

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

2035

1

		}]);

2036

1

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

2037

1

		assert!(XcmExecutor::prepare(invalid_message).is_err());

2038

1

});

2039

1

2040

2041

#[test]

2042

1

fn test_xcm_utils_get_units_per_second() {

2043

1

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

2044

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2045

1

		let location = SelfReserve::get();

2046

1

2047

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2048

1

2049

1

		let expected_units =

2050

1

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

2051

1

2052

1

		Precompiles::new()

2053

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2054

1

			.expect_cost(

2055

1

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

2056

1

					.read

2057

1

					.saturating_div(WEIGHT_PER_GAS)

2058

1

					.saturating_mul(2),

2059

1

2060

1

			.expect_no_logs()

2061

1

			.execute_returns(expected_units);

2062

1

});

2063

1

2064

2065

#[test]

2066

1

fn precompile_existence() {

2067

1

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

2068

1

		let precompiles = Precompiles::new();

2069

1

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

2070

1

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

2071

1

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

2072

1

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

2073

1

2074

1

		.into_iter()

2075

1

		.map(H160::from_low_u64_be)

2076

1

		.collect();

2077

2078

3001

		for i in 0..3000 {

2079

3000

			let address = H160::from_low_u64_be(i);

2080

3000

2081

3000

			if precompile_addresses.contains(&address) {

2082

48

				assert!(

2083

48

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

2084

					"is_precompile({}) should return true",

2085

2086

);

2087

2088

48

				assert!(

2089

48

					precompiles

2090

48

						.execute(&mut MockHandle::new(

2091

48

							address,

2092

48

							Context {

2093

48

								address,

2094

48

								caller: H160::zero(),

2095

48

								apparent_value: U256::zero()

2096

48

2097

48

),)

2098

48

						.is_some(),

2099

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

2100

2101

);

2102

			} else {

2103

2952

				assert!(

2104

2952

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

2105

					"is_precompile({}) should return false",

2106

2107

);

2108

2109

2952

				assert!(

2110

2952

					precompiles

2111

2952

						.execute(&mut MockHandle::new(

2112

2952

							address,

2113

2952

							Context {

2114

2952

								address,

2115

2952

								caller: H160::zero(),

2116

2952

								apparent_value: U256::zero()

2117

2952

2118

2952

),)

2119

2952

						.is_none(),

2120

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

2121

2122

);

2123

2124

2125

1

});

2126

1

2127

2128

#[test]

2129

1

fn removed_precompiles() {

2130

1

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

2131

1

		let precompiles = Precompiles::new();

2132

1

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

2133

2134

3000

		for i in 1..3000 {

2135

2999

			let address = H160::from_low_u64_be(i);

2136

2999

2137

2999

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

2138

2951

				continue;

2139

48

2140

48

2141

48

			if !removed_precompiles.contains(&i) {

2142

44

				assert!(

2143

44

					match precompiles.is_active_precompile(address, 100_000u64) {

2144

44

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

2145

						_ => false,

2146

},

2147

					"{i} should be an active precompile"

2148

);

2149

44

				continue;

2150

4

2151

4

2152

4

			assert!(

2153

4

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

2154

4

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

2155

					_ => false,

2156

},

2157

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

2158

);

2159

2160

4

			precompiles

2161

4

				.prepare_test(Alice, address, [])

2162

4

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

2163

4

2164

1

})

2165

1

2166

2167

#[test]

2168

1

fn deal_with_fees_handles_tip() {

2169

	use frame_support::traits::OnUnbalanced;

2170

	use moonbeam_runtime::Treasury;

2171

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2172

2173

1

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

2174

1

		set_parachain_inherent_data();

2175

1

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

2176

1

		// in the Moonbeam runtime. It verifies that:

2177

1

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

2178

1

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

2179

1

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

2180

1

2181

1

		// The test details:

2182

1

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

2183

1

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

2184

1

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

2185

1

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

2186

1

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

2187

1

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

2188

1

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

2189

1

2190

1

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

2191

1

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

2192

1

			AccountId,

2193

1

		>>::issue(100);

2194

1

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

2195

1

			AccountId,

2196

1

		>>::issue(1000);

2197

1

2198

1

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

2199

1

		let total_supply_before = Balances::total_issuance();

2200

1

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

2201

1

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

2202

1

		assert_eq!(total_supply_before, 1_100);

2203

1

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

2204

2205

		// Step 3: Execute the fees handling logic.

2206

1

		DealWithSubstrateFeesAndTip::<

2207

1

			Runtime,

2208

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2209

1

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

2210

1

2211

1

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

2212

1

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

2213

1

2214

1

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

2215

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2216

1

2217

1

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

2218

1

		assert_eq!(

2219

1

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

2220

1

			treasury_fee_part,

2221

1

);

2222

2223

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

2224

1

		let total_supply_after = Balances::total_issuance();

2225

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2226

2227

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

2228

1

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

2229

1

		assert_eq!(

2230

1

			block_author_balance_after - block_author_balance_before,

2231

1

			1000,

2232

1

);

2233

1

});

2234

1

2235

2236

#[test]

2237

1

fn evm_revert_substrate_events() {

2238

1

	ExtBuilder::default()

2239

1

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

2240

1

		.build()

2241

1

		.execute_with(|| {

2242

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2243

1

2244

1

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

2245

1

			// Thus BatchAll will revert the transfer.

2246

1

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

2247

1

				source: ALICE.into(),

2248

1

				target: batch_precompile_address,

2249

1

2250

1

				input: BatchPCall::batch_all {

2251

1

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

2252

1

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

2253

1

					call_data: vec![].into(),

2254

1

					gas_limit: vec![].into()

2255

1

2256

1

				.into(),

2257

1

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

2258

1

				gas_limit: 500_000,

2259

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2260

1

				max_priority_fee_per_gas: None,

2261

1

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

2262

1

				access_list: Vec::new(),

2263

1

				authorization_list: Vec::new(),

2264

1

})

2265

1

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

2266

2267

1

			let transfer_count = System::events()

2268

1

				.iter()

2269

4

				.filter(|r| match r.event {

2270

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

2271

6

					_ => false,

2272

6

})

2273

1

				.count();

2274

1

2275

1

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

2276

1

});

2277

1

2278

2279

#[test]

2280

1

fn evm_success_keeps_substrate_events() {

2281

1

	ExtBuilder::default()

2282

1

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

2283

1

		.build()

2284

1

		.execute_with(|| {

2285

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2286

1

2287

1

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

2288

1

				source: ALICE.into(),

2289

1

				target: batch_precompile_address,

2290

1

				input: BatchPCall::batch_all {

2291

1

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

2292

1

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

2293

1

					call_data: vec![].into(),

2294

1

					gas_limit: vec![].into()

2295

1

2296

1

				.into(),

2297

1

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

2298

1

				gas_limit: 500_000,

2299

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2300

1

				max_priority_fee_per_gas: None,

2301

1

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

2302

1

				access_list: Vec::new(),

2303

1

				authorization_list: Vec::new(),

2304

1

})

2305

1

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

2306

2307

1

			let transfer_count = System::events()

2308

1

				.iter()

2309

6

				.filter(|r| match r.event {

2310

1

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

2311

9

					_ => false,

2312

10

})

2313

1

				.count();

2314

1

2315

1

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

2316

1

});

2317

1

2318

2319

#[cfg(test)]

2320

mod bridge_tests {

2321

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

2322

	use crate::currency_to_asset;

2323

	use bp_messages::target_chain::DispatchMessageData;

2324

	use bp_messages::ReceptionResult;

2325

	use bp_runtime::messages::MessageDispatchResult;

2326

	use cumulus_primitives_core::AggregateMessageOrigin;

2327

	use frame_support::assert_ok;

2328

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

2329

	use moonbeam_core_primitives::AccountId;

2330

	use moonbeam_runtime::bridge_config::{

2331

		KusamaGlobalConsensusNetwork, WithKusamaMessagesInstance,

2332

};

2333

	use moonbeam_runtime::currency::GLMR;

2334

	use moonbeam_runtime::xcm_config::CurrencyId;

2335

	use moonbeam_runtime::{

2336

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

2337

		RuntimeEvent, System,

2338

};

2339

	use pallet_bridge_messages::{LanesManager, StoredMessagePayload};

2340

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

2341

	use parity_scale_codec::{Decode, Encode};

2342

	use sp_core::H256;

2343

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

2344

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

2345

	use xcm::prelude::{

2346

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

2347

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

2348

		SetTopic, UniversalOrigin, XCM_VERSION,

2349

};

2350

	use xcm::v5::WildAsset;

2351

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

2352

	use xcm_builder::BridgeMessage;

2353

2354

1

	fn next_block() {

2355

1

		System::reset_events();

2356

1

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

2357

1

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

2358

1

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

2359

1

2360

2361

	#[test]

2362

1

	fn transfer_asset_moonbeam_to_moonriver() {

2363

1

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

2364

1

2365

1

		ExtBuilder::default()

2366

1

			.with_balances(vec![

2367

1

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

2368

1

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

2369

1

])

2370

1

			.with_safe_xcm_version(XCM_VERSION)

2371

1

			.with_open_bridges(vec![(

2372

1

				Location::new(

2373

1

1,

2374

1

					[Parachain(

2375

1

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

2376

1

)],

2377

1

),

2378

1

				Junctions::from([

2379

1

					NetworkId::Kusama.into(),

2380

1

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

2381

1

]),

2382

1

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

2383

1

)])

2384

1

			.build()

2385

1

			.execute_with(|| {

2386

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2387

1

					root_origin(),

2388

1

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

2389

1

					XCM_VERSION

2390

1

));

2391

2392

1

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

2393

1

2394

1

				let message_data = BridgeKusamaMessages::outbound_message_data(

2395

1

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

2396

1

					1u64,

2397

1

);

2398

1

				assert!(message_data.is_none());

2399

2400

1

				assert_ok!(PolkadotXcm::transfer_assets(

2401

1

					origin_of(AccountId::from(ALICE)),

2402

1

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

2403

1

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

2404

1

						parents: 0,

2405

1

						interior: [AccountKey20 {

2406

1

							network: None,

2407

1

							key: ALICE,

2408

1

}]

2409

1

						.into(),

2410

1

					})),

2411

1

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

2412

1

0,

2413

1

					WeightLimit::Unlimited

2414

1

));

2415

2416

1

				let message_data = BridgeKusamaMessages::outbound_message_data(

2417

1

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

2418

1

					1u64,

2419

1

				).unwrap();

2420

1

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

2421

1

2422

1

				let BridgeMessage { universal_dest, message } =

2423

1

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

2424

1

2425

1

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

2426

1

				assert_eq!(universal_dest, expected_universal_dest);

2427

2428

1

				assert_eq!(

2429

1

					message,

2430

1

					VersionedXcm::V5(

2431

1

						Xcm(

2432

1

2433

1

								UniversalOrigin(GlobalConsensus(NetworkId::Polkadot)),

2434

1

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

2435

1

								ReserveAssetDeposited(

2436

1

									vec![

2437

1

										Asset {

2438

1

											id: AssetId(

2439

1

												Location::new(

2440

1

2,

2441

1

2442

1

														GlobalConsensus(NetworkId::Polkadot),

2443

1

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

2444

1

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

2445

1

2446

1

2447

1

),

2448

1

											fun: Fungible(100_000_000_000_000_000_000)

2449

1

2450

1

									].into()

2451

1

),

2452

1

								ClearOrigin,

2453

1

								BuyExecution {

2454

1

									fees: Asset {

2455

1

										id: AssetId(

2456

1

											Location::new(

2457

1

2,

2458

1

2459

1

													GlobalConsensus(NetworkId::Polkadot),

2460

1

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

2461

1

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

2462

1

2463

1

2464

1

),

2465

1

										fun: Fungible(100_000_000_000_000_000_000)

2466

1

},

2467

1

									weight_limit: WeightLimit::Unlimited

2468

1

},

2469

1

								DepositAsset {

2470

1

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

2471

1

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

2472

1

},

2473

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])

2474

1

							].into()

2475

1

2476

1

2477

1

);

2478

1

})

2479

1

2480

2481

	#[test]

2482

1

	fn receive_message_from_moonriver() {

2483

1

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

2484

1

2485

1

		ExtBuilder::default()

2486

1

			.with_balances(vec![

2487

1

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

2488

1

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

2489

1

])

2490

1

			.with_xcm_assets(vec![XcmAssetInitialization {

2491

1

				asset_id: 1,

2492

1

				xcm_location: Location::new(

2493

1

2,

2494

1

2495

1

						GlobalConsensus(KusamaGlobalConsensusNetwork::get()),

2496

1

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

2497

1

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

2498

1

2499

1

),

2500

1

				name: "xcMOVR",

2501

1

				symbol: "xcMOVR",

2502

1

				decimals: 18,

2503

1

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

2504

1

}])

2505

1

			.with_safe_xcm_version(XCM_VERSION)

2506

1

			.with_open_bridges(vec![(

2507

1

				Location::new(

2508

1

1,

2509

1

					[Parachain(

2510

1

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

2511

1

)],

2512

1

),

2513

1

				Junctions::from([

2514

1

					NetworkId::Kusama.into(),

2515

1

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

2516

1

]),

2517

1

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

2518

1

)])

2519

1

			.build()

2520

1

			.execute_with(|| {

2521

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2522

1

					root_origin(),

2523

1

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

2524

1

					XCM_VERSION

2525

1

));

2526

2527

1

				let bridge_message: BridgeMessage = BridgeMessage {

2528

1

					universal_dest: VersionedInteriorLocation::V5(

2529

1

2530

1

							GlobalConsensus(NetworkId::Polkadot),

2531

1

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

2532

1

						].into()

2533

1

),

2534

1

					message: VersionedXcm::V5(

2535

1

						Xcm(

2536

1

2537

1

								UniversalOrigin(GlobalConsensus(NetworkId::Kusama)),

2538

1

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

2539

1

								ReserveAssetDeposited(

2540

1

									vec![

2541

1

										Asset {

2542

1

											id: AssetId(

2543

1

												Location::new(

2544

1

2,

2545

1

2546

1

														GlobalConsensus(NetworkId::Kusama),

2547

1

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

2548

1

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

2549

1

2550

1

2551

1

),

2552

1

											fun: Fungible(10_000_000_000_000_000_000_000_000_000_000_000)

2553

1

2554

1

									].into()

2555

1

),

2556

1

								ClearOrigin,

2557

1

								BuyExecution {

2558

1

									fees: Asset {

2559

1

										id: AssetId(

2560

1

											Location::new(

2561

1

2,

2562

1

2563

1

													GlobalConsensus(NetworkId::Kusama),

2564

1

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

2565

1

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

2566

1

2567

1

2568

1

),

2569

1

										fun: Fungible(6_000_000_000_000_000_000_000_000_000_000_000)

2570

1

},

2571

1

									weight_limit: WeightLimit::Unlimited

2572

1

},

2573

1

								DepositAsset {

2574

1

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

2575

1

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

2576

1

},

2577

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])

2578

1

							].into()

2579

1

2580

1

2581

1

};

2582

1

2583

1

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

2584

1

					.active_inbound_lane(Default::default())

2585

1

					.unwrap();

2586

1

2587

1

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

2588

1

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

2589

1

1,

2590

1

					msg,

2591

1

);

2592

1

2593

1

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

2594

2595

				// Produce next block

2596

1

				next_block();

2597

1

				// Confirm that the xcm message was successfully processed

2598

7

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

2599

1

					matches!(

2600

1

						evt.event,

2601

						RuntimeEvent::MessageQueue(

2602

							pallet_message_queue::Event::Processed {

2603

								origin: AggregateMessageOrigin::Here,

2604

								success: true,

2605

..

2606

2607

2608

2609

7

				}));

2610

1

});

2611

1

2612

2613

2614

#[cfg(test)]

2615

mod treasury_tests {

2616

	use super::*;

2617

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

2618

	use moonbeam_runtime::XcmWeightTrader;

2619

	use sp_core::bounded_vec;

2620

	use sp_runtime::traits::Hash;

2621

2622

4

	fn expect_events(events: Vec<RuntimeEvent>) {

2623

4

		let block_events: Vec<RuntimeEvent> =

2624

29

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

2625

4

2626

7

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

2627

4

2628

2629

7

	fn next_block() {

2630

7

		System::reset_events();

2631

7

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

2632

7

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

2633

7

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

2634

7

2635

2636

3

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

2637

3

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

2638

3

			.expect("failed to get account balance")

2639

3

2640

2641

	#[test]

2642

1

	fn test_treasury_spend_local_with_council_origin() {

2643

1

		let initial_treasury_balance = 1_000 * GLMR;

2644

1

		ExtBuilder::default()

2645

1

			.with_balances(vec![

2646

1

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

2647

1

				(Treasury::account_id(), initial_treasury_balance),

2648

1

])

2649

1

			.build()

2650

1

			.execute_with(|| {

2651

1

				let spend_amount = 100u128 * GLMR;

2652

1

				let spend_beneficiary = AccountId::from(BOB);

2653

1

2654

1

				next_block();

2655

1

2656

1

				// TreasuryCouncilCollective

2657

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2658

1

					root_origin(),

2659

1

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

2660

1

					Some(AccountId::from(ALICE)),

2661

1

2662

1

));

2663

2664

1

				next_block();

2665

1

2666

1

				// Perform treasury spending

2667

1

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

2668

1

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

2669

1

					amount: spend_amount,

2670

1

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

2671

1

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

2672

1

					valid_from: Some(valid_from),

2673

1

});

2674

1

				assert_ok!(TreasuryCouncilCollective::propose(

2675

1

					origin_of(AccountId::from(ALICE)),

2676

1

1,

2677

1

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

2678

1

					1_000

2679

1

));

2680

2681

1

				let payout_period =

2682

1

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

2683

1

				let expected_events = [

2684

1

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

2685

1

						index: 0,

2686

1

						asset_kind: NativeOrWithId::Native,

2687

1

						amount: spend_amount,

2688

1

						beneficiary: spend_beneficiary,

2689

1

						valid_from,

2690

1

						expire_at: payout_period + valid_from,

2691

1

}),

2692

1

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

2693

1

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

2694

1

						result: Ok(()),

2695

1

}),

2696

1

2697

1

				.to_vec();

2698

1

				expect_events(expected_events);

2699

2700

6

				while System::block_number() < valid_from {

2701

5

					next_block();

2702

5

2703

2704

1

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

2705

2706

1

				let expected_events = [

2707

1

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

2708

1

						index: 0,

2709

1

						payment_id: (),

2710

1

}),

2711

1

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

2712

1

						from: Treasury::account_id(),

2713

1

						to: spend_beneficiary,

2714

1

						amount: spend_amount,

2715

1

}),

2716

1

2717

1

				.to_vec();

2718

1

				expect_events(expected_events);

2719

1

});

2720

1

2721

2722

	#[test]

2723

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2724

1

		let initial_treasury_balance = 1_000 * GLMR;

2725

1

		let asset_id = 1000100010001000u128;

2726

1

		ExtBuilder::default()

2727

1

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

2728

1

			.build()

2729

1

			.execute_with(|| {

2730

1

				let spend_amount = 100u128 * GLMR;

2731

1

				let spend_beneficiary = AccountId::from(BOB);

2732

1

2733

1

				let asset_location: Location = Location {

2734

1

					parents: 1,

2735

1

					interior: Junctions::Here,

2736

1

};

2737

1

2738

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2739

1

					root_origin(),

2740

1

					asset_id,

2741

1

					asset_location.clone(),

2742

1

12,

2743

1

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

2744

1

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

2745

1

));

2746

2747

1

				assert_ok!(XcmWeightTrader::add_asset(

2748

1

					root_origin(),

2749

1

					asset_location,

2750

1

					1u128

2751

1

));

2752

2753

1

				assert_ok!(EvmForeignAssets::mint_into(

2754

1

					asset_id,

2755

1

					Treasury::account_id(),

2756

1

					initial_treasury_balance.into()

2757

1

));

2758

2759

1

				assert_eq!(

2760

1

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

2761

1

					initial_treasury_balance.into(),

2762

					"Treasury balance not updated"

2763

);

2764

2765

				// TreasuryCouncilCollective

2766

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2767

1

					root_origin(),

2768

1

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

2769

1

					Some(AccountId::from(ALICE)),

2770

1

2771

1

));

2772

2773

				// Perform treasury spending

2774

1

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

2775

1

					amount: spend_amount,

2776

1

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

2777

1

					beneficiary: Box::new(spend_beneficiary),

2778

1

					valid_from: None,

2779

1

});

2780

1

				assert_ok!(TreasuryCouncilCollective::propose(

2781

1

					origin_of(AccountId::from(ALICE)),

2782

1

1,

2783

1

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

2784

1

					1_000

2785

1

));

2786

2787

1

				let payout_period =

2788

1

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

2789

1

2790

1

				let current_block = System::block_number();

2791

1

				let expected_events = [

2792

1

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

2793

1

						index: 0,

2794

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2795

1

						amount: spend_amount,

2796

1

						beneficiary: spend_beneficiary,

2797

1

						valid_from: current_block,

2798

1

						expire_at: current_block + payout_period,

2799

1

}),

2800

1

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

2801

1

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

2802

1

						result: Ok(()),

2803

1

}),

2804

1

2805

1

				.to_vec();

2806

1

				expect_events(expected_events);

2807

1

2808

1

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

2809

2810

1

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

2811

1

					index: 0,

2812

1

					payment_id: (),

2813

1

				})]);

2814

1

2815

1

				assert_eq!(

2816

1

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

2817

1

					(initial_treasury_balance - spend_amount).into(),

2818

					"Treasury balance not updated"

2819

);

2820

2821

1

				assert_eq!(

2822

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2823

1

					spend_amount.into(),

2824

					"Treasury payout failed"

2825

);

2826

1

});

2827

1

2828

2829

2830

#[cfg(test)]

2831

mod fee_tests {

2832

	use super::*;

2833

	use fp_evm::FeeCalculator;

2834

	use frame_support::{

2835

		traits::{ConstU128, OnFinalize},

2836

		weights::{ConstantMultiplier, WeightToFee},

2837

};

2838

	use moonbeam_runtime::{

2839

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2840

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2841

};

2842

	use sp_core::Get;

2843

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

2844

2845

1

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

2846

1

	where

2847

1

		F: FnMut() -> (),

2848

1

2849

1

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

2850

1

			.build_storage()

2851

1

			.unwrap()

2852

1

			.into();

2853

1

		t.execute_with(|| {

2854

1

			System::set_block_consumed_resources(w, 0);

2855

1

			assertions()

2856

1

});

2857

1

2858

2859

	#[test]

2860

1

	fn test_multiplier_can_grow_from_zero() {

2861

1

		let minimum_multiplier = MinimumMultiplier::get();

2862

1

		let target = TargetBlockFullness::get()

2863

1

			* RuntimeBlockWeights::get()

2864

1

				.get(DispatchClass::Normal)

2865

1

				.max_total

2866

1

				.unwrap();

2867

1

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

2868

1

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

2869

1

		run_with_system_weight(target * 101 / 100, || {

2870

1

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

2871

1

			assert!(

2872

1

				next > minimum_multiplier,

2873

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

2874

				next,

2875

				minimum_multiplier

2876

);

2877

1

})

2878

1

2879

2880

	#[test]

2881

1

	fn test_fee_calculation() {

2882

1

		let base_extrinsic = RuntimeBlockWeights::get()

2883

1

			.get(DispatchClass::Normal)

2884

1

			.base_extrinsic;

2885

1

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

2886

1

		let extrinsic_len = 100u32;

2887

1

		let extrinsic_weight = 5_000u64;

2888

1

		let tip = 42u128;

2889

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

2890

		type LengthToFeeImpl = LengthToFee;

2891

2892

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

2893

1

		let expected_fee =

2894

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

2895

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

2896

1

					&Weight::from_parts(extrinsic_weight, 1),

2897

1

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

2898

1

				+ tip;

2899

1

2900

1

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

2901

1

			.build_storage()

2902

1

			.unwrap()

2903

1

			.into();

2904

1

		t.execute_with(|| {

2905

1

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

2906

1

			let actual_fee = TransactionPayment::compute_fee(

2907

1

				extrinsic_len,

2908

1

				&frame_support::dispatch::DispatchInfo {

2909

1

					class: DispatchClass::Normal,

2910

1

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

2911

1

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

2912

1

					extension_weight: Weight::zero(),

2913

1

},

2914

1

				tip,

2915

1

);

2916

1

2917

1

			assert_eq!(

2918

				expected_fee,

2919

				actual_fee,

2920

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

2921

				actual_fee - expected_fee

2922

);

2923

1

});

2924

1

2925

2926

	#[test]

2927

1

	fn test_min_gas_price_is_deterministic() {

2928

1

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

2929

1

			.build_storage()

2930

1

			.unwrap()

2931

1

			.into();

2932

1

		t.execute_with(|| {

2933

1

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

2934

1

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

2935

1

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

2936

1

			let expected: U256 = multiplier

2937

1

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

2938

1

				.into();

2939

1

2940

1

			assert_eq!(expected, actual);

2941

1

});

2942

1

2943

2944

	#[test]

2945

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

2946

1

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

2947

1

			.build_storage()

2948

1

			.unwrap()

2949

1

			.into();

2950

1

		t.execute_with(|| {

2951

1

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

2952

1

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

2953

1

2954

1

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

2955

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

2956

1

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

2957

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

2958

1

2959

1

			assert_ne!(

2960

				a, b,

2961

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

2962

);

2963

1

});

2964

1

2965

2966

	#[test]

2967

1

	fn test_fee_scenarios() {

2968

		use sp_runtime::FixedU128;

2969

1

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

2970

1

			.build_storage()

2971

1

			.unwrap()

2972

1

			.into();

2973

1

		t.execute_with(|| {

2974

1

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

2975

12

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

2976

12

				let start_multiplier =

2977

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

2978

12

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

2979

12

2980

12

				let block_weight = NORMAL_WEIGHT * fullness;

2981

2982

60004

				for i in 0..num_blocks {

2983

60004

					System::set_block_number(i as u32);

2984

60004

					System::set_block_consumed_resources(block_weight, 0);

2985

60004

					TransactionPayment::on_finalize(i as u32);

2986

60004

2987

2988

12

				TransactionPaymentAsGasPrice::min_gas_price().0

2989

12

};

2990

2991

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

2992

			// they are expected to change when parameters that influence

2993

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

2994

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

2995

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

2996

2997

1

			assert_eq!(

2998

1

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

2999

1

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

3000

1

);

3001

1

			assert_eq!(

3002

1

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

3003

1

				U256::from(31_250_000_000u128),

3004

1

);

3005

1

			assert_eq!(

3006

1

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

3007

1

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

3008

1

);

3009

1

			assert_eq!(

3010

1

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

3011

1

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

3012

1

);

3013

3014

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

3015

1

			assert_eq!(

3016

1

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

3017

1

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

3018

1

);

3019

1

			assert_eq!(

3020

1

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

3021

1

				U256::from(31_250_000_000u128),

3022

1

);

3023

1

			assert_eq!(

3024

1

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

3025

1

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

3026

1

);

3027

1

			assert_eq!(

3028

1

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

3029

1

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

3030

1

);

3031

3032

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

3033

1

			assert_eq!(

3034

1

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

3035

1

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

3036

1

);

3037

1

			assert_eq!(

3038

1

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

3039

1

				U256::from(31_250_000_000u128),

3040

1

);

3041

1

			assert_eq!(

3042

1

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

3043

1

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

3044

1

);

3045

1

			assert_eq!(

3046

1

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

3047

1

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

3048

1

);

3049

1

});

3050

1

3051

3052

3053

#[cfg(test)]

3054

mod balance_tests {

3055

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

3056

	use frame_support::assert_ok;

3057

	use frame_support::traits::LockableCurrency;

3058

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

3059

	use moonbeam_core_primitives::AccountId;

3060

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

3061

3062

	#[test]

3063

1

	fn reserve_should_work_for_frozen_balance() {

3064

1

		let alice = AccountId::from(ALICE);

3065

		const ID_1: LockIdentifier = *b"1       ";

3066

3067

1

		ExtBuilder::default()

3068

1

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

3069

1

			.build()

3070

1

			.execute_with(|| {

3071

1

				// Check balances

3072

1

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

3073

1

				assert_eq!(account.free, 10);

3074

1

				assert_eq!(account.frozen, 0);

3075

1

				assert_eq!(account.reserved, 0);

3076

3077

1

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

3078

1

3079

1

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

3080

1

				assert_eq!(account.free, 10);

3081

1

				assert_eq!(account.frozen, 9);

3082

1

				assert_eq!(account.reserved, 0);

3083

3084

1

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

3085

3086

1

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

3087

1

				assert_eq!(account.free, 5);

3088

1

				assert_eq!(account.frozen, 9);

3089

1

				assert_eq!(account.reserved, 5);

3090

3091

1

				let previous_reserved_amount = account.reserved;

3092

1

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

3093

1

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

3094

1

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

3095

3096

1

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

3097

1

				assert_eq!(account.free, ed);

3098

1

				assert_eq!(account.frozen, 9);

3099

1

				assert_eq!(

3100

1

					account.reserved,

3101

1

					previous_reserved_amount.saturating_add(next_reserve)

3102

1

);

3103

1

});

3104

1

3105

3106

3107

moonbeam_runtime_common::generate_common_xcm_tests!(moonbeam_runtime);