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

use std::cell::Cell;

25

use std::rc::Rc;

26

27

use fp_evm::{Context, IsPrecompileResult};

28

use frame_support::{

29

	assert_noop, assert_ok,

30

	dispatch::DispatchClass,

31

	traits::{

32

		fungible::Inspect, Currency as CurrencyT, EnsureOrigin, OnInitialize, PalletInfo,

33

		StorageInfo, StorageInfoTrait,

34

},

35

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

36

	StorageHasher, Twox128,

37

};

38

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

39

use moonbeam_runtime::runtime_params::dynamic_params;

40

use moonbeam_runtime::xcm_config::XcmExecutor;

41

use moonbeam_runtime::{

42

	asset_config::ForeignAssetInstance,

43

	currency::GLMR,

44

	moonbeam_xcm_weights,

45

	xcm_config::{CurrencyId, SelfReserve},

46

	AccountId, Balances, CrowdloanRewards, EvmForeignAssets, Executive,

47

	OpenTechCommitteeCollective, ParachainStaking, PolkadotXcm, Precompiles, Runtime,

48

	RuntimeBlockWeights, RuntimeCall, RuntimeEvent, System, TransactionPayment,

49

	TransactionPaymentAsGasPrice, Treasury, TreasuryCouncilCollective, XcmTransactor,

50

	FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, WEEKS,

51

};

52

use moonbeam_xcm_weights::XcmWeight;

53

use moonkit_xcm_primitives::AccountIdAssetIdConversion;

54

use nimbus_primitives::NimbusId;

55

use pallet_evm::PrecompileSet;

56

use pallet_evm_precompileset_assets_erc20::{SELECTOR_LOG_APPROVAL, SELECTOR_LOG_TRANSFER};

57

use pallet_transaction_payment::Multiplier;

58

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

59

use parity_scale_codec::Encode;

60

use polkadot_parachain::primitives::Sibling;

61

use precompile_utils::{

62

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

63

	prelude::*,

64

	testing::*,

65

};

66

use sha3::{Digest, Keccak256};

67

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

68

use sp_runtime::{

69

	traits::{Convert, Dispatchable},

70

	BuildStorage, DispatchError, ModuleError,

71

};

72

use std::str::from_utf8;

73

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

74

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

75

use xcm_executor::traits::ConvertLocation;

76

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

77

78

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

79

type CrowdloanRewardsPCall =

80

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

81

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

82

	Runtime,

83

	moonbeam_runtime::xcm_config::XcmExecutorConfig,

84

>;

85

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

86

type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

87

	Runtime,

88

	ForeignAssetInstance,

89

>;

90

type XcmTransactorV2PCall =

91

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

92

93

const BASE_FEE_GENESIS: u128 = 10000 * GIGAWEI;

94

95

4

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

96

