Grcov report - integration

1

// Copyright 2019-2022 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

use common::*;

23

24

use fp_evm::{Context, IsPrecompileResult};

25

use frame_support::{

26

	assert_noop, assert_ok,

27

	dispatch::DispatchClass,

28

	traits::{

29

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

30

		StorageInfoTrait,

31

},

32

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

33

	StorageHasher, Twox128,

34

};

35

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

36

use moonbeam_runtime::{

37

	asset_config::ForeignAssetInstance,

38

	currency::GLMR,

39

	xcm_config::{CurrencyId, SelfReserve},

40

	AccountId, Balances, CrowdloanRewards, Executive, OpenTechCommitteeCollective,

41

	ParachainStaking, PolkadotXcm, Precompiles, Runtime, RuntimeBlockWeights, RuntimeCall,

42

	RuntimeEvent, System, TransactionPayment, TransactionPaymentAsGasPrice,

43

	TreasuryCouncilCollective, XcmTransactor, FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, WEEKS,

44

};

45

use moonbeam_xcm_benchmarks::weights::XcmWeight;

46

use moonkit_xcm_primitives::AccountIdAssetIdConversion;

47

use nimbus_primitives::NimbusId;

48

use pallet_evm::PrecompileSet;

49

use pallet_evm_precompileset_assets_erc20::{SELECTOR_LOG_APPROVAL, SELECTOR_LOG_TRANSFER};

50

use pallet_transaction_payment::Multiplier;

51

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

52

use parity_scale_codec::Encode;

53

use polkadot_parachain::primitives::Sibling;

54

use precompile_utils::{

55

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

56

	prelude::*,

57

	testing::*,

58

};

59

use sha3::{Digest, Keccak256};

60

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

61

use sp_runtime::{

62

	traits::{Convert, Dispatchable},

63

	BuildStorage, DispatchError, ModuleError,

64

};

65

use std::str::from_utf8;

66

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

67

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

68

use xcm_executor::traits::ConvertLocation;

69

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

70

71

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

72

type CrowdloanRewardsPCall =

73

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

74

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

75

	Runtime,

76

	moonbeam_runtime::xcm_config::XcmExecutorConfig,

77

>;

78

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

79

type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

80

	Runtime,

81

	ForeignAssetInstance,

82

>;

83

type XcmTransactorV2PCall =

84

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

85

86

const BASE_FEE_GENESIS: u128 = 10000 * GIGAWEI;

87

88

3

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

89

