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

//! Moonriver 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::traits::fungible::Inspect;

26

use frame_support::{

27

	assert_noop, assert_ok,

28

	dispatch::DispatchClass,

29

	traits::{Currency as CurrencyT, EnsureOrigin, PalletInfo, StorageInfo, StorageInfoTrait},

30

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

31

	StorageHasher, Twox128,

32

};

33

use moonbeam_xcm_benchmarks::weights::XcmWeight;

34

use moonkit_xcm_primitives::AccountIdAssetIdConversion;

35

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

36

use moonriver_runtime::{

37

	asset_config::ForeignAssetInstance,

38

	xcm_config::{CurrencyId, SelfReserve},

39

	AssetId, Balances, CrowdloanRewards, Executive, OpenTechCommitteeCollective, PolkadotXcm,

40

	Precompiles, RuntimeBlockWeights, TransactionPayment, TransactionPaymentAsGasPrice,

41

	TreasuryCouncilCollective, XcmTransactor, FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, WEEKS,

42

};

43

use nimbus_primitives::NimbusId;

44

use pallet_evm::PrecompileSet;

45

use pallet_evm_precompileset_assets_erc20::{SELECTOR_LOG_APPROVAL, SELECTOR_LOG_TRANSFER};

46

use pallet_transaction_payment::Multiplier;

47

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

48

use parity_scale_codec::Encode;

49

use polkadot_parachain::primitives::Sibling;

50

use precompile_utils::{

51

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

52

	prelude::*,

53

	testing::*,

54

};

55

use sha3::{Digest, Keccak256};

56

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

57

use sp_runtime::{

58

	traits::{Convert, Dispatchable},

59

	BuildStorage, DispatchError, ModuleError,

60

};

61

use std::str::from_utf8;

62

use xcm::latest::prelude::*;

63

use xcm::{VersionedAssets, VersionedLocation};

64

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

65

use xcm_executor::traits::ConvertLocation;

66

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

67

68

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

69

type CrowdloanRewardsPCall =

70

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

71

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

72

	Runtime,

73

	moonriver_runtime::xcm_config::XcmExecutorConfig,

74

>;

75

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

76

type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

77

	Runtime,

78

	ForeignAssetInstance,

79

>;

80

type XcmTransactorV2PCall =

81

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

82

83

const BASE_FEE_GENESIS: u128 = 100 * GIGAWEI;

84

85

3

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

86