4

	Asset {

97

4

		id: AssetId(

98

4

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

99

4

				currency_id,

100

4

101

4

			.unwrap(),

102

4

),

103

4

		fun: Fungibility::Fungible(amount),

104

4

105

4

106

#[test]

107

1

fn xcmp_queue_controller_origin_is_root() {

108

1

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

109

1

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

110

1

	assert_ok!(

111

1

		<moonbeam_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

112

1

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

113

1

);

114

1

115

116

#[test]

117

1

fn verify_pallet_prefixes() {

118

34

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

119

34

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

120

34

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

121

34

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

122

34

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

123

34

		// expand/storage.rs#L389-L401

124

34

		assert_eq!(

125

34

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

126

34

			Some(name)

127

34

);

128

34

129

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

130

	// is pulled in substrate deps.

131

1

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

132

1

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

133

1

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

134

1

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

135

1

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

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

	is_pallet_prefix::<moonbeam_runtime::OpenTechCommitteeCollective>(

142

1

		"OpenTechCommitteeCollective",

143

1

);

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

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

155

1

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

156

1

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

157

1

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

158

1

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

159

1

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

160

1

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

161

1

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

162

1

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

163

1

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

164

1

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

165

1

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

166

1

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

167

1

168

14

	let prefix = |pallet_name, storage_name| {

169

14

		let mut res = [0u8; 32];

170

14

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

171

14

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

172

14

		res.to_vec()

173

14

};

174

1

	assert_eq!(

175

1

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

176

1

		vec![

177

1

			StorageInfo {

178

1

				pallet_name: b"Timestamp".to_vec(),

179

1

				storage_name: b"Now".to_vec(),

180

1

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

181

1

				max_values: Some(1),

182

1

				max_size: Some(8),

183

1

},

184

1

			StorageInfo {

185

1

				pallet_name: b"Timestamp".to_vec(),

186

1

				storage_name: b"DidUpdate".to_vec(),

187

1

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

188

1

				max_values: Some(1),

189

1

				max_size: Some(1),

190

1

191

1

192

1

);

193

1

	assert_eq!(

194

1

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

195

1

		vec![

196

1

			StorageInfo {

197

1

				pallet_name: b"Balances".to_vec(),

198

1

				storage_name: b"TotalIssuance".to_vec(),

199

1

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

200

1

				max_values: Some(1),

201

1

				max_size: Some(16),

202

1

},

203

1

			StorageInfo {

204

1

				pallet_name: b"Balances".to_vec(),

205

1

				storage_name: b"InactiveIssuance".to_vec(),

206

1

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

207

1

				max_values: Some(1),

208

1

				max_size: Some(16),

209

1

},

210

1

			StorageInfo {

211

1

				pallet_name: b"Balances".to_vec(),

212

1

				storage_name: b"Account".to_vec(),

213

1

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

214

1

				max_values: None,

215

1

				max_size: Some(100),

216

1

},

217

1

			StorageInfo {

218

1

				pallet_name: b"Balances".to_vec(),

219

1

				storage_name: b"Locks".to_vec(),

220

1

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

221

1

				max_values: None,

222

1

				max_size: Some(1287),

223

1

},

224

1

			StorageInfo {

225

1

				pallet_name: b"Balances".to_vec(),

226

1

				storage_name: b"Reserves".to_vec(),

227

1

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

228

1

				max_values: None,

229

1

				max_size: Some(1037),

230

1

},

231

1

			StorageInfo {

232

1

				pallet_name: b"Balances".to_vec(),

233

1

				storage_name: b"Holds".to_vec(),

234

1

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

235

1

				max_values: None,

236

1

				max_size: Some(91),

237

1

},

238

1

			StorageInfo {

239

1

				pallet_name: b"Balances".to_vec(),

240

1

				storage_name: b"Freezes".to_vec(),

241

1

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

242

1

				max_values: None,

243

1

				max_size: Some(37),

244

1

},

245

1

246

1

);

247

1

	assert_eq!(

248

1

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

249

1

		vec![

250

1

			StorageInfo {

251

1

				pallet_name: b"Proxy".to_vec(),

252

1

				storage_name: b"Proxies".to_vec(),

253

1

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

254

1

				max_values: None,

255

1

				max_size: Some(845),

256

1

},

257

1

			StorageInfo {

258

1

				pallet_name: b"Proxy".to_vec(),

259

1

				storage_name: b"Announcements".to_vec(),

260

1

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

261

1

				max_values: None,

262

1

				max_size: Some(1837),

263

1

264

1

265

1

);

266

1

	assert_eq!(

267

1

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

268

1

		vec![StorageInfo {

269

1

			pallet_name: b"MaintenanceMode".to_vec(),

270

1

			storage_name: b"MaintenanceMode".to_vec(),

271

1

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

272

1

			max_values: Some(1),

273

1

			max_size: None,

274

1

},]

275

1

);

276

1

	assert_eq!(

277

1

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

278

1

		vec![

279

1

			StorageInfo {

280

1

				pallet_name: b"RelayStorageRoots".to_vec(),

281

1

				storage_name: b"RelayStorageRoot".to_vec(),

282

1

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

283

1

				max_values: None,

284

1

				max_size: Some(44),

285

1

},

286

1

			StorageInfo {

287

1

				pallet_name: b"RelayStorageRoots".to_vec(),

288

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

289

1

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

290

1

				max_values: Some(1),

291

1

				max_size: Some(121),

292

1

},

293

1

294

1

);

295

1

296

297

#[test]

298

1

fn test_collectives_storage_item_prefixes() {

299

7

	for StorageInfo { pallet_name, .. } in

300

8

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

301

302

7

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

303

304

305

7

	for StorageInfo { pallet_name, .. } in

306

8

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

307

308

7

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

309

310

1

311

312

#[test]

313

1

fn collective_set_members_root_origin_works() {

314

1

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

315

1

		// TreasuryCouncilCollective

316

1

		assert_ok!(TreasuryCouncilCollective::set_members(

317

1

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

318

1

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

319

1

			Some(AccountId::from(ALICE)),

320

1

321

1

));

322

		// OpenTechCommitteeCollective

323

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

324

1

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

325

1

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

326

1

			Some(AccountId::from(ALICE)),

327

1

328

1

));

329

1

});

330

1

331

332

#[test]

333

1

fn collective_set_members_general_admin_origin_works() {

334

	use moonbeam_runtime::{

335

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

336

};

337

338

1

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

339

1

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

340

1

		let alice = AccountId::from(ALICE);

341

1

342

1

		// TreasuryCouncilCollective

343

1

		let _ = Utility::dispatch_as(

344

1

			root_caller.clone(),

345

1

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

346

1

			Box::new(

347

1

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

348

1

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

349

1

					prime: Some(alice),

350

1

					old_count: 2,

351

1

352

1

				.into(),

353

1

),

354

1

);

355

1

		// OpenTechCommitteeCollective

356

1

		let _ = Utility::dispatch_as(

357

1

			root_caller,

358

1

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

359

1

			Box::new(

360

1

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

361

1

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

362

1

					prime: Some(alice),

363

1

					old_count: 2,

364

1

365

1

				.into(),

366

1

),

367

1

);

368

1

369

1

		assert_eq!(

370

1

			System::events()

371

1

				.into_iter()

372

2

				.filter_map(|r| {

373

2

					match r.event {

374

2

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

375

2

							if result.is_ok() =>

376

2

377

2

							Some(true)

378

379

						_ => None,

380

381

2

})

382

1

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

383

1

				.len(),

384

1

385

1

386

1

});

387

1

388

389

#[test]

390

1

fn collective_set_members_signed_origin_does_not_work() {

391

1

	let alice = AccountId::from(ALICE);

392

1

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

393

1

		// TreasuryCouncilCollective

394

1

		assert!(TreasuryCouncilCollective::set_members(

395

1

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

396

1

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

397

1

			Some(AccountId::from(ALICE)),

398

1

399

1

400

1

		.is_err());

401

		// OpenTechCommitteeCollective

402

1

		assert!(OpenTechCommitteeCollective::set_members(

403

1

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

404

1

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

405

1

			Some(AccountId::from(ALICE)),

406

1

407

1

408

1

		.is_err());

409

1

});

410

1

411

412

#[test]

413

1

fn verify_pallet_indices() {

414

36

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

415

36

		assert_eq!(

416

36

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

417

36

			Some(index)

418

36

);

419

36

420

421

	// System support

422

1

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

423

1

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

424

1

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

425

1

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

426

1

	// Monetary

427

1

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

428

1

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

429

1

	// Consensus support

430

1

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

431

1

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

432

1

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

433

1

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

434

1

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

435

1

	// Handy utilities

436

1

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

437

1

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

438

1

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

439

1

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

440

1

	is_pallet_index::<moonbeam_runtime::Migrations>(34);

441

1

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

442

1

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

443

1

	// Ethereum compatibility

444

1

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

445

1

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

446

1

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

447

1

	// Governance

448

1

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

449

1

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

450

1

	// Council

451

1

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

452

1

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

453

1

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

454

1

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

455

1

	// Treasury

456

1

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

457

1

	// Crowdloan

458

1

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

459

1

	// XCM Stuff

460

1

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

461

1

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

462

1

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

463

1

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

464

1

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

465

1

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

466

1

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

467

1

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

468

1

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

469

1

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

470

1

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

471

1

472

473

#[test]

474

1

fn verify_reserved_indices() {

475

1

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

476

1

		.build_storage()

477

1

		.unwrap()

478

1

		.into();

479

1

480

1

	t.execute_with(|| {

481

		use frame_metadata::*;

482

1

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

483

1

		let metadata = match metadata.1 {

484

1

			RuntimeMetadata::V14(metadata) => metadata,

485

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

486

};

487

		// 40: Sudo

488

		// 53: BaseFee

489

		// 108: pallet_assets::<Instance1>

490

1

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

491

1

		let existing = metadata

492

1

			.pallets

493

1

			.iter()

494

53

			.map(|p| p.index)

495

1

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

496

3

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

497

1

});

498

1

499

500

#[test]

501

1

fn verify_proxy_type_indices() {

502

1

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

503

1

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

504

1

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

505

1

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

506

1

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

507

1

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

508

1

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

509

1

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

510

1

511

512

#[test]

513

1

fn join_collator_candidates() {

514

1

	ExtBuilder::default()

515

1

		.with_balances(vec![

516

1

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

517

1

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

518

1

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

519

1

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

520

1

])

521

1

		.with_collators(vec![

522

1

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

523

1

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

524

1

])

525

1

		.with_delegations(vec![

526

1

527

1

				AccountId::from(CHARLIE),

528

1

				AccountId::from(ALICE),

529

1

				5_000 * GLMR,

530

1

),

531

1

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

532

1

])

533

1

		.build()

534

1

		.execute_with(|| {

535

1

			assert_noop!(

536

1

				ParachainStaking::join_candidates(

537

1

					origin_of(AccountId::from(ALICE)),

538

1

					2_000_000 * GLMR,

539

1

					2u32

540

1

),

541

1

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

542

1

);

543

1

			assert_noop!(

544

1

				ParachainStaking::join_candidates(

545

1

					origin_of(AccountId::from(CHARLIE)),

546

1

					2_000_000 * GLMR,

547

1

					2u32

548

1

),

549

1

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

550

1

);

551

1

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

552

1

			assert_ok!(ParachainStaking::join_candidates(

553

1

				origin_of(AccountId::from(DAVE)),

554

1

				2_000_000 * GLMR,

555

1

				2u32

556

1

));

557

1

			assert_eq!(

558

1

				last_event(),

559

1

				RuntimeEvent::ParachainStaking(

560

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

561

1

						account: AccountId::from(DAVE),

562

1

						amount_locked: 2_000_000 * GLMR,

563

1

						new_total_amt_locked: 6_010_000 * GLMR

564

1

565

1

566

1

);

567

1

			let candidates = ParachainStaking::candidate_pool();

568

1

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

569

1

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

570

1

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

571

1

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

572

1

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

573

1

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

574

1

});

575

1

576

577

#[test]

578

1

fn transfer_through_evm_to_stake() {

579

1

	ExtBuilder::default()

580

1

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

581

1

		.build()

582

1

		.execute_with(|| {

583

1

			// Charlie has no balance => fails to stake

584

1

			assert_noop!(

585

1

				ParachainStaking::join_candidates(

586

1

					origin_of(AccountId::from(CHARLIE)),

587

1

					2_000_000 * GLMR,

588

1

					2u32

589

1

),

590

1

				DispatchError::Module(ModuleError {

591

1

					index: 20,

592

1

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

593

1

					message: Some("InsufficientBalance")

594

1

})

595

1

);

596

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

597

1

			assert_ok!(Balances::transfer_allow_death(

598

1

				origin_of(AccountId::from(ALICE)),

599

1

				AccountId::from(BOB),

600

1

				3_000_000 * GLMR,

601

1

));

602

1

			assert_eq!(

603

1

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

604

1

				3_000_000 * GLMR

605

1

);

606

607

1

			let gas_limit = 100000u64;

608

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

609

1

			// Bob transfers 2_000_000 GLMR to Charlie via EVM

610

1

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

611

1

				source: H160::from(BOB),

612

1

				target: H160::from(CHARLIE),

613

1

				input: vec![],

614

1

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

615

1

				gas_limit,

616

1

				max_fee_per_gas: gas_price,

617

1

				max_priority_fee_per_gas: None,

618

1

				nonce: None,

619

1

				access_list: Vec::new(),

620

1

})

621

1

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

622

1

			assert_eq!(

623

1

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

624

1

				2_000_000 * GLMR,

625

1

);

626

627

			// Charlie can stake now

628

1

			assert_ok!(ParachainStaking::join_candidates(

629

1

				origin_of(AccountId::from(CHARLIE)),

630

1

				2_000_000 * GLMR,

631

1

				2u32

632

1

			),);

633

1

			let candidates = ParachainStaking::candidate_pool();

634

1

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

635

1

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

636

1

});

637

1

638

639

#[test]

640

1

fn reward_block_authors() {

641

1

	ExtBuilder::default()

642

1

		.with_balances(vec![

643

1

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

644

1

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

645

1

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

646

1

])

647

1

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

648

1

		.with_delegations(vec![(

649

1

			AccountId::from(BOB),

650

1

			AccountId::from(ALICE),

651

1

			50_000 * GLMR,

652

1

)])

653

1

		.with_mappings(vec![(

654

1

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

655

1

			AccountId::from(ALICE),

656

1

)])

657

1

		.build()

658

1

		.execute_with(|| {

659

1

			increase_last_relay_slot_number(1);

660

1

			// Just before round 3

661

1

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

662

1

			// no rewards doled out yet

663

1

			assert_eq!(

664

1

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

665

1

				8_010_000 * GLMR,

666

1

);

667

1

			assert_eq!(

668

1

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

669

1

				9_950_000 * GLMR,

670

1

);

671

1

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

672

1

			// rewards minted and distributed

673

1

			assert_eq!(

674

1

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

675

1

				8990978048702400000000000,

676

1

);

677

1

			assert_eq!(

678

1

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

679

1

				9969521950497200000000000,

680

1

);

681

1

});

682

1

683

684

#[test]

685

1

fn reward_block_authors_with_parachain_bond_reserved() {

686

1

	ExtBuilder::default()

687

1

		.with_balances(vec![

688

1

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

689

1

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

690

1

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

691

1

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

692

1

])

693

1

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

694

1

		.with_delegations(vec![(

695

1

			AccountId::from(BOB),

696

1

			AccountId::from(ALICE),

697

1

			50_000 * GLMR,

698

1

)])

699

1

		.with_mappings(vec![(

700

1

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

701

1

			AccountId::from(ALICE),

702

1

)])

703

1

		.build()

704

1

		.execute_with(|| {

705

1

			increase_last_relay_slot_number(1);

706

1

			assert_ok!(ParachainStaking::set_parachain_bond_account(

707

1

				root_origin(),

708

1

				AccountId::from(CHARLIE),

709

1

			),);

710

711

			// Stop just before round 3

712

1

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

713

1

			// no collators rewards doled out yet

714

1

			assert_eq!(

715

1

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

716

1

				8_010_000 * GLMR,

717

1

);

718

1

			assert_eq!(

719

1

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

720

1

				9_950_000 * GLMR,

721

1

);

722

			// 30% reserved for parachain bond

723

1

			assert_eq!(

724

1

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

725

1

				310300000000000000000000,

726

1

);

727

728

			// Go to round 3

729

1

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

730

1

731

1

			// collators rewards minted and distributed

732

1

			assert_eq!(

733

1

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

734

1

				8698492682878000000000000,

735

1

);

736

1

			assert_eq!(

737

1

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

738

1

				9962207316621500000000000,

739

1

);

740

			// 30% reserved for parachain bond again

741

1

			assert_eq!(

742

1

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

743

1

				615104500000000000000000,

744

1

);

745

1

});

746

1

747

748

#[test]

749

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

750

1

	ExtBuilder::default()

751

1

		.with_balances(vec![

752

1

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

753

1

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

754

1

])

755

1

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

756

1

		.with_mappings(vec![(

757

1

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

758

1

			AccountId::from(ALICE),

759

1

)])

760

1

		.with_crowdloan_fund(300_000_000 * GLMR)

761

1

		.build()

762

1

		.execute_with(|| {

763

1

			// set parachain inherent data

764

1

			set_parachain_inherent_data();

765

1

			let init_block = CrowdloanRewards::init_vesting_block();

766

1

			// This matches the previous vesting

767

1

			let end_block = init_block + 4 * WEEKS;

768

1

			// Batch calls always succeed. We just need to check the inner event

769

1

			assert_ok!(

770

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch_all {

771

1

					calls: vec![

772

1

						RuntimeCall::CrowdloanRewards(

773

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

774

1

								rewards: vec![(

775

1

									[4u8; 32].into(),

776

1

									Some(AccountId::from(CHARLIE)),

777

1

									150_000_000 * GLMR

778

1

)]

779

1

780

1

),

781

1

						RuntimeCall::CrowdloanRewards(

782

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

783

1

								rewards: vec![(

784

1

									[5u8; 32].into(),

785

1

									Some(AccountId::from(DAVE)),

786

1

									150_000_000 * GLMR

787

1

)]

788

1

789

1

),

790

1

						RuntimeCall::CrowdloanRewards(

791

1

							pallet_crowdloan_rewards::Call::<Runtime>::complete_initialization {

792

1

								lease_ending_block: end_block

793

1

794

1

795

1

796

1

})

797

1

				.dispatch(root_origin())

798

1

);

799

			// 30 percent initial payout

800

1

			assert_eq!(

801

1

				Balances::balance(&AccountId::from(CHARLIE)),

802

1

				45_000_000 * GLMR

803

1

);

804

			// 30 percent initial payout

805

1

			assert_eq!(Balances::balance(&AccountId::from(DAVE)), 45_000_000 * GLMR);

806

1

			let expected = RuntimeEvent::Utility(pallet_utility::Event::BatchCompleted);

807

1

			assert_eq!(last_event(), expected);

808

			// This one should fail, as we already filled our data

809

1

			assert_ok!(

810

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch {

811

1

					calls: vec![RuntimeCall::CrowdloanRewards(

812

1

						pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

813

1

							rewards: vec![(

814

1

								[4u8; 32].into(),

815

1

								Some(AccountId::from(ALICE)),

816

1

								43_200_000

817

1

)]

818

1

819

1

)]

820

1

})

821

1

				.dispatch(root_origin())

822

1

);

823

1

			let expected_fail = RuntimeEvent::Utility(pallet_utility::Event::BatchInterrupted {

824

1

				index: 0,

825

1

				error: DispatchError::Module(ModuleError {

826

1

					index: 90,

827

1

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

828

1

					message: None,

829

1

}),

830

1

});

831

1

			assert_eq!(last_event(), expected_fail);

832

			// Claim 1 block.

833

1

			assert_ok!(CrowdloanRewards::claim(origin_of(AccountId::from(CHARLIE))));

834

1

			assert_ok!(CrowdloanRewards::claim(origin_of(AccountId::from(DAVE))));

835

836

1

			let vesting_period = 4 * WEEKS as u128;

837

1

			let per_block = (105_000_000 * GLMR) / vesting_period;

838

1

839

1

			assert_eq!(

840

1

				CrowdloanRewards::accounts_payable(&AccountId::from(CHARLIE))

841

1

					.unwrap()

842

1

					.claimed_reward,

843

1

				(45_000_000 * GLMR) + per_block

844

1

);

845

1

			assert_eq!(

846

1

				CrowdloanRewards::accounts_payable(&AccountId::from(DAVE))

847

1

					.unwrap()

848

1

					.claimed_reward,

849

1

				(45_000_000 * GLMR) + per_block

850

1

);

851

			// The total claimed reward should be equal to the account balance at this point.

852

1

			assert_eq!(

853

1

				Balances::balance(&AccountId::from(CHARLIE)),

854

1

				(45_000_000 * GLMR) + per_block

855

1

);

856

1

			assert_eq!(

857

1

				Balances::balance(&AccountId::from(DAVE)),

858

1

				(45_000_000 * GLMR) + per_block

859

1

);

860

1

			assert_noop!(

861

1

				CrowdloanRewards::claim(origin_of(AccountId::from(ALICE))),

862

1

				pallet_crowdloan_rewards::Error::<Runtime>::NoAssociatedClaim

863

1

);

864

1

});

865

1

866

867

#[test]

868

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

869

1

	ExtBuilder::default()

870

1

		.with_balances(vec![

871

1

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

872

1

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

873

1

])

874

1

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

875

1

		.with_mappings(vec![(

876

1

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

877

1

			AccountId::from(ALICE),

878

1

)])

879

1

		.with_crowdloan_fund(3_000_000 * GLMR)

880

1

		.build()

881

1

		.execute_with(|| {

882

1

			// set parachain inherent data

883

1

			set_parachain_inherent_data();

884

1

			let init_block = CrowdloanRewards::init_vesting_block();

885

1

			// This matches the previous vesting

886

1

			let end_block = init_block + 4 * WEEKS;

887

1

888

1

			let (pair1, _) = sp_core::sr25519::Pair::generate();

889

1

			let (pair2, _) = sp_core::sr25519::Pair::generate();

890

1

891

1

			let public1 = pair1.public();

892

1

			let public2 = pair2.public();

893

1

894

1

			// signature is new_account || previous_account

895

1

			let mut message = pallet_crowdloan_rewards::WRAPPED_BYTES_PREFIX.to_vec();

896

1

			message.append(&mut b"moonbeam-".to_vec());

897

1

			message.append(&mut AccountId::from(DAVE).encode());

898

1

			message.append(&mut AccountId::from(CHARLIE).encode());

899

1

			message.append(&mut pallet_crowdloan_rewards::WRAPPED_BYTES_POSTFIX.to_vec());

900

1

			let signature1 = pair1.sign(&message);

901

1

			let signature2 = pair2.sign(&message);

902

1

903

1

			// Batch calls always succeed. We just need to check the inner event

904

1

			assert_ok!(

905

1

				// two relay accounts pointing at the same reward account

906

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch_all {

907

1

					calls: vec![

908

1

						RuntimeCall::CrowdloanRewards(

909

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

910

1

								rewards: vec![(

911

1

									public1.into(),

912

1

									Some(AccountId::from(CHARLIE)),

913

1

									1_500_000 * GLMR

914

1

)]

915

1

916

1

),

917

1

						RuntimeCall::CrowdloanRewards(

918

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

919

1

								rewards: vec![(

920

1

									public2.into(),

921

1

									Some(AccountId::from(CHARLIE)),

922

1

									1_500_000 * GLMR

923

1

)]

924

1

925

1

),

926

1

						RuntimeCall::CrowdloanRewards(

927

1

							pallet_crowdloan_rewards::Call::<Runtime>::complete_initialization {

928

1

								lease_ending_block: end_block

929

1

930

1

931

1

932

1

})

933

1

				.dispatch(root_origin())

934

1

);

935

			// 30 percent initial payout

936

1

			assert_eq!(Balances::balance(&AccountId::from(CHARLIE)), 900_000 * GLMR);

937

938

			// this should fail, as we are only providing one signature

939

1

			assert_noop!(

940

1

				CrowdloanRewards::change_association_with_relay_keys(

941

1

					origin_of(AccountId::from(CHARLIE)),

942

1

					AccountId::from(DAVE),

943

1

					AccountId::from(CHARLIE),

944

1

					vec![(public1.into(), signature1.clone().into())]

945

1

),

946

1

				pallet_crowdloan_rewards::Error::<Runtime>::InsufficientNumberOfValidProofs

947

1

);

948

949

			// this should be valid

950

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

951

1

				origin_of(AccountId::from(CHARLIE)),

952

1

				AccountId::from(DAVE),

953

1

				AccountId::from(CHARLIE),

954

1

				vec![

955

1

					(public1.into(), signature1.into()),

956

1

					(public2.into(), signature2.into())

957

1

958

1

));

959

960

1

			assert_eq!(

961

1

				CrowdloanRewards::accounts_payable(&AccountId::from(DAVE))

962

1

					.unwrap()

963

1

					.claimed_reward,

964

1

				(900_000 * GLMR)

965

1

);

966

1

});

967

1

968

969

#[test]

970

1

fn claim_via_precompile() {

971

1

	ExtBuilder::default()

972

1

		.with_balances(vec![

973

1

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

974

1

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

975

1

])

976

1

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

977

1

		.with_mappings(vec![(

978

1

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

979

1

			AccountId::from(ALICE),

980

1

)])

981

1

		.with_crowdloan_fund(3_000_000 * GLMR)

982

1

		.build()

983

1

		.execute_with(|| {

984

1

			// set parachain inherent data

985

1

			set_parachain_inherent_data();

986

1

			let init_block = CrowdloanRewards::init_vesting_block();

987

1

			// This matches the previous vesting

988

1

			let end_block = init_block + 4 * WEEKS;

989

1

			// Batch calls always succeed. We just need to check the inner event

990

1

			assert_ok!(

991

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch_all {

992

1

					calls: vec![

993

1

						RuntimeCall::CrowdloanRewards(

994

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

995

1

								rewards: vec![(

996

1

									[4u8; 32].into(),

997

1

									Some(AccountId::from(CHARLIE)),

998

1

									1_500_000 * GLMR

999

1

)]

1000

1

1001

1

),

1002

1

						RuntimeCall::CrowdloanRewards(

1003

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1004

1

								rewards: vec![(

1005

1

									[5u8; 32].into(),

1006

1

									Some(AccountId::from(DAVE)),

1007

1

									1_500_000 * GLMR

1008

1

)]

1009

1

1010

1

),

1011

1

						RuntimeCall::CrowdloanRewards(

1012

1

							pallet_crowdloan_rewards::Call::<Runtime>::complete_initialization {

1013

1

								lease_ending_block: end_block

1014

1

1015

1

1016

1

1017

1

})

1018

1

				.dispatch(root_origin())

1019

1

);

1020

1021

1

			assert!(CrowdloanRewards::initialized());

1022

1023

			// 30 percent initial payout

1024

1

			assert_eq!(Balances::balance(&AccountId::from(CHARLIE)), 450_000 * GLMR);

1025

			// 30 percent initial payout

1026

1

			assert_eq!(Balances::balance(&AccountId::from(DAVE)), 450_000 * GLMR);

1027

1028

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1029

1

1030

1

			// Alice uses the crowdloan precompile to claim through the EVM

1031

1

			let gas_limit = 100000u64;

1032

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1033

1

1034

1

			// Construct the call data (selector, amount)

1035

1

			let mut call_data = Vec::<u8>::from([0u8; 4]);

1036

1

			call_data[0..4].copy_from_slice(&Keccak256::digest(b"claim()")[0..4]);

1037

1

1038

1

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

1039

1

				source: H160::from(CHARLIE),

1040

1

				target: crowdloan_precompile_address,

1041

1

				input: call_data,

1042

1

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

1043

1

				gas_limit,

1044

1

				max_fee_per_gas: gas_price,

1045

1

				max_priority_fee_per_gas: None,

1046

1

				nonce: None, // Use the next nonce

1047

1

				access_list: Vec::new(),

1048

1

})

1049

1

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

1050

1051

1

			let vesting_period = 4 * WEEKS as u128;

1052

1

			let per_block = (1_050_000 * GLMR) / vesting_period;

1053

1

1054

1

			assert_eq!(

1055

1

				CrowdloanRewards::accounts_payable(&AccountId::from(CHARLIE))

1056

1

					.unwrap()

1057

1

					.claimed_reward,

1058

1

				(450_000 * GLMR) + per_block

1059

1

);

1060

1

})

1061

1

1062

1063

#[test]

1064

1

fn is_contributor_via_precompile() {

1065

1

	ExtBuilder::default()

1066

1

		.with_balances(vec![

1067

1

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

1068

1

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

1069

1

])

1070

1

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

1071

1

		.with_mappings(vec![(

1072

1

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

1073

1

			AccountId::from(ALICE),

1074

1

)])

1075

1

		.with_crowdloan_fund(3_000_000_000 * GLMR)

1076

1

		.build()

1077

1

		.execute_with(|| {

1078

1

			// set parachain inherent data

1079

1

			set_parachain_inherent_data();

1080

1

			let init_block = CrowdloanRewards::init_vesting_block();

1081

1

			// This matches the previous vesting

1082

1

			let end_block = init_block + 4 * WEEKS;

1083

1

			// Batch calls always succeed. We just need to check the inner event

1084

1

			assert_ok!(

1085

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch_all {

1086

1

					calls: vec![

1087

1

						RuntimeCall::CrowdloanRewards(

1088

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1089

1

								rewards: vec![(

1090

1

									[4u8; 32].into(),

1091

1

									Some(AccountId::from(CHARLIE)),

1092

1

									1_500_000_000 * GLMR

1093

1

)]

1094

1

1095

1

),

1096

1

						RuntimeCall::CrowdloanRewards(

1097

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1098

1

								rewards: vec![(

1099

1

									[5u8; 32].into(),

1100

1

									Some(AccountId::from(DAVE)),

1101

1

									1_500_000_000 * GLMR

1102

1

)]

1103

1

1104

1

),

1105

1

						RuntimeCall::CrowdloanRewards(

1106

1

							pallet_crowdloan_rewards::Call::<Runtime>::complete_initialization {

1107

1

								lease_ending_block: end_block

1108

1

1109

1

1110

1

1111

1

})

1112

1

				.dispatch(root_origin())

1113

1

);

1114

1115

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1116

1

1117

1

			// Assert precompile reports Bob is not a contributor

1118

1

			Precompiles::new()

1119

1

				.prepare_test(

1120

1

					ALICE,

1121

1

					crowdloan_precompile_address,

1122

1

					CrowdloanRewardsPCall::is_contributor {

1123

1

						contributor: Address(AccountId::from(BOB).into()),

1124

1

},

1125

1

1126

1

				.expect_cost(3338)

1127

1

				.expect_no_logs()

1128

1

				.execute_returns(false);

1129

1

1130

1

			// Assert precompile reports Charlie is a nominator

1131

1

			Precompiles::new()

1132

1

				.prepare_test(

1133

1

					ALICE,

1134

1

					crowdloan_precompile_address,

1135

1

					CrowdloanRewardsPCall::is_contributor {

1136

1

						contributor: Address(AccountId::from(CHARLIE).into()),

1137

1

},

1138

1

1139

1

				.expect_cost(3338)

1140

1

				.expect_no_logs()

1141

1

				.execute_returns(true);

1142

1

})

1143

1

1144

1145

#[test]

1146

1

fn reward_info_via_precompile() {

1147

1

	ExtBuilder::default()

1148

1

		.with_balances(vec![

1149

1

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

1150

1

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

1151

1

])

1152

1

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

1153

1

		.with_mappings(vec![(

1154

1

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

1155

1

			AccountId::from(ALICE),

1156

1

)])

1157

1

		.with_crowdloan_fund(3_000_000 * GLMR)

1158

1

		.build()

1159

1

		.execute_with(|| {

1160

1

			// set parachain inherent data

1161

1

			set_parachain_inherent_data();

1162

1

			let init_block = CrowdloanRewards::init_vesting_block();

1163

1

			// This matches the previous vesting

1164

1

			let end_block = init_block + 4 * WEEKS;

1165

1

			// Batch calls always succeed. We just need to check the inner event

1166

1

			assert_ok!(

1167

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch_all {

1168

1

					calls: vec![

1169

1

						RuntimeCall::CrowdloanRewards(

1170

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1171

1

								rewards: vec![(

1172

1

									[4u8; 32].into(),

1173

1

									Some(AccountId::from(CHARLIE)),

1174

1

									1_500_000 * GLMR

1175

1

)]

1176

1

1177

1

),

1178

1

						RuntimeCall::CrowdloanRewards(

1179

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1180

1

								rewards: vec![(

1181

1

									[5u8; 32].into(),

1182

1

									Some(AccountId::from(DAVE)),

1183

1

									1_500_000 * GLMR

1184

1

)]

1185

1

1186

1

),

1187

1

						RuntimeCall::CrowdloanRewards(

1188

1

							pallet_crowdloan_rewards::Call::<Runtime>::complete_initialization {

1189

1

								lease_ending_block: end_block

1190

1

1191

1

1192

1

1193

1

})

1194

1

				.dispatch(root_origin())

1195

1

);

1196

1197

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1198

1

1199

1

			let expected_total: U256 = (1_500_000 * GLMR).into();

1200

1

			let expected_claimed: U256 = (450_000 * GLMR).into();

1201

1

1202

1

			// Assert precompile reports correct Charlie reward info.

1203

1

			Precompiles::new()

1204

1

				.prepare_test(

1205

1

					ALICE,

1206

1

					crowdloan_precompile_address,

1207

1

					CrowdloanRewardsPCall::reward_info {

1208

1

						contributor: Address(AccountId::from(CHARLIE).into()),

1209

1

},

1210

1

1211

1

				.expect_cost(3338)

1212

1

				.expect_no_logs()

1213

1

				.execute_returns((expected_total, expected_claimed));

1214

1

})

1215

1

1216

1217

#[test]

1218

1

fn update_reward_address_via_precompile() {

1219

1

	ExtBuilder::default()

1220

1

		.with_balances(vec![

1221

1

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

1222

1

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

1223

1

])

1224

1

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

1225

1

		.with_mappings(vec![(

1226

1

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

1227

1

			AccountId::from(ALICE),

1228

1

)])

1229

1

		.with_crowdloan_fund(3_000_000 * GLMR)

1230

1

		.build()

1231

1

		.execute_with(|| {

1232

1

			// set parachain inherent data

1233

1

			set_parachain_inherent_data();

1234

1

			let init_block = CrowdloanRewards::init_vesting_block();

1235

1

			// This matches the previous vesting

1236

1

			let end_block = init_block + 4 * WEEKS;

1237

1

			// Batch calls always succeed. We just need to check the inner event

1238

1

			assert_ok!(

1239

1

				RuntimeCall::Utility(pallet_utility::Call::<Runtime>::batch_all {

1240

1

					calls: vec![

1241

1

						RuntimeCall::CrowdloanRewards(

1242

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1243

1

								rewards: vec![(

1244

1

									[4u8; 32].into(),

1245

1

									Some(AccountId::from(CHARLIE)),

1246

1

									1_500_000 * GLMR

1247

1

)]

1248

1

1249

1

),

1250

1

						RuntimeCall::CrowdloanRewards(

1251

1

							pallet_crowdloan_rewards::Call::<Runtime>::initialize_reward_vec {

1252

1

								rewards: vec![(

1253

1

									[5u8; 32].into(),

1254

1

									Some(AccountId::from(DAVE)),

1255

1

									1_500_000 * GLMR

1256

1

)]

1257

1

1258

1

),

1259

1

						RuntimeCall::CrowdloanRewards(

1260

1

							pallet_crowdloan_rewards::Call::<Runtime>::complete_initialization {

1261

1

								lease_ending_block: end_block

1262

1

1263

1

1264

1

1265

1

})

1266

1

				.dispatch(root_origin())

1267

1

);

1268

1269

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1270

1

1271

1

			// Charlie uses the crowdloan precompile to update address through the EVM

1272

1

			let gas_limit = 100000u64;

1273

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1274

1

1275

1

			// Construct the input data to check if Bob is a contributor

1276

1

			let mut call_data = Vec::<u8>::from([0u8; 36]);

1277

1

			call_data[0..4]

1278

1

				.copy_from_slice(&Keccak256::digest(b"update_reward_address(address)")[0..4]);

1279

1

			call_data[16..36].copy_from_slice(&ALICE);

1280

1

1281

1

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

1282

1

				source: H160::from(CHARLIE),

1283

1

				target: crowdloan_precompile_address,

1284

1

				input: call_data,

1285

1

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

1286

1

				gas_limit,

1287

1

				max_fee_per_gas: gas_price,

1288

1

				max_priority_fee_per_gas: None,

1289

1

				nonce: None, // Use the next nonce

1290

1

				access_list: Vec::new(),

1291

1

})

1292

1

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

1293

1294

1

			assert!(CrowdloanRewards::accounts_payable(&AccountId::from(CHARLIE)).is_none());

1295

1

			assert_eq!(

1296

1

				CrowdloanRewards::accounts_payable(&AccountId::from(ALICE))

1297

1

					.unwrap()

1298

1

					.claimed_reward,

1299

1

				(450_000 * GLMR)

1300

1

);

1301

1

})

1302

1

1303

1304

1

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

1305

1

where

1306

1

	F: FnMut() -> (),

1307

1

1308

1

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

1309

1

		.build_storage()

1310

1

		.unwrap()

1311

1

		.into();

1312

1

	t.execute_with(|| {

1313

1

		System::set_block_consumed_resources(w, 0);

1314

1

		assertions()

1315

1

});

1316

1

1317

1318

#[test]

1319

#[rustfmt::skip]

1320

1

fn length_fee_is_sensible() {

1321

	use sp_runtime::testing::TestXt;

1322

1323

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

1324

1

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

1325

1

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

1326

1

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

1327

1

1328

9

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

1329

9

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

1330

9

				.inclusion_fee

1331

9

				.expect("fee should be calculated")

1332

9

				.len_fee

1333

9

};

1334

1335

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

1336

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

1337

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

1338

		//                             |           |

1339

1

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

1340

1

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

1341

1

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

1342

1

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

1343

1

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

1344

1

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

1345

1

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

1346

1

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

1347

1

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

1348

1

});

1349

1

1350

1351

#[test]

1352

1

fn multiplier_can_grow_from_zero() {

1353

	use frame_support::traits::Get;

1354

1355

1

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

1356

1

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

1357

1

		* RuntimeBlockWeights::get()

1358

1

			.get(DispatchClass::Normal)

1359

1

			.max_total

1360

1

			.unwrap();

1361

1

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

1362

1

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

1363

1

	run_with_system_weight(target * 101 / 100, || {

1364

1

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

1365

1

		assert!(

1366

1

			next > minimum_multiplier,

1367

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

1368

			next,

1369

			minimum_multiplier

1370

);

1371

1

})

1372

1

1373

1374

#[test]

1375

1

fn ethereum_invalid_transaction() {

1376

1

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

1377

1

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

1378

1

		// on chain is rejected.

1379

1

		assert_eq!(

1380

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1381

1

			Err(

1382

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1383

1

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

1384

1

1385

1

1386

1

);

1387

1

});

1388

1

1389

1390

#[test]

1391

1

fn initial_gas_fee_is_correct() {

1392

	use fp_evm::FeeCalculator;

1393

1394

1

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

1395

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1396

1

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

1397

1398

1

		assert_eq!(

1399

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1400

1

1401

1

				31_250_000_000u128.into(),

1402

1

				Weight::from_parts(41_742_000u64, 0)

1403

1

1404

1

);

1405

1

});

1406

1

1407

1408

#[test]

1409

1

fn min_gas_fee_is_correct() {

1410

	use fp_evm::FeeCalculator;

1411

	use frame_support::traits::Hooks;

1412

1413

1

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

1414

1

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

1415

1

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

1416

1

1417

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1418

1

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

1419

1420

1

		assert_eq!(

1421

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1422

1

1423

1

				31_250_000_000u128.into(),

1424

1

				Weight::from_parts(41_742_000u64, 0)

1425

1

1426

1

);

1427

1

});

1428

1

1429

1430

#[test]

1431

1

fn transfer_ed_0_substrate() {

1432

1

	ExtBuilder::default()

1433

1

		.with_balances(vec![

1434

1

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

1435

1

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

1436

1

])

1437

1

		.build()

1438

1

		.execute_with(|| {

1439

1

			// Substrate transfer

1440

1

			assert_ok!(Balances::transfer_allow_death(

1441

1

				origin_of(AccountId::from(ALICE)),

1442

1

				AccountId::from(BOB),

1443

1

				1 * GLMR,

1444

1

));

1445

			// 1 WEI is left in the account

1446

1

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

1447

1

});

1448

1

1449

1450

#[test]

1451

1

fn transfer_ed_0_evm() {

1452

1

	ExtBuilder::default()

1453

1

		.with_balances(vec![

1454

1

1455

1

				AccountId::from(ALICE),

1456

1

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

1457

1

),

1458

1

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

1459

1

])

1460

1

		.build()

1461

1

		.execute_with(|| {

1462

1

			set_parachain_inherent_data();

1463

1

			// EVM transfer

1464

1

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

1465

1

				source: H160::from(ALICE),

1466

1

				target: H160::from(BOB),

1467

1

				input: Vec::new(),

1468

1

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

1469

1

				gas_limit: 21_000u64,

1470

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1471

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1472

1

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

1473

1

				access_list: Vec::new(),

1474

1

})

1475

1

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

1476

			// 1 WEI is left in the account

1477

1

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

1478

1

});

1479

1

1480

1481

#[test]

1482

1

fn refund_ed_0_evm() {

1483

1

	ExtBuilder::default()

1484

1

		.with_balances(vec![

1485

1

1486

1

				AccountId::from(ALICE),

1487

1

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

1488

1

),

1489

1

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

1490

1

])

1491

1

		.build()

1492

1

		.execute_with(|| {

1493

1

			set_parachain_inherent_data();

1494

1

			// EVM transfer that zeroes ALICE

1495

1

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

1496

1

				source: H160::from(ALICE),

1497

1

				target: H160::from(BOB),

1498

1

				input: Vec::new(),

1499

1

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

1500

1

				gas_limit: 21_777u64,

1501

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1502

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1503

1

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

1504

1

				access_list: Vec::new(),

1505

1

})

1506

1

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

1507

			// ALICE is refunded

1508

1

			assert_eq!(

1509

1

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

1510

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

1511

1

);

1512

1

});

1513

1

1514

1515

#[test]

1516

1

fn author_does_receive_priority_fee() {

1517

1

	ExtBuilder::default()

1518

1

		.with_balances(vec![(

1519

1

			AccountId::from(BOB),

1520

1

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

1521

1

)])

1522

1

		.build()

1523

1

		.execute_with(|| {

1524

1

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

1525

1

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

1526

1

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

1527

1

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

1528

1

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

1529

1

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

1530

1

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

1531

1

1532

1

			// EVM transfer.

1533

1

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

1534

1

				source: H160::from(BOB),

1535

1

				target: H160::from(ALICE),

1536

1

				input: Vec::new(),

1537

1

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

1538

1

				gas_limit: 21_000u64,

1539

1

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

1540

1

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

1541

1

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

1542

1

				access_list: Vec::new(),

1543

1

})

1544

1

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

1545

1546

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1547

1

			// Author free balance increased by priority fee.

1548

1

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

1549

1

});

1550

1

1551

1552

#[test]

1553

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1554

	use fp_evm::FeeCalculator;

1555

1

	ExtBuilder::default()

1556

1

		.with_balances(vec![

1557

1

1558

1

				AccountId::from(BOB),

1559

1

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

1560

1

),

1561

1

1562

1

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

1563

1

				existential_deposit(),

1564

1

),

1565

1

])

1566

1

		.build()

1567

1

		.execute_with(|| {

1568

1

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

1569

1

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

1570

1

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

1571

1

			// EVM transfer.

1572

1

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

1573

1

				source: H160::from(BOB),

1574

1

				target: H160::from(ALICE),

1575

1

				input: Vec::new(),

1576

1

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

1577

1

				gas_limit: 21_000u64,

1578

1

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

1579

1

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

1580

1

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

1581

1

				access_list: Vec::new(),

1582

1

})

1583

1

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

1584

1585

1

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

1586

1

1587

1

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

1588

1

1589

1

			let base_fee: Balance = base_fee * 21_000;

1590

1

1591

1

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

1592

1

1593

1

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

1594

1

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

1595

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1596

1

1597

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1598

1599

1

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

1600

1

});

1601

1

1602

1603

#[test]

1604

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1605

	use fp_evm::FeeCalculator;

1606

1

	ExtBuilder::default()

1607

1

		.with_balances(vec![

1608

1

1609

1

				AccountId::from(BOB),

1610

1

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

1611

1

),

1612

1

1613

1

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

1614

1

				existential_deposit(),

1615

1

),

1616

1

])

1617

1

		.build()

1618

1

		.execute_with(|| {

1619

1

			set_parachain_inherent_data();

1620

1

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

1621

1

			// EVM transfer.

1622

1

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

1623

1

				source: H160::from(BOB),

1624

1

				target: H160::from(ALICE),

1625

1

				input: Vec::new(),

1626

1

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

1627

1

				gas_limit: 21_000u64,

1628

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1629

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1630

1

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

1631

1

				access_list: Vec::new(),

1632

1

})

1633

1

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

1634

1635

1

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

1636

1

1637

1

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

1638

1

1639

1

			let base_fee: Balance = base_fee * 21_000;

1640

1

1641

1

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

1642

1

1643

1

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

1644

1

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

1645

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1646

1

1647

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1648

1649

1

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

1650

1

});

1651

1

1652

1653

#[test]

1654

1

fn root_can_change_default_xcm_vers() {

1655

1

	ExtBuilder::default()

1656

1

		.with_balances(vec![

1657

1

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

1658

1

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

1659

1

])

1660

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1661

1

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

1662

1

			metadata: AssetRegistrarMetadata {

1663

1

				name: b"RelayToken".to_vec(),

1664

1

				symbol: b"Relay".to_vec(),

1665

1

				decimals: 12,

1666

1

				is_frozen: false,

1667

1

},

1668

1

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

1669

1

			is_sufficient: true,

1670

1

}])

1671

1

		.build()

1672

1

		.execute_with(|| {

1673

1

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

1674

1

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

1675

1

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

1676

1

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

1677

1

			// know with which version to send

1678

1

			assert_noop!(

1679

1

				PolkadotXcm::transfer_assets(

1680

1

					origin_of(AccountId::from(ALICE)),

1681

1

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

1682

1

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

1683

1

						parents: 0,

1684

1

						interior: [AccountId32 {

1685

1

							network: None,

1686

1

							id: [1u8; 32],

1687

1

}]

1688

1

						.into(),

1689

1

					})),

1690

1

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

1691

1

0,

1692

1

					WeightLimit::Unlimited

1693

1

),

1694

1

				pallet_xcm::Error::<Runtime>::SendFailure

1695

1

);

1696

1697

			// Root sets the defaultXcm

1698

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1699

1

				root_origin(),

1700

1

				Some(3)

1701

1

));

1702

1703

			// Now transferring does not fail

1704

1

			assert_ok!(PolkadotXcm::transfer_assets(

1705

1

				origin_of(AccountId::from(ALICE)),

1706

1

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

1707

1

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

1708

1

					parents: 0,

1709

1

					interior: [AccountId32 {

1710

1

						network: None,

1711

1

						id: [1u8; 32],

1712

1

}]

1713

1

					.into(),

1714

1

				})),

1715

1

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

1716

1

0,

1717

1

				WeightLimit::Unlimited

1718

1

));

1719

1

})

1720

1

1721

1722

#[test]

1723

1

fn asset_can_be_registered() {

1724

1

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

1725

1

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

1726

1

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

1727

1

		let asset_metadata = AssetRegistrarMetadata {

1728

1

			name: b"RelayToken".to_vec(),

1729

1

			symbol: b"Relay".to_vec(),

1730

1

			decimals: 12,

1731

1

			is_frozen: false,

1732

1

};

1733

1

		assert_ok!(AssetManager::register_foreign_asset(

1734

1

			moonbeam_runtime::RuntimeOrigin::root(),

1735

1

			source_location,

1736

1

			asset_metadata,

1737

1

			1u128,

1738

1

			true

1739

1

));

1740

1

		assert!(AssetManager::asset_id_type(source_id).is_some());

1741

1

});

1742

1

1743

1744

#[test]

1745

1

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1746

1

	ExtBuilder::default()

1747

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1748

1

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

1749

1

			metadata: AssetRegistrarMetadata {

1750

1

				name: b"RelayToken".to_vec(),

1751

1

				symbol: b"Relay".to_vec(),

1752

1

				decimals: 12,

1753

1

				is_frozen: false,

1754

1

},

1755

1

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

1756

1

			is_sufficient: true,

1757

1

}])