3

	Asset {

90

3

		id: AssetId(

91

3

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

92

3

				currency_id,

93

3

94

3

			.unwrap(),

95

3

),

96

3

		fun: Fungibility::Fungible(amount),

97

3

98

3

99

#[test]

100

1

fn xcmp_queue_controller_origin_is_root() {

101

1

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

102

1

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

103

1

	assert_ok!(

104

1

		<moonbeam_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

105

1

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

106

1

);

107

1

108

109

#[test]

110

1

fn verify_pallet_prefixes() {

111

30

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

112

30

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

113

30

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

114

30

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

115

30

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

116

30

		// expand/storage.rs#L389-L401

117

30

		assert_eq!(

118

30

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

119

30

			Some(name)

120

30

);

121

30

122

1

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

123

1

	// is pulled in substrate deps.

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

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

130

1

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

131

1

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

132

1

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

133

1

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

134

1

	is_pallet_prefix::<moonbeam_runtime::OpenTechCommitteeCollective>(

135

1

		"OpenTechCommitteeCollective",

136

1

);

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

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

155

1

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

156

1

157

14

	let prefix = |pallet_name, storage_name| {

158

14

		let mut res = [0u8; 32];

159

14

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

160

14

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

161

14

		res.to_vec()

162

14

};

163

1

	assert_eq!(

164

1

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

165

1

		vec![

166

1

			StorageInfo {

167

1

				pallet_name: b"Timestamp".to_vec(),

168

1

				storage_name: b"Now".to_vec(),

169

1

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

170

1

				max_values: Some(1),

171

1

				max_size: Some(8),

172

1

},

173

1

			StorageInfo {

174

1

				pallet_name: b"Timestamp".to_vec(),

175

1

				storage_name: b"DidUpdate".to_vec(),

176

1

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

177

1

				max_values: Some(1),

178

1

				max_size: Some(1),

179

1

180

1

181

1

);

182

1

	assert_eq!(

183

1

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

184

1

		vec![

185

1

			StorageInfo {

186

1

				pallet_name: b"Balances".to_vec(),

187

1

				storage_name: b"TotalIssuance".to_vec(),

188

1

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

189

1

				max_values: Some(1),

190

1

				max_size: Some(16),

191

1

},

192

1

			StorageInfo {

193

1

				pallet_name: b"Balances".to_vec(),

194

1

				storage_name: b"InactiveIssuance".to_vec(),

195

1

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

196

1

				max_values: Some(1),

197

1

				max_size: Some(16),

198

1

},

199

1

			StorageInfo {

200

1

				pallet_name: b"Balances".to_vec(),

201

1

				storage_name: b"Account".to_vec(),

202

1

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

203

1

				max_values: None,

204

1

				max_size: Some(100),

205

1

},

206

1

			StorageInfo {

207

1

				pallet_name: b"Balances".to_vec(),

208

1

				storage_name: b"Locks".to_vec(),

209

1

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

210

1

				max_values: None,

211

1

				max_size: Some(1287),

212

1

},

213

1

			StorageInfo {

214

1

				pallet_name: b"Balances".to_vec(),

215

1

				storage_name: b"Reserves".to_vec(),

216

1

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

217

1

				max_values: None,

218

1

				max_size: Some(1037),

219

1

},

220

1

			StorageInfo {

221

1

				pallet_name: b"Balances".to_vec(),

222

1

				storage_name: b"Holds".to_vec(),

223

1

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

224

1

				max_values: None,

225

1

				max_size: Some(55),

226

1

},

227

1

			StorageInfo {

228

1

				pallet_name: b"Balances".to_vec(),

229

1

				storage_name: b"Freezes".to_vec(),

230

1

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

231

1

				max_values: None,

232

1

				max_size: Some(37),

233

1

},

234

1

235

1

);

236

1

	assert_eq!(

237

1

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

238

1

		vec![

239

1

			StorageInfo {

240

1

				pallet_name: b"Proxy".to_vec(),

241

1

				storage_name: b"Proxies".to_vec(),

242

1

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

243

1

				max_values: None,

244

1

				max_size: Some(845),

245

1

},

246

1

			StorageInfo {

247

1

				pallet_name: b"Proxy".to_vec(),

248

1

				storage_name: b"Announcements".to_vec(),

249

1

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

250

1

				max_values: None,

251

1

				max_size: Some(1837),

252

1

253

1

254

1

);

255

1

	assert_eq!(

256

1

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

257

1

		vec![StorageInfo {

258

1

			pallet_name: b"MaintenanceMode".to_vec(),

259

1

			storage_name: b"MaintenanceMode".to_vec(),

260

1

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

261

1

			max_values: Some(1),

262

1

			max_size: None,

263

1

},]

264

1

);

265

1

	assert_eq!(

266

1

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

267

1

		vec![

268

1

			StorageInfo {

269

1

				pallet_name: b"RelayStorageRoots".to_vec(),

270

1

				storage_name: b"RelayStorageRoot".to_vec(),

271

1

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

272

1

				max_values: None,

273

1

				max_size: Some(44),

274

1

},

275

1

			StorageInfo {

276

1

				pallet_name: b"RelayStorageRoots".to_vec(),

277

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

278

1

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

279

1

				max_values: Some(1),

280

1

				max_size: Some(121),

281

1

},

282

1

283

1

);

284

1

285

286

#[test]

287

1

fn test_collectives_storage_item_prefixes() {

288

6

	for StorageInfo { pallet_name, .. } in

289

7

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

290

291

6

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

292

293

294

6

	for StorageInfo { pallet_name, .. } in

295

7

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

296

297

6

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

298

299

1

300

301

#[test]

302

1

fn collective_set_members_root_origin_works() {

303

1

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

304

1

		// TreasuryCouncilCollective

305

1

		assert_ok!(TreasuryCouncilCollective::set_members(

306

1

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

307

1

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

308

1

			Some(AccountId::from(ALICE)),

309

1

310

1

));

311

		// OpenTechCommitteeCollective

312

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

313

1

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

314

1

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

315

1

			Some(AccountId::from(ALICE)),

316

1

317

1

));

318

1

});

319

1

320

321

#[test]

322

1

fn collective_set_members_general_admin_origin_works() {

323

1

	use moonbeam_runtime::{

324

1

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

325

1

};

326

1

327

1

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

328

1

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

329

1

		let alice = AccountId::from(ALICE);

330

1

331

1

		// TreasuryCouncilCollective

332

1

		let _ = Utility::dispatch_as(

333

1

			root_caller.clone(),

334

1

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

335

1

			Box::new(

336

1

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

337

1

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

338

1

					prime: Some(alice),

339

1

					old_count: 2,

340

1

341

1

				.into(),

342

1

),

343

1

);

344

1

		// OpenTechCommitteeCollective

345

1

		let _ = Utility::dispatch_as(

346

1

			root_caller,

347

1

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

348

1

			Box::new(

349

1

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

350

1

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

351

1

					prime: Some(alice),

352

1

					old_count: 2,

353

1

354

1

				.into(),

355

1

),

356

1

);

357

1

358

1

		assert_eq!(

359

1

			System::events()

360

1

				.into_iter()

361

2

				.filter_map(|r| {

362

2

					match r.event {

363

2

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

364

2

							if result.is_ok() =>

365

2

366

2

							Some(true)

367

368

						_ => None,

369

370

2

})

371

1

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

372

1

				.len(),

373

1

374

1

375

1

});

376

1

377

378

#[test]

379

1

fn collective_set_members_signed_origin_does_not_work() {

380

1

	let alice = AccountId::from(ALICE);

381

1

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

382

1

		// TreasuryCouncilCollective

383

1

		assert!(TreasuryCouncilCollective::set_members(

384

1

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

385

1

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

386

1

			Some(AccountId::from(ALICE)),

387

1

388

1

389

1

		.is_err());

390

		// OpenTechCommitteeCollective

391

1

		assert!(OpenTechCommitteeCollective::set_members(

392

1

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

393

1

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

394

1

			Some(AccountId::from(ALICE)),

395

1

396

1

397

1

		.is_err());

398

1

});

399

1

400

401

#[test]

402

1

fn verify_pallet_indices() {

403

32

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

404

32

		assert_eq!(

405

32

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

406

32

			Some(index)

407

32

);

408

32

409

1

410

1

	// System support

411

1

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

412

1

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

413

1

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

414

1

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

415

1

	// Monetary

416

1

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

417

1

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

418

1

	// Consensus support

419

1

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

420

1

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

421

1

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

422

1

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

423

1

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

424

1

	// Handy utilities

425

1

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

426

1

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

427

1

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

428

1

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

429

1

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

430

1

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

431

1

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

432

1

	// Ethereum compatibility

433

1

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

434

1

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

435

1

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

436

1

	// Governance

437

1

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

438

1

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

439

1

	// Council

440

1

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

441

1

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

442

1

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

443

1

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

444

1

	// Treasury

445

1

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

446

1

	// Crowdloan

447

1

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

448

1

	// XCM Stuff

449

1

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

450

1

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

451

1

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

452

1

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

453

1

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

454

1

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

455

1

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

456

1

457

458

#[test]

459

1

fn verify_reserved_indices() {

460

1

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

461

1

		.build_storage()

462

1

		.unwrap()

463

1

		.into();

464

1

465

1

	t.execute_with(|| {

466

1

		use frame_metadata::*;

467

1

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

468

1

		let metadata = match metadata.1 {

469

1

			RuntimeMetadata::V14(metadata) => metadata,

470

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

471

};

472

		// 40: Sudo

473

		// 53: BaseFee

474

		// 108: pallet_assets::<Instance1>

475

1

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

476

1

		let existing = metadata

477

1

			.pallets

478

1

			.iter()

479

49

			.map(|p| p.index)

480

1

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

481

3

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

482

1

});

483

1

484

485

#[test]

486

1

fn verify_proxy_type_indices() {

487

1

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

488

1

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

489

1

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

490

1

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

491

1

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

492

1

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

493

1

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

494

1

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

495

1

496

497

#[test]

498

1

fn join_collator_candidates() {

499

1

	ExtBuilder::default()

500

1

		.with_balances(vec![

501

1

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

502

1

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

503

1

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

504

1

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

505

1

])

506

1

		.with_collators(vec![

507

1

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

508

1

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

509

1

])

510

1

		.with_delegations(vec![

511

1

512

1

				AccountId::from(CHARLIE),

513

1

				AccountId::from(ALICE),

514

1

				5_000 * GLMR,

515

1

),

516

1

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

517

1

])

518

1

		.build()

519

1

		.execute_with(|| {

520

1

			assert_noop!(

521

1

				ParachainStaking::join_candidates(

522

1

					origin_of(AccountId::from(ALICE)),

523

1

					2_000_000 * GLMR,

524

1

					2u32

525

1

),

526

1

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

527

1

);

528

1

			assert_noop!(

529

1

				ParachainStaking::join_candidates(

530

1

					origin_of(AccountId::from(CHARLIE)),

531

1

					2_000_000 * GLMR,

532

1

					2u32

533

1

),

534

1

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

535

1

);

536

1

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

537

1

			assert_ok!(ParachainStaking::join_candidates(

538

1

				origin_of(AccountId::from(DAVE)),

539

1

				2_000_000 * GLMR,

540

1

				2u32

541

1

));

542

1

			assert_eq!(

543

1

				last_event(),

544

1

				RuntimeEvent::ParachainStaking(

545

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

546

1

						account: AccountId::from(DAVE),

547

1

						amount_locked: 2_000_000 * GLMR,

548

1

						new_total_amt_locked: 6_010_000 * GLMR

549

1

550

1

551

1

);

552

1

			let candidates = ParachainStaking::candidate_pool();

553

1

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

554

1

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

555

1

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

556

1

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

557

1

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

558

1

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

559

1

});

560

1

561

562

#[test]

563

1

fn transfer_through_evm_to_stake() {

564

1

	ExtBuilder::default()

565

1

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

566

1

		.build()

567

1

		.execute_with(|| {

568

1

			// Charlie has no balance => fails to stake

569

1

			assert_noop!(

570

1

				ParachainStaking::join_candidates(

571

1

					origin_of(AccountId::from(CHARLIE)),

572

1

					2_000_000 * GLMR,

573

1

					2u32

574

1

),

575

1

				DispatchError::Module(ModuleError {

576

1

					index: 20,

577

1

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

578

1

					message: Some("InsufficientBalance")

579

1

})

580

1

);

581

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

582

1

			assert_ok!(Balances::transfer_allow_death(

583

1

				origin_of(AccountId::from(ALICE)),

584

1

				AccountId::from(BOB),

585

1

				3_000_000 * GLMR,

586

1

));

587

1

			assert_eq!(

588

1

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

589

1

				3_000_000 * GLMR

590

1

);

591

592

1

			let gas_limit = 100000u64;

593

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

594

1

			// Bob transfers 2_000_000 GLMR to Charlie via EVM

595

1

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

596

1

				source: H160::from(BOB),

597

1

				target: H160::from(CHARLIE),

598

1

				input: vec![],

599

1

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

600

1

				gas_limit,

601

1

				max_fee_per_gas: gas_price,

602

1

				max_priority_fee_per_gas: None,

603

1

				nonce: None,

604

1

				access_list: Vec::new(),

605

1

})

606

1

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

607

1

			assert_eq!(

608

1

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

609

1

				2_000_000 * GLMR,

610

1

);

611

612

			// Charlie can stake now

613

1

			assert_ok!(ParachainStaking::join_candidates(

614

1

				origin_of(AccountId::from(CHARLIE)),

615

1

				2_000_000 * GLMR,

616

1

				2u32

617

1

			),);

618

1

			let candidates = ParachainStaking::candidate_pool();

619

1

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

620

1

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

621

1

});

622

1

623

624

#[test]

625

1

fn reward_block_authors() {

626

1

	ExtBuilder::default()

627

1

		.with_balances(vec![

628

1

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

629

1

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

630

1

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

631

1

])

632

1

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

633

1

		.with_delegations(vec![(

634

1

			AccountId::from(BOB),

635

1

			AccountId::from(ALICE),

636

1

			50_000 * GLMR,

637

1

)])

638

1

		.with_mappings(vec![(

639

1

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

640

1

			AccountId::from(ALICE),

641

1

)])

642

1

		.build()

643

1

		.execute_with(|| {

644

1

			increase_last_relay_slot_number(1);

645

1

			// Just before round 3

646

1

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

647

1

			// no rewards doled out yet

648

1

			assert_eq!(

649

1

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

650

1

				8_010_000 * GLMR,

651

1

);

652

1

			assert_eq!(

653

1

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

654

1

				9_950_000 * GLMR,

655

1

);

656

1

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

657

1

			// rewards minted and distributed

658

1

			assert_eq!(

659

1

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

660

1

				8990978048702400000000000,

661

1

);

662

1

			assert_eq!(

663

1

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

664

1

				9969521950497200000000000,

665

1

);

666

1

});

667

1

668

669

#[test]

670

1

fn reward_block_authors_with_parachain_bond_reserved() {

671

1

	ExtBuilder::default()

672

1

		.with_balances(vec![

673

1

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

674

1

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

675

1

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

676

1

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

677

1

])

678

1

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

679

1

		.with_delegations(vec![(

680

1

			AccountId::from(BOB),

681

1

			AccountId::from(ALICE),

682

1

			50_000 * GLMR,

683

1

)])

684

1

		.with_mappings(vec![(

685

1

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

686

1

			AccountId::from(ALICE),

687

1

)])

688

1

		.build()

689

1

		.execute_with(|| {

690

1

			increase_last_relay_slot_number(1);

691

1

			assert_ok!(ParachainStaking::set_parachain_bond_account(

692

1

				root_origin(),

693

1

				AccountId::from(CHARLIE),

694

1

			),);

695

696

			// Stop just before round 3

697

1

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

698

1

			// no collators rewards doled out yet

699

1

			assert_eq!(

700

1

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

701

1

				8_010_000 * GLMR,

702

1

);

703

1

			assert_eq!(

704

1

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

705

1

				9_950_000 * GLMR,

706

1

);

707

			// 30% reserved for parachain bond

708

1

			assert_eq!(

709

1

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

710

1

				310300000000000000000000,

711

1

);

712

713

			// Go to round 3

714

1

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

715

1

716

1

			// collators rewards minted and distributed

717

1

			assert_eq!(

718

1

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

719

1

				8698492682878000000000000,

720

1

);

721

1

			assert_eq!(

722

1

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

723

1

				9962207316621500000000000,

724

1

);

725

			// 30% reserved for parachain bond again

726

1

			assert_eq!(

727

1

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

728

1

				615104500000000000000000,

729

1

);

730

1

});

731

1

732

733

#[test]

734

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

735

1

	ExtBuilder::default()

736

1

		.with_balances(vec![

737

1

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

738

1

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

739

1

])

740

1

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

741

1

		.with_mappings(vec![(

742

1

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

743

1

			AccountId::from(ALICE),

744

1

)])

745

1

		.with_crowdloan_fund(300_000_000 * GLMR)

746

1

		.build()

747

1

		.execute_with(|| {

748

1

			// set parachain inherent data

749

1

			set_parachain_inherent_data();

750

1

			let init_block = CrowdloanRewards::init_vesting_block();

751

1

			// This matches the previous vesting

752

1

			let end_block = init_block + 4 * WEEKS;

753

1

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

754

1

			assert_ok!(

755

1

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

756

1

					calls: vec![

757

1

						RuntimeCall::CrowdloanRewards(

758

1

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

759

1

								rewards: vec![(

760

1

									[4u8; 32].into(),

761

1

									Some(AccountId::from(CHARLIE)),

762

1

									150_000_000 * GLMR

763

1

)]

764

1

765

1

),

766

1

						RuntimeCall::CrowdloanRewards(

767

1

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

768

1

								rewards: vec![(

769

1

									[5u8; 32].into(),

770

1

									Some(AccountId::from(DAVE)),

771

1

									150_000_000 * GLMR

772

1

)]

773

1

774

1

),

775

1

						RuntimeCall::CrowdloanRewards(

776

1

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

777

1

								lease_ending_block: end_block

778

1

779

1

780

1

781

1

})

782

1

				.dispatch(root_origin())

783

1

);

784

			// 30 percent initial payout

785

1

			assert_eq!(

786

1

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

787

1

				45_000_000 * GLMR

788

1

);

789

			// 30 percent initial payout

790

1

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

791

1

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

792

1

			assert_eq!(last_event(), expected);

793

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

794

1

			assert_ok!(

795

1

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

796

1

					calls: vec![RuntimeCall::CrowdloanRewards(

797

1

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

798

1

							rewards: vec![(

799

1

								[4u8; 32].into(),

800

1

								Some(AccountId::from(ALICE)),

801

1

								43_200_000

802

1

)]

803

1

804

1

)]

805

1

})

806

1

				.dispatch(root_origin())

807

1

);

808

1

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

809

1

				index: 0,

810

1

				error: DispatchError::Module(ModuleError {

811

1

					index: 90,

812

1

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

813

1

					message: None,

814

1

}),

815

1

});

816

1

			assert_eq!(last_event(), expected_fail);

817

			// Claim 1 block.

818

1

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

819

1

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

820

821

1

			let vesting_period = 4 * WEEKS as u128;

822

1

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

823

1

824

1

			assert_eq!(

825

1

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

826

1

					.unwrap()

827

1

					.claimed_reward,

828

1

				(45_000_000 * GLMR) + per_block

829

1

);

830

1

			assert_eq!(

831

1

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

832

1

					.unwrap()

833

1

					.claimed_reward,

834

1

				(45_000_000 * GLMR) + per_block

835

1

);

836

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

837

1

			assert_eq!(

838

1

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

839

1

				(45_000_000 * GLMR) + per_block

840

1

);

841

1

			assert_eq!(

842

1

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

843

1

				(45_000_000 * GLMR) + per_block

844

1

);

845

1

			assert_noop!(

846

1

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

847

1

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

848

1

);

849

1

});

850

1

851

852

#[test]

853

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

854

1

	ExtBuilder::default()

855

1

		.with_balances(vec![

856

1

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

857

1

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

858

1

])

859

1

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

860

1

		.with_mappings(vec![(

861

1

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

862

1

			AccountId::from(ALICE),

863

1

)])

864

1

		.with_crowdloan_fund(3_000_000 * GLMR)

865

1

		.build()

866

1

		.execute_with(|| {

867

1

			// set parachain inherent data

868

1

			set_parachain_inherent_data();

869

1

			let init_block = CrowdloanRewards::init_vesting_block();

870

1

			// This matches the previous vesting

871

1

			let end_block = init_block + 4 * WEEKS;

872

1

873

1

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

874

1

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

875

1

876

1

			let public1 = pair1.public();

877

1

			let public2 = pair2.public();

878

1

879

1

			// signature is new_account || previous_account

880

1

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

881

1

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

882

1

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

883

1

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

884

1

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

885

1

			let signature1 = pair1.sign(&message);

886

1

			let signature2 = pair2.sign(&message);

887

1

888

1

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

889

1

			assert_ok!(

890

1

				// two relay accounts pointing at the same reward account

891

1

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

892

1

					calls: vec![

893

1

						RuntimeCall::CrowdloanRewards(

894

1

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

895

1

								rewards: vec![(

896

1

									public1.into(),

897

1

									Some(AccountId::from(CHARLIE)),

898

1

									1_500_000 * GLMR

899

1

)]

900

1

901

1

),

902

1

						RuntimeCall::CrowdloanRewards(

903

1

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

904

1

								rewards: vec![(

905

1

									public2.into(),

906

1

									Some(AccountId::from(CHARLIE)),

907

1

									1_500_000 * GLMR

908

1

)]

909

1

910

1

),

911

1

						RuntimeCall::CrowdloanRewards(

912

1

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

913

1

								lease_ending_block: end_block

914

1

915

1

916

1

917

1

})

918

1

				.dispatch(root_origin())

919

1

);

920

			// 30 percent initial payout

921

1

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

922

923

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

924

1

			assert_noop!(

925

1

				CrowdloanRewards::change_association_with_relay_keys(

926

1

					origin_of(AccountId::from(CHARLIE)),

927

1

					AccountId::from(DAVE),

928

1

					AccountId::from(CHARLIE),

929

1

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

930

1

),

931

1

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

932

1

);

933

934

			// this should be valid

935

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

936

1

				origin_of(AccountId::from(CHARLIE)),

937

1

				AccountId::from(DAVE),

938

1

				AccountId::from(CHARLIE),

939

1

				vec![

940

1

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

941

1

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

942

1

943

1

));

944

945

1

			assert_eq!(

946

1

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

947

1

					.unwrap()

948

1

					.claimed_reward,

949

1

				(900_000 * GLMR)

950

1

);

951

1

});

952

1

953

954

#[test]

955

1

fn claim_via_precompile() {

956

1

	ExtBuilder::default()

957

1

		.with_balances(vec![

958

1

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

959

1

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

960

1

])

961

1

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

962

1

		.with_mappings(vec![(

963

1

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

964

1

			AccountId::from(ALICE),

965

1

)])

966

1

		.with_crowdloan_fund(3_000_000 * GLMR)

967

1

		.build()

968

1

		.execute_with(|| {

969

1

			// set parachain inherent data

970

1

			set_parachain_inherent_data();

971

1

			let init_block = CrowdloanRewards::init_vesting_block();

972

1

			// This matches the previous vesting

973

1

			let end_block = init_block + 4 * WEEKS;

974

1

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

975

1

			assert_ok!(

976

1

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

977

1

					calls: vec![

978

1

						RuntimeCall::CrowdloanRewards(

979

1

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

980

1

								rewards: vec![(

981

1

									[4u8; 32].into(),

982

1

									Some(AccountId::from(CHARLIE)),

983

1

									1_500_000 * GLMR

984

1

)]

985

1

986

1

),

987

1

						RuntimeCall::CrowdloanRewards(

988

1

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

989

1

								rewards: vec![(

990

1

									[5u8; 32].into(),

991

1

									Some(AccountId::from(DAVE)),

992

1

									1_500_000 * GLMR

993

1

)]

994

1

995

1

),

996

1

						RuntimeCall::CrowdloanRewards(

997

1

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

998

1

								lease_ending_block: end_block

999

1

1000

1

1001

1

1002

1

})

1003

1

				.dispatch(root_origin())

1004

1

);

1005

1006

1

			assert!(CrowdloanRewards::initialized());

1007

1008

			// 30 percent initial payout

1009

1

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

1010

			// 30 percent initial payout

1011

1

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

1012

1013

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1014

1

1015

1

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

1016

1

			let gas_limit = 100000u64;

1017

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1018

1

1019

1

			// Construct the call data (selector, amount)

1020

1

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

1021

1

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

1022

1

1023

1

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

1024

1

				source: H160::from(CHARLIE),

1025

1

				target: crowdloan_precompile_address,

1026

1

				input: call_data,

1027

1

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

1028

1

				gas_limit,

1029

1

				max_fee_per_gas: gas_price,

1030

1

				max_priority_fee_per_gas: None,

1031

1

				nonce: None, // Use the next nonce

1032

1

				access_list: Vec::new(),

1033

1

})

1034

1

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

1035

1036

1

			let vesting_period = 4 * WEEKS as u128;

1037

1

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

1038

1

1039

1

			assert_eq!(

1040

1

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

1041

1

					.unwrap()

1042

1

					.claimed_reward,

1043

1

				(450_000 * GLMR) + per_block

1044

1

);

1045

1

})

1046

1

1047

1048

#[test]

1049

1

fn is_contributor_via_precompile() {

1050

1

	ExtBuilder::default()

1051

1

		.with_balances(vec![

1052

1

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

1053

1

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

1054

1

])

1055

1

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

1056

1

		.with_mappings(vec![(

1057

1

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

1058

1

			AccountId::from(ALICE),

1059

1

)])

1060

1

		.with_crowdloan_fund(3_000_000_000 * GLMR)

1061

1

		.build()

1062

1

		.execute_with(|| {

1063

1

			// set parachain inherent data

1064

1

			set_parachain_inherent_data();

1065

1

			let init_block = CrowdloanRewards::init_vesting_block();

1066

1

			// This matches the previous vesting

1067

1

			let end_block = init_block + 4 * WEEKS;

1068

1

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

1069

1

			assert_ok!(

1070

1

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

1071

1

					calls: vec![

1072

1

						RuntimeCall::CrowdloanRewards(

1073

1

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

1074

1

								rewards: vec![(

1075

1

									[4u8; 32].into(),

1076

1

									Some(AccountId::from(CHARLIE)),

1077

1

									1_500_000_000 * GLMR

1078

1

)]

1079

1

1080

1

),

1081

1

						RuntimeCall::CrowdloanRewards(

1082

1

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

1083

1

								rewards: vec![(

1084

1

									[5u8; 32].into(),

1085

1

									Some(AccountId::from(DAVE)),

1086

1

									1_500_000_000 * GLMR

1087

1

)]

1088

1

1089

1

),

1090

1

						RuntimeCall::CrowdloanRewards(

1091

1

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

1092

1

								lease_ending_block: end_block

1093

1

1094

1

1095

1

1096

1

})

1097

1

				.dispatch(root_origin())

1098

1

);

1099

1100

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1101

1

1102

1

			// Assert precompile reports Bob is not a contributor

1103

1

			Precompiles::new()

1104

1

				.prepare_test(

1105

1

					ALICE,

1106

1

					crowdloan_precompile_address,

1107

1

					CrowdloanRewardsPCall::is_contributor {

1108

1

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

1109

1

},

1110

1

1111

1

				.expect_cost(1669)

1112

1

				.expect_no_logs()

1113

1

				.execute_returns(false);

1114

1

1115

1

			// Assert precompile reports Charlie is a nominator

1116

1

			Precompiles::new()

1117

1

				.prepare_test(

1118

1

					ALICE,

1119

1

					crowdloan_precompile_address,

1120

1

					CrowdloanRewardsPCall::is_contributor {

1121

1

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

1122

1

},

1123

1

1124

1

				.expect_cost(1669)

1125

1

				.expect_no_logs()

1126

1

				.execute_returns(true);

1127

1

})

1128

1

1129

1130

#[test]

1131

1

fn reward_info_via_precompile() {

1132

1

	ExtBuilder::default()

1133

1

		.with_balances(vec![

1134

1

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

1135

1

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

1136

1

])

1137

1

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

1138

1

		.with_mappings(vec![(

1139

1

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

1140

1

			AccountId::from(ALICE),

1141

1

)])

1142

1

		.with_crowdloan_fund(3_000_000 * GLMR)

1143

1

		.build()

1144

1

		.execute_with(|| {

1145

1

			// set parachain inherent data

1146

1

			set_parachain_inherent_data();

1147

1

			let init_block = CrowdloanRewards::init_vesting_block();

1148

1

			// This matches the previous vesting

1149

1

			let end_block = init_block + 4 * WEEKS;

1150

1

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

1151

1

			assert_ok!(

1152

1

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

1153

1

					calls: vec![

1154

1

						RuntimeCall::CrowdloanRewards(

1155

1

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

1156

1

								rewards: vec![(

1157

1

									[4u8; 32].into(),

1158

1

									Some(AccountId::from(CHARLIE)),

1159

1

									1_500_000 * GLMR

1160

1

)]

1161

1

1162

1

),

1163

1

						RuntimeCall::CrowdloanRewards(

1164

1

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

1165

1

								rewards: vec![(

1166

1

									[5u8; 32].into(),

1167

1

									Some(AccountId::from(DAVE)),

1168

1

									1_500_000 * GLMR

1169

1

)]

1170

1

1171

1

),

1172

1

						RuntimeCall::CrowdloanRewards(

1173

1

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

1174

1

								lease_ending_block: end_block

1175

1

1176

1

1177

1

1178

1

})

1179

1

				.dispatch(root_origin())

1180

1

);

1181

1182

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1183

1

1184

1

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

1185

1

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

1186

1

1187

1

			// Assert precompile reports correct Charlie reward info.

1188

1

			Precompiles::new()

1189

1

				.prepare_test(

1190

1

					ALICE,

1191

1

					crowdloan_precompile_address,

1192

1

					CrowdloanRewardsPCall::reward_info {

1193

1

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

1194

1

},

1195

1

1196

1

				.expect_cost(1669)

1197

1

				.expect_no_logs()

1198

1

				.execute_returns((expected_total, expected_claimed));

1199

1

})

1200

1

1201

1202

#[test]

1203

1

fn update_reward_address_via_precompile() {

1204

1

	ExtBuilder::default()

1205

1

		.with_balances(vec![

1206

1

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

1207

1

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

1208

1

])

1209

1

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

1210

1

		.with_mappings(vec![(

1211

1

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

1212

1

			AccountId::from(ALICE),

1213

1

)])

1214

1

		.with_crowdloan_fund(3_000_000 * GLMR)

1215

1

		.build()

1216

1

		.execute_with(|| {

1217

1

			// set parachain inherent data

1218

1

			set_parachain_inherent_data();

1219

1

			let init_block = CrowdloanRewards::init_vesting_block();

1220

1

			// This matches the previous vesting

1221

1

			let end_block = init_block + 4 * WEEKS;

1222

1

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

1223

1

			assert_ok!(

1224

1

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

1225

1

					calls: vec![

1226

1

						RuntimeCall::CrowdloanRewards(

1227

1

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

1228

1

								rewards: vec![(

1229

1

									[4u8; 32].into(),

1230

1

									Some(AccountId::from(CHARLIE)),

1231

1

									1_500_000 * GLMR

1232

1

)]

1233

1

1234

1

),

1235

1

						RuntimeCall::CrowdloanRewards(

1236

1

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

1237

1

								rewards: vec![(

1238

1

									[5u8; 32].into(),

1239

1

									Some(AccountId::from(DAVE)),

1240

1

									1_500_000 * GLMR

1241

1

)]

1242

1

1243

1

),

1244

1

						RuntimeCall::CrowdloanRewards(

1245

1

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

1246

1

								lease_ending_block: end_block

1247

1

1248

1

1249

1

1250

1

})

1251

1

				.dispatch(root_origin())

1252

1

);

1253

1254

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1255

1

1256

1

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

1257

1

			let gas_limit = 100000u64;

1258

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1259

1

1260

1

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

1261

1

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

1262

1

			call_data[0..4]

1263

1

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

1264

1

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

1265

1

1266

1

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

1267

1

				source: H160::from(CHARLIE),

1268

1

				target: crowdloan_precompile_address,

1269

1

				input: call_data,

1270

1

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

1271

1

				gas_limit,

1272

1

				max_fee_per_gas: gas_price,

1273

1

				max_priority_fee_per_gas: None,

1274

1

				nonce: None, // Use the next nonce

1275

1

				access_list: Vec::new(),

1276

1

})

1277

1

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

1278

1279

1

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

1280

1

			assert_eq!(

1281

1

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

1282

1

					.unwrap()

1283

1

					.claimed_reward,

1284

1

				(450_000 * GLMR)

1285

1

);

1286

1

})

1287

1

1288

1289

1

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

1290

1

where

1291

1

	F: FnMut() -> (),

1292

1

1293

1

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

1294

1

		.build_storage()

1295

1

		.unwrap()

1296

1

		.into();

1297

1

	t.execute_with(|| {

1298

1

		System::set_block_consumed_resources(w, 0);

1299

1

		assertions()

1300

1

});

1301

1

1302

1303

#[test]

1304

#[rustfmt::skip]

1305

1

fn length_fee_is_sensible() {

1306

1

	use sp_runtime::testing::TestXt;

1307

1

1308

1

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

1309

1

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

1310

1

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

1311

1

		let uxt: TestXt<_, ()> = TestXt::new(call, Some((1u64, ())));

1312

1

1313

9

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

1314

9

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

1315

9

				.inclusion_fee

1316

9

				.expect("fee should be calculated")

1317

9

				.len_fee

1318

9

};

1319

1320

		// editorconfig-checker-disable

1321

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

1322

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

1323

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

1324

		//                             |           |

1325

1

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

1326

1

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

1327

1

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

1328

1

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

1329

1

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

1330

1

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

1331

1

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

1332

1

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

1333

1

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

1334

		// editorconfig-checker-enable

1335

1

});

1336

1

1337

1338

#[test]

1339

1

fn multiplier_can_grow_from_zero() {

1340

1

	use frame_support::traits::Get;

1341

1

1342

1

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

1343

1

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

1344

1

		* RuntimeBlockWeights::get()

1345

1

			.get(DispatchClass::Normal)

1346

1

			.max_total

1347

1

			.unwrap();

1348

1

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

1349

1

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

1350

1

	run_with_system_weight(target * 101 / 100, || {

1351

1

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

1352

1

		assert!(

1353

1

			next > minimum_multiplier,

1354

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

1355

			next,

1356

			minimum_multiplier

1357

);

1358

1

})

1359

1

1360

1361

#[test]

1362

1

fn ethereum_invalid_transaction() {

1363

1

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

1364

1

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

1365

1

		// on chain is rejected.

1366

1

		assert_eq!(

1367

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1368

1

			Err(

1369

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1370

1

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

1371

1

1372

1

1373

1

);

1374

1

});

1375

1

1376

1377

#[test]

1378

1

fn initial_gas_fee_is_correct() {

1379

1

	use fp_evm::FeeCalculator;

1380

1

1381

1

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

1382

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1383

1

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

1384

1385

1

		assert_eq!(

1386

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1387

1

1388

1

				125_000_000_000u128.into(),

1389

1

				Weight::from_parts(41_742_000u64, 0)

1390

1

1391

1

);

1392

1

});

1393

1

1394

1395

#[test]

1396

1

fn min_gas_fee_is_correct() {

1397

1

	use fp_evm::FeeCalculator;

1398

1

	use frame_support::traits::Hooks;

1399

1

1400

1

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

1401

1

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

1402

1

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

1403

1

1404

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1405

1

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

1406

1407

1

		assert_eq!(

1408

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1409

1

1410

1

				125_000_000_000u128.into(),

1411

1

				Weight::from_parts(41_742_000u64, 0)

1412

1

1413

1

);

1414

1

});

1415

1

1416

1417

#[test]

1418

1

fn transfer_ed_0_substrate() {

1419

1

	ExtBuilder::default()

1420

1

		.with_balances(vec![

1421

1

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

1422

1

			(AccountId::from(BOB), 0),

1423

1

])

1424

1

		.build()

1425

1

		.execute_with(|| {

1426

1

			// Substrate transfer

1427

1

			assert_ok!(Balances::transfer_allow_death(

1428

1

				origin_of(AccountId::from(ALICE)),

1429

1

				AccountId::from(BOB),

1430

1

				1 * GLMR,

1431

1

));

1432

			// 1 WEI is left in the account

1433

1

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

1434

1

});

1435

1

1436

1437

#[test]

1438

1

fn transfer_ed_0_evm() {

1439

1

	ExtBuilder::default()

1440

1

		.with_balances(vec![

1441

1

1442

1

				AccountId::from(ALICE),

1443

1

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

1444

1

),

1445

1

			(AccountId::from(BOB), 0),

1446

1

])

1447

1

		.build()

1448

1

		.execute_with(|| {

1449

1

			// EVM transfer

1450

1

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

1451

1

				source: H160::from(ALICE),

1452

1

				target: H160::from(BOB),

1453

1

				input: Vec::new(),

1454

1

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

1455

1

				gas_limit: 21_000u64,

1456

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1457

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1458

1

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

1459

1

				access_list: Vec::new(),

1460

1

})

1461

1

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

1462

			// 1 WEI is left in the account

1463

1

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

1464

1

});

1465

1

1466

1467

#[test]

1468

1

fn refund_ed_0_evm() {

1469

1

	ExtBuilder::default()

1470

1

		.with_balances(vec![

1471

1

1472

1

				AccountId::from(ALICE),

1473

1

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

1474

1

),

1475

1

			(AccountId::from(BOB), 0),

1476

1

])

1477

1

		.build()

1478

1

		.execute_with(|| {

1479

1

			// EVM transfer that zeroes ALICE

1480

1

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

1481

1

				source: H160::from(ALICE),

1482

1

				target: H160::from(BOB),

1483

1

				input: Vec::new(),

1484

1

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

1485

1

				gas_limit: 21_777u64,

1486

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1487

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1488

1

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

1489

1

				access_list: Vec::new(),

1490

1

})

1491

1

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

1492

			// ALICE is refunded

1493

1

			assert_eq!(

1494

1

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

1495

1

				777 * BASE_FEE_GENESIS,

1496

1

);

1497

1

});

1498

1

1499

1500

#[test]

1501

1

fn author_does_not_receive_priority_fee() {

1502

1

	ExtBuilder::default()

1503

1

		.with_balances(vec![(

1504

1

			AccountId::from(BOB),

1505

1

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

1506

1

)])

1507

1

		.build()

1508

1

		.execute_with(|| {

1509

1

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

1510

1

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

1511

1

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

1512

1

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

1513

1

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

1514

1

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

1515

1

1516

1

			// EVM transfer.

1517

1

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

1518

1

				source: H160::from(BOB),

1519

1

				target: H160::from(ALICE),

1520

1

				input: Vec::new(),

1521

1

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

1522

1

				gas_limit: 21_000u64,

1523

1

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

1524

1

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

1525

1

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

1526

1

				access_list: Vec::new(),

1527

1

})

1528

1

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

1529

			// Author free balance didn't change.

1530

1

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

1531

1

});

1532

1

1533

1534

#[test]

1535

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1536

1

	ExtBuilder::default()

1537

1

		.with_balances(vec![(

1538

1

			AccountId::from(BOB),

1539

1

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

1540

1

)])

1541

1

		.build()

1542

1

		.execute_with(|| {

1543

1

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

1544

1

			// EVM transfer.

1545

1

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

1546

1

				source: H160::from(BOB),

1547

1

				target: H160::from(ALICE),

1548

1

				input: Vec::new(),

1549

1

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

1550

1

				gas_limit: 21_000u64,

1551

1

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

1552

1

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

1553

1

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

1554

1

				access_list: Vec::new(),

1555

1

})

1556

1

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

1557

1558

1

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

1559

1

			// Fee is 100 GWEI base fee + 100 GWEI tip.

1560

1

			let fee = ((200 * GIGAWEI) * 21_000) as f64;

1561

1

			// 80% was burned.

1562

1

			let expected_burn = (fee * 0.8) as u128;

1563

1

			assert_eq!(issuance_after, issuance_before - expected_burn,);

1564

			// 20% was sent to treasury.

1565

1

			let expected_treasury = (fee * 0.2) as u128;

1566

1

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

1567

1

});

1568

1

1569

1570

#[test]

1571

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1572

1

	ExtBuilder::default()

1573

1

		.with_balances(vec![(

1574

1

			AccountId::from(BOB),

1575

1

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

1576

1

)])

1577

1

		.build()

1578

1

		.execute_with(|| {

1579

1

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

1580

1

			// EVM transfer.

1581

1

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

1582

1

				source: H160::from(BOB),

1583

1

				target: H160::from(ALICE),

1584

1

				input: Vec::new(),

1585

1

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

1586

1

				gas_limit: 21_000u64,

1587

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

1588

1

				max_priority_fee_per_gas: Some(BASE_FEE_GENESIS.into()),

1589

1

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

1590

1

				access_list: Vec::new(),

1591

1

})

1592

1

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

1593

1594

1

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

1595

1

			// Fee is 100 GWEI base fee.

1596

1

			let fee = (BASE_FEE_GENESIS * 21_000) as f64;

1597

1

			// 80% was burned.

1598

1

			let expected_burn = (fee * 0.8) as u128;

1599

1

			assert_eq!(issuance_after, issuance_before - expected_burn,);

1600

			// 20% was sent to treasury.

1601

1

			let expected_treasury = (fee * 0.2) as u128;

1602

1

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

1603

1

});

1604

1

1605

1606

#[test]

1607

1

fn root_can_change_default_xcm_vers() {

1608

1

	ExtBuilder::default()

1609

1

		.with_balances(vec![

1610

1

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

1611

1

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

1612

1

])

1613

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1614

1

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

1615

1

			metadata: AssetRegistrarMetadata {

1616

1

				name: b"RelayToken".to_vec(),

1617

1

				symbol: b"Relay".to_vec(),

1618

1

				decimals: 12,

1619

1

				is_frozen: false,

1620

1

},

1621

1

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

1622

1

			is_sufficient: true,

1623

1

}])