3

	Asset {

87

3

		id: AssetId(

88

3

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

89

3

				currency_id,

90

3

91

3

			.unwrap(),

92

3

),

93

3

		fun: Fungibility::Fungible(amount),

94

3

95

3

96

97

#[test]

98

1

fn xcmp_queue_controller_origin_is_root() {

99

1

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

100

1

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

101

1

	assert_ok!(

102

1

		<moonriver_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

103

1

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

104

1

);

105

1

106

107

#[test]

108

1

fn verify_pallet_prefixes() {

109

30

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

110

30

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

111

30

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

112

30

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

113

30

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

114

30

		// expand/storage.rs#L389-L401

115

30

		assert_eq!(

116

30

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

117

30

			Some(name)

118

30

);

119

30

120

1

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

121

1

	// This is now available with polkadot-v0.9.9 dependencies

122

1

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

123

1

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

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

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

130

1

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

131

1

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

132

1

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

133

1

	is_pallet_prefix::<moonriver_runtime::OpenTechCommitteeCollective>(

134

1

		"OpenTechCommitteeCollective",

135

1

);

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

155

14

	let prefix = |pallet_name, storage_name| {

156

14

		let mut res = [0u8; 32];

157

14

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

158

14

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

159

14

		res.to_vec()

160

14

};

161

1

	assert_eq!(

162

1

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

163

1

		vec![

164

1

			StorageInfo {

165

1

				pallet_name: b"Timestamp".to_vec(),

166

1

				storage_name: b"Now".to_vec(),

167

1

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

168

1

				max_values: Some(1),

169

1

				max_size: Some(8),

170

1

},

171

1

			StorageInfo {

172

1

				pallet_name: b"Timestamp".to_vec(),

173

1

				storage_name: b"DidUpdate".to_vec(),

174

1

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

175

1

				max_values: Some(1),

176

1

				max_size: Some(1),

177

1

178

1

179

1

);

180

1

	assert_eq!(

181

1

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

182

1

		vec![

183

1

			StorageInfo {

184

1

				pallet_name: b"Balances".to_vec(),

185

1

				storage_name: b"TotalIssuance".to_vec(),

186

1

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

187

1

				max_values: Some(1),

188

1

				max_size: Some(16),

189

1

},

190

1

			StorageInfo {

191

1

				pallet_name: b"Balances".to_vec(),

192

1

				storage_name: b"InactiveIssuance".to_vec(),

193

1

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

194

1

				max_values: Some(1),

195

1

				max_size: Some(16),

196

1

},

197

1

			StorageInfo {

198

1

				pallet_name: b"Balances".to_vec(),

199

1

				storage_name: b"Account".to_vec(),

200

1

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

201

1

				max_values: None,

202

1

				max_size: Some(100),

203

1

},

204

1

			StorageInfo {

205

1

				pallet_name: b"Balances".to_vec(),

206

1

				storage_name: b"Locks".to_vec(),

207

1

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

208

1

				max_values: None,

209

1

				max_size: Some(1287),

210

1

},

211

1

			StorageInfo {

212

1

				pallet_name: b"Balances".to_vec(),

213

1

				storage_name: b"Reserves".to_vec(),

214

1

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

215

1

				max_values: None,

216

1

				max_size: Some(1037),

217

1

},

218

1

			StorageInfo {

219

1

				pallet_name: b"Balances".to_vec(),

220

1

				storage_name: b"Holds".to_vec(),

221

1

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

222

1

				max_values: None,

223

1

				max_size: Some(55),

224

1

},

225

1

			StorageInfo {

226

1

				pallet_name: b"Balances".to_vec(),

227

1

				storage_name: b"Freezes".to_vec(),

228

1

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

229

1

				max_values: None,

230

1

				max_size: Some(37),

231

1

},

232

1

233

1

);

234

1

	assert_eq!(

235

1

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

236

1

		vec![

237

1

			StorageInfo {

238

1

				pallet_name: b"Proxy".to_vec(),

239

1

				storage_name: b"Proxies".to_vec(),

240

1

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

241

1

				max_values: None,

242

1

				max_size: Some(845),

243

1

},

244

1

			StorageInfo {

245

1

				pallet_name: b"Proxy".to_vec(),

246

1

				storage_name: b"Announcements".to_vec(),

247

1

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

248

1

				max_values: None,

249

1

				max_size: Some(1837),

250

1

251

1

252

1

);

253

1

	assert_eq!(

254

1

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

255

1

		vec![StorageInfo {

256

1

			pallet_name: b"MaintenanceMode".to_vec(),

257

1

			storage_name: b"MaintenanceMode".to_vec(),

258

1

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

259

1

			max_values: Some(1),

260

1

			max_size: None,

261

1

},]

262

1

);

263

1

	assert_eq!(

264

1

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

265

1

		vec![

266

1

			StorageInfo {

267

1

				pallet_name: b"RelayStorageRoots".to_vec(),

268

1

				storage_name: b"RelayStorageRoot".to_vec(),

269

1

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

270

1

				max_values: None,

271

1

				max_size: Some(44),

272

1

},

273

1

			StorageInfo {

274

1

				pallet_name: b"RelayStorageRoots".to_vec(),

275

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

276

1

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

277

1

				max_values: Some(1),

278

1

				max_size: Some(121),

279

1

},

280

1

281

1

);

282

1

283

284

#[test]

285

1

fn test_collectives_storage_item_prefixes() {

286

6

	for StorageInfo { pallet_name, .. } in

287

7

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

288

289

6

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

290

291

292

6

	for StorageInfo { pallet_name, .. } in

293

7

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

294

295

6

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

296

297

1

298

299

#[test]

300

1

fn collective_set_members_root_origin_works() {

301

1

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

302

1

		// TreasuryCouncilCollective

303

1

		assert_ok!(TreasuryCouncilCollective::set_members(

304

1

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

305

1

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

306

1

			Some(AccountId::from(ALICE)),

307

1

308

1

));

309

		// OpenTechCommitteeCollective

310

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

311

1

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

312

1

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

313

1

			Some(AccountId::from(ALICE)),

314

1

315

1

));

316

1

});

317

1

318

319

#[test]

320

1

fn collective_set_members_general_admin_origin_works() {

321

1

	use moonriver_runtime::{

322

1

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

323

1

};

324

1

325

1

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

326

1

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

327

1

		let alice = AccountId::from(ALICE);

328

1

329

1

		// TreasuryCouncilCollective

330

1

		let _ = Utility::dispatch_as(

331

1

			root_caller.clone(),

332

1

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

333

1

			Box::new(

334

1

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

335

1

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

336

1

					prime: Some(alice),

337

1

					old_count: 2,

338

1

339

1

				.into(),

340

1

),

341

1

);

342

1

		// OpenTechCommitteeCollective

343

1

		let _ = Utility::dispatch_as(

344

1

			root_caller,

345

1

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

346

1

			Box::new(

347

1

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

348

1

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

349

1

					prime: Some(alice),

350

1

					old_count: 2,

351

1

352

1

				.into(),

353

1

),

354

1

);

355

1

356

1

		assert_eq!(

357

1

			System::events()

358

1

				.into_iter()

359

2

				.filter_map(|r| {

360

2

					match r.event {

361

2

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

362

2

							if result.is_ok() =>

363

2

364

2

							Some(true)

365

366

						_ => None,

367

368

2

})

369

1

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

370

1

				.len(),

371

1

372

1

373

1

});

374

1

375

376

#[test]

377

1

fn collective_set_members_signed_origin_does_not_work() {

378

1

	let alice = AccountId::from(ALICE);

379

1

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

380

1

		// TreasuryCouncilCollective

381

1

		assert!(TreasuryCouncilCollective::set_members(

382

1

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

383

1

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

384

1

			Some(AccountId::from(ALICE)),

385

1

386

1

387

1

		.is_err());

388

		// OpenTechCommitteeCollective

389

1

		assert!(OpenTechCommitteeCollective::set_members(

390

1

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

391

1

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

392

1

			Some(AccountId::from(ALICE)),

393

1

394

1

395

1

		.is_err());

396

1

});

397

1

398

399

#[test]

400

1

fn verify_pallet_indices() {

401

32

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

402

32

		assert_eq!(

403

32

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

404

32

			Some(index)

405

32

);

406

32

407

1

	// System support

408

1

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

409

1

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

410

1

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

411

1

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

412

1

	// Monetary

413

1

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

414

1

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

415

1

	// Consensus support

416

1

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

417

1

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

418

1

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

419

1

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

420

1

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

421

1

	// Handy utilities

422

1

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

423

1

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

424

1

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

425

1

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

426

1

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

427

1

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

428

1

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

429

1

	// Ethereum compatibility

430

1

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

431

1

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

432

1

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

433

1

	// Governance

434

1

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

435

1

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

436

1

	// Council

437

1

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

438

1

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

439

1

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

440

1

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

441

1

	// Treasury

442

1

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

443

1

	// Crowdloan

444

1

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

445

1

	// XCM Stuff

446

1

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

447

1

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

448

1

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

449

1

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

450

1

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

451

1

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

452

1

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

453

1

454

455

#[test]

456

1

fn verify_reserved_indices() {

457

1

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

458

1

		.build_storage()

459

1

		.unwrap()

460

1

		.into();

461

1

462

1

	t.execute_with(|| {

463

1

		use frame_metadata::*;

464

1

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

465

1

		let metadata = match metadata.1 {

466

1

			RuntimeMetadata::V14(metadata) => metadata,

467

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

468

};

469

		// 40: Sudo

470

		// 53: BaseFee

471

		// 108: pallet_assets::<Instance1>

472

1

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

473

1

		let existing = metadata

474

1

			.pallets

475

1

			.iter()

476

49

			.map(|p| p.index)

477

1

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

478

3

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

479

1

});

480

1

481

482

#[test]

483

1

fn verify_proxy_type_indices() {

484

1

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

485

1

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

486

1

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

487

1

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

488

1

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

489

1

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

490

1

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

491

1

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

492

1

493

494

#[test]

495

1

fn join_collator_candidates() {

496

1

	ExtBuilder::default()

497

1

		.with_balances(vec![

498

1

			(AccountId::from(ALICE), 20_000 * MOVR),

499

1

			(AccountId::from(BOB), 20_000 * MOVR),

500

1

			(AccountId::from(CHARLIE), 10_100 * MOVR),

501

1

			(AccountId::from(DAVE), 10_000 * MOVR),

502

1

])

503

1

		.with_collators(vec![

504

1

			(AccountId::from(ALICE), 10_000 * MOVR),

505

1

			(AccountId::from(BOB), 10_000 * MOVR),

506

1

])

507

1

		.with_delegations(vec![

508

1

			(AccountId::from(CHARLIE), AccountId::from(ALICE), 50 * MOVR),

509

1

			(AccountId::from(CHARLIE), AccountId::from(BOB), 50 * MOVR),

510

1

])

511

1

		.build()

512

1

		.execute_with(|| {

513

1

			assert_noop!(

514

1

				ParachainStaking::join_candidates(

515

1

					origin_of(AccountId::from(ALICE)),

516

1

					10_000 * MOVR,

517

1

					2u32

518

1

),

519

1

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

520

1

);

521

1

			assert_noop!(

522

1

				ParachainStaking::join_candidates(

523

1

					origin_of(AccountId::from(CHARLIE)),

524

1

					10_000 * MOVR,

525

1

					2u32

526

1

),

527

1

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

528

1

);

529

1

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

530

1

			assert_ok!(ParachainStaking::join_candidates(

531

1

				origin_of(AccountId::from(DAVE)),

532

1

				10_000 * MOVR,

533

1

				2u32

534

1

));

535

1

			assert_eq!(

536

1

				last_event(),

537

1

				RuntimeEvent::ParachainStaking(

538

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

539

1

						account: AccountId::from(DAVE),

540

1

						amount_locked: 10_000 * MOVR,

541

1

						new_total_amt_locked: 30_100 * MOVR

542

1

543

1

544

1

);

545

1

			let candidates = ParachainStaking::candidate_pool();

546

1

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

547

1

			assert_eq!(candidates.0[0].amount, 10_050 * MOVR);

548

1

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

549

1

			assert_eq!(candidates.0[1].amount, 10_050 * MOVR);

550

1

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

551

1

			assert_eq!(candidates.0[2].amount, 10_000 * MOVR);

552

1

});

553

1

554

555

#[test]

556

1

fn transfer_through_evm_to_stake() {

557

1

	ExtBuilder::default()

558

1

		.with_balances(vec![(AccountId::from(ALICE), 20_000 * MOVR)])

559

1

		.build()

560

1

		.execute_with(|| {

561

1

			// Charlie has no balance => fails to stake

562

1

			assert_noop!(

563

1

				ParachainStaking::join_candidates(

564

1

					origin_of(AccountId::from(CHARLIE)),

565

1

					10_000 * MOVR,

566

1

					2u32

567

1

),

568

1

				DispatchError::Module(ModuleError {

569

1

					index: 20,

570

1

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

571

1

					message: Some("InsufficientBalance")

572

1

})

573

1

);

574

			// Alice transfer from free balance 20000 MOVR to Bob

575

1

			assert_ok!(Balances::transfer_allow_death(

576

1

				origin_of(AccountId::from(ALICE)),

577

1

				AccountId::from(BOB),

578

1

				20_000 * MOVR,

579

1

));

580

1

			assert_eq!(Balances::free_balance(AccountId::from(BOB)), 20_000 * MOVR);

581

582

1

			let gas_limit = 100000u64;

583

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

584

1

			// Bob transfers 10000 MOVR to Charlie via EVM

585

1

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

586

1

				source: H160::from(BOB),

587

1

				target: H160::from(CHARLIE),

588

1

				input: vec![],

589

1

				value: (10_000 * MOVR).into(),

590

1

				gas_limit,

591

1

				max_fee_per_gas: gas_price,

592

1

				max_priority_fee_per_gas: None,

593

1

				nonce: None,

594

1

				access_list: Vec::new(),

595

1

})

596

1

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

597

1

			assert_eq!(

598

1

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

599

1

				10_000 * MOVR,

600

1

);

601

602

			// Charlie can stake now

603

1

			assert_ok!(ParachainStaking::join_candidates(

604

1

				origin_of(AccountId::from(CHARLIE)),

605

1

				10_000 * MOVR,

606

1

				2u32,

607

1

			),);

608

1

			let candidates = ParachainStaking::candidate_pool();

609

1

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

610

1

			assert_eq!(candidates.0[0].amount, 10_000 * MOVR);

611

1

});

612

1

613

614

#[test]

615

1

fn reward_block_authors() {

616

1

	ExtBuilder::default()

617

1

		.with_balances(vec![

618

1

			// Alice gets 100 extra tokens for her mapping deposit

619

1

			(AccountId::from(ALICE), 20_100 * MOVR),

620

1

			(AccountId::from(BOB), 10_000 * MOVR),

621

1

])

622

1

		.with_collators(vec![(AccountId::from(ALICE), 10_000 * MOVR)])

623

1

		.with_delegations(vec![(

624

1

			AccountId::from(BOB),

625

1

			AccountId::from(ALICE),

626

1

			500 * MOVR,

627

1

)])

628

1

		.with_mappings(vec![(

629

1

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

630

1

			AccountId::from(ALICE),

631

1

)])

632

1

		.build()

633

1

		.execute_with(|| {

634

1

			increase_last_relay_slot_number(1);

635

1

636

1

			// Just before round 3

637

1

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

638

1

639

1

			// no rewards doled out yet

640

1

			assert_eq!(

641

1

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

642

1

				10_100 * MOVR,

643

1

);

644

1

			assert_eq!(Balances::usable_balance(AccountId::from(BOB)), 9500 * MOVR,);

645

1

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

646

1

647

1

			// rewards minted and distributed

648

1

			assert_eq!(

649

1

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

650

1

				11547666666208000000000,

651

1

);

652

1

			assert_eq!(

653

1

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

654

1

				9557333332588000000000,

655

1

);

656

1

});

657

1

658

659

#[test]

660

1

fn reward_block_authors_with_parachain_bond_reserved() {

661

1

	ExtBuilder::default()

662

1

		.with_balances(vec![

663

1

			// Alice gets 100 extra tokens for her mapping deposit

664

1

			(AccountId::from(ALICE), 20_100 * MOVR),

665

1

			(AccountId::from(BOB), 10_000 * MOVR),

666

1

			(AccountId::from(CHARLIE), MOVR),

667

1

])

668

1

		.with_collators(vec![(AccountId::from(ALICE), 10_000 * MOVR)])

669

1

		.with_delegations(vec![(

670

1

			AccountId::from(BOB),

671

1

			AccountId::from(ALICE),

672

1

			500 * MOVR,

673

1

)])

674

1

		.with_mappings(vec![(

675

1

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

676

1

			AccountId::from(ALICE),

677

1

)])

678

1

		.build()

679

1

		.execute_with(|| {

680

1

			increase_last_relay_slot_number(1);

681

1

			assert_ok!(ParachainStaking::set_parachain_bond_account(

682

1

				root_origin(),

683

1

				AccountId::from(CHARLIE),

684

1

			),);

685

686

			// Stop just before round 2

687

1

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

688

1

689

1

			// no collator rewards doled out yet

690

1

			assert_eq!(

691

1

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

692

1

				10_100 * MOVR,

693

1

);

694

1

			assert_eq!(Balances::usable_balance(AccountId::from(BOB)), 9500 * MOVR,);

695

696

			// Go to round 2

697

1

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

698

1

699

1

			// 30% reserved for parachain bond

700

1

			assert_eq!(

701

1

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

702

1

				452515000000000000000,

703

1

);

704

705

			// Go to round 3

706

1

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

707

1

708

1

			// rewards minted and distributed

709

1

			assert_eq!(

710

1

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

711

1

				11117700475903800000000,

712

1

);

713

1

			assert_eq!(

714

1

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

715

1

				9535834523343675000000,

716

1

);

717

			// 30% reserved for parachain bond again

718

1

			assert_eq!(

719

1

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

720

1

				910802725000000000000,

721

1

);

722

1

});

723

1

724

725

#[test]

726

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

727

1

	ExtBuilder::default()

728

1

		.with_balances(vec![

729

1

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

730

1

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

731

1

])

732

1

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

733

1

		.with_mappings(vec![(

734

1

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

735

1

			AccountId::from(ALICE),

736

1

)])

737

1

		.with_crowdloan_fund(3_000_000 * MOVR)

738

1

		.build()

739

1

		.execute_with(|| {

740

1

			// set parachain inherent data

741

1

			set_parachain_inherent_data();

742

1

			let init_block = CrowdloanRewards::init_vesting_block();

743

1

			// This matches the previous vesting

744

1

			let end_block = init_block + 48 * WEEKS;

745

1

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

746

1

			assert_ok!(

747

1

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

748

1

					calls: vec![

749

1

						RuntimeCall::CrowdloanRewards(

750

1

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

751

1

								rewards: vec![(

752

1

									[4u8; 32].into(),

753

1

									Some(AccountId::from(CHARLIE)),

754

1

									1_500_000 * MOVR

755

1

)]

756

1

757

1

),

758

1

						RuntimeCall::CrowdloanRewards(

759

1

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

760

1

								rewards: vec![(

761

1

									[5u8; 32].into(),

762

1

									Some(AccountId::from(DAVE)),

763

1

									1_500_000 * MOVR

764

1

)]

765

1

766

1

),

767

1

						RuntimeCall::CrowdloanRewards(

768

1

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

769

1

								lease_ending_block: end_block

770

1

771

1

772

1

773

1

})

774

1

				.dispatch(root_origin())

775

1

);

776

			// 30 percent initial payout

777

1

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

778

			// 30 percent initial payout

779

1

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

780

1

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

781

1

			assert_eq!(last_event(), expected);

782

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

783

1

			assert_ok!(

784

1

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

785

1

					calls: vec![RuntimeCall::CrowdloanRewards(

786

1

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

787

1

							rewards: vec![([4u8; 32].into(), Some(AccountId::from(ALICE)), 432000)]

788

1

789

1

)]

790

1

})

791

1

				.dispatch(root_origin())

792

1

);

793

1

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

794

1

				index: 0,

795

1

				error: DispatchError::Module(ModuleError {

796

1

					index: 90,

797

1

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

798

1

					message: None,

799

1

}),

800

1

});

801

1

			assert_eq!(last_event(), expected_fail);

802

			// Claim 1 block.

803

1

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

804

1

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

805

806

1

			let vesting_period = 48 * WEEKS as u128;

807

1

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

808

1

809

1

			assert_eq!(

810

1

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

811

1

					.unwrap()

812

1

					.claimed_reward,

813

1

				(450_000 * MOVR) + per_block

814

1

);

815

1

			assert_eq!(

816

1

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

817

1

					.unwrap()

818

1

					.claimed_reward,

819

1

				(450_000 * MOVR) + per_block

820

1

);

821

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

822

1

			assert_eq!(

823

1

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

824

1

				(450_000 * MOVR) + per_block

825

1

);

826

1

			assert_eq!(

827

1

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

828

1

				(450_000 * MOVR) + per_block

829

1

);

830

1

			assert_noop!(

831

1

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

832

1

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

833

1

);

834

1

});

835

1

836

837

#[test]

838

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

839

1

	ExtBuilder::default()

840

1

		.with_balances(vec![

841

1

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

842

1

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

843

1

])

844

1

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

845

1

		.with_mappings(vec![(

846

1

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

847

1

			AccountId::from(ALICE),

848

1

)])

849

1

		.with_crowdloan_fund(3_000_000 * MOVR)

850

1

		.build()

851

1

		.execute_with(|| {

852

1

			// set parachain inherent data

853

1

			set_parachain_inherent_data();

854

1

			let init_block = CrowdloanRewards::init_vesting_block();

855

1

			// This matches the previous vesting

856

1

			let end_block = init_block + 4 * WEEKS;

857

1

858

1

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

859

1

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

860

1

861

1

			let public1 = pair1.public();

862

1

			let public2 = pair2.public();

863

1

864

1

			// signature:

865

1

			// WRAP_BYTES|| NetworkIdentifier|| new_account || previous_account || WRAP_BYTES

866

1

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

867

1

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

868

1

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

869

1

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

870

1

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

871

1

			let signature1 = pair1.sign(&message);

872

1

			let signature2 = pair2.sign(&message);

873

1

874

1

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

875

1

			assert_ok!(

876

1

				// two relay accounts pointing at the same reward account

877

1

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

878

1

					calls: vec![

879

1

						RuntimeCall::CrowdloanRewards(

880

1

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

881

1

								rewards: vec![(

882

1

									public1.into(),

883

1

									Some(AccountId::from(CHARLIE)),

884

1

									1_500_000 * MOVR

885

1

)]

886

1

887

1

),

888

1

						RuntimeCall::CrowdloanRewards(

889

1

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

890

1

								rewards: vec![(

891

1

									public2.into(),

892

1

									Some(AccountId::from(CHARLIE)),

893

1

									1_500_000 * MOVR

894

1

)]

895

1

896

1

),

897

1

						RuntimeCall::CrowdloanRewards(

898

1

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

899

1

								lease_ending_block: end_block

900

1

901

1

902

1

903

1

})

904

1

				.dispatch(root_origin())

905

1

);

906

			// 30 percent initial payout

907

1

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

908

909

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

910

1

			assert_noop!(

911

1

				CrowdloanRewards::change_association_with_relay_keys(

912

1

					origin_of(AccountId::from(CHARLIE)),

913

1

					AccountId::from(DAVE),

914

1

					AccountId::from(CHARLIE),

915

1

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

916

1

),

917

1

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

918

1

);

919

920

			// this should be valid

921

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

922

1

				origin_of(AccountId::from(CHARLIE)),

923

1

				AccountId::from(DAVE),

924

1

				AccountId::from(CHARLIE),

925

1

				vec![

926

1

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

927

1

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

928

1

929

1

));

930

931

1

			assert_eq!(

932

1

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

933

1

					.unwrap()

934

1

					.claimed_reward,

935

1

				(900_000 * MOVR)

936

1

);

937

1

});

938

1

939

940

#[test]

941

1

fn claim_via_precompile() {

942

1

	ExtBuilder::default()

943

1

		.with_balances(vec![

944

1

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

945

1

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

946

1

])

947

1

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

948

1

		.with_mappings(vec![(

949

1

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

950

1

			AccountId::from(ALICE),

951

1

)])

952

1

		.with_crowdloan_fund(3_000_000 * MOVR)

953

1

		.build()

954

1

		.execute_with(|| {

955

1

			// set parachain inherent data

956

1

			set_parachain_inherent_data();

957

1

			let init_block = CrowdloanRewards::init_vesting_block();

958

1

			// This matches the previous vesting

959

1

			let end_block = init_block + 4 * WEEKS;

960

1

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

961

1

			assert_ok!(

962

1

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

963

1

					calls: vec![

964

1

						RuntimeCall::CrowdloanRewards(

965

1

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

966

1

								rewards: vec![(

967

1

									[4u8; 32].into(),

968

1

									Some(AccountId::from(CHARLIE)),

969

1

									1_500_000 * MOVR

970

1

)]

971

1

972

1

),

973

1

						RuntimeCall::CrowdloanRewards(

974

1

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

975

1

								rewards: vec![(

976

1

									[5u8; 32].into(),

977

1

									Some(AccountId::from(DAVE)),

978

1

									1_500_000 * MOVR

979

1

)]

980

1

981

1

),

982

1

						RuntimeCall::CrowdloanRewards(

983

1

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

984

1

								lease_ending_block: end_block

985

1

986

1

987

1

988

1

})

989

1

				.dispatch(root_origin())

990

1

);

991

992

1

			assert!(CrowdloanRewards::initialized());

993

994

			// 30 percent initial payout

995

1

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

996

			// 30 percent initial payout

997

1

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

998

999

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1000

1

1001

1

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

1002

1

			let gas_limit = 100000u64;

1003

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1004

1

1005

1

			// Construct the call data (selector, amount)

1006

1

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

1007

1

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

1008

1

1009

1

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

1010

1

				source: H160::from(CHARLIE),

1011

1

				target: crowdloan_precompile_address,

1012

1

				input: call_data,

1013

1

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

1014

1

				gas_limit,

1015

1

				max_fee_per_gas: gas_price,

1016

1

				max_priority_fee_per_gas: None,

1017

1

				nonce: None, // Use the next nonce

1018

1

				access_list: Vec::new(),

1019

1

})

1020

1

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

1021

1022

1

			let vesting_period = 4 * WEEKS as u128;

1023

1

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

1024

1

1025

1

			assert_eq!(

1026

1

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

1027

1

					.unwrap()

1028

1

					.claimed_reward,

1029

1

				(450_000 * MOVR) + per_block

1030

1

);

1031

1

})

1032

1

1033

1034

#[test]

1035

1

fn is_contributor_via_precompile() {

1036

1

	ExtBuilder::default()

1037

1

		.with_balances(vec![

1038

1

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

1039

1

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

1040

1

])

1041

1

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

1042

1

		.with_mappings(vec![(

1043

1

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

1044

1

			AccountId::from(ALICE),

1045

1

)])

1046

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1047

1

		.build()

1048

1

		.execute_with(|| {

1049

1

			// set parachain inherent data

1050

1

			set_parachain_inherent_data();

1051

1

			let init_block = CrowdloanRewards::init_vesting_block();

1052

1

			// This matches the previous vesting

1053

1

			let end_block = init_block + 4 * WEEKS;

1054

1

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

1055

1

			assert_ok!(

1056

1

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

1057

1

					calls: vec![

1058

1

						RuntimeCall::CrowdloanRewards(

1059

1

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

1060

1

								rewards: vec![(

1061

1

									[4u8; 32].into(),

1062

1

									Some(AccountId::from(CHARLIE)),

1063

1

									1_500_000 * MOVR

1064

1

)]

1065

1

1066

1

),

1067

1

						RuntimeCall::CrowdloanRewards(

1068

1

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

1069

1

								rewards: vec![(

1070

1

									[5u8; 32].into(),

1071

1

									Some(AccountId::from(DAVE)),

1072

1

									1_500_000 * MOVR

1073

1

)]

1074

1

1075

1

),

1076

1

						RuntimeCall::CrowdloanRewards(

1077

1

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

1078

1

								lease_ending_block: end_block

1079

1

1080

1

1081

1

1082

1

})

1083

1

				.dispatch(root_origin())

1084

1

);

1085

1086

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1087

1

1088

1

			// Assert precompile reports Bob is not a contributor

1089

1

			Precompiles::new()

1090

1

				.prepare_test(

1091

1

					ALICE,

1092

1

					crowdloan_precompile_address,

1093

1

					CrowdloanRewardsPCall::is_contributor {

1094

1

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

1095

1

},

1096

1

1097

1

				.expect_cost(1669)

1098

1

				.expect_no_logs()

1099

1

				.execute_returns(false);

1100

1

1101

1

			// Assert precompile reports Charlie is a nominator

1102

1

			Precompiles::new()

1103

1

				.prepare_test(

1104

1

					ALICE,

1105

1

					crowdloan_precompile_address,

1106

1

					CrowdloanRewardsPCall::is_contributor {

1107

1

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

1108

1

},

1109

1

1110

1

				.expect_cost(1669)

1111

1

				.expect_no_logs()

1112

1

				.execute_returns(true);

1113

1

})

1114

1

1115

1116

#[test]

1117

1

fn reward_info_via_precompile() {

1118

1

	ExtBuilder::default()

1119

1

		.with_balances(vec![

1120

1

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

1121

1

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

1122

1

])

1123

1

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

1124

1

		.with_mappings(vec![(

1125

1

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

1126

1

			AccountId::from(ALICE),

1127

1

)])

1128

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1129

1

		.build()

1130

1

		.execute_with(|| {

1131

1

			// set parachain inherent data

1132

1

			set_parachain_inherent_data();

1133

1

			let init_block = CrowdloanRewards::init_vesting_block();

1134

1

			// This matches the previous vesting

1135

1

			let end_block = init_block + 4 * WEEKS;

1136

1

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

1137

1

			assert_ok!(

1138

1

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

1139

1

					calls: vec![

1140

1

						RuntimeCall::CrowdloanRewards(

1141

1

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

1142

1

								rewards: vec![(

1143

1

									[4u8; 32].into(),

1144

1

									Some(AccountId::from(CHARLIE)),

1145

1

									1_500_000 * MOVR

1146

1

)]

1147

1

1148

1

),

1149

1

						RuntimeCall::CrowdloanRewards(

1150

1

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

1151

1

								rewards: vec![(

1152

1

									[5u8; 32].into(),

1153

1

									Some(AccountId::from(DAVE)),

1154

1

									1_500_000 * MOVR

1155

1

)]

1156

1

1157

1

),

1158

1

						RuntimeCall::CrowdloanRewards(

1159

1

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

1160

1

								lease_ending_block: end_block

1161

1

1162

1

1163

1

1164

1

})

1165

1

				.dispatch(root_origin())

1166

1

);

1167

1168

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1169

1

1170

1

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

1171

1

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

1172

1

1173

1

			// Assert precompile reports correct Charlie reward info.

1174

1

			Precompiles::new()

1175

1

				.prepare_test(

1176

1

					ALICE,

1177

1

					crowdloan_precompile_address,

1178

1

					CrowdloanRewardsPCall::reward_info {

1179

1

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

1180

1

},

1181

1

1182

1

				.expect_cost(1669)

1183

1

				.expect_no_logs()

1184

1

				.execute_returns((expected_total, expected_claimed));

1185

1

})

1186

1

1187

1188

#[test]

1189

1

fn update_reward_address_via_precompile() {

1190

1

	ExtBuilder::default()

1191

1

		.with_balances(vec![

1192

1

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

1193

1

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

1194

1

])

1195

1

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

1196

1

		.with_mappings(vec![(

1197

1

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

1198

1

			AccountId::from(ALICE),

1199

1

)])

1200

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1201

1

		.build()

1202

1

		.execute_with(|| {

1203

1

			// set parachain inherent data

1204

1

			set_parachain_inherent_data();

1205

1

			let init_block = CrowdloanRewards::init_vesting_block();

1206

1

			// This matches the previous vesting

1207

1

			let end_block = init_block + 4 * WEEKS;

1208

1

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

1209

1

			assert_ok!(

1210

1

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

1211

1

					calls: vec![

1212

1

						RuntimeCall::CrowdloanRewards(

1213

1

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

1214

1

								rewards: vec![(

1215

1

									[4u8; 32].into(),

1216

1

									Some(AccountId::from(CHARLIE)),

1217

1

									1_500_000 * MOVR

1218

1

)]

1219

1

1220

1

),

1221

1

						RuntimeCall::CrowdloanRewards(

1222

1

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

1223

1

								rewards: vec![(

1224

1

									[5u8; 32].into(),

1225

1

									Some(AccountId::from(DAVE)),

1226

1

									1_500_000 * MOVR

1227

1

)]

1228

1

1229

1

),

1230

1

						RuntimeCall::CrowdloanRewards(

1231

1

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

1232

1

								lease_ending_block: end_block

1233

1

1234

1

1235

1

1236

1

})

1237

1

				.dispatch(root_origin())

1238

1

);

1239

1240

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1241

1

1242

1

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

1243

1

			let gas_limit = 100000u64;

1244

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1245

1

1246

1

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

1247

1

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

1248

1

			call_data[0..4]

1249

1

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

1250

1

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

1251

1

1252

1

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

1253

1

				source: H160::from(CHARLIE),

1254

1

				target: crowdloan_precompile_address,

1255

1

				input: call_data,

1256

1

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

1257

1

				gas_limit,

1258

1

				max_fee_per_gas: gas_price,

1259

1

				max_priority_fee_per_gas: None,

1260

1

				nonce: None, // Use the next nonce

1261

1

				access_list: Vec::new(),

1262

1

})

1263

1

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

1264

1265

1

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

1266

1

			assert_eq!(

1267

1

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

1268

1

					.unwrap()

1269

1

					.claimed_reward,

1270

1

				(450_000 * MOVR)

1271

1

);

1272

1

})

1273

1

1274

1275

1

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

1276

1

where

1277

1

	F: FnMut() -> (),

1278

1

1279

1

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

1280

1

		.build_storage()

1281

1

		.unwrap()

1282

1

		.into();

1283

1

	t.execute_with(|| {

1284

1

		System::set_block_consumed_resources(w, 0);

1285

1

		assertions()

1286

1

});

1287

1

1288

1289

#[test]

1290

#[rustfmt::skip]

1291

1

fn length_fee_is_sensible() {

1292

1

	use sp_runtime::testing::TestXt;

1293

1

1294

1

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

1295

1

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

1296

1

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

1297

1

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

1298

1

1299

9

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

1300

9

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

1301

9

				.inclusion_fee

1302

9

				.expect("fee should be calculated")

1303

9

				.len_fee

1304

9

};

1305

1306

		// editorconfig-checker-disable

1307

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

1308

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

1309

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

1310

		//                             |           |

1311

1

		assert_eq!(                    1_000_000_001, calc_fee(1));

1312

1

		assert_eq!(                   10_000_001_000, calc_fee(10));

1313

1

		assert_eq!(                  100_001_000_000, calc_fee(100));

1314

1

		assert_eq!(                1_001_000_000_000, calc_fee(1_000));

1315

1

		assert_eq!(               11_000_000_000_000, calc_fee(10_000)); // inflection point

1316

1

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

1317

1

		assert_eq!(        1_001_000_000_000_000_000, calc_fee(1_000_000)); // one MOVR, ~ 1MB

1318

1

		assert_eq!(    1_000_010_000_000_000_000_000, calc_fee(10_000_000));

1319

1

		assert_eq!(1_000_000_100_000_000_000_000_000, calc_fee(100_000_000));

1320

		// editorconfig-checker-enable

1321

1

});

1322

1

1323

1324

#[test]

1325

1

fn multiplier_can_grow_from_zero() {

1326

1

	use frame_support::traits::Get;

1327

1

1328

1

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

1329

1

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

1330

1

		* RuntimeBlockWeights::get()

1331

1

			.get(DispatchClass::Normal)

1332

1

			.max_total

1333

1

			.unwrap();

1334

1

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

1335

1

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

1336

1

	run_with_system_weight(target * 101 / 100, || {

1337

1

		let next =

1338

1

			moonriver_runtime::SlowAdjustingFeeUpdate::<Runtime>::convert(minimum_multiplier);

1339

1

		assert!(

1340

1

			next > minimum_multiplier,

1341

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

1342

			next,

1343

			minimum_multiplier

1344

);

1345

1

})

1346

1

1347

1348

#[test]

1349

1

fn ethereum_invalid_transaction() {

1350

1

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

1351

1

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

1352

1

		// on chain is rejected.

1353

1

		assert_eq!(

1354

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1355

1

			Err(

1356

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1357

1

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

1358

1

1359

1

1360

1

);

1361

1

});

1362

1

1363

1364

#[test]

1365

1

fn initial_gas_fee_is_correct() {

1366

1

	use fp_evm::FeeCalculator;

1367

1

1368

1

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

1369

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1370

1

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

1371

1372

1

		assert_eq!(

1373

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1374

1

1375

1

				12_500_000_000u128.into(),

1376

1

				Weight::from_parts(41_742_000u64, 0)

1377

1

1378

1

);

1379

1

});

1380

1

1381

1382

#[test]

1383

1

fn min_gas_fee_is_correct() {

1384

1

	use fp_evm::FeeCalculator;

1385

1

	use frame_support::traits::Hooks;

1386

1

1387

1

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

1388

1

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

1389

1

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

1390

1

1391

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1392

1

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

1393

1394

1

		assert_eq!(

1395

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1396

1

1397

1

				1_250_000_000u128.into(),

1398

1

				Weight::from_parts(41_742_000u64, 0)

1399

1

1400

1

);

1401

1

});

1402

1

1403

1404

#[test]

1405

1

fn transfer_ed_0_substrate() {

1406

1

	ExtBuilder::default()

1407

1

		.with_balances(vec![

1408

1

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

1409

1

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

1410

1

])

1411

1

		.build()

1412

1

		.execute_with(|| {

1413

1

			// Substrate transfer

1414

1

			assert_ok!(Balances::transfer_allow_death(

1415

1

				origin_of(AccountId::from(ALICE)),

1416

1

				AccountId::from(BOB),

1417

1

				1 * MOVR,

1418

1

));

1419

			// 1 WEI is left in the account

1420

1

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

1421

1

});

1422

1

1423

1424

#[test]

1425

1

fn transfer_ed_0_evm() {

1426

1

	ExtBuilder::default()

1427

1

		.with_balances(vec![

1428

1

1429

1

				AccountId::from(ALICE),

1430

1

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

1431

1

),

1432

1

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

1433

1

])

1434

1

		.build()

1435

1

		.execute_with(|| {

1436

1

			// EVM transfer

1437

1

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

1438

1

				source: H160::from(ALICE),

1439

1

				target: H160::from(BOB),

1440

1

				input: Vec::new(),

1441

1

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

1442

1

				gas_limit: 21_000u64,

1443

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1444

1

				max_priority_fee_per_gas: Some(U256::from(BASE_FEE_GENESIS)),

1445

1

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

1446

1

				access_list: Vec::new(),

1447

1

})

1448

1

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

1449

			// 1 WEI is left in the account

1450

1

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

1451

1

});

1452

1

1453

1454

#[test]

1455

1

fn refund_ed_0_evm() {

1456

1

	ExtBuilder::default()

1457

1

		.with_balances(vec![

1458

1

1459

1

				AccountId::from(ALICE),

1460

1

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

1461

1

),

1462

1

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

1463

1

])

1464

1

		.build()

1465

1

		.execute_with(|| {

1466

1

			// EVM transfer that zeroes ALICE

1467

1

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

1468

1

				source: H160::from(ALICE),

1469

1

				target: H160::from(BOB),

1470

1

				input: Vec::new(),

1471

1

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

1472

1

				gas_limit: 21_777u64,

1473

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1474

1

				max_priority_fee_per_gas: Some(U256::from(BASE_FEE_GENESIS)),

1475

1

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

1476

1

				access_list: Vec::new(),

1477

1

})

1478

1

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

1479

			// ALICE is refunded

1480

1

			assert_eq!(

1481

1

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

1482

1

				777 * BASE_FEE_GENESIS,

1483

1

);

1484

1

});

1485

1

1486

1487

#[test]

1488

1

fn author_does_not_receive_priority_fee() {

1489

1

	ExtBuilder::default()

1490

1

		.with_balances(vec![(

1491

1

			AccountId::from(BOB),

1492

1

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

1493

1

)])

1494

1

		.build()

1495

1

		.execute_with(|| {

1496

1

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

1497

1

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

1498

1

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

1499

1

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

1500

1

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

1501

1

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

1502

1

1503

1

			// EVM transfer.

1504

1

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

1505

1

				source: H160::from(BOB),

1506

1

				target: H160::from(ALICE),

1507

1

				input: Vec::new(),

1508

1

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

1509

1

				gas_limit: 21_000u64,

1510

1

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

1511

1

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

1512

1

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

1513

1

				access_list: Vec::new(),

1514

1

})

1515

1

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

1516

			// Author free balance didn't change.

1517

1

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

1518

1

});

1519

1

1520

1521

#[test]

1522

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1523

1

	ExtBuilder::default()

1524

1

		.with_balances(vec![(

1525

1

			AccountId::from(BOB),

1526

1

			(1 * MOVR) + (21_000 * (2 * BASE_FEE_GENESIS)),

1527

1

)])

1528

1

		.build()

1529

1

		.execute_with(|| {

1530

1

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

1531

1

			// EVM transfer.

1532

1

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

1533

1

				source: H160::from(BOB),

1534

1

				target: H160::from(ALICE),

1535

1

				input: Vec::new(),

1536

1

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

1537

1

				gas_limit: 21_000u64,

1538

1

				max_fee_per_gas: U256::from(2u128 * BASE_FEE_GENESIS),

1539

1

				max_priority_fee_per_gas: Some(U256::from(2u128 * BASE_FEE_GENESIS)),

1540

1

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

1541

1

				access_list: Vec::new(),

1542

1

})

1543

1

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

1544

1545

1

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

1546

1

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

1547

1

			// 80% was burned.

1548

1

			let expected_burn = (fee * 0.8) as u128;

1549

1

			assert_eq!(issuance_after, issuance_before - expected_burn,);

1550

			// 20% was sent to treasury.

1551

1

			let expected_treasury = (fee * 0.2) as u128;

1552

1

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

1553

1

});

1554

1

1555

1556

#[test]

1557

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1558

1

	ExtBuilder::default()

1559

1

		.with_balances(vec![(

1560

1

			AccountId::from(BOB),

1561

1

			(1 * MOVR) + (21_000 * (2 * BASE_FEE_GENESIS)),

1562

1

)])

1563

1

		.build()

1564

1

		.execute_with(|| {

1565

1

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

1566

1

			// EVM transfer.

1567

1

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

1568

1

				source: H160::from(BOB),

1569

1

				target: H160::from(ALICE),

1570

1

				input: Vec::new(),

1571

1

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

1572

1

				gas_limit: 21_000u64,

1573

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1574

1

				max_priority_fee_per_gas: Some(U256::from(BASE_FEE_GENESIS)),

1575

1

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

1576

1

				access_list: Vec::new(),

1577

1

})

1578

1

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

1579

1580

1

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

1581

1

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

1582

1

			// 80% was burned.

1583

1

			let expected_burn = (fee * 0.8) as u128;

1584

1

			assert_eq!(issuance_after, issuance_before - expected_burn,);

1585

			// 20% was sent to treasury.

1586

1

			let expected_treasury = (fee * 0.2) as u128;

1587

1

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

1588

1

});

1589

1

1590

1591

#[test]

1592

1

fn root_can_change_default_xcm_vers() {

1593

1

	ExtBuilder::default()

1594

1

		.with_balances(vec![

1595

1

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

1596

1

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

1597

1

])

1598

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1599

1

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

1600

1

			metadata: AssetRegistrarMetadata {

1601

1

				name: b"RelayToken".to_vec(),

1602

1

				symbol: b"Relay".to_vec(),

1603

1

				decimals: 12,

1604

1

				is_frozen: false,

1605

1

},

1606

1

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

1607

1

			is_sufficient: true,

1608

1

}])