1758

1

		.with_balances(vec![

1759

1

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

1760

1

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

1761

1

])

1762

1

		.build()

1763

1

		.execute_with(|| {

1764

1

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

1765

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1766

1

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

1767

1

1768

1

			// Its address is

1769

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1770

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1771

1

				relay_asset_id,

1772

1

);

1773

1

1774

1

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

1775

1

			assert_eq!(

1776

1

				moonbeam_runtime::Assets::total_supply(relay_asset_id),

1777

1

				1_000 * GLMR

1778

1

);

1779

1780

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

1781

1

			Precompiles::new()

1782

1

				.prepare_test(

1783

1

					ALICE,

1784

1

					asset_precompile_address,

1785

1

					ForeignAssetsPCall::total_supply {},

1786

1

1787

1

				.expect_cost(5007)

1788

1

				.expect_no_logs()

1789

1

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

1790

1

1791

1

			// Access balanceOf through precompile

1792

1

			Precompiles::new()

1793

1

				.prepare_test(

1794

1

					ALICE,

1795

1

					asset_precompile_address,

1796

1

					ForeignAssetsPCall::balance_of {

1797

1

						who: Address(ALICE.into()),

1798

1

},

1799

1

1800

1

				.expect_cost(5007)

1801

1

				.expect_no_logs()

1802

1

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

1803

1

});

1804

1

1805

1806

#[test]

1807

1

fn xcm_asset_erc20_precompiles_transfer() {

1808

1

	ExtBuilder::default()

1809

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1810

1

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

1811

1

			metadata: AssetRegistrarMetadata {

1812

1

				name: b"RelayToken".to_vec(),

1813

1

				symbol: b"Relay".to_vec(),

1814

1

				decimals: 12,

1815

1

				is_frozen: false,

1816

1

},

1817

1

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

1818

1

			is_sufficient: true,

1819

1

}])