1624

1

		.build()

1625

1

		.execute_with(|| {

1626

1

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

1627

1

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

1628

1

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

1629

1

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

1630

1

			// know with which version to send

1631

1

			assert_noop!(

1632

1

				PolkadotXcm::transfer_assets(

1633

1

					origin_of(AccountId::from(ALICE)),

1634

1

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

1635

1

					Box::new(VersionedLocation::V4(Location {

1636

1

						parents: 0,

1637

1

						interior: [AccountId32 {

1638

1

							network: None,

1639

1

							id: [1u8; 32],

1640

1

}]

1641

1

						.into(),

1642

1

					})),

1643

1

					Box::new(VersionedAssets::V4(asset.clone().into())),

1644

1

0,

1645

1

					WeightLimit::Unlimited

1646

1

),

1647

1

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

1648

1

);

1649

1650

			// Root sets the defaultXcm

1651

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1652

1

				root_origin(),

1653

1

				Some(2)

1654

1

));

1655

1656

			// Now transferring does not fail

1657

1

			assert_ok!(PolkadotXcm::transfer_assets(

1658

1

				origin_of(AccountId::from(ALICE)),

1659

1

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

1660

1

				Box::new(VersionedLocation::V4(Location {

1661

1

					parents: 0,

1662

1

					interior: [AccountId32 {

1663

1

						network: None,

1664

1

						id: [1u8; 32],

1665

1

}]

1666

1

					.into(),

1667

1

				})),

1668

1

				Box::new(VersionedAssets::V4(asset.clone().into())),

1669

1

0,

1670

1

				WeightLimit::Unlimited

1671

1

));