1609

1

		.build()

1610

1

		.execute_with(|| {

1611

1

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

1612

1

			let dest = Location {

1613

1

				parents: 1,

1614

1

				interior: [AccountId32 {

1615

1

					network: None,

1616

1

					id: [1u8; 32],

1617

1

}]

1618

1

				.into(),

1619

1

};

1620

1

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

1621

1

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

1622

1

			let (chain_part, beneficiary) =

1623

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1624

1

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

1625

1

			// know with which version to send

1626

1

			assert_noop!(

1627

1

				PolkadotXcm::transfer_assets(

1628

1

					origin_of(AccountId::from(ALICE)),

1629

1

					Box::new(xcm::VersionedLocation::V4(chain_part.clone())),

1630

1

					Box::new(xcm::VersionedLocation::V4(beneficiary.clone())),

1631

1

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

1632

1

0,

1633

1

					WeightLimit::Limited(4000000000.into())

1634

1

),

1635

1

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

1636

1

);

1637

1638

			// Root sets the defaultXcm

1639

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1640

1

				root_origin(),

1641

1

				Some(2)

1642

1

));

1643

1644

			// Now transferring does not fail

1645

1

			assert_ok!(PolkadotXcm::transfer_assets(

1646

1

				origin_of(AccountId::from(ALICE)),

1647

1

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

1648

1

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

1649

1

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

1650

1

0,

1651

1

				WeightLimit::Limited(4000000000.into())

1652

1

));