1820

1

		.with_balances(vec![

1821

1

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

1822

1

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

1823

1

])

1824

1

		.build()

1825

1

		.execute_with(|| {

1826

1

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

1827

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1828

1

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

1829

1

1830

1

			// Its address is

1831

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1832

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1833

1

				relay_asset_id,

1834

1

);

1835

1

1836

1

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

1837

1

			Precompiles::new()

1838

1

				.prepare_test(

1839

1

					ALICE,

1840

1

					asset_precompile_address,

1841

1

					ForeignAssetsPCall::transfer {

1842

1

						to: Address(BOB.into()),

1843

1

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

1844

1

},

1845

1

1846

1

				.expect_cost(26580)

1847

1

				.expect_log(log3(

1848

1

					asset_precompile_address,

1849

1

					SELECTOR_LOG_TRANSFER,

1850

1

					H160::from(ALICE),

1851

1

					H160::from(BOB),

1852

1

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

1853

1

))

1854

1

				.execute_returns(true);

1855

1

1856

1

			// Make sure BOB has 400 GLMR

1857

1

			Precompiles::new()

1858

1

				.prepare_test(

1859

1

					BOB,

1860

1

					asset_precompile_address,

1861

1

					ForeignAssetsPCall::balance_of {

1862

1

						who: Address(BOB.into()),

1863

1

},

1864

1

1865

1

				.expect_cost(5007)

1866

1

				.expect_no_logs()

1867

1

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

1868

1

});

1869

1

1870

1871

#[test]

1872

1

fn xcm_asset_erc20_precompiles_approve() {

1873

1

	ExtBuilder::default()

1874

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1875

1

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

1876

1

			metadata: AssetRegistrarMetadata {

1877

1

				name: b"RelayToken".to_vec(),

1878

1

				symbol: b"Relay".to_vec(),

1879

1

				decimals: 12,

1880

1

				is_frozen: false,

1881

1

},

1882

1

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

1883

1

			is_sufficient: true,

1884

1

}])