1672

1

})

1673

1

1674

1675

#[test]

1676

1

fn asset_can_be_registered() {

1677

1

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

1678

1

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

1679

1

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

1680

1

		let asset_metadata = AssetRegistrarMetadata {

1681

1

			name: b"RelayToken".to_vec(),

1682

1

			symbol: b"Relay".to_vec(),

1683

1

			decimals: 12,

1684

1

			is_frozen: false,

1685

1

};

1686

1

		assert_ok!(AssetManager::register_foreign_asset(

1687

1

			moonbeam_runtime::RuntimeOrigin::root(),

1688

1

			source_location,

1689

1

			asset_metadata,

1690

1

			1u128,

1691

1

			true

1692

1

));

1693

1

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

1694

1

});

1695

1

1696

1697

#[test]

1698

1

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1699

1

	ExtBuilder::default()

1700

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1701

1

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

1702

1

			metadata: AssetRegistrarMetadata {

1703

1

				name: b"RelayToken".to_vec(),

1704

1

				symbol: b"Relay".to_vec(),

1705

1

				decimals: 12,

1706

1

				is_frozen: false,

1707

1

},

1708

1

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

1709

1

			is_sufficient: true,

1710

1

}])

1711

1

		.with_balances(vec![

1712

1

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

1713

1

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

1714

1

])