1653

1

})

1654

1

1655

1656

#[test]

1657

1

fn asset_can_be_registered() {

1658

1

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

1659

1

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

1660

1

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

1661

1

		let asset_metadata = AssetRegistrarMetadata {

1662

1

			name: b"RelayToken".to_vec(),

1663

1

			symbol: b"Relay".to_vec(),

1664

1

			decimals: 12,

1665

1

			is_frozen: false,

1666

1

};

1667

1

		assert_ok!(AssetManager::register_foreign_asset(

1668

1

			moonriver_runtime::RuntimeOrigin::root(),

1669

1

			source_location,

1670

1

			asset_metadata,

1671

1

			1u128,

1672

1

			true

1673

1

));

1674

1

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

1675

1

});

1676

1

1677

1678

#[test]

1679

1

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1680

1

	ExtBuilder::default()

1681

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1682

1

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

1683

1

			metadata: AssetRegistrarMetadata {

1684

1

				name: b"RelayToken".to_vec(),

1685

1

				symbol: b"Relay".to_vec(),

1686

1

				decimals: 12,

1687

1

				is_frozen: false,

1688

1

},

1689

1

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

1690

1

			is_sufficient: true,

1691

1

}])

1692

1

		.with_balances(vec![

1693

1

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

1694

1

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

1695

1

])