1885

1

		.with_balances(vec![

1886

1

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

1887

1

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

1888

1

])

1889

1

		.build()

1890

1

		.execute_with(|| {

1891

1

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

1892

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1893

1

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

1894

1

1895

1

			// Its address is

1896

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1897

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1898

1

				relay_asset_id,

1899

1

);

1900

1

1901

1

			// Aprove Bob for spending 400 GLMR from Alice

1902

1

			Precompiles::new()

1903

1

				.prepare_test(

1904

1

					ALICE,

1905

1

					asset_precompile_address,

1906

1

					ForeignAssetsPCall::approve {

1907

1

						spender: Address(BOB.into()),

1908

1

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

1909

1

},

1910

1

1911

1

				.expect_cost(17323)

1912

1

				.expect_log(log3(

1913

1

					asset_precompile_address,

1914

1

					SELECTOR_LOG_APPROVAL,

1915

1

					H160::from(ALICE),

1916

1

					H160::from(BOB),

1917

1

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

1918

1

))

1919

1

				.execute_returns(true);

1920

1

1921

1

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

1922

1

			Precompiles::new()

1923

1

				.prepare_test(

1924

1

					BOB,

1925

1

					asset_precompile_address,

1926

1

					ForeignAssetsPCall::transfer_from {

1927

1

						from: Address(ALICE.into()),

1928

1

						to: Address(CHARLIE.into()),

1929

1

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

1930

1

},

1931

1

1932

1

				.expect_cost(31887)

1933

1

				.expect_log(log3(

1934

1

					asset_precompile_address,

1935

1

					SELECTOR_LOG_TRANSFER,

1936

1

					H160::from(ALICE),

1937

1

					H160::from(CHARLIE),

1938

1

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

1939

1

))

1940

1

				.execute_returns(true);

1941

1

1942

1

			// Make sure CHARLIE has 400 GLMR

1943

1

			Precompiles::new()

1944

1

				.prepare_test(

1945

1

					CHARLIE,

1946

1

					asset_precompile_address,

1947

1

					ForeignAssetsPCall::balance_of {

1948

1

						who: Address(CHARLIE.into()),

1949

1

},

1950

1

1951

1

				.expect_cost(5007)

1952

1

				.expect_no_logs()

1953

1

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

1954

1

});

1955

1

1956

1957

#[test]

1958

1

fn xtokens_precompile_transfer() {

1959

2

	fn run_test_variant(evm_native: bool) {

1960

2

		let mut builder = ExtBuilder::default();

1961

2

1962

2

		if evm_native {

1963

1

			builder = builder.with_evm_native_foreign_assets();

1964

1

1965

1966

2

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

1967

2

		builder

1968

2

			.with_xcm_assets(vec![XcmAssetInitialization {

1969

2

				asset_type: asset_type.clone(),

1970

2

				metadata: AssetRegistrarMetadata {

1971

2

					name: b"RelayToken".to_vec(),

1972

2

					symbol: b"Relay".to_vec(),

1973

2

					decimals: 12,

1974

2

					is_frozen: false,

1975

2

},

1976

2

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

1977

2

				is_sufficient: true,

1978

2

}])

1979

2

			.with_balances(vec![

1980

2

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

1981

2

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

1982

2

])

1983

2

			.with_safe_xcm_version(3)

1984

2

			.build()

1985

2

			.execute_with(|| {

1986

2

				let xtokens_precompile_address = H160::from_low_u64_be(2052);

1987

2

1988

2

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

1989

2

				let relay_asset_id: moonbeam_runtime::AssetId =

1990

2

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

1991

2

1992

2

				// Its address is

1993

2

				let asset_precompile_address = Runtime::asset_id_to_account(

1994

2

					FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1995

2

					relay_asset_id,

1996

2

);

1997

2

1998

2

				// Alice has 1000 tokens. She should be able to send through precompile

1999

2

				let destination = Location::new(

2000

2

1,

2001

2

					[Junction::AccountId32 {

2002

2

						network: None,

2003

2

						id: [1u8; 32],

2004

2

}],

2005

2

);

2006

2

2007

2

				let inside = Rc::new(Cell::new(false));

2008

2

				let inside2 = inside.clone();

2009

2

2010

2

				// We use the address of the asset as an identifier of the asset we want to transfer

2011

2

				Precompiles::new()

2012

2

					.prepare_test(

2013

2

						ALICE,

2014

2

						xtokens_precompile_address,

2015

2

						XtokensPCall::transfer {

2016

2

							currency_address: Address(asset_precompile_address.into()),

2017

2

							amount: 500_000_000_000_000u128.into(),

2018

2

							destination,

2019

2

							weight: 4_000_000,

2020

2

},

2021

2

2022

2

					.expect_cost(if evm_native { 178453 } else { 26853 })

2023

2

					.expect_no_logs()

2024

2

					// We expect an evm subcall ERC20.burnFrom

2025

2

					.with_subcall_handle(move |subcall| {

2026

1

						let Subcall {

2027

1

							address,

2028

1

							transfer,

2029

1

							input,

2030

1

							target_gas: _,

2031

1

							is_static,

2032

1

							context,

2033

1

						} = subcall;

2034

1

2035

1

						assert_eq!(context.caller, EvmForeignAssets::account_id().into());

2036

2037

1

						let asset_id: u128 = asset_type.clone().into();

2038

1

						let expected_address: H160 = Runtime::asset_id_to_account(

2039

1

							FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

2040

1

							asset_id,

2041

1

2042

1

						.into();

2043

1

						assert_eq!(address, expected_address);

2044

1

						assert_eq!(is_static, false);

2045

2046

1

						assert!(transfer.is_none());

2047

2048

1

						assert_eq!(context.address, expected_address);

2049

1

						assert_eq!(context.apparent_value, 0u8.into());

2050

2051

1

						assert_eq!(&input[..4], &keccak256!("burnFrom(address,uint256)")[..4]);

2052

1

						assert_eq!(&input[4..16], &[0u8; 12]);

2053

1

						assert_eq!(&input[16..36], ALICE);

2054

2055

1

						inside2.set(true);

2056

1

2057

1

						SubcallOutput {

2058

1

							output: Default::default(),

2059

1

							cost: 149_000,

2060

1

							logs: vec![],

2061

1

							..SubcallOutput::succeed()

2062

1

2063

2

})

2064

2

					.execute_returns(())

2065

2

})

2066

2

2067

2068

1

	run_test_variant(false);

2069

1

	run_test_variant(true);

2070

1

2071

2072

#[test]

2073

1

fn xtokens_precompile_transfer_multiasset() {

2074

1

	ExtBuilder::default()

2075

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2076

1

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

2077

1

			metadata: AssetRegistrarMetadata {

2078

1

				name: b"RelayToken".to_vec(),

2079

1

				symbol: b"Relay".to_vec(),

2080

1

				decimals: 12,

2081

1

				is_frozen: false,

2082

1

},

2083

1

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

2084

1

			is_sufficient: true,

2085

1

}])

2086

1

		.with_balances(vec![

2087

1

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

2088

1

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

2089

1

])

2090

1

		.with_safe_xcm_version(3)

2091

1

		.build()

2092

1

		.execute_with(|| {

2093

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

2094

1

2095

1

			// Alice has 1000 tokens. She should be able to send through precompile

2096

1

			let destination = Location::new(

2097

1

1,

2098

1

				[Junction::AccountId32 {

2099

1

					network: None,

2100

1

					id: [1u8; 32],

2101

1

}],

2102

1

);

2103

1

2104

1

			// This time we transfer it through TransferMultiAsset

2105

1

			// Instead of the address, we encode directly the multilocation referencing the asset

2106

1

			Precompiles::new()

2107

1

				.prepare_test(

2108

1

					ALICE,

2109

1

					xtokens_precompile_address,

2110

1

					XtokensPCall::transfer_multiasset {

2111

1

						// We want to transfer the relay token

2112

1

						asset: Location::parent(),

2113

1

						amount: 500_000_000_000_000u128.into(),

2114

1

						destination,

2115

1

						weight: 4_000_000,

2116

1

},

2117

1

2118

1

				.expect_cost(26853)

2119

1

				.expect_no_logs()

2120

1

				.execute_returns(());

2121

1

})

2122

1

2123

2124

#[test]

2125

1

fn make_sure_glmr_can_be_transferred_precompile() {

2126

1

	ExtBuilder::default()

2127

1

		.with_balances(vec![

2128

1

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

2129

1

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

2130

1

])

2131

1

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

2132

1

		.with_mappings(vec![(

2133

1

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

2134

1

			AccountId::from(ALICE),

2135

1

)])

2136

1

		.with_safe_xcm_version(3)

2137

1

		.build()

2138

1

		.execute_with(|| {

2139

1

			assert_ok!(PolkadotXcm::transfer_assets(

2140

1

				origin_of(AccountId::from(ALICE)),

2141

1

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

2142

1

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

2143

1

					parents: 0,

2144

1

					interior: [AccountId32 {

2145

1

						network: None,

2146

1

						id: [1u8; 32],

2147

1

}]

2148

1

					.into(),

2149

1

				})),

2150

1

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

2151

1

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

2152

1

					fun: Fungible(1000)

2153

1

				})),

2154

1

0,

2155

1

				WeightLimit::Limited(40000.into())

2156

1

));

2157

1

});

2158

1

2159

2160

#[test]

2161

1

fn make_sure_glmr_can_be_transferred() {

2162

1

	ExtBuilder::default()

2163

1

		.with_balances(vec![

2164

1

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

2165

1

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

2166

1

])

2167

1

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

2168

1

		.with_mappings(vec![(

2169

1

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

2170

1

			AccountId::from(ALICE),

2171

1

)])

2172

1

		.with_safe_xcm_version(3)

2173

1

		.build()

2174

1

		.execute_with(|| {

2175

1

			let dest = Location {

2176

1

				parents: 1,

2177

1

				interior: [AccountId32 {

2178

1

					network: None,

2179

1

					id: [1u8; 32],

2180

1

}]

2181

1

				.into(),

2182

1

};

2183

1

			assert_ok!(PolkadotXcm::transfer_assets(

2184

1

				origin_of(AccountId::from(ALICE)),

2185

1

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

2186

1

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

2187

1

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

2188

1

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

2189

1

					fun: Fungible(100)

2190

1

				})),

2191

1

0,

2192

1

				WeightLimit::Limited(40000.into())

2193

1

));

2194

1

});

2195

1

2196

2197

#[test]

2198

1