1715

1

		.build()

1716

1

		.execute_with(|| {

1717

1

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

1718

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1719

1

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

1720

1

1721

1

			// Its address is

1722

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1723

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1724

1

				relay_asset_id,

1725

1

);

1726

1

1727

1

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

1728

1

			assert_eq!(

1729

1

				moonbeam_runtime::Assets::total_supply(relay_asset_id),

1730

1

				1_000 * GLMR

1731

1

);

1732

1733

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

1734

1

			Precompiles::new()

1735

1

				.prepare_test(

1736

1

					ALICE,

1737

1

					asset_precompile_address,

1738

1

					ForeignAssetsPCall::total_supply {},

1739

1

1740

1

				.expect_cost(3338)

1741

1

				.expect_no_logs()

1742

1

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

1743

1

1744

1

			// Access balanceOf through precompile

1745

1

			Precompiles::new()

1746

1

				.prepare_test(

1747

1

					ALICE,

1748

1

					asset_precompile_address,

1749

1

					ForeignAssetsPCall::balance_of {

1750

1

						who: Address(ALICE.into()),

1751

1

},

1752

1

1753

1

				.expect_cost(3338)

1754

1

				.expect_no_logs()

1755

1

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

1756

1

});

1757

1

1758

1759

#[test]

1760

1

fn xcm_asset_erc20_precompiles_transfer() {

1761

1

	ExtBuilder::default()

1762

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1763

1

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

1764

1

			metadata: AssetRegistrarMetadata {

1765

1

				name: b"RelayToken".to_vec(),

1766

1

				symbol: b"Relay".to_vec(),

1767

1

				decimals: 12,

1768

1

				is_frozen: false,

1769

1

},

1770

1

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

1771

1

			is_sufficient: true,

1772

1

}])

1773

1

		.with_balances(vec![

1774

1

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

1775

1

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

1776

1

])

1777

1

		.build()

1778

1

		.execute_with(|| {

1779

1

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

1780

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1781

1

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

1782

1

1783

1

			// Its address is

1784

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1785

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1786

1

				relay_asset_id,

1787

1

);

1788

1

1789

1

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

1790

1

			Precompiles::new()

1791

1

				.prepare_test(

1792

1

					ALICE,

1793

1

					asset_precompile_address,

1794

1

					ForeignAssetsPCall::transfer {

1795

1

						to: Address(BOB.into()),

1796

1

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

1797

1

},

1798

1

1799

1

				.expect_cost(24684)

1800

1

				.expect_log(log3(

1801

1

					asset_precompile_address,

1802

1

					SELECTOR_LOG_TRANSFER,

1803

1

					H160::from(ALICE),

1804

1

					H160::from(BOB),

1805

1

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

1806

1

))

1807

1

				.execute_returns(true);

1808

1

1809

1

			// Make sure BOB has 400 GLMR

1810

1

			Precompiles::new()

1811

1

				.prepare_test(

1812

1

					BOB,

1813

1

					asset_precompile_address,

1814

1

					ForeignAssetsPCall::balance_of {

1815

1

						who: Address(BOB.into()),

1816

1

},

1817

1

1818

1

				.expect_cost(3338)

1819

1

				.expect_no_logs()

1820

1

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

1821

1

});

1822

1

1823

1824

#[test]

1825

1

fn xcm_asset_erc20_precompiles_approve() {

1826

1

	ExtBuilder::default()

1827

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1828

1

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

1829

1

			metadata: AssetRegistrarMetadata {

1830

1

				name: b"RelayToken".to_vec(),

1831

1

				symbol: b"Relay".to_vec(),

1832

1

				decimals: 12,

1833

1

				is_frozen: false,

1834

1

},

1835

1

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

1836

1

			is_sufficient: true,

1837

1

}])

1838

1

		.with_balances(vec![

1839

1

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

1840

1

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

1841

1

])

1842

1

		.build()

1843