1696

1

		.build()

1697

1

		.execute_with(|| {

1698

1

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

1699

1

			let relay_asset_id: AssetId = AssetType::Xcm(xcm::v3::Location::parent()).into();

1700

1

1701

1

			// Its address is

1702

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1703

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1704

1

				relay_asset_id,

1705

1

);

1706

1

1707

1

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

1708

1

			assert_eq!(

1709

1

				moonriver_runtime::Assets::total_supply(relay_asset_id),

1710

1

				1_000 * MOVR

1711

1

);

1712

1713

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

1714

1

			Precompiles::new()

1715

1

				.prepare_test(

1716

1

					ALICE,

1717

1

					asset_precompile_address,

1718

1

					ForeignAssetsPCall::total_supply {},

1719

1

1720

1

				.expect_cost(3338)

1721

1

				.expect_no_logs()

1722

1

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

1723

1

1724

1

			// Access balanceOf through precompile

1725

1

			Precompiles::new()

1726

1

				.prepare_test(

1727

1

					ALICE,

1728

1

					asset_precompile_address,

1729

1

					ForeignAssetsPCall::balance_of {

1730

1

						who: Address(ALICE.into()),

1731

1

},

1732

1

1733

1

				.expect_cost(3338)

1734

1

				.expect_no_logs()

1735

1

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

1736

1

});

1737

1

1738

1739

#[test]

1740

1

fn xcm_asset_erc20_precompiles_transfer() {

1741

1

	ExtBuilder::default()

1742

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1743

1

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

1744

1

			metadata: AssetRegistrarMetadata {

1745

1

				name: b"RelayToken".to_vec(),

1746

1

				symbol: b"Relay".to_vec(),

1747

1

				decimals: 12,

1748

1

				is_frozen: false,

1749

1

},

1750

1

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

1751

1

			is_sufficient: true,

1752

1

}])

1753

1

		.with_balances(vec![

1754

1

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

1755

1

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

1756

1

])

1757

1

		.build()

1758