fn make_sure_polkadot_xcm_cannot_be_called() {

2199

1

	ExtBuilder::default()

2200

1

		.with_balances(vec![

2201

1

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

2202

1

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

2203

1

])

2204

1

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

2205

1

		.with_mappings(vec![(

2206

1

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

2207

1

			AccountId::from(ALICE),

2208

1

)])

2209

1

		.build()

2210

1

		.execute_with(|| {

2211

1

			let dest = Location {

2212

1

				parents: 1,

2213

1

				interior: [AccountId32 {

2214

1

					network: None,

2215

1

					id: [1u8; 32],

2216

1

}]

2217

1

				.into(),

2218

1

};

2219

1

			let assets: Assets = [Asset {

2220

1

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

2221

1

				fun: Fungible(1000),

2222

1

}]

2223

1

			.to_vec()

2224

1

			.into();

2225

1

			assert_noop!(

2226

1

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

2227

1

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

2228

1

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

2229

1

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

2230

1

					fee_asset_item: 0,

2231

1

})

2232

1

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

2233

1

					AccountId::from(ALICE)

2234

1

)),

2235

1

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

2236

1

);

2237

1

});

2238

1

2239

2240

#[test]

2241

1

fn transact_through_signed_precompile_works_v2() {

2242

1

	ExtBuilder::default()

2243

1

		.with_balances(vec![

2244

1

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

2245

1

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

2246

1

])

2247

1

		.with_safe_xcm_version(3)

2248

1

		.build()

2249

1

		.execute_with(|| {

2250

1

			// Destination

2251

1

			let dest = Location::parent();

2252

1

2253

1

			let fee_payer_asset = Location::parent();

2254

1

2255

1

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

2256

1

2257

1

			let total_weight = 1_000_000_000u64;

2258

1

2259

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2260

1

2261

1

			Precompiles::new()

2262

1

				.prepare_test(

2263

1

					ALICE,

2264

1

					xcm_transactor_v2_precompile_address,

2265

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2266

1

						dest,

2267

1

						fee_asset: fee_payer_asset,

2268

1

						weight: 4_000_000,

2269

1

						call: bytes.into(),

2270

1

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

2271

1

						overall_weight: total_weight,

2272

1

},

2273

1

2274

1

				.expect_cost(25242)

2275

1

				.expect_no_logs()

2276

1

				.execute_returns(());

2277

1

});

2278

1

2279

2280

#[test]

2281

1

fn transact_through_signed_cannot_send_to_local_chain() {

2282

1

	ExtBuilder::default()

2283

1

		.with_balances(vec![

2284

1

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

2285

1

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

2286

1

])

2287

1

		.with_safe_xcm_version(3)

2288

1

		.build()

2289

1

		.execute_with(|| {

2290

1

			// Destination

2291

1

			let dest = Location::here();

2292

1

2293

1

			let fee_payer_asset = Location::parent();

2294

1

2295

1

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

2296

1

2297

1

			let total_weight = 1_000_000_000u64;

2298

1

2299

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2300

1

2301

1

			Precompiles::new()

2302

1

				.prepare_test(

2303

1

					ALICE,

2304

1

					xcm_transactor_v2_precompile_address,

2305

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2306

1

						dest,

2307

1

						fee_asset: fee_payer_asset,

2308

1

						weight: 4_000_000,

2309

1

						call: bytes.into(),

2310

1

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

2311

1

						overall_weight: total_weight,

2312

1

},

2313

1

2314

1

				.execute_reverts(|output| {

2315

1

					from_utf8(&output)

2316

1

						.unwrap()

2317

1

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

2318

1

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

2319

1

});

2320

1

});

2321

1

2322

2323

#[test]

2324

1

fn transactor_cannot_use_more_than_max_weight() {

2325

1

	ExtBuilder::default()

2326

1

		.with_balances(vec![

2327

1

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

2328

1

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

2329

1

])

2330

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2331

1

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

2332

1

			metadata: AssetRegistrarMetadata {

2333

1

				name: b"RelayToken".to_vec(),

2334

1

				symbol: b"Relay".to_vec(),

2335

1

				decimals: 12,

2336

1

				is_frozen: false,

2337

1

},

2338

1

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

2339

1

			is_sufficient: true,

2340

1

}])

2341

1

		.build()

2342

1

		.execute_with(|| {

2343

1

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

2344

1

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

2345

1

			assert_ok!(XcmTransactor::register(

2346

1

				root_origin(),

2347

1

				AccountId::from(ALICE),

2348

1

0,

2349

1

));

2350

2351

			// Root can set transact info

2352

1

			assert_ok!(XcmTransactor::set_transact_info(

2353

1

				root_origin(),

2354

1

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

2355

1

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

2356

1

				3000.into(),

2357

1

				20000.into(),

2358

1

				None

2359

1

));

2360

2361

			// Root can set transact info

2362

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2363

1

				root_origin(),

2364

1

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

2365

1

1,

2366

1

));

2367

2368

1

			assert_noop!(

2369

1

				XcmTransactor::transact_through_derivative(

2370

1

					origin_of(AccountId::from(ALICE)),

2371

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

2372

1

0,

2373

1

					CurrencyPayment {

2374

1

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

2375

1

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

2376

1

)),

2377

1

						fee_amount: None

2378

1

},

2379

1

					vec![],

2380

1

					// 2000 is the max

2381

1

					TransactWeights {

2382

1

						transact_required_weight_at_most: 17001.into(),

2383

1

						overall_weight: None

2384

1

},

2385

1

					false

2386

1

),

2387

1

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

2388

1

);

2389

1

			assert_noop!(

2390

1

				XcmTransactor::transact_through_derivative(

2391

1

					origin_of(AccountId::from(ALICE)),

2392

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

2393

1

0,

2394

1

					CurrencyPayment {

2395

1

						currency: Currency::AsCurrencyId(CurrencyId::ForeignAsset(source_id)),

2396

1

						fee_amount: None

2397

1

},

2398

1

					vec![],

2399

1

					// 20000 is the max

2400

1

					TransactWeights {

2401

1

						transact_required_weight_at_most: 17001.into(),

2402

1

						overall_weight: None

2403

1

},

2404

1

					false

2405

1

),

2406

1

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

2407

1

);

2408

1

})

2409

1

2410

2411

#[test]

2412

1

fn call_xtokens_with_fee() {

2413

1

	ExtBuilder::default()

2414

1

		.with_balances(vec![

2415

1

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

2416

1

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

2417

1

])

2418

1

		.with_safe_xcm_version(3)

2419

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2420

1

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

2421

1

			metadata: AssetRegistrarMetadata {

2422

1

				name: b"RelayToken".to_vec(),

2423

1

				symbol: b"Relay".to_vec(),

2424

1

				decimals: 12,

2425

1

				is_frozen: false,

2426

1

},

2427

1

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

2428

1

			is_sufficient: true,

2429

1

}])

2430

1

		.build()

2431

1

		.execute_with(|| {

2432

1

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

2433

1

			let dest = Location {

2434

1

				parents: 1,

2435

1

				interior: [AccountId32 {

2436

1

					network: None,

2437

1

					id: [1u8; 32],

2438

1

}]

2439

1

				.into(),

2440

1

};

2441

1

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

2442

1

2443

1

			let before_balance =

2444

1

				moonbeam_runtime::Assets::balance(source_id, &AccountId::from(ALICE));

2445

1

			let (chain_part, beneficiary) =

2446

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2447

1

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

2448

1

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

2449

1

			// We are able to transfer with fee

2450

1

			assert_ok!(PolkadotXcm::transfer_assets(

2451

1

				origin_of(AccountId::from(ALICE)),

2452

1

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

2453

1

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

2454

1

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

2455

1

0,

2456

1

				WeightLimit::Limited(4000000000.into())

2457

1

));

2458

2459

1

			let after_balance =

2460

1

				moonbeam_runtime::Assets::balance(source_id, &AccountId::from(ALICE));

2461

1

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

2462

1

			assert_eq!(before_balance - 100_000_000_000_000 - 100, after_balance);

2463

1

});

2464

1

2465

2466

#[test]

2467

1

fn test_xcm_utils_ml_tp_account() {

2468

1

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

2469

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2470

1

		let expected_address_parent: H160 =

2471

1

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

2472

1

				.unwrap()

2473

1

				.into();

2474

1

2475

1

		Precompiles::new()

2476

1

			.prepare_test(

2477

1

				ALICE,

2478

1

				xcm_utils_precompile_address,

2479

1

				XcmUtilsPCall::multilocation_to_address {

2480

1

					location: Location::parent(),

2481

1

},

2482

1

2483

1

			.expect_cost(3338)

2484

1

			.expect_no_logs()

2485

1

			.execute_returns(Address(expected_address_parent));

2486

1

2487

1

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

2488

1

		let expected_address_parachain: H160 =

2489

1

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

2490

1

				&parachain_2000_location,

2491

1

2492

1

			.unwrap()

2493

1

			.into();

2494

1

2495

1

		Precompiles::new()

2496

1

			.prepare_test(

2497

1

				ALICE,

2498

1

				xcm_utils_precompile_address,

2499

1

				XcmUtilsPCall::multilocation_to_address {

2500

1

					location: parachain_2000_location,

2501

1

},

2502

1

2503

1

			.expect_cost(3338)

2504

1

			.expect_no_logs()

2505

1

			.execute_returns(Address(expected_address_parachain));

2506

1

2507

1

		let alice_in_parachain_2000_location = Location::new(

2508

1

1,

2509

1

2510

1

				Parachain(2000),

2511

1

				AccountKey20 {

2512

1

					network: None,

2513

1

					key: ALICE,

2514

1

},

2515

1

],

2516

1

);

2517

1

		let expected_address_alice_in_parachain_2000 =

2518

1

			xcm_builder::HashedDescription::<

2519

1

				AccountId,

2520

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2521

1

			>::convert_location(&alice_in_parachain_2000_location)

2522

1

			.unwrap()

2523

1

			.into();

2524

1

2525

1

		Precompiles::new()

2526

1

			.prepare_test(

2527

1

				ALICE,

2528

1

				xcm_utils_precompile_address,

2529

1

				XcmUtilsPCall::multilocation_to_address {

2530

1

					location: alice_in_parachain_2000_location,

2531

1

},

2532

1

2533

1

			.expect_cost(3338)

2534

1

			.expect_no_logs()

2535

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2536

1

});

2537

1

2538

2539

#[test]

2540

1

fn test_xcm_utils_weight_message() {

2541

1

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

2542

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2543

1

		let expected_weight =

2544

1

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

2545

1

2546

1

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

2547

1

2548

1

		let input = XcmUtilsPCall::weight_message {

2549

1

			message: message.into(),

2550

1

};

2551

1

2552

1

		Precompiles::new()

2553

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2554

1

			.expect_cost(1669)

2555

1

			.expect_no_logs()

2556

1

			.execute_returns(expected_weight);

2557

1

});

2558

1

2559

2560

#[test]

2561

1

fn test_nested_batch_calls_from_xcm_transact() {

2562

1

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

2563

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2564

1

		// in a future polkadot-sdk version

2565

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2566

2567

1

		let mut valid_nested_calls =

2568

1

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

2569

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2570

8

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

2571

8

				calls: vec![valid_nested_calls],

2572

8

});

2573

8

2574

2575

1

		let valid_message = Xcm(vec![Transact {

2576

1

			origin_kind: OriginKind::SovereignAccount,

2577

1

			fallback_max_weight: None,

2578

1

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

2579

1

		}]);

2580

1

2581

1

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

2582

2583

1

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

2584

1

			calls: vec![valid_nested_calls],

2585

1

});

2586

1

2587

1

		let invalid_message = Xcm(vec![Transact {

2588

1

			origin_kind: OriginKind::SovereignAccount,

2589

1

			fallback_max_weight: None,

2590

1

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

2591

1

		}]);

2592

1

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

2593

1

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

2594

1

});

2595

1

2596

2597

#[test]

2598

1

fn test_xcm_utils_get_units_per_second() {

2599

1

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

2600

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2601

1

		let location = SelfReserve::get();

2602

1

2603

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2604

1

2605

1

		let expected_units =

2606

1

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

2607

1

2608

1

		Precompiles::new()

2609

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2610

1

			.expect_cost(3338)

2611

1

			.expect_no_logs()

2612

1

			.execute_returns(expected_units);

2613

1

});

2614

1

2615

2616

#[test]

2617

1