1

		.execute_with(|| {

1844

1

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

1845

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1846

1

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

1847

1

1848

1

			// Its address is

1849

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1850

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1851

1

				relay_asset_id,

1852

1

);

1853

1

1854

1

			// Aprove Bob for spending 400 GLMR from Alice

1855

1

			Precompiles::new()

1856

1

				.prepare_test(

1857

1

					ALICE,

1858

1

					asset_precompile_address,

1859

1

					ForeignAssetsPCall::approve {

1860

1

						spender: Address(BOB.into()),

1861

1

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

1862

1

},

1863

1

1864

1

				.expect_cost(15573)

1865

1

				.expect_log(log3(

1866

1

					asset_precompile_address,

1867

1

					SELECTOR_LOG_APPROVAL,

1868

1

					H160::from(ALICE),

1869

1

					H160::from(BOB),

1870

1

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

1871

1

))

1872

1

				.execute_returns(true);

1873

1

1874

1

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

1875

1

			Precompiles::new()

1876

1

				.prepare_test(

1877

1

					BOB,

1878

1

					asset_precompile_address,

1879

1

					ForeignAssetsPCall::transfer_from {

1880

1

						from: Address(ALICE.into()),

1881

1

						to: Address(CHARLIE.into()),

1882

1

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

1883

1

},

1884

1

1885

1

				.expect_cost(29947)

1886

1

				.expect_log(log3(

1887

1

					asset_precompile_address,

1888

1

					SELECTOR_LOG_TRANSFER,

1889

1

					H160::from(ALICE),

1890

1

					H160::from(CHARLIE),

1891

1

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

1892

1

))

1893

1

				.execute_returns(true);

1894

1

1895

1

			// Make sure CHARLIE has 400 GLMR

1896

1

			Precompiles::new()

1897

1

				.prepare_test(

1898

1

					CHARLIE,

1899

1

					asset_precompile_address,

1900

1

					ForeignAssetsPCall::balance_of {

1901

1

						who: Address(CHARLIE.into()),

1902

1

},

1903

1

1904

1

				.expect_cost(3338)

1905

1

				.expect_no_logs()

1906

1

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

1907

1

});

1908

1

1909

1910

#[test]

1911

1

fn xtokens_precompile_transfer() {

1912

1

	ExtBuilder::default()

1913

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1914

1

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

1915

1

			metadata: AssetRegistrarMetadata {

1916

1

				name: b"RelayToken".to_vec(),

1917

1

				symbol: b"Relay".to_vec(),

1918

1

				decimals: 12,

1919

1

				is_frozen: false,

1920

1

},

1921

1

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

1922

1

			is_sufficient: true,

1923

1

}])

1924

1

		.with_balances(vec![

1925

1

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

1926

1

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

1927

1

])

1928

1

		.with_safe_xcm_version(2)

1929

1

		.build()

1930

1

		.execute_with(|| {

1931

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1932

1

1933

1

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

1934

1

			let relay_asset_id: moonbeam_runtime::AssetId =

1935

1

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

1936

1

1937

1

			// Its address is

1938

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1939

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1940

1

				relay_asset_id,

1941

1

);

1942

1

1943

1

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

1944

1

			let destination = Location::new(

1945

1

1,

1946

1

				[Junction::AccountId32 {

1947

1

					network: None,

1948

1

					id: [1u8; 32],

1949

1

}],

1950

1

);

1951

1

1952

1

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

1953

1

			Precompiles::new()

1954

1

				.prepare_test(

1955

1

					ALICE,

1956

1

					xtokens_precompile_address,

1957

1

					XtokensPCall::transfer {

1958

1

						currency_address: Address(asset_precompile_address.into()),

1959

1

						amount: 500_000_000_000_000u128.into(),

1960

1

						destination,

1961

1

						weight: 4_000_000,

1962

1

},

1963

1

1964

1

				.expect_cost(24691)

1965

1

				.expect_no_logs()

1966

1

				.execute_returns(())

1967

1

})

1968

1

1969

1970

#[test]

1971

1

fn xtokens_precompile_transfer_multiasset() {

1972

1

	ExtBuilder::default()

1973

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1974

1

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

1975

1

			metadata: AssetRegistrarMetadata {

1976

1

				name: b"RelayToken".to_vec(),

1977

1

				symbol: b"Relay".to_vec(),

1978

1

				decimals: 12,

1979

1

				is_frozen: false,

1980

1

},

1981

1

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

1982

1

			is_sufficient: true,

1983

1

}])

1984

1

		.with_balances(vec![

1985

1

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

1986

1

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

1987

1

])

1988

1

		.with_safe_xcm_version(2)

1989

1

		.build()

1990

1

		.execute_with(|| {

1991

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1992

1

1993

1

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

1994

1

			let destination = Location::new(

1995

1

1,

1996

1

				[Junction::AccountId32 {

1997

1

					network: None,

1998

1

					id: [1u8; 32],

1999

1

}],

2000

1

);

2001

1

2002

1

			// This time we transfer it through TransferMultiAsset

2003

1

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

2004

1

			Precompiles::new()

2005

1

				.prepare_test(

2006

1

					ALICE,

2007

1

					xtokens_precompile_address,

2008

1

					XtokensPCall::transfer_multiasset {

2009

1

						// We want to transfer the relay token

2010

1

						asset: Location::parent(),

2011

1

						amount: 500_000_000_000_000u128.into(),

2012

1

						destination,

2013

1

						weight: 4_000_000,

2014

1

},

2015

1

2016

1

				.expect_cost(24691)

2017

1

				.expect_no_logs()

2018

1

				.execute_returns(());

2019

1

})

2020

1

2021

2022

#[test]

2023

1

fn make_sure_glmr_can_be_transferred_precompile() {

2024

1

	ExtBuilder::default()

2025

1

		.with_balances(vec![

2026

1

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

2027

1

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

2028

1

])

2029

1

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

2030

1

		.with_mappings(vec![(

2031

1

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

2032

1

			AccountId::from(ALICE),

2033

1

)])

2034

1

		.with_safe_xcm_version(2)

2035

1

		.build()

2036

1

		.execute_with(|| {

2037

1

			assert_ok!(PolkadotXcm::transfer_assets(

2038

1

				origin_of(AccountId::from(ALICE)),

2039

1

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

2040

1

				Box::new(VersionedLocation::V4(Location {

2041

1

					parents: 0,

2042

1

					interior: [AccountId32 {

2043

1

						network: None,

2044

1

						id: [1u8; 32],

2045

1

}]

2046

1

					.into(),

2047

1

				})),

2048

1

				Box::new(VersionedAssets::V4(

2049

1

					Asset {

2050

1

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

2051

1

						fun: Fungible(1000)

2052

1

2053

1

					.into()

2054

1

)),

2055

1

0,

2056

1

				WeightLimit::Limited(40000.into())

2057

1

));

2058

1

});

2059

1

2060

2061

#[test]

2062

1

fn make_sure_glmr_can_be_transferred() {

2063

1

	ExtBuilder::default()

2064

1

		.with_balances(vec![

2065

1

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

2066

1

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

2067

1

])

2068

1

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

2069

1

		.with_mappings(vec![(

2070

1

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

2071

1

			AccountId::from(ALICE),

2072

1

)])

2073

1

		.with_safe_xcm_version(2)

2074

1

		.build()

2075

1

		.execute_with(|| {

2076

1

			let dest = Location {

2077

1

				parents: 1,

2078

1

				interior: [AccountId32 {

2079

1

					network: None,

2080

1

					id: [1u8; 32],

2081

1

}]

2082

1

				.into(),

2083

1

};

2084

1

			assert_ok!(PolkadotXcm::transfer_assets(

2085

1

				origin_of(AccountId::from(ALICE)),

2086

1

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

2087

1

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

2088

1

				Box::new(VersionedAssets::V4(

2089

1

					Asset {

2090

1

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

2091

1

						fun: Fungible(100)

2092

1

2093

1

					.into()

2094

1

)),

2095

1

0,

2096

1

				WeightLimit::Limited(40000.into())

2097

1

));

2098

1

});

2099

1

2100

2101

#[test]

2102

1

fn make_sure_polkadot_xcm_cannot_be_called() {

2103

1

	ExtBuilder::default()

2104

1

		.with_balances(vec![

2105

1

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

2106

1

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

2107

1

])

2108

1

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

2109

1

		.with_mappings(vec![(

2110

1

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

2111

1

			AccountId::from(ALICE),

2112

1

)])

2113

1

		.build()

2114

1

		.execute_with(|| {

2115

1

			let dest = Location {

2116

1

				parents: 1,

2117

1

				interior: [AccountId32 {

2118

1

					network: None,

2119

1

					id: [1u8; 32],

2120

1

}]

2121

1

				.into(),

2122

1

};

2123

1

			let assets: Assets = [Asset {

2124

1

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

2125

1

				fun: Fungible(1000),

2126

1

}]

2127

1

			.to_vec()

2128

1

			.into();

2129

1

			assert_noop!(

2130

1

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

2131

1

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

2132

1

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

2133

1

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

2134

1

					fee_asset_item: 0,

2135

1

})

2136

1

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

2137

1

					AccountId::from(ALICE)

2138

1

)),

2139

1

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

2140

1

);

2141

1

});

2142

1

2143

2144

#[test]

2145

1

fn transact_through_signed_precompile_works_v2() {

2146

1

	ExtBuilder::default()

2147

1

		.with_balances(vec![

2148

1

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

2149

1

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

2150

1

])

2151

1

		.with_safe_xcm_version(2)

2152

1

		.build()

2153

1

		.execute_with(|| {

2154

1

			// Destination

2155

1

			let dest = Location::parent();

2156

1

2157

1

			let fee_payer_asset = Location::parent();

2158

1

2159

1

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

2160

1

2161

1

			let total_weight = 1_000_000_000u64;

2162

1

2163

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2164

1

2165

1

			Precompiles::new()

2166

1

				.prepare_test(

2167

1

					ALICE,

2168

1

					xcm_transactor_v2_precompile_address,

2169

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2170

1

						dest,

2171

1

						fee_asset: fee_payer_asset,

2172

1

						weight: 4_000_000,

2173

1

						call: bytes.into(),

2174

1

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

2175

1

						overall_weight: total_weight,

2176

1

},

2177

1

2178

1

				.expect_cost(23275)

2179

1

				.expect_no_logs()

2180

1

				.execute_returns(());

2181

1

});

2182

1

2183

2184

#[test]

2185

1

fn transact_through_signed_cannot_send_to_local_chain() {

2186

1

	ExtBuilder::default()

2187

1

		.with_balances(vec![

2188

1

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

2189

1

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

2190

1

])

2191

1

		.with_safe_xcm_version(2)

2192

1

		.build()

2193

1

		.execute_with(|| {

2194

1

			// Destination

2195

1

			let dest = Location::here();

2196

1

2197

1

			let fee_payer_asset = Location::parent();

2198

1

2199

1

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

2200

1

2201

1

			let total_weight = 1_000_000_000u64;

2202

1

2203

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2204

1

2205

1

			Precompiles::new()

2206

1

				.prepare_test(

2207

1

					ALICE,

2208

1

					xcm_transactor_v2_precompile_address,

2209

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2210

1

						dest,

2211

1

						fee_asset: fee_payer_asset,

2212

1

						weight: 4_000_000,

2213

1

						call: bytes.into(),

2214

1

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

2215

1

						overall_weight: total_weight,

2216

1

},

2217

1

2218

1

				.execute_reverts(|output| {

2219

1

					from_utf8(&output)

2220

1

						.unwrap()

2221

1

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

2222

1

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

2223

1

});

2224

1

});

2225

1

2226

2227

#[test]

2228

1

fn transactor_cannot_use_more_than_max_weight() {

2229

1

	ExtBuilder::default()

2230

1

		.with_balances(vec![

2231

1

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

2232

1

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

2233

1

])

2234

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2235

1

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

2236

1

			metadata: AssetRegistrarMetadata {

2237

1

				name: b"RelayToken".to_vec(),

2238

1

				symbol: b"Relay".to_vec(),

2239

1

				decimals: 12,

2240

1

				is_frozen: false,

2241

1

},

2242

1

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

2243

1

			is_sufficient: true,

2244

1

}])

2245

1

		.build()

2246

1

		.execute_with(|| {

2247

1

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

2248

1

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

2249

1

			assert_ok!(XcmTransactor::register(

2250

1

				root_origin(),

2251

1

				AccountId::from(ALICE),

2252

1

0,

2253

1

));

2254

2255

			// Root can set transact info

2256

1

			assert_ok!(XcmTransactor::set_transact_info(

2257

1

				root_origin(),

2258

1

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

2259

1

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

2260

1

				3000.into(),

2261

1

				20000.into(),

2262

1

				None

2263

1

));

2264

2265

			// Root can set transact info

2266

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2267

1

				root_origin(),

2268

1

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

2269

1

1,

2270

1

));

2271

2272

1

			assert_noop!(

2273

1

				XcmTransactor::transact_through_derivative(

2274

1

					origin_of(AccountId::from(ALICE)),

2275

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

2276

1

0,

2277

1

					CurrencyPayment {

2278

1

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

2279

1

							Location::parent()

2280

1

						))),

2281

1

						fee_amount: None

2282

1

},

2283

1

					vec![],

2284

1

					// 2000 is the max

2285

1

					TransactWeights {

2286

1

						transact_required_weight_at_most: 17001.into(),

2287

1

						overall_weight: None

2288

1

},

2289

1

					false

2290

1

),