1

		.execute_with(|| {

1759

1

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

1760

1

			let relay_asset_id: AssetId = AssetType::Xcm(xcm::v3::Location::parent()).into();

1761

1

1762

1

			// Its address is

1763

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1764

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1765

1

				relay_asset_id,

1766

1

);

1767

1

1768

1

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

1769

1

			Precompiles::new()

1770

1

				.prepare_test(

1771

1

					ALICE,

1772

1

					asset_precompile_address,

1773

1

					ForeignAssetsPCall::transfer {

1774

1

						to: Address(BOB.into()),

1775

1

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

1776

1

},

1777

1

1778

1

				.expect_cost(24684)

1779

1

				.expect_log(log3(

1780

1

					asset_precompile_address,

1781

1

					SELECTOR_LOG_TRANSFER,

1782

1

					H160::from(ALICE),

1783

1

					H160::from(BOB),

1784

1

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

1785

1

))

1786

1

				.execute_returns(true);

1787

1

1788

1

			// Make sure BOB has 400 MOVR

1789

1

			Precompiles::new()

1790

1

				.prepare_test(

1791

1

					BOB,

1792

1

					asset_precompile_address,

1793

1

					ForeignAssetsPCall::balance_of {

1794

1

						who: Address(BOB.into()),

1795

1

},

1796

1

1797

1

				.expect_cost(3338)

1798

1

				.expect_no_logs()

1799

1

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

1800

1

});

1801

1

1802

1803

#[test]

1804

1

fn xcm_asset_erc20_precompiles_approve() {

1805

1

	ExtBuilder::default()

1806

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1807

1

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

1808

1

			metadata: AssetRegistrarMetadata {

1809

1

				name: b"RelayToken".to_vec(),

1810

1

				symbol: b"Relay".to_vec(),

1811

1

				decimals: 12,

1812

1

				is_frozen: false,

1813

1

},

1814

1

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

1815

1

			is_sufficient: true,

1816

1

}])

1817

1

		.with_balances(vec![

1818

1

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

1819

1

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

1820

1

])

1821

1

		.build()

1822

1

		.execute_with(|| {

1823

1

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

1824

1

			let relay_asset_id: AssetId = AssetType::Xcm(xcm::v3::Location::parent()).into();

1825

1

1826

1

			// Its address is

1827

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1828

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1829

1

				relay_asset_id,

1830

1

);

1831

1

1832

1

			// Aprove Bob for spending 400 MOVR from Alice

1833

1

			Precompiles::new()

1834

1

				.prepare_test(

1835

1

					ALICE,

1836

1

					asset_precompile_address,

1837

1

					ForeignAssetsPCall::approve {

1838

1

						spender: Address(BOB.into()),

1839

1

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

1840

1

},

1841

1

1842

1

				.expect_cost(15573)

1843

1

				.expect_log(log3(

1844

1

					asset_precompile_address,

1845

1

					SELECTOR_LOG_APPROVAL,

1846

1

					H160::from(ALICE),

1847

1

					H160::from(BOB),

1848

1

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

1849

1

))

1850

1

				.execute_returns(true);

1851

1

1852

1

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

1853

1

			Precompiles::new()

1854

1

				.prepare_test(

1855

1

					BOB,

1856

1

					asset_precompile_address,

1857

1

					ForeignAssetsPCall::transfer_from {

1858

1

						from: Address(ALICE.into()),

1859

1

						to: Address(CHARLIE.into()),

1860

1

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

1861

1

},

1862

1

1863

1

				.expect_cost(29947)

1864

1

				.expect_log(log3(

1865

1

					asset_precompile_address,

1866

1

					SELECTOR_LOG_TRANSFER,

1867

1

					H160::from(ALICE),

1868

1

					H160::from(CHARLIE),

1869

1

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

1870

1

))

1871

1

				.execute_returns(true);

1872

1

1873

1

			// Make sure CHARLIE has 400 MOVR

1874

1

			Precompiles::new()

1875

1

				.prepare_test(

1876

1

					CHARLIE,

1877

1

					asset_precompile_address,

1878

1

					ForeignAssetsPCall::balance_of {

1879

1

						who: Address(CHARLIE.into()),

1880

1

},

1881

1

1882

1

				.expect_cost(3338)

1883

1

				.expect_no_logs()

1884

1

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

1885

1

});

1886

1

1887

1888

#[test]

1889

1

fn xtokens_precompiles_transfer() {

1890

1

	ExtBuilder::default()

1891

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1892

1

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

1893

1

			metadata: AssetRegistrarMetadata {

1894

1

				name: b"RelayToken".to_vec(),

1895

1

				symbol: b"Relay".to_vec(),

1896

1

				decimals: 12,

1897

1

				is_frozen: false,

1898

1

},

1899

1

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

1900

1

			is_sufficient: true,

1901

1

}])

1902

1

		.with_balances(vec![

1903

1

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

1904

1

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

1905

1

])

1906

1

		.with_safe_xcm_version(2)

1907

1

		.build()

1908

1

		.execute_with(|| {

1909

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1910

1

1911

1

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

1912

1

			let relay_asset_id: moonriver_runtime::AssetId =

1913

1

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

1914

1

1915

1

			// Its address is

1916

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1917

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1918

1

				relay_asset_id,

1919

1

);

1920

1

1921

1

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

1922

1

			let destination = Location::new(

1923

1

1,

1924

1

				[Junction::AccountId32 {

1925

1

					network: None,

1926

1

					id: [1u8; 32],

1927

1

}],

1928

1

);

1929

1

1930

1

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

1931

1

			Precompiles::new()

1932

1

				.prepare_test(

1933

1

					ALICE,

1934

1

					xtokens_precompile_address,

1935

1

					XtokensPCall::transfer {

1936

1

						currency_address: Address(asset_precompile_address.into()),

1937

1

						amount: 500_000_000_000_000u128.into(),

1938

1

						destination,

1939

1

						weight: 4_000_000,

1940

1

},

1941

1

1942

1

				.expect_cost(24691)

1943

1

				.expect_no_logs()

1944

1

				.execute_returns(())

1945

1

})

1946

1

1947

1948

#[test]

1949

1

fn xtokens_precompiles_transfer_multiasset() {

1950

1

	ExtBuilder::default()

1951

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1952

1

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

1953

1

			metadata: AssetRegistrarMetadata {

1954

1

				name: b"RelayToken".to_vec(),

1955

1

				symbol: b"Relay".to_vec(),

1956

1

				decimals: 12,

1957

1

				is_frozen: false,

1958

1

},

1959

1

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

1960

1

			is_sufficient: true,

1961

1

}])

1962

1

		.with_balances(vec![

1963

1

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

1964

1

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

1965

1

])

1966

1

		.with_safe_xcm_version(2)

1967

1

		.build()

1968

1

		.execute_with(|| {

1969

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1970

1

1971

1

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

1972

1

			let destination = Location::new(

1973

1

1,

1974

1

				[Junction::AccountId32 {

1975

1

					network: None,

1976

1

					id: [1u8; 32],

1977

1

}],

1978

1

);

1979

1

1980

1

			// This time we transfer it through TransferMultiAsset

1981

1

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

1982

1

			Precompiles::new()

1983

1

				.prepare_test(

1984

1

					ALICE,

1985

1

					xtokens_precompile_address,

1986

1

					XtokensPCall::transfer_multiasset {

1987

1

						// We want to transfer the relay token

1988

1

						asset: Location::parent(),

1989

1

						amount: 500_000_000_000_000u128.into(),

1990

1

						destination,

1991

1

						weight: 4_000_000,

1992

1

},

1993

1

1994

1

				.expect_cost(24691)

1995

1

				.expect_no_logs()

1996

1

				.execute_returns(());

1997

1

})

1998

1

1999

2000

#[test]

2001

1

fn make_sure_polkadot_xcm_cannot_be_called() {

2002

1

	ExtBuilder::default()

2003

1

		.with_balances(vec![

2004

1

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

2005

1

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

2006

1

])

2007

1

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

2008

1

		.with_mappings(vec![(

2009

1

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

2010

1

			AccountId::from(ALICE),

2011

1

)])

2012

1

		.build()

2013

1

		.execute_with(|| {

2014

1

			let dest = Location {

2015

1

				parents: 1,

2016

1

				interior: [AccountId32 {

2017

1

					network: None,

2018

1

					id: [1u8; 32],

2019

1

}]

2020

1

				.into(),

2021

1

};

2022

1

			let assets: Assets = [Asset {

2023

1

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

2024

1

				fun: Fungible(1000),

2025

1

}]

2026

1

			.to_vec()

2027

1

			.into();

2028

1

			assert_noop!(

2029

1

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

2030

1

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

2031

1

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

2032

1

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

2033

1

					fee_asset_item: 0,

2034

1

})

2035

1

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

2036

1

					AccountId::from(ALICE)

2037

1

)),

2038

1

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

2039

1

);

2040

1

});

2041

1

2042

2043

#[test]

2044

1

fn transactor_cannot_use_more_than_max_weight() {

2045

1

	ExtBuilder::default()

2046

1

		.with_balances(vec![

2047

1

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

2048

1

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

2049

1

])

2050

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2051

1

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

2052

1

			metadata: AssetRegistrarMetadata {

2053

1

				name: b"RelayToken".to_vec(),

2054

1

				symbol: b"Relay".to_vec(),

2055

1

				decimals: 12,

2056

1

				is_frozen: false,

2057

1

},

2058

1

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

2059

1

			is_sufficient: true,

2060

1

}])

2061

1

		.build()

2062

1

		.execute_with(|| {

2063

1

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

2064

1

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

2065

1

			assert_ok!(XcmTransactor::register(

2066

1

				root_origin(),

2067

1

				AccountId::from(ALICE),

2068

1

0,

2069

1

));

2070

2071

			// Root can set transact info

2072

1

			assert_ok!(XcmTransactor::set_transact_info(

2073

1

				root_origin(),

2074

1

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

2075

1

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

2076

1

				3000.into(),

2077

1

				20000.into(),

2078

1

				None

2079

1

));

2080

2081

			// Root can set transact info

2082

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2083

1

				root_origin(),

2084

1

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

2085

1

2086

1

));

2087

2088

1

			assert_noop!(

2089

1

				XcmTransactor::transact_through_derivative(

2090

1

					origin_of(AccountId::from(ALICE)),

2091

1

					moonriver_runtime::xcm_config::Transactors::Relay,

2092

1

0,

2093

1

					CurrencyPayment {

2094

1

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

2095

1

							Location::parent()

2096

1

						))),

2097