fn precompile_existence() {

2618

1

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

2619

1

		let precompiles = Precompiles::new();

2620

1

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

2621

1

			1, 2, 3, 4, 5, 6, 7, 8, 9, 256, 1024, 1025, 1026, 2048, 2049, 2050, 2051, 2052, 2053,

2622

1

			2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067,

2623

1

			2068, 2069, 2070, 2071, 2072, 2073, 2074,

2624

1

2625

1

		.into_iter()

2626

1

		.map(H160::from_low_u64_be)

2627

1

		.collect();

2628

2629

3001

		for i in 0..3000 {

2630

3000

			let address = H160::from_low_u64_be(i);

2631

3000

2632

3000

			if precompile_addresses.contains(&address) {

2633

40

				assert!(

2634

40

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

2635

					"is_precompile({}) should return true",

2636

2637

);

2638

2639

40

				assert!(

2640

40

					precompiles

2641

40

						.execute(&mut MockHandle::new(

2642

40

							address,

2643

40

							Context {

2644

40

								address,

2645

40

								caller: H160::zero(),

2646

40

								apparent_value: U256::zero()

2647

40

2648

40

),)

2649

40

						.is_some(),

2650

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

2651

2652

);

2653

			} else {

2654

2960

				assert!(

2655

2960

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

2656

					"is_precompile({}) should return false",

2657

2658

);

2659

2660

2960

				assert!(

2661

2960

					precompiles

2662

2960

						.execute(&mut MockHandle::new(

2663

2960

							address,

2664

2960

							Context {

2665

2960

								address,

2666

2960

								caller: H160::zero(),

2667

2960

								apparent_value: U256::zero()

2668

2960

2669

2960

),)

2670

2960

						.is_none(),

2671

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

2672

2673

);

2674

2675

2676

1

});

2677

1

2678

2679

#[test]

2680

1

fn removed_precompiles() {

2681

1

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

2682

1

		let precompiles = Precompiles::new();

2683

1

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

2684

2685

3000

		for i in 1..3000 {

2686

2999

			let address = H160::from_low_u64_be(i);

2687

2999

2688

2999

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

2689

2959

				continue;

2690

40

2691

40

2692

40

			if !removed_precompiles.contains(&i) {

2693

36

				assert!(

2694

36

					match precompiles.is_active_precompile(address, 100_000u64) {

2695

36

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

2696

						_ => false,

2697

},

2698

					"{i} should be an active precompile"

2699

);

2700

36

				continue;

2701

4

2702

4

2703

4

			assert!(

2704

4

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

2705

4

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

2706

					_ => false,

2707

},

2708

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

2709

);

2710

2711

4

			precompiles

2712

4

				.prepare_test(Alice, address, [])

2713

4

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

2714

4

2715

1

})

2716

1

2717

2718

#[test]

2719

1

fn deal_with_fees_handles_tip() {

2720

	use frame_support::traits::OnUnbalanced;

2721

	use moonbeam_runtime::Treasury;

2722

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2723

2724

1

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

2725

1

		set_parachain_inherent_data();

2726

1

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

2727

1

		// in the Moonbeam runtime. It verifies that:

2728

1

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

2729

1

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

2730

1

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

2731

1

2732

1

		// The test details:

2733

1

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

2734

1

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

2735

1

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

2736

1

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

2737

1

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

2738

1

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

2739

1

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

2740

1

2741

1

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

2742

1

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

2743

1

			AccountId,

2744

1

		>>::issue(100);

2745

1

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

2746

1

			AccountId,

2747

1

		>>::issue(1000);

2748

1

2749

1

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

2750

1

		let total_supply_before = Balances::total_issuance();

2751

1

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

2752

1

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

2753

1

		assert_eq!(total_supply_before, 1_100);

2754

1

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

2755

2756

		// Step 3: Execute the fees handling logic.

2757

1

		DealWithSubstrateFeesAndTip::<

2758

1

			Runtime,

2759

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2760

1

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

2761

1

2762

1

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

2763

1

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

2764

1

2765

1

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

2766

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2767

1

2768

1

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

2769

1

		assert_eq!(

2770

1

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

2771

1

			treasury_fee_part,

2772

1

);

2773

2774

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

2775

1

		let total_supply_after = Balances::total_issuance();

2776

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2777

2778

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

2779

1

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

2780

1

		assert_eq!(

2781

1

			block_author_balance_after - block_author_balance_before,

2782

1

			1000,

2783

1

);

2784

1

});

2785

1

2786

2787

#[test]

2788

1

fn evm_revert_substrate_events() {

2789

1

	ExtBuilder::default()

2790

1

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

2791

1

		.build()

2792

1

		.execute_with(|| {

2793

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2794

1

2795

1

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

2796

1

			// Thus BatchAll will revert the transfer.

2797

1

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

2798

1

				source: ALICE.into(),

2799

1

				target: batch_precompile_address,

2800

1

2801

1

				input: BatchPCall::batch_all {

2802

1

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

2803

1

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

2804

1

					call_data: vec![].into(),

2805

1

					gas_limit: vec![].into()

2806

1

2807

1

				.into(),

2808

1

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

2809

1

				gas_limit: 500_000,

2810

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2811

1

				max_priority_fee_per_gas: None,

2812

1

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

2813

1

				access_list: Vec::new(),

2814

1

})

2815

1

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

2816

2817

1

			let transfer_count = System::events()

2818

1

				.iter()

2819

6

				.filter(|r| match r.event {

2820

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

2821

6

					_ => false,

2822

6

})

2823

1

				.count();

2824

1

2825

1

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

2826

1

});

2827

1

2828

2829

#[test]

2830

1

fn evm_success_keeps_substrate_events() {

2831

1

	ExtBuilder::default()

2832

1

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

2833

1

		.build()

2834

1

		.execute_with(|| {

2835

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2836

1

2837

1

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

2838

1

				source: ALICE.into(),

2839

1

				target: batch_precompile_address,

2840

1

				input: BatchPCall::batch_all {

2841

1

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

2842

1

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

2843

1

					call_data: vec![].into(),

2844

1

					gas_limit: vec![].into()

2845

1

2846

1

				.into(),

2847

1

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

2848

1

				gas_limit: 500_000,

2849

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2850

1

				max_priority_fee_per_gas: None,

2851

1

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

2852

1

				access_list: Vec::new(),

2853

1

})

2854

1

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

2855

2856

1

			let transfer_count = System::events()

2857

1

				.iter()

2858

10

				.filter(|r| match r.event {

2859

1

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

2860

9

					_ => false,

2861

10

})

2862

1

				.count();

2863

1

2864

1

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

2865

1

});

2866

1

2867

2868

#[cfg(test)]

2869

mod bridge_tests {

2870

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

2871

	use crate::currency_to_asset;

2872

	use bp_messages::target_chain::DispatchMessageData;

2873

	use bp_messages::ReceptionResult;

2874

	use bp_runtime::messages::MessageDispatchResult;

2875

	use cumulus_primitives_core::AggregateMessageOrigin;

2876

	use frame_support::assert_ok;

2877

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

2878

	use moonbeam_core_primitives::AccountId;

2879

	use moonbeam_runtime::asset_config::AssetRegistrarMetadata;

2880

	use moonbeam_runtime::bridge_config::{

2881

		KusamaGlobalConsensusNetwork, WithKusamaMessagesInstance,

2882

};

2883

	use moonbeam_runtime::currency::GLMR;

2884

	use moonbeam_runtime::xcm_config::{AssetType, CurrencyId};

2885

	use moonbeam_runtime::{

2886

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

2887

		RuntimeEvent, System,

2888

};

2889

	use pallet_bridge_messages::{LanesManager, StoredMessagePayload};

2890

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

2891

	use parity_scale_codec::{Decode, Encode};

2892

	use sp_core::H256;

2893

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

2894

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

2895

	use xcm::prelude::{

2896

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

2897

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

2898

		SetTopic, UniversalOrigin, XCM_VERSION,

2899

};

2900

	use xcm::v5::WildAsset;

2901

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

2902

	use xcm_builder::BridgeMessage;

2903

2904

1

	fn next_block() {

2905

1

		System::reset_events();

2906

1

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

2907

1

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

2908

1

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

2909

1

2910

2911

	#[test]

2912

1

	fn transfer_asset_moonbeam_to_moonriver() {

2913

1

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

2914

1

2915

1

		ExtBuilder::default()

2916

1

			.with_balances(vec![

2917

1

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

2918

1

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

2919

1

])

2920

1

			.with_safe_xcm_version(XCM_VERSION)

2921

1

			.with_open_bridges(vec![(

2922

1

				Location::new(

2923

1

1,

2924

1

					[Parachain(

2925

1

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

2926

1

)],

2927

1

),

2928

1

				Junctions::from([

2929

1

					NetworkId::Kusama.into(),

2930

1

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

2931

1

]),

2932

1

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

2933

1

)])

2934

1

			.build()

2935

1

			.execute_with(|| {

2936

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2937

1

					root_origin(),

2938

1

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

2939

1

					XCM_VERSION

2940

1

));

2941

2942

1

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

2943

1

2944

1

				let message_data = BridgeKusamaMessages::outbound_message_data(

2945

1

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

2946

1

					1u64,

2947

1

);

2948

1

				assert!(message_data.is_none());

2949

2950

1

				assert_ok!(PolkadotXcm::transfer_assets(

2951

1

					origin_of(AccountId::from(ALICE)),

2952

1

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

2953

1

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

2954

1

						parents: 0,

2955

1

						interior: [AccountKey20 {

2956

1

							network: None,

2957

1

							key: ALICE,

2958

1

}]

2959

1

						.into(),

2960

1

					})),

2961

1

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

2962

1

0,

2963

1

					WeightLimit::Unlimited

2964

1

));

2965

2966

1

				let message_data = BridgeKusamaMessages::outbound_message_data(

2967

1

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

2968

1

					1u64,

2969

1

				).unwrap();

2970

1

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

2971

1

2972

1

				let BridgeMessage { universal_dest, message } =

2973

1

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

2974

1

2975

1

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

2976

1

				assert_eq!(universal_dest, expected_universal_dest);

2977

2978

1

				assert_eq!(

2979

1

					message,

2980

1

					VersionedXcm::V5(

2981

1

						Xcm(

2982

1

2983

1

								UniversalOrigin(GlobalConsensus(NetworkId::Polkadot)),

2984

1

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

2985

1

								ReserveAssetDeposited(

2986

1

									vec![

2987

1

										Asset {

2988

1

											id: AssetId(

2989

1

												Location::new(

2990

1

2,

2991

1

2992

1

														GlobalConsensus(NetworkId::Polkadot),

2993

1

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

2994

1

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

2995

1

2996

1

2997

1

),

2998

1

											fun: Fungible(100_000_000_000_000_000_000)

2999

1

3000

1

									].into()

3001

1

),

3002

1

								ClearOrigin,

3003

1

								BuyExecution {

3004

1

									fees: Asset {

3005

1

										id: AssetId(

3006

1

											Location::new(

3007

1

2,

3008

1

3009

1

													GlobalConsensus(NetworkId::Polkadot),

3010

1

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

3011

1

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

3012

1

3013

1

3014

1

),

3015

1

										fun: Fungible(100_000_000_000_000_000_000)

3016

1

},

3017

1

									weight_limit: WeightLimit::Unlimited

3018

1

},

3019

1

								DepositAsset {

3020

1

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

3021

1

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

3022

1

},

3023

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

3024

1

							].into()

3025

1

3026

1

3027

1

);

3028

1

})

3029

1

3030

3031

	#[test]

3032

1

	fn receive_message_from_moonriver() {

3033

1

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

3034

1

3035

1

		ExtBuilder::default()

3036

1

			.with_balances(vec![

3037

1

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

3038

1

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

3039

1

])

3040

1

			.with_evm_native_foreign_assets()

3041

1

			.with_xcm_assets(vec![XcmAssetInitialization {

3042

1

				asset_type: AssetType::Xcm(xcm::VersionedLocation::from(Location::new(

3043

1

2,

3044

1

3045

1

						GlobalConsensus(KusamaGlobalConsensusNetwork::get()),

3046

1

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

3047

1

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

3048

1

3049

1

				)).try_into().unwrap()),

3050

1

				metadata: AssetRegistrarMetadata {

3051

1

					name: b"xcMOVR".to_vec(),

3052

1

					symbol: b"xcMOVR".to_vec(),

3053

1

					decimals: 18,

3054

1

					is_frozen: false,

3055

1

},

3056

1

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

3057

1

				is_sufficient: true,

3058

1

}])

3059

1

			.with_safe_xcm_version(XCM_VERSION)

3060

1

			.with_open_bridges(vec![(

3061

1

				Location::new(

3062

1

1,

3063

1

					[Parachain(

3064

1

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

3065

1

)],

3066

1

),

3067

1

				Junctions::from([

3068

1

					NetworkId::Kusama.into(),

3069

1

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

3070

1

]),

3071

1

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

3072

1

)])

3073

1

			.build()

3074

1

			.execute_with(|| {

3075

1

				assert_ok!(PolkadotXcm::force_xcm_version(

3076

1

					root_origin(),

3077

1

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

3078

1

					XCM_VERSION

3079

1

));

3080

3081

1

				let bridge_message: BridgeMessage = BridgeMessage {

3082

1

					universal_dest: VersionedInteriorLocation::V5(

3083

1

3084

1

							GlobalConsensus(NetworkId::Polkadot),

3085

1

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

3086

1

						].into()

3087

1

),

3088

1

					message: VersionedXcm::V5(

3089

1

						Xcm(

3090

1

3091

1

								UniversalOrigin(GlobalConsensus(NetworkId::Kusama)),

3092

1

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

3093

1

								ReserveAssetDeposited(

3094

1

									vec![

3095

1

										Asset {

3096

1

											id: AssetId(

3097

1

												Location::new(

3098

1

2,

3099

1

3100

1

														GlobalConsensus(NetworkId::Kusama),

3101

1

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

3102

1

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

3103

1

3104

1

3105

1

),

3106

1

											fun: Fungible(10_000_000_000_000_000_000_000_000_000_000_000)

3107

1

3108

1

									].into()

3109

1

),

3110

1

								ClearOrigin,

3111

1

								BuyExecution {

3112

1

									fees: Asset {

3113

1

										id: AssetId(

3114

1

											Location::new(

3115

1

2,

3116

1

3117

1

													GlobalConsensus(NetworkId::Kusama),

3118

1

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

3119

1

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

3120

1

3121

1

3122

1

),

3123

1

										fun: Fungible(6_000_000_000_000_000_000_000_000_000_000_000)

3124

1

},

3125

1

									weight_limit: WeightLimit::Unlimited

3126

1

},

3127

1

								DepositAsset {

3128

1

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

3129

1

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

3130

1

},

3131

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

3132

1

							].into()

3133

1

3134

1

3135

1

};

3136

1

3137

1

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

3138

1

					.active_inbound_lane(Default::default())

3139

1

					.unwrap();

3140

1

3141

1

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

3142

1

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

3143

1

1,

3144

1

					msg,

3145

1

);

3146

1

3147

1

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

3148

3149

				// Produce next block

3150

1

				next_block();

3151

1

				// Confirm that the xcm message was successfully processed

3152

7

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

3153

1

					matches!(

3154

1

						evt.event,

3155

						RuntimeEvent::MessageQueue(

3156

							pallet_message_queue::Event::Processed {

3157

								origin: AggregateMessageOrigin::Here,

3158

								success: true,

3159

..

3160

3161

3162

3163

7

				}));

3164

1

});

3165

1

3166

3167

3168

#[cfg(test)]

3169

mod treasury_tests {

3170

	use super::*;

3171

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

3172

	use moonbeam_runtime::XcmWeightTrader;

3173

	use sp_core::bounded_vec;

3174

	use sp_runtime::traits::Hash;

3175

3176

4

	fn expect_events(events: Vec<RuntimeEvent>) {

3177

4

		let block_events: Vec<RuntimeEvent> =

3178

29

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

3179

4

3180

7

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

3181

4

3182

3183

7

	fn next_block() {

3184

7

		System::reset_events();

3185

7

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

3186

7

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

3187

7

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

3188

7

3189

3190

3

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

3191

3

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

3192

3

			.expect("failed to get account balance")

3193

3

3194

3195

	#[test]

3196

1

	fn test_treasury_spend_local_with_council_origin() {

3197

1

		let initial_treasury_balance = 1_000 * GLMR;

3198

1

		ExtBuilder::default()

3199

1

			.with_balances(vec![

3200

1

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

3201

1

				(Treasury::account_id(), initial_treasury_balance),

3202

1

])

3203

1

			.build()

3204

1

			.execute_with(|| {

3205

1

				let spend_amount = 100u128 * GLMR;

3206

1

				let spend_beneficiary = AccountId::from(BOB);

3207

1

3208

1

				next_block();

3209

1

3210

1

				// TreasuryCouncilCollective

3211

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3212

1

					root_origin(),

3213

1

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

3214

1

					Some(AccountId::from(ALICE)),

3215

1

3216

1

));

3217

3218

1

				next_block();

3219

1

3220

1

				// Perform treasury spending

3221

1

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

3222

1

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

3223

1

					amount: spend_amount,

3224

1

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

3225

1

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

3226

1

					valid_from: Some(valid_from),

3227

1

});

3228

1

				assert_ok!(TreasuryCouncilCollective::propose(

3229

1

					origin_of(AccountId::from(ALICE)),

3230

1

1,

3231

1

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

3232

1

					1_000

3233

1

));

3234

3235

1

				let payout_period =

3236

1

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

3237

1

				let expected_events = [

3238

1

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

3239

1

						index: 0,

3240

1

						asset_kind: NativeOrWithId::Native,

3241

1

						amount: spend_amount,

3242

1

						beneficiary: spend_beneficiary,

3243

1

						valid_from,

3244

1

						expire_at: payout_period + valid_from,

3245

1

}),

3246

1

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

3247

1

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

3248

1

						result: Ok(()),

3249

1

}),

3250

1

3251

1

				.to_vec();

3252

1

				expect_events(expected_events);

3253

3254

6

				while System::block_number() < valid_from {

3255

5

					next_block();

3256

5

3257

3258

1

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

3259

3260

1

				let expected_events = [

3261

1

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

3262

1

						index: 0,

3263

1

						payment_id: (),

3264

1

}),

3265

1

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

3266

1

						from: Treasury::account_id(),

3267

1

						to: spend_beneficiary,

3268

1

						amount: spend_amount,

3269

1

}),

3270

1

3271

1

				.to_vec();

3272

1

				expect_events(expected_events);

3273

1

});

3274

1

3275

3276

	#[test]

3277

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

3278

1

		let initial_treasury_balance = 1_000 * GLMR;

3279

1

		let asset_id = 1000100010001000u128;

3280

1

		ExtBuilder::default()

3281

1

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

3282

1

			.build()

3283

1

			.execute_with(|| {

3284

1

				let spend_amount = 100u128 * GLMR;

3285

1

				let spend_beneficiary = AccountId::from(BOB);

3286

1

3287

1

				let asset_location: Location = Location {

3288

1

					parents: 1,

3289

1

					interior: Junctions::Here,

3290

1

};

3291

1

3292

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

3293

1

					root_origin(),

3294

1

					asset_id,

3295

1

					asset_location.clone(),

3296

1

12,

3297

1

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

3298

1

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

3299

1

));

3300

3301

1

				assert_ok!(XcmWeightTrader::add_asset(

3302

1

					root_origin(),

3303

1

					asset_location,

3304

1

					1u128

3305

1

));

3306

3307

1

				assert_ok!(EvmForeignAssets::mint_into(

3308

1

					asset_id,

3309

1

					Treasury::account_id(),

3310

1

					initial_treasury_balance.into()

3311

1

));

3312

3313

1

				assert_eq!(

3314

1

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

3315

1

					initial_treasury_balance.into(),

3316

					"Treasury balance not updated"

3317

);

3318

3319

				// TreasuryCouncilCollective

3320

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3321

1

					root_origin(),

3322

1

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

3323

1

					Some(AccountId::from(ALICE)),

3324

1

3325

1

));