2291

1

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

2292

1

);

2293

1

			assert_noop!(

2294

1

				XcmTransactor::transact_through_derivative(

2295

1

					origin_of(AccountId::from(ALICE)),

2296

1

					moonbeam_runtime::xcm_config::Transactors::Relay,

2297

1

0,

2298

1

					CurrencyPayment {

2299

1

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

2300

1

						fee_amount: None

2301

1

},

2302

1

					vec![],

2303

1

					// 20000 is the max

2304

1

					TransactWeights {

2305

1

						transact_required_weight_at_most: 17001.into(),

2306

1

						overall_weight: None

2307

1

},

2308

1

					false

2309

1

),

2310

1

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

2311

1

);

2312

1

})

2313

1

2314

2315

#[test]

2316

1

fn call_xtokens_with_fee() {

2317

1

	ExtBuilder::default()

2318

1

		.with_balances(vec![

2319

1

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

2320

1

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

2321

1

])

2322

1

		.with_safe_xcm_version(2)

2323

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2324

1

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

2325

1

			metadata: AssetRegistrarMetadata {

2326

1

				name: b"RelayToken".to_vec(),

2327

1

				symbol: b"Relay".to_vec(),

2328

1

				decimals: 12,

2329

1

				is_frozen: false,

2330

1

},

2331

1

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

2332

1

			is_sufficient: true,

2333

1

}])

2334

1

		.build()

2335

1

		.execute_with(|| {

2336

1

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

2337

1

			let dest = Location {

2338

1

				parents: 1,

2339

1

				interior: [AccountId32 {

2340

1

					network: None,

2341

1

					id: [1u8; 32],

2342

1

}]

2343

1

				.into(),

2344

1

};

2345

1

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

2346

1

2347

1

			let before_balance =

2348

1

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

2349

1

			let (chain_part, beneficiary) =

2350

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2351

1

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

2352

1

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

2353

1

			// We are able to transfer with fee

2354

1

			assert_ok!(PolkadotXcm::transfer_assets(

2355

1

				origin_of(AccountId::from(ALICE)),

2356

1

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

2357

1

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

2358

1

				Box::new(VersionedAssets::V4(vec![asset_fee, asset].into())),

2359

1

0,

2360

1

				WeightLimit::Limited(4000000000.into())

2361

1

));

2362

2363

1

			let after_balance =

2364

1

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

2365

1

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

2366

1

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

2367

1

});

2368

1

2369

2370

#[test]

2371

1

fn test_xcm_utils_ml_tp_account() {

2372

1

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

2373

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2374

1

		let expected_address_parent: H160 =

2375

1

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

2376

1

				.unwrap()

2377

1

				.into();

2378

1

2379

1

		Precompiles::new()

2380

1

			.prepare_test(

2381

1

				ALICE,

2382

1

				xcm_utils_precompile_address,

2383

1

				XcmUtilsPCall::multilocation_to_address {

2384

1

					location: Location::parent(),

2385

1

},

2386

1

2387

1

			.expect_cost(1669)

2388

1

			.expect_no_logs()

2389

1

			.execute_returns(Address(expected_address_parent));

2390

1

2391

1

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

2392

1

		let expected_address_parachain: H160 =

2393

1

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

2394

1

				&parachain_2000_location,

2395

1

2396

1

			.unwrap()

2397

1

			.into();

2398

1

2399

1

		Precompiles::new()

2400

1

			.prepare_test(

2401

1

				ALICE,

2402

1

				xcm_utils_precompile_address,

2403

1

				XcmUtilsPCall::multilocation_to_address {

2404

1

					location: parachain_2000_location,

2405

1

},

2406

1

2407

1

			.expect_cost(1669)

2408

1

			.expect_no_logs()

2409

1

			.execute_returns(Address(expected_address_parachain));

2410

1

2411

1

		let alice_in_parachain_2000_location = Location::new(

2412

1

1,

2413

1

2414

1

				Parachain(2000),

2415

1

				AccountKey20 {

2416

1

					network: None,

2417

1

					key: ALICE,

2418

1

},

2419

1

],

2420

1

);

2421

1

		let expected_address_alice_in_parachain_2000 =

2422

1

			xcm_builder::HashedDescription::<

2423

1

				AccountId,

2424

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2425

1

			>::convert_location(&alice_in_parachain_2000_location)

2426

1

			.unwrap()

2427

1

			.into();

2428

1

2429

1

		Precompiles::new()

2430

1

			.prepare_test(

2431

1

				ALICE,

2432

1

				xcm_utils_precompile_address,

2433

1

				XcmUtilsPCall::multilocation_to_address {

2434

1

					location: alice_in_parachain_2000_location,

2435

1

},

2436

1

2437

1

			.expect_cost(1669)

2438

1

			.expect_no_logs()

2439

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2440

1

});

2441

1

2442

2443

#[test]

2444

1

fn test_xcm_utils_weight_message() {

2445

1

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

2446

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2447

1

		let expected_weight =

2448

1

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

2449

1

2450

1

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

2451

1

2452

1

		let input = XcmUtilsPCall::weight_message {

2453

1

			message: message.into(),

2454

1

};

2455

1

2456

1

		Precompiles::new()

2457

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2458

1

			.expect_cost(0)

2459

1

			.expect_no_logs()

2460

1

			.execute_returns(expected_weight);

2461

1

});

2462

1

2463

2464

#[test]

2465

1

fn test_xcm_utils_get_units_per_second() {

2466

1

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

2467

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2468

1

		let location = SelfReserve::get();

2469

1

2470

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2471

1

2472

1

		let expected_units =

2473

1

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

2474

1

2475

1

		Precompiles::new()

2476

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2477

1

			.expect_cost(1669)

2478

1

			.expect_no_logs()

2479

1

			.execute_returns(expected_units);

2480

1

});

2481

1

2482

2483

#[test]

2484

1