1

						fee_amount: None

2098

1

},

2099

1

					vec![],

2100

1

					// 2000 is the max

2101

1

					TransactWeights {

2102

1

						transact_required_weight_at_most: 17001.into(),

2103

1

						overall_weight: None

2104

1

},

2105

1

					false

2106

1

),

2107

1

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

2108

1

);

2109

1

			assert_noop!(

2110

1

				XcmTransactor::transact_through_derivative(

2111

1

					origin_of(AccountId::from(ALICE)),

2112

1

					moonriver_runtime::xcm_config::Transactors::Relay,

2113

1

0,

2114

1

					CurrencyPayment {

2115

1

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

2116

1

						fee_amount: None

2117

1

},

2118

1

					vec![],

2119

1

					// 20000 is the max

2120

1

					TransactWeights {

2121

1

						transact_required_weight_at_most: 17001.into(),

2122

1

						overall_weight: None

2123

1

},

2124

1

					false

2125

1

),

2126

1

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

2127

1

);

2128

1

})

2129

1

2130

2131

#[test]

2132

1

fn transact_through_signed_precompile_works_v2() {

2133

1

	ExtBuilder::default()

2134

1

		.with_balances(vec![

2135

1

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

2136

1

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

2137

1

])

2138

1

		.with_safe_xcm_version(2)

2139

1

		.build()

2140

1

		.execute_with(|| {

2141

1

			// Destination

2142

1

			let dest = Location::parent();

2143

1

2144

1

			let fee_payer_asset = Location::parent();

2145

1

2146

1

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

2147

1

2148

1

			let total_weight = 1_000_000_000u64;

2149

1

2150

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2151

1

2152

1

			Precompiles::new()

2153

1

				.prepare_test(

2154

1

					ALICE,

2155

1

					xcm_transactor_v2_precompile_address,

2156

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2157

1

						dest,

2158

1

						fee_asset: fee_payer_asset,

2159

1

						weight: 4_000_000,

2160

1

						call: bytes.into(),

2161

1

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

2162

1

						overall_weight: total_weight,

2163

1

},

2164

1

2165

1

				.expect_cost(23275)

2166

1

				.expect_no_logs()

2167

1

				.execute_returns(());

2168

1

});

2169

1

2170

2171

#[test]

2172

1

fn transact_through_signed_cannot_send_to_local_chain() {

2173

1

	ExtBuilder::default()

2174

1

		.with_balances(vec![

2175

1

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

2176

1

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

2177

1

])

2178

1

		.with_safe_xcm_version(2)

2179

1

		.build()

2180

1

		.execute_with(|| {

2181

1

			// Destination

2182

1

			let dest = Location::here();

2183

1

2184

1

			let fee_payer_asset = Location::parent();

2185

1

2186

1

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

2187

1

2188

1

			let total_weight = 1_000_000_000u64;

2189

1

2190

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2191

1

2192

1

			Precompiles::new()

2193

1

				.prepare_test(

2194

1

					ALICE,

2195

1

					xcm_transactor_v2_precompile_address,

2196

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2197

1

						dest,

2198

1

						fee_asset: fee_payer_asset,

2199

1

						weight: 4_000_000,

2200

1

						call: bytes.into(),

2201

1

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

2202

1

						overall_weight: total_weight,

2203

1

},

2204

1

2205

1

				.execute_reverts(|output| {

2206

1

					from_utf8(&output)

2207

1

						.unwrap()

2208

1

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

2209

1

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

2210

1

});

2211

1

});

2212

1

2213

2214

#[test]

2215

1

fn call_xtokens_with_fee() {

2216

1

	ExtBuilder::default()

2217

1

		.with_balances(vec![

2218

1

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

2219

1

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

2220

1

])

2221

1

		.with_safe_xcm_version(2)

2222

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2223

1

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

2224

1

			metadata: AssetRegistrarMetadata {

2225

1

				name: b"RelayToken".to_vec(),

2226

1

				symbol: b"Relay".to_vec(),

2227

1

				decimals: 12,

2228

1

				is_frozen: false,

2229

1

},

2230

1

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

2231

1

			is_sufficient: true,

2232

1

}])

2233

1

		.build()

2234

1

		.execute_with(|| {

2235

1

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

2236

1

			let dest = Location {

2237

1

				parents: 1,

2238

1

				interior: [AccountId32 {

2239

1

					network: None,

2240

1

					id: [1u8; 32],

2241

1

}]

2242

1

				.into(),

2243

1

};

2244

1

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

2245

1

2246

1

			let before_balance =

2247

1

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

2248

1

2249

1

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

2250

1

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

2251

1

			let (chain_part, beneficiary) =

2252

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2253

1

2254

1

			// We are able to transfer with fee

2255

1

			assert_ok!(PolkadotXcm::transfer_assets(

2256

1

				origin_of(AccountId::from(ALICE)),

2257

1

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

2258

1

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

2259

1

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

2260

1

0,

2261

1

				WeightLimit::Limited(4000000000.into()),

2262

1

			),);

2263

2264

1

			let after_balance =

2265

1

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

2266

1

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

2267

1

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

2268

1

});

2269

1

2270

2271

#[test]

2272

1

fn test_xcm_utils_ml_tp_account() {

2273

1

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

2274

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2275

1

		let expected_address_parent: H160 =

2276

1

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

2277

1

				.unwrap()

2278

1

				.into();

2279

1

2280

1

		Precompiles::new()

2281

1

			.prepare_test(

2282

1

				ALICE,

2283

1

				xcm_utils_precompile_address,

2284

1

				XcmUtilsPCall::multilocation_to_address {

2285

1

					location: Location::parent(),

2286

1

},

2287

1

2288

1

			.expect_cost(1669)

2289

1

			.expect_no_logs()

2290

1

			.execute_returns(Address(expected_address_parent));

2291

1

2292

1

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

2293

1

		let expected_address_parachain: H160 =

2294

1

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

2295

1

				&parachain_2000_multilocation,

2296

1

2297

1

			.unwrap()

2298

1

			.into();

2299

1

2300

1

		Precompiles::new()

2301

1

			.prepare_test(

2302

1

				ALICE,

2303

1

				xcm_utils_precompile_address,

2304

1

				XcmUtilsPCall::multilocation_to_address {

2305

1

					location: parachain_2000_multilocation,

2306

1

},

2307

1

2308

1

			.expect_cost(1669)

2309

1

			.expect_no_logs()

2310

1

			.execute_returns(Address(expected_address_parachain));

2311

1

2312

1

		let alice_in_parachain_2000_location = Location::new(

2313

1

1,

2314

1

2315

1

				Parachain(2000),

2316

1

				AccountKey20 {

2317

1

					network: None,

2318

1

					key: ALICE,

2319

1

},

2320

1

],

2321

1

);

2322

1

		let expected_address_alice_in_parachain_2000 =

2323

1

			xcm_builder::HashedDescription::<

2324

1

				AccountId,

2325

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2326

1

			>::convert_location(&alice_in_parachain_2000_location)

2327

1

			.unwrap()

2328

1

			.into();

2329

1

2330

1

		Precompiles::new()

2331

1

			.prepare_test(

2332

1

				ALICE,

2333

1

				xcm_utils_precompile_address,

2334

1

				XcmUtilsPCall::multilocation_to_address {

2335

1

					location: alice_in_parachain_2000_location,

2336

1

},

2337

1

2338

1

			.expect_cost(1669)

2339

1

			.expect_no_logs()

2340

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2341

1

});

2342

1

2343

2344

#[test]

2345

1

fn test_xcm_utils_weight_message() {

2346

1

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

2347

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2348

1

		let expected_weight =

2349

1

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

2350

1

2351

1

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

2352

1

2353

1

		let input = XcmUtilsPCall::weight_message {

2354

1

			message: message.into(),

2355

1

};

2356

1

2357

1

		Precompiles::new()

2358

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2359

1

			.expect_cost(0)

2360

1

			.expect_no_logs()

2361

1

			.execute_returns(expected_weight);

2362

1

});

2363

1

2364

2365

#[test]

2366

1

fn test_xcm_utils_get_units_per_second() {

2367

1

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

2368

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2369

1

		let location = SelfReserve::get();

2370

1

2371

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2372

1

2373

1

		let expected_units =

2374

1

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

2375

1

2376

1

		Precompiles::new()

2377

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2378

1

			.expect_cost(1669)

2379

1

			.expect_no_logs()

2380

1

			.execute_returns(expected_units);

2381

1

});

2382

1

2383

2384

#[test]

2385

1