3326

3327

				// Perform treasury spending

3328

1

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

3329

1

					amount: spend_amount,

3330

1

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

3331

1

					beneficiary: Box::new(spend_beneficiary),

3332

1

					valid_from: None,

3333

1

});

3334

1

				assert_ok!(TreasuryCouncilCollective::propose(

3335

1

					origin_of(AccountId::from(ALICE)),

3336

1

1,

3337

1

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

3338

1

					1_000

3339

1

));

3340

3341

1

				let payout_period =

3342

1

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

3343

1

3344

1

				let current_block = System::block_number();

3345

1

				let expected_events = [

3346

1

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

3347

1

						index: 0,

3348

1

						asset_kind: NativeOrWithId::WithId(asset_id),

3349

1

						amount: spend_amount,

3350

1

						beneficiary: spend_beneficiary,

3351

1

						valid_from: current_block,

3352

1

						expire_at: current_block + payout_period,

3353

1

}),

3354

1

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

3355

1

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

3356

1

						result: Ok(()),

3357

1

}),

3358

1

3359

1

				.to_vec();

3360

1

				expect_events(expected_events);

3361

1

3362

1

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

3363

3364

1

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

3365

1

					index: 0,

3366

1

					payment_id: (),

3367

1

				})]);

3368

1

3369

1

				assert_eq!(

3370

1

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

3371

1

					(initial_treasury_balance - spend_amount).into(),

3372

					"Treasury balance not updated"

3373

);

3374

3375

1

				assert_eq!(

3376

1

					get_asset_balance(&asset_id, &spend_beneficiary),

3377

1

					spend_amount.into(),

3378

					"Treasury payout failed"

3379

);

3380

1

});

3381

1

3382

3383

3384

#[cfg(test)]

3385

mod fee_tests {

3386

	use super::*;

3387

	use fp_evm::FeeCalculator;

3388

	use frame_support::{

3389

		traits::{ConstU128, OnFinalize},

3390

		weights::{ConstantMultiplier, WeightToFee},

3391

};

3392

	use moonbeam_runtime::{

3393

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

3394

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

3395

};

3396

	use sp_core::Get;

3397

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

3398

3399

1

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

3400

1

	where

3401

1

		F: FnMut() -> (),

3402

1

3403

1

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

3404

1

			.build_storage()

3405

1

			.unwrap()

3406

1

			.into();

3407

1

		t.execute_with(|| {

3408

1

			System::set_block_consumed_resources(w, 0);

3409

1

			assertions()

3410

1

});

3411

1

3412

3413

	#[test]

3414

1

	fn test_multiplier_can_grow_from_zero() {

3415

1

		let minimum_multiplier = MinimumMultiplier::get();

3416

1

		let target = TargetBlockFullness::get()

3417

1

			* RuntimeBlockWeights::get()

3418

1

				.get(DispatchClass::Normal)

3419

1

				.max_total

3420

1

				.unwrap();

3421

1

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

3422

1

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

3423

1

		run_with_system_weight(target * 101 / 100, || {

3424

1

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

3425

1

			assert!(

3426

1

				next > minimum_multiplier,

3427

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

3428

				next,

3429

				minimum_multiplier

3430

);

3431

1

})

3432

1

3433

3434

	#[test]

3435

1

	fn test_fee_calculation() {

3436

1

		let base_extrinsic = RuntimeBlockWeights::get()

3437

1

			.get(DispatchClass::Normal)

3438

1

			.base_extrinsic;

3439

1

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

3440

1

		let extrinsic_len = 100u32;

3441

1

		let extrinsic_weight = 5_000u64;

3442

1

		let tip = 42u128;

3443

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

3444

		type LengthToFeeImpl = LengthToFee;

3445

3446

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

3447

1

		let expected_fee =

3448

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3449

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

3450

1

					&Weight::from_parts(extrinsic_weight, 1),

3451

1

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

3452

1

				+ tip;

3453

1

3454

1

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

3455

1

			.build_storage()

3456

1

			.unwrap()

3457

1

			.into();

3458

1

		t.execute_with(|| {

3459

1

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

3460

1

			let actual_fee = TransactionPayment::compute_fee(

3461

1

				extrinsic_len,

3462

1

				&frame_support::dispatch::DispatchInfo {

3463

1

					class: DispatchClass::Normal,

3464

1

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

3465

1

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

3466

1

					extension_weight: Weight::zero(),

3467

1

},

3468

1

				tip,

3469

1

);

3470

1

3471

1

			assert_eq!(

3472

				expected_fee,

3473

				actual_fee,

3474

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

3475

				actual_fee - expected_fee

3476

);

3477

1

});

3478

1

3479

3480

	#[test]

3481

1

	fn test_min_gas_price_is_deterministic() {

3482

1

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

3483

1

			.build_storage()

3484

1

			.unwrap()

3485

1

			.into();

3486

1

		t.execute_with(|| {

3487

1

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

3488

1

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

3489

1

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

3490

1

			let expected: U256 = multiplier

3491

1

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

3492

1

				.into();

3493

1

3494

1

			assert_eq!(expected, actual);

3495

1

});

3496

1

3497

3498

	#[test]

3499

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3500

1

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

3501

1

			.build_storage()

3502

1

			.unwrap()

3503

1

			.into();

3504

1

		t.execute_with(|| {

3505

1

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

3506

1

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

3507

1

3508

1

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

3509

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3510

1

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

3511

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3512

1

3513

1

			assert_ne!(

3514

				a, b,

3515

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

3516

);

3517

1

});

3518

1

3519

3520

	#[test]

3521

1

	fn test_fee_scenarios() {

3522

		use sp_runtime::FixedU128;

3523

1

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

3524

1

			.build_storage()

3525

1

			.unwrap()

3526

1

			.into();

3527

1

		t.execute_with(|| {

3528

1

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

3529

12

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

3530

12

				let start_multiplier =

3531

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3532

12

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

3533

12

3534

12

				let block_weight = NORMAL_WEIGHT * fullness;

3535

3536

60004

				for i in 0..num_blocks {

3537

60004

					System::set_block_number(i as u32);

3538

60004

					System::set_block_consumed_resources(block_weight, 0);

3539

60004

					TransactionPayment::on_finalize(i as u32);

3540

60004

3541

3542

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3543

12

};

3544

3545

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

3546

			// they are expected to change when parameters that influence

3547

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

3548

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

3549

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

3550

3551

1

			assert_eq!(

3552

1

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

3553

1

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

3554

1

);

3555

1

			assert_eq!(

3556

1

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

3557

1

				U256::from(31_250_000_000u128),

3558

1

);

3559

1

			assert_eq!(

3560

1

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

3561

1

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

3562

1

);

3563

1

			assert_eq!(

3564

1

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

3565

1

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

3566

1

);

3567

3568

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

3569

1

			assert_eq!(

3570

1

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

3571

1

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

3572

1

);

3573

1

			assert_eq!(

3574

1

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

3575

1

				U256::from(31_250_000_000u128),

3576

1

);

3577

1

			assert_eq!(

3578

1

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

3579

1

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

3580

1

);

3581

1

			assert_eq!(

3582

1

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

3583

1

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

3584

1

);

3585

3586

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

3587

1

			assert_eq!(

3588

1

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

3589

1

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

3590

1

);

3591

1

			assert_eq!(

3592

1

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

3593

1

				U256::from(31_250_000_000u128),

3594

1

);

3595

1

			assert_eq!(

3596

1

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

3597

1

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

3598

1

);

3599

1

			assert_eq!(

3600

1

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

3601

1

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

3602

1

);

3603

1

});

3604

1

3605