fn precompile_existence() {

2485

1

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

2486

1

		let precompiles = Precompiles::new();

2487

1

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

2488

1

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

2489

1

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

2490

1

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

2491

1

2492

1

		.into_iter()

2493

1

		.map(H160::from_low_u64_be)

2494

1

		.collect();

2495

2496

3001

		for i in 0..3000 {

2497

3000

			let address = H160::from_low_u64_be(i);

2498

3000

2499

3000

			if precompile_addresses.contains(&address) {

2500

40

				assert!(

2501

40

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

2502

					"is_precompile({}) should return true",

2503

2504

);

2505

2506

40

				assert!(

2507

40

					precompiles

2508

40

						.execute(&mut MockHandle::new(

2509

40

							address,

2510

40

							Context {

2511

40

								address,

2512

40

								caller: H160::zero(),

2513

40

								apparent_value: U256::zero()

2514

40

2515

40

),)

2516

40

						.is_some(),

2517

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

2518

2519

);

2520

			} else {

2521

2960

				assert!(

2522

2960

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

2523

					"is_precompile({}) should return false",

2524

2525

);

2526

2527

2960

				assert!(

2528

2960

					precompiles

2529

2960

						.execute(&mut MockHandle::new(

2530

2960

							address,

2531

2960

							Context {

2532

2960

								address,

2533

2960

								caller: H160::zero(),

2534

2960

								apparent_value: U256::zero()

2535

2960

2536

2960

),)

2537

2960

						.is_none(),

2538

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

2539

2540

);

2541

2542

2543

1

});

2544

1

2545

2546

#[test]

2547

1

fn removed_precompiles() {

2548

1

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

2549

1

		let precompiles = Precompiles::new();

2550

1

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

2551

2552

3000

		for i in 1..3000 {

2553

2999

			let address = H160::from_low_u64_be(i);

2554

2999

2555

2999

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

2556

2959

				continue;

2557

40

2558

40

2559

40

			if !removed_precompiles.contains(&i) {

2560

36

				assert!(

2561

36

					match precompiles.is_active_precompile(address, 100_000u64) {

2562

36

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

2563

						_ => false,

2564

},

2565

					"{i} should be an active precompile"

2566

);

2567

36

				continue;

2568

4

2569

4

2570

4

			assert!(

2571

4

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

2572

4

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

2573

					_ => false,

2574

},

2575

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

2576

);

2577

2578

4

			precompiles

2579

4

				.prepare_test(Alice, address, [])

2580

4

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

2581

2582

1

})

2583

1

2584

2585

#[test]

2586

1

fn deal_with_fees_handles_tip() {

2587

1

	use frame_support::traits::OnUnbalanced;

2588

1

	use moonbeam_runtime::{DealWithFees, Treasury};

2589

1

2590

1

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

2591

1

		// This test checks the functionality of the `DealWithFees` trait implementation in the runtime.

2592

1

		// It simulates a scenario where a fee and a tip are issued to an account and ensures that the

2593

1

		// treasury receives the correct amount (20% of the total), and the rest is burned (80%).

2594

1

//

2595

1

		// The test follows these steps:

2596

1

		// 1. It issues a fee of 100 and a tip of 1000.

2597

1

		// 2. It checks the total supply before the fee and tip are dealt with, which should be 1_100.

2598

1

		// 3. It checks that the treasury's balance is initially 0.

2599

1

		// 4. It calls `DealWithFees::on_unbalanceds` with the fee and tip.

2600

1

		// 5. It checks that the treasury's balance is now 220 (20% of the fee and tip).

2601

1

		// 6. It checks that the total supply has decreased by 880 (80% of the fee and tip), indicating

2602

1

		//    that this amount was burned.

2603

1

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

2604

1

			AccountId,

2605

1

		>>::issue(100);

2606

1

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

2607

1

			AccountId,

2608

1

		>>::issue(1000);

2609

1

2610

1

		let total_supply_before = Balances::total_issuance();

2611

1

		assert_eq!(total_supply_before, 1_100);

2612

1

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

2613

2614

1

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

2615

1

2616

1

		// treasury should have received 20%

2617

1

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

2618

2619

		// verify 80% burned

2620

1

		let total_supply_after = Balances::total_issuance();

2621

1

		assert_eq!(total_supply_before - total_supply_after, 880);

2622

1

});

2623

1

2624

2625

#[test]

2626

1

fn evm_revert_substrate_events() {

2627

1

	ExtBuilder::default()

2628

1

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

2629

1

		.build()

2630

1

		.execute_with(|| {

2631

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2632

1

2633

1

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

2634

1

			// Thus BatchAll will revert the transfer.

2635

1

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

2636

1

				source: ALICE.into(),

2637

1

				target: batch_precompile_address,

2638

1

2639

1

				input: BatchPCall::batch_all {

2640

1

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

2641

1

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

2642

1

					call_data: vec![].into(),

2643

1

					gas_limit: vec![].into()

2644

1

2645

1

				.into(),

2646

1

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

2647

1

				gas_limit: 500_000,

2648

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2649

1

				max_priority_fee_per_gas: None,

2650

1

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

2651

1

				access_list: Vec::new(),

2652

1

})

2653

1

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

2654

2655

1

			let transfer_count = System::events()

2656

1

				.iter()

2657

6

				.filter(|r| match r.event {

2658

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

2659

6

					_ => false,

2660

6

})

2661

1

				.count();

2662

1

2663

1

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

2664

1

});

2665

1

2666

2667

#[test]

2668

1

fn evm_success_keeps_substrate_events() {

2669

1

	ExtBuilder::default()

2670

1

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

2671

1

		.build()

2672

1

		.execute_with(|| {

2673

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2674

1

2675

1

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

2676

1

				source: ALICE.into(),

2677

1

				target: batch_precompile_address,

2678

1

				input: BatchPCall::batch_all {

2679

1

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

2680

1

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

2681

1

					call_data: vec![].into(),

2682

1

					gas_limit: vec![].into()

2683

1

2684

1

				.into(),

2685

1

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

2686

1

				gas_limit: 500_000,

2687

1

				max_fee_per_gas: BASE_FEE_GENESIS.into(),

2688

1

				max_priority_fee_per_gas: None,

2689

1

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

2690

1

				access_list: Vec::new(),

2691

1

})

2692

1

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

2693

2694

1

			let transfer_count = System::events()

2695

1

				.iter()

2696

10

				.filter(|r| match r.event {

2697

1

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

2698

9

					_ => false,

2699

10

})

2700

1

				.count();

2701

1

2702

1

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

2703

1

});

2704

1

2705

2706

#[cfg(test)]

2707

mod fee_tests {

2708

	use super::*;

2709

	use fp_evm::FeeCalculator;

2710

	use frame_support::{

2711

		traits::{ConstU128, OnFinalize},

2712

		weights::{ConstantMultiplier, WeightToFee},

2713

};

2714

	use moonbeam_runtime::{

2715

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2716

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2717

};

2718

	use sp_core::Get;

2719

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

2720

2721

1

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

2722

1

	where

2723

1

		F: FnMut() -> (),

2724

1

2725

1

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

2726

1

			.build_storage()

2727

1

			.unwrap()

2728

1

			.into();

2729

1

		t.execute_with(|| {

2730

1

			System::set_block_consumed_resources(w, 0);

2731

1

			assertions()

2732

1

});

2733

1

2734

2735

	#[test]

2736

1

	fn test_multiplier_can_grow_from_zero() {

2737

1

		let minimum_multiplier = MinimumMultiplier::get();

2738

1

		let target = TargetBlockFullness::get()

2739

1

			* RuntimeBlockWeights::get()

2740

1

				.get(DispatchClass::Normal)

2741

1

				.max_total

2742

1

				.unwrap();

2743

1

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

2744

1

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

2745

1

		run_with_system_weight(target * 101 / 100, || {

2746

1

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

2747

1

			assert!(

2748

1

				next > minimum_multiplier,

2749

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

2750

				next,

2751

				minimum_multiplier

2752

);

2753

1

})

2754

1

2755

2756

	#[test]

2757

1

	fn test_fee_calculation() {

2758

1

		let base_extrinsic = RuntimeBlockWeights::get()

2759

1

			.get(DispatchClass::Normal)

2760

1

			.base_extrinsic;

2761

1

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

2762

1

		let extrinsic_len = 100u32;

2763

1

		let extrinsic_weight = 5_000u64;

2764

1

		let tip = 42u128;

2765

1

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

2766

1

		type LengthToFeeImpl = LengthToFee;

2767

1

2768

1

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

2769

1

		let expected_fee =

2770

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

2771

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

2772

1

					&Weight::from_parts(extrinsic_weight, 1),

2773

1

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

2774

1

				+ tip;

2775

1

2776

1

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

2777

1

			.build_storage()

2778

1

			.unwrap()

2779

1

			.into();

2780

1

		t.execute_with(|| {

2781

1

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

2782

1

			let actual_fee = TransactionPayment::compute_fee(

2783

1

				extrinsic_len,

2784

1

				&frame_support::dispatch::DispatchInfo {

2785

1

					class: DispatchClass::Normal,

2786

1

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

2787

1

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

2788

1

},

2789

1

				tip,

2790

1

);

2791

1

2792

1

			assert_eq!(

2793

				expected_fee,

2794

				actual_fee,

2795

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

2796

				actual_fee - expected_fee

2797

);

2798

1

});

2799

1

2800

2801

	#[test]

2802

1

	fn test_min_gas_price_is_deterministic() {

2803

1

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

2804

1

			.build_storage()

2805

1

			.unwrap()

2806

1

			.into();

2807

1

		t.execute_with(|| {

2808

1

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

2809

1

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

2810

1

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

2811

1

			let expected: U256 = multiplier

2812

1

				.saturating_mul_int(

2813

1

					(currency::WEIGHT_FEE * 4).saturating_mul(WEIGHT_PER_GAS as u128),

2814

1

2815

1

				.into();

2816

1

2817

1

			assert_eq!(expected, actual);

2818

1

});

2819

1

2820

2821

	#[test]

2822

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

2823

1

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

2824

1

			.build_storage()

2825

1

			.unwrap()

2826

1

			.into();

2827

1

		t.execute_with(|| {

2828

1

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

2829

1

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

2830

1

2831

1

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

2832

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

2833

1

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

2834

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

2835

1

2836

1

			assert_ne!(

2837

				a, b,

2838

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

2839

);

2840

1

});

2841

1

2842

2843

	#[test]

2844

1

	fn test_fee_scenarios() {

2845

1

		use sp_runtime::FixedU128;

2846

1

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

2847

1

			.build_storage()

2848

1

			.unwrap()

2849

1

			.into();

2850

1

		t.execute_with(|| {

2851

1

			let weight_fee_per_gas =

2852

1

				(currency::WEIGHT_FEE * 4).saturating_mul(WEIGHT_PER_GAS as u128);

2853

12

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

2854

12

				let start_multiplier =

2855

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

2856

12

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

2857

12

2858

12

				let block_weight = NORMAL_WEIGHT * fullness;

2859

2860

60004

				for i in 0..num_blocks {

2861

60004

					System::set_block_number(i as u32);

2862

60004

					System::set_block_consumed_resources(block_weight, 0);

2863

60004

					TransactionPayment::on_finalize(i as u32);

2864

60004

2865

2866

12

				TransactionPaymentAsGasPrice::min_gas_price().0

2867

12

};

2868

2869

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

2870

			// they are expected to change when parameters that influence

2871

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

2872

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

2873

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

2874

2875

1

			assert_eq!(

2876

1

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

2877

1

				U256::from(125_000_000_000u128),

2878

1

);

2879

1

			assert_eq!(

2880

1

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

2881

1

				U256::from(125_000_000_000u128),

2882

1

);

2883

1

			assert_eq!(

2884

1

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

2885

1

				U256::from(125_075_022_500u128),

2886

1

);

2887

1

			assert_eq!(

2888

1

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

2889

1

				U256::from(125_325_422_500u128),

2890

1

);

2891

2892

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

2893

1

			assert_eq!(

2894

1

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

2895

1

				U256::from(125_000_000_000u128),

2896

1

);

2897

1

			assert_eq!(

2898

1

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

2899

1

				U256::from(125_000_000_000u128),

2900

1

);

2901

1

			assert_eq!(

2902

1

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

2903

1

				U256::from(179_166_172_951u128),

2904

1

);

2905

1

			assert_eq!(

2906

1

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

2907

1

				U256::from(594_851_612_166u128),

2908

1

);

2909

2910

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

2911

1

			assert_eq!(

2912

1

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

2913

1

				U256::from(125_000_000_000u128), // lower bound enforced

2914

1

);

2915

1

			assert_eq!(

2916

1

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

2917

1

				U256::from(125_000_000_000u128),

2918

1

);

2919

1

			assert_eq!(

2920

1

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

2921

1

				U256::from(706_665_861_883_635u128),

2922

1

);

2923

1

			assert_eq!(

2924

1

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

2925

1

				U256::from(12_500_000_000_000_000u128), // upper bound enforced

2926

1

);

2927

1

});

2928

1

2929