fn precompile_existence() {

2386

1

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

2387

1

		let precompiles = Precompiles::new();

2388

1

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

2389

1

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

2390

1

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

2391

1

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

2392

1

2393

1

		.into_iter()

2394

1

		.map(H160::from_low_u64_be)

2395

1

		.collect();

2396

2397

3001

		for i in 0..3000 {

2398

3000

			let address = H160::from_low_u64_be(i);

2399

3000

2400

3000

			if precompile_addresses.contains(&address) {

2401

40

				assert!(

2402

40

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

2403

					"is_precompile({}) should return true",

2404

2405

);

2406

2407

40

				assert!(

2408

40

					precompiles

2409

40

						.execute(&mut MockHandle::new(

2410

40

							address,

2411

40

							Context {

2412

40

								address,

2413

40

								caller: H160::zero(),

2414

40

								apparent_value: U256::zero()

2415

40

2416

40

),)

2417

40

						.is_some(),

2418

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

2419

2420

);

2421

			} else {

2422

2960

				assert!(

2423

2960

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

2424

					"is_precompile({}) should return false",

2425

2426

);

2427

2428

2960

				assert!(

2429

2960

					precompiles

2430

2960

						.execute(&mut MockHandle::new(

2431

2960

							address,

2432

2960

							Context {

2433

2960

								address,

2434

2960

								caller: H160::zero(),

2435

2960

								apparent_value: U256::zero()

2436

2960

2437

2960

),)

2438

2960

						.is_none(),

2439

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

2440

2441

);

2442

2443

2444

1

});

2445

1

2446

2447

#[test]

2448

1

fn removed_precompiles() {

2449

1

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

2450

1

		let precompiles = Precompiles::new();

2451

1

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

2452

2453

3000

		for i in 1..3000 {

2454

2999

			let address = H160::from_low_u64_be(i);

2455

2999

2456

2999

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

2457

2959

				continue;

2458

40

2459

40

2460

40

			if !removed_precompiles.contains(&i) {

2461

36

				assert!(

2462

36

					match precompiles.is_active_precompile(address, 100_000u64) {

2463

36

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

2464

						_ => false,

2465

},

2466

					"{i} should be an active precompile"

2467

);

2468

36

				continue;

2469

4

2470

4

2471

4

			assert!(

2472

4

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

2473

4

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

2474

					_ => false,

2475

},

2476

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

2477

);

2478

2479

4

			precompiles

2480

4

				.prepare_test(Alice, address, [])

2481

4

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

2482

2483

1

})

2484

1

2485

2486

#[test]

2487

1

fn deal_with_fees_handles_tip() {

2488

1

	use frame_support::traits::OnUnbalanced;

2489

1

	use moonriver_runtime::{DealWithFees, Treasury};

2490

1

2491

1

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

2492

1

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

2493

1

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

2494

1

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

2495

1

//

2496

1

		// The test follows these steps:

2497

1

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

2498

1

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

2499

1

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

2500

1

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

2501

1

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

2502

1

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

2503

1

		//    that this amount was burned.

2504

1

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

2505

1

			AccountId,

2506

1

		>>::issue(100);

2507

1

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

2508

1

			AccountId,

2509

1

		>>::issue(1000);

2510

1

2511

1

		let total_supply_before = Balances::total_issuance();

2512

1

		assert_eq!(total_supply_before, 1_100);

2513

1

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

2514

2515

1

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

2516

1

2517

1

		// treasury should have received 20%

2518

1

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

2519

2520

		// verify 80% burned

2521

1

		let total_supply_after = Balances::total_issuance();

2522

1

		assert_eq!(total_supply_before - total_supply_after, 880);

2523

1

});

2524

1

2525

2526

#[test]

2527

1

fn evm_revert_substrate_events() {

2528

1

	ExtBuilder::default()

2529

1

		.with_balances(vec![(AccountId::from(ALICE), 1_000 * MOVR)])

2530

1

		.build()

2531

1

		.execute_with(|| {

2532

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2533

1

2534

1

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

2535

1

			// Thus BatchAll will revert the transfer.

2536

1

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

2537

1

				source: ALICE.into(),

2538

1

				target: batch_precompile_address,

2539

1

				input: BatchPCall::batch_all {

2540

1

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

2541

1

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

2542

1

					call_data: vec![].into(),

2543

1

					gas_limit: vec![].into()

2544

1

2545

1

				.into(),

2546

1

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

2547

1

				gas_limit: 500_000,

2548

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2549

1

				max_priority_fee_per_gas: None,

2550

1

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

2551

1

				access_list: Vec::new(),

2552

1

})

2553

1

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

2554

2555

1

			let transfer_count = System::events()

2556

1

				.iter()

2557

6

				.filter(|r| match r.event {

2558

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

2559

6

					_ => false,

2560

6

})

2561

1

				.count();

2562

1

2563

1

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

2564

1

});

2565

1

2566

2567

#[test]

2568

1

fn evm_success_keeps_substrate_events() {

2569

1

	ExtBuilder::default()

2570

1

		.with_balances(vec![(AccountId::from(ALICE), 1_000 * MOVR)])

2571

1

		.build()

2572

1

		.execute_with(|| {

2573

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2574

1

2575

1

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

2576

1

				source: ALICE.into(),

2577

1

				target: batch_precompile_address,

2578

1

				input: BatchPCall::batch_all {

2579

1

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

2580

1

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

2581

1

					call_data: vec![].into(),

2582

1

					gas_limit: vec![].into()

2583

1

2584

1

				.into(),

2585

1

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

2586

1

				gas_limit: 500_000,

2587

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2588

1

				max_priority_fee_per_gas: None,

2589

1

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

2590

1

				access_list: Vec::new(),

2591

1

})

2592

1

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

2593

2594

1

			let transfer_count = System::events()

2595

1

				.iter()

2596

10

				.filter(|r| match r.event {

2597

1

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

2598

9

					_ => false,

2599

10

})

2600

1

				.count();

2601

1

2602

1

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

2603

1

});

2604

1

2605

2606

#[cfg(test)]

2607

mod fee_tests {

2608

	use super::*;

2609

	use fp_evm::FeeCalculator;

2610

	use frame_support::{

2611

		traits::{ConstU128, OnFinalize},

2612

		weights::{ConstantMultiplier, WeightToFee},

2613

};

2614

	use moonriver_runtime::{

2615

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2616

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2617

};

2618

	use sp_core::Get;

2619

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

2620

2621

1

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

2622

1

	where

2623

1

		F: FnMut() -> (),

2624

1

2625

1

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

2626

1

			.build_storage()

2627

1

			.unwrap()

2628

1

			.into();

2629

1

		t.execute_with(|| {

2630

1

			System::set_block_consumed_resources(w, 0);

2631

1

			assertions()

2632

1

});

2633

1

2634

2635

	#[test]

2636

1

	fn test_multiplier_can_grow_from_zero() {

2637

1

		let minimum_multiplier = MinimumMultiplier::get();

2638

1

		let target = TargetBlockFullness::get()

2639

1

			* RuntimeBlockWeights::get()

2640

1

				.get(DispatchClass::Normal)

2641

1

				.max_total

2642

1

				.unwrap();

2643

1

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

2644

1

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

2645

1

		run_with_system_weight(target * 101 / 100, || {

2646

1

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

2647

1

			assert!(

2648

1

				next > minimum_multiplier,

2649

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

2650

				next,

2651

				minimum_multiplier

2652

);

2653

1

})

2654

1

2655

2656

	#[test]

2657

1

	fn test_fee_calculation() {

2658

1

		let base_extrinsic = RuntimeBlockWeights::get()

2659

1

			.get(DispatchClass::Normal)

2660

1

			.base_extrinsic;

2661

1

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

2662

1

		let extrinsic_len = 100u32;

2663

1

		let extrinsic_weight = Weight::from_parts(5_000u64, 1);

2664

1

		let tip = 42u128;

2665

1

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

2666

1

		type LengthToFeeImpl = LengthToFee;

2667

1

2668

1

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

2669

1

		let expected_fee = WeightToFeeImpl::weight_to_fee(&base_extrinsic)

2670

1

			+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(&extrinsic_weight))

2671

1

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

2672

1

			+ tip;

2673

1

2674

1

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

2675

1

			.build_storage()

2676

1

			.unwrap()

2677

1

			.into();

2678

1

		t.execute_with(|| {

2679

1

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

2680

1

			let actual_fee = TransactionPayment::compute_fee(

2681

1

				extrinsic_len,

2682

1

				&frame_support::dispatch::DispatchInfo {

2683

1

					class: DispatchClass::Normal,

2684

1

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

2685

1

					weight: extrinsic_weight,

2686

1

},

2687

1

				tip,

2688

1

);

2689

1

2690

1

			assert_eq!(

2691

				expected_fee,

2692

				actual_fee,

2693

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

2694

				actual_fee - expected_fee

2695

);

2696

1

});

2697

1

2698

2699

	#[test]

2700

1

	fn test_min_gas_price_is_deterministic() {

2701

1

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

2702

1

			.build_storage()

2703

1

			.unwrap()

2704

1

			.into();

2705

1

		t.execute_with(|| {

2706

1

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

2707

1

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

2708

1

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

2709

1

			let expected: U256 = multiplier

2710

1

				.saturating_mul_int(

2711

1

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

2712

1

2713

1

				.into();

2714

1

2715

1

			assert_eq!(expected, actual);

2716

1

});

2717

1

2718

2719

	#[test]

2720

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

2721

1

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

2722

1

			.build_storage()

2723

1

			.unwrap()

2724

1

			.into();

2725

1

		t.execute_with(|| {

2726

1

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

2727

1

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

2728

1

2729

1

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

2730

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

2731

1

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

2732

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

2733

1

2734

1

			assert_ne!(

2735

				a, b,

2736

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

2737

);

2738

1

});

2739

1

2740

2741

	#[test]

2742

1

	fn test_fee_scenarios() {

2743

1

		use sp_runtime::FixedU128;

2744

1

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

2745

1

			.build_storage()

2746

1

			.unwrap()

2747

1

			.into();

2748

1

		t.execute_with(|| {

2749

1

			let weight_fee_per_gas =

2750

1

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

2751

12

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

2752

12

				let start_multiplier =

2753

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

2754

12

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

2755

12

2756

12

				let block_weight = NORMAL_WEIGHT * fullness;

2757

2758

60004

				for i in 0..num_blocks {

2759

60004

					System::set_block_number(i as u32);

2760

60004

					System::set_block_consumed_resources(block_weight, 0);

2761

60004

					TransactionPayment::on_finalize(i as u32);

2762

60004

2763

2764

12

				TransactionPaymentAsGasPrice::min_gas_price().0

2765

12

};

2766

2767

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

2768

			// they are expected to change when parameters that influence

2769

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

2770

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

2771

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

2772

2773

1

			assert_eq!(

2774

1

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

2775

1

				U256::from(1_250_000_000u128),

2776

1

);

2777

1

			assert_eq!(

2778

1

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

2779

1

				U256::from(1_250_000_000u128),

2780

1

);

2781

1

			assert_eq!(

2782

1

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

2783

1

				U256::from(1_250_750_225u128),

2784

1

);

2785

1

			assert_eq!(

2786

1

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

2787

1

				U256::from(1_253_254_225u128),

2788

1

);

2789

2790

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

2791

1

			assert_eq!(

2792

1

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

2793

1

				U256::from(1_250_000_000u128),

2794

1

);

2795

1

			assert_eq!(

2796

1

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

2797

1

				U256::from(1_250_000_000u128),

2798

1

);

2799

1

			assert_eq!(

2800

1

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

2801

1

				U256::from(1_791_661_729u128),

2802

1

);

2803

1

			assert_eq!(

2804

1

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

2805

1

				U256::from(5_948_516_121u128),

2806

1

);

2807

2808

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

2809

1

			assert_eq!(

2810

1

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

2811

1

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

2812

1

);

2813

1

			assert_eq!(

2814

1

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

2815

1

				U256::from(1_250_000_000u128),

2816

1

);

2817

1

			assert_eq!(

2818

1

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

2819

1

				U256::from(7_066_658_618_836u128),

2820

1

);

2821

1

			assert_eq!(

2822

1

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

2823

1

				U256::from(125_000_000_000_000u128), // upper bound enforced

2824

1

);

2825

1

});

2826

1

2827