Grcov report - integration

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

// Moonbeam is free software: you can redistribute it and/or modify

5

// it under the terms of the GNU General Public License as published by

6

// the Free Software Foundation, either version 3 of the License, or

7

// (at your option) any later version.

8

9

// Moonbeam is distributed in the hope that it will be useful,

10

// but WITHOUT ANY WARRANTY; without even the implied warranty of

11

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

12

// GNU General Public License for more details.

13

14

// You should have received a copy of the GNU General Public License

15

// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

16

17

//! Moonriver Runtime Integration Tests

18

19

#![cfg(test)]

20

21

mod common;

22

23

use common::*;

24

25

use fp_evm::{Context, IsPrecompileResult};

26

use frame_support::{

27

	assert_noop, assert_ok,

28

	dispatch::DispatchClass,

29

	traits::{

30

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

31

		StorageInfo, StorageInfoTrait,

32

},

33

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

34

	StorageHasher, Twox128,

35

};

36

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

37

use moonriver_runtime::runtime_params::dynamic_params;

38

use moonriver_runtime::xcm_config::{AssetHubLocation, LocationToAccountId, XcmExecutor};

39

use moonriver_runtime::{

40

	moonriver_xcm_weights,

41

	xcm_config::{CurrencyId, SelfReserve},

42

	Balances, CrowdloanRewards, EvmForeignAssets, Executive, OpenTechCommitteeCollective,

43

	PolkadotXcm, Precompiles, RuntimeBlockWeights, TransactionPayment,

44

	TransactionPaymentAsGasPrice, Treasury, TreasuryCouncilCollective, XcmTransactor, WEEKS,

45

};

46

use moonriver_xcm_weights::XcmWeight;

47

use nimbus_primitives::NimbusId;

48

use pallet_evm::PrecompileSet;

49

use pallet_moonbeam_foreign_assets::AssetStatus;

50

use pallet_parachain_staking::InflationDistributionAccount;

51

use pallet_transaction_payment::Multiplier;

52

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

53

use parity_scale_codec::Encode;

54

use polkadot_parachain::primitives::Sibling;

55

use precompile_utils::{

56

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

57

	prelude::*,

58

	testing::*,

59

};

60

use sha3::{Digest, Keccak256};

61

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

62

use sp_runtime::{

63

	traits::{Convert, Dispatchable},

64

	BuildStorage, DispatchError, ModuleError, Percent,

65

};

66

use std::str::from_utf8;

67

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

68

use xcm::{VersionedAssets, VersionedLocation};

69

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

70

use xcm_executor::traits::ConvertLocation;

71

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

72

73

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

74

type CrowdloanRewardsPCall =

75

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

76

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

77

	Runtime,

78

	moonriver_runtime::xcm_config::XcmExecutorConfig,

79

>;

80

type XcmTransactorV2PCall =

81

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

82

83

const BASE_FEE_GENESIS: u128 = 100 * GIGAWEI;

84

85

7

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

86

7

	Asset {

87

7

		id: AssetId(

88

7

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

89

7

				currency_id,

90

7

91

7

			.unwrap(),

92

7

),

93

7

		fun: Fungibility::Fungible(amount),

94

7

95

7

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

31

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

110

31

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

111

31

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

112

31

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

113

31

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

114

31

		// expand/storage.rs#L389-L401

115

31

		assert_eq!(

116

31

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

117

31

			Some(name)

118

31

);

119

31

120

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

121

	// 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::XcmTransactor>("XcmTransactor");

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

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

155

1

156

14

	let prefix = |pallet_name, storage_name| {

157

14

		let mut res = [0u8; 32];

158

14

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

159

14

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

160

14

		res.to_vec()

161

14

};

162

1

	assert_eq!(

163

1

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

164

1

		vec![

165

1

			StorageInfo {

166

1

				pallet_name: b"Timestamp".to_vec(),

167

1

				storage_name: b"Now".to_vec(),

168

1

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

169

1

				max_values: Some(1),

170

1

				max_size: Some(8),

171

1

},

172

1

			StorageInfo {

173

1

				pallet_name: b"Timestamp".to_vec(),

174

1

				storage_name: b"DidUpdate".to_vec(),

175

1

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

176

1

				max_values: Some(1),

177

1

				max_size: Some(1),

178

1

179

1

180

1

);

181

1

	assert_eq!(

182

1

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

183

1

		vec![

184

1

			StorageInfo {

185

1

				pallet_name: b"Balances".to_vec(),

186

1

				storage_name: b"TotalIssuance".to_vec(),

187

1

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

188

1

				max_values: Some(1),

189

1

				max_size: Some(16),

190

1

},

191

1

			StorageInfo {

192

1

				pallet_name: b"Balances".to_vec(),

193

1

				storage_name: b"InactiveIssuance".to_vec(),

194

1

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

195

1

				max_values: Some(1),

196

1

				max_size: Some(16),

197

1

},

198

1

			StorageInfo {

199

1

				pallet_name: b"Balances".to_vec(),

200

1

				storage_name: b"Account".to_vec(),

201

1

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

202

1

				max_values: None,

203

1

				max_size: Some(100),

204

1

},

205

1

			StorageInfo {

206

1

				pallet_name: b"Balances".to_vec(),

207

1

				storage_name: b"Locks".to_vec(),

208

1

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

209

1

				max_values: None,

210

1

				max_size: Some(1287),

211

1

},

212

1

			StorageInfo {

213

1

				pallet_name: b"Balances".to_vec(),

214

1

				storage_name: b"Reserves".to_vec(),

215

1

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

216

1

				max_values: None,

217

1

				max_size: Some(1037),

218

1

},

219

1

			StorageInfo {

220

1

				pallet_name: b"Balances".to_vec(),

221

1

				storage_name: b"Holds".to_vec(),

222

1

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

223

1

				max_values: None,

224

1

				max_size: Some(91),

225

1

},

226

1

			StorageInfo {

227

1

				pallet_name: b"Balances".to_vec(),

228

1

				storage_name: b"Freezes".to_vec(),

229

1

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

230

1

				max_values: None,

231

1

				max_size: Some(37),

232

1

},

233

1

234

1

);

235

1

	assert_eq!(

236

1

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

237

1

		vec![

238

1

			StorageInfo {

239

1

				pallet_name: b"Proxy".to_vec(),

240

1

				storage_name: b"Proxies".to_vec(),

241

1

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

242

1

				max_values: None,

243

1

				max_size: Some(845),

244

1

},

245

1

			StorageInfo {

246

1

				pallet_name: b"Proxy".to_vec(),

247

1

				storage_name: b"Announcements".to_vec(),

248

1

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

249

1

				max_values: None,

250

1

				max_size: Some(1837),

251

1

252

1

253

1

);

254

1

	assert_eq!(

255

1

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

256

1

		vec![StorageInfo {

257

1

			pallet_name: b"MaintenanceMode".to_vec(),

258

1

			storage_name: b"MaintenanceMode".to_vec(),

259

1

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

260

1

			max_values: Some(1),

261

1

			max_size: None,

262

1

},]

263

1

);

264

1

	assert_eq!(

265

1

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

266

1

		vec![

267

1

			StorageInfo {

268

1

				pallet_name: b"RelayStorageRoots".to_vec(),

269

1

				storage_name: b"RelayStorageRoot".to_vec(),

270

1

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

271

1

				max_values: None,

272

1

				max_size: Some(44),

273

1

},

274

1

			StorageInfo {

275

1

				pallet_name: b"RelayStorageRoots".to_vec(),

276

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

277

1

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

278

1

				max_values: Some(1),

279

1

				max_size: Some(121),

280

1

},

281

1

282

1

);

283

1

284

285

#[test]

286

1

fn test_collectives_storage_item_prefixes() {

287

7

	for StorageInfo { pallet_name, .. } in

288

8

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

289

290

7

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

291

292

293

7

	for StorageInfo { pallet_name, .. } in

294

8

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

295

296

7

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

297

298

1

299

300

#[test]

301

1

fn collective_set_members_root_origin_works() {

302

1

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

303

1

		// TreasuryCouncilCollective

304

1

		assert_ok!(TreasuryCouncilCollective::set_members(

305

1

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

306

1

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

307

1

			Some(AccountId::from(ALICE)),

308

1

309

1

));

310

		// OpenTechCommitteeCollective

311

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

312

1

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

313

1

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

314

1

			Some(AccountId::from(ALICE)),

315

1

316

1

));

317

1

});

318

1

319

320

#[test]

321

1

fn collective_set_members_general_admin_origin_works() {

322

	use moonriver_runtime::{

323

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

324

};

325

326

1

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

327

1

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

328

1

		let alice = AccountId::from(ALICE);

329

1

330

1

		// TreasuryCouncilCollective

331

1

		let _ = Utility::dispatch_as(

332

1

			root_caller.clone(),

333

1

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

334

1

			Box::new(

335

1

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

336

1

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

337

1

					prime: Some(alice),

338

1

					old_count: 2,

339

1

340

1

				.into(),

341

1

),

342

1

);

343

1

		// OpenTechCommitteeCollective

344

1

		let _ = Utility::dispatch_as(

345

1

			root_caller,

346

1

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

347

1

			Box::new(

348

1

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

349

1

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

350

1

					prime: Some(alice),

351

1

					old_count: 2,

352

1

353

1

				.into(),

354

1

),

355

1

);

356

1

357

1

		assert_eq!(

358

1

			System::events()

359

1

				.into_iter()

360

2

				.filter_map(|r| {

361

2

					match r.event {

362

2

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

363

2

							if result.is_ok() =>

364

2

365

2

							Some(true)

366

367

						_ => None,

368

369

2

})

370

1

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

371

1

				.len(),

372

1

373

1

374

1

});

375

1

376

377

#[test]

378

1

fn collective_set_members_signed_origin_does_not_work() {

379

1

	let alice = AccountId::from(ALICE);

380

1

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

381

1

		// TreasuryCouncilCollective

382

1

		assert!(TreasuryCouncilCollective::set_members(

383

1

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

384

1

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

385

1

			Some(AccountId::from(ALICE)),

386

1

387

1

388

1

		.is_err());

389

		// OpenTechCommitteeCollective

390

1

		assert!(OpenTechCommitteeCollective::set_members(

391

1

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

392

1

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

393

1

			Some(AccountId::from(ALICE)),

394

1

395

1

396

1

		.is_err());

397

1

});

398

1

399

400

#[test]

401

1

fn verify_pallet_indices() {

402

33

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

403

33

		assert_eq!(

404

33

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

405

33

			Some(index)

406

33

);

407

33

408

	// System support

409

1

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

410

1

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

411

1

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

412

1

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

413

1

	// Monetary

414

1

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

415

1

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

416

1

	// Consensus support

417

1

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

418

1

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

419

1

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

420

1

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

421

1

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

422

1

	// Handy utilities

423

1

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

424

1

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

425

1

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

426

1

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

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); Removed

450

1

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

451

1

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

452

1

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

453

1

	is_pallet_index::<moonriver_runtime::BridgePolkadotGrandpa>(130);

454

1

	is_pallet_index::<moonriver_runtime::BridgePolkadotParachains>(131);

455

1

	is_pallet_index::<moonriver_runtime::BridgePolkadotMessages>(132);

456

1

	is_pallet_index::<moonriver_runtime::BridgeXcmOverMoonbeam>(133);

457

1

458

459

#[test]

460

1

fn verify_reserved_indices() {

461

1

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

462

1

		.build_storage()

463

1

		.unwrap()

464

1

		.into();

465

1

466

1

	t.execute_with(|| {

467

		use frame_metadata::*;

468

1

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

469

1

		let metadata = match metadata.1 {

470

1

			RuntimeMetadata::V14(metadata) => metadata,

471

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

472

};

473

		// 40: Sudo

474

		// 53: BaseFee

475

		// 108: pallet_assets::<Instance1>

476

1

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

477

1

		let existing = metadata

478

1

			.pallets

479

1

			.iter()

480

51

			.map(|p| p.index)

481

1

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

482

3

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

483

1

});

484

1

485

486

#[test]

487

1

fn verify_proxy_type_indices() {

488

1

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

489

1

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

490

1

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

491

1

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

492

1

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

493

1

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

494

1

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

495

1

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

496

1

497

498

#[test]

499

1

fn join_collator_candidates() {

500

1

	ExtBuilder::default()

501

1

		.with_balances(vec![

502

1

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

503

1

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

504

1

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

505

1

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

506

1

])

507

1

		.with_collators(vec![

508

1

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

509

1

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

510

1

])

511

1

		.with_delegations(vec![

512

1

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

513

1

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

514

1

])

515

1

		.build()

516

1

		.execute_with(|| {

517

1

			assert_noop!(

518

1

				ParachainStaking::join_candidates(

519

1

					origin_of(AccountId::from(ALICE)),

520

1

					10_000 * MOVR,

521

1

					2u32

522

1

),

523

1

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

524

1

);

525

1

			assert_noop!(

526

1

				ParachainStaking::join_candidates(

527

1

					origin_of(AccountId::from(CHARLIE)),

528

1

					10_000 * MOVR,

529

1

					2u32

530

1

),

531

1

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

532

1

);

533

1

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

534

1

			assert_ok!(ParachainStaking::join_candidates(

535

1

				origin_of(AccountId::from(DAVE)),

536

1

				10_000 * MOVR,

537

1

				2u32

538

1

));

539

1

			assert_eq!(

540

1

				last_event(),

541

1

				RuntimeEvent::ParachainStaking(

542

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

543

1

						account: AccountId::from(DAVE),

544

1

						amount_locked: 10_000 * MOVR,

545

1

						new_total_amt_locked: 30_100 * MOVR

546

1

547

1

548

1

);

549

1

			let candidates = ParachainStaking::candidate_pool();

550

1

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

551

1

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

552

1

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

553

1

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

554

1

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

555

1

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

556

1

});

557

1

558

559

#[test]

560

1

fn transfer_through_evm_to_stake() {

561

1

	ExtBuilder::default()

562

1

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

563

1

		.build()

564

1

		.execute_with(|| {

565

1

			// Charlie has no balance => fails to stake

566

1

			assert_noop!(

567

1

				ParachainStaking::join_candidates(

568

1

					origin_of(AccountId::from(CHARLIE)),

569

1

					10_000 * MOVR,

570

1

					2u32

571

1

),

572

1

				DispatchError::Module(ModuleError {

573

1

					index: 20,

574

1

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

575

1

					message: Some("InsufficientBalance")

576

1

})

577

1

);

578

			// Alice transfer from free balance 20000 MOVR to Bob

579

1

			assert_ok!(Balances::transfer_allow_death(

580

1

				origin_of(AccountId::from(ALICE)),

581

1

				AccountId::from(BOB),

582

1

				20_000 * MOVR,

583

1

));

584

1

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

585

586

1

			let gas_limit = 100000u64;

587

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

588

1

			// Bob transfers 10000 MOVR to Charlie via EVM

589

1

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

590

1

				source: H160::from(BOB),

591

1

				target: H160::from(CHARLIE),

592

1

				input: vec![],

593

1

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

594

1

				gas_limit,

595

1

				max_fee_per_gas: gas_price,

596

1

				max_priority_fee_per_gas: None,

597

1

				nonce: None,

598

1

				access_list: Vec::new(),

599

1

				authorization_list: Vec::new(),

600

1

})

601

1

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

602

1

			assert_eq!(

603

1

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

604

1

				10_000 * MOVR,

605

1

);

606

607

			// Charlie can stake now

608

1

			assert_ok!(ParachainStaking::join_candidates(

609

1

				origin_of(AccountId::from(CHARLIE)),

610

1

				10_000 * MOVR,

611

1

				2u32,

612

1

			),);

613

1

			let candidates = ParachainStaking::candidate_pool();

614

1

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

615

1

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

616

1

});

617

1

618

619

#[test]

620

1

fn reward_block_authors() {

621

1

	ExtBuilder::default()

622

1

		.with_balances(vec![

623

1

			// Alice gets 100 extra tokens for her mapping deposit

624

1

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

625

1

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

626

1

])

627

1

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

628

1

		.with_delegations(vec![(

629

1

			AccountId::from(BOB),

630

1

			AccountId::from(ALICE),

631

1

			500 * MOVR,

632

1

)])

633

1

		.with_mappings(vec![(

634

1

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

635

1

			AccountId::from(ALICE),

636

1

)])

637

1

		.build()

638

1

		.execute_with(|| {

639

1

			increase_last_relay_slot_number(1);

640

1

641

1

			// Just before round 3

642

1

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

643

1

644

1

			// no rewards doled out yet

645

1

			assert_eq!(

646

1

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

647

1

				10_100 * MOVR,

648

1

);

649

1

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

650

1

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

651

1

652

1

			// rewards minted and distributed

653

1

			assert_eq!(

654

1

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

655

1

				11547666666208000000000,

656

1

);

657

1

			assert_eq!(

658

1

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

659

1

				9557333332588000000000,

660

1

);

661

1

});

662

1

663

664

#[test]

665

1

fn reward_block_authors_with_parachain_bond_reserved() {

666

1

	ExtBuilder::default()

667

1

		.with_balances(vec![

668

1

			// Alice gets 100 extra tokens for her mapping deposit

669

1

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

670

1

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

671

1

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

672

1

])

673

1

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

674

1

		.with_delegations(vec![(

675

1

			AccountId::from(BOB),

676

1

			AccountId::from(ALICE),

677

1

			500 * MOVR,

678

1

)])

679

1

		.with_mappings(vec![(

680

1

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

681

1

			AccountId::from(ALICE),

682

1

)])

683

1

		.build()

684

1

		.execute_with(|| {

685

1

			increase_last_relay_slot_number(1);

686

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

687

1

				root_origin(),

688

1

689

1

					InflationDistributionAccount {

690

1

						account: AccountId::from(CHARLIE),

691

1

						percent: Percent::from_percent(30),

692

1

},

693

1

					InflationDistributionAccount::default(),

694

1

695

1

				.into()

696

1

));

697

698

			// Stop just before round 2

699

1

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

700

1

701

1

			// no collator rewards doled out yet

702

1

			assert_eq!(

703

1

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

704

1

				10_100 * MOVR,

705

1

);

706

1

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

707

708

			// Go to round 2

709

1

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

710

1

711

1

			// 30% reserved for parachain bond

712

1

			assert_eq!(

713

1

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

714

1

				452515000000000000000,

715

1

);

716

717

			// Go to round 3

718

1

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

719

1

720

1

			// rewards minted and distributed

721

1

			assert_eq!(

722

1

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

723

1

				11117700475903800000000,

724

1

);

725

1

			assert_eq!(

726

1

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

727

1

				9535834523343675000000,

728

1

);

729

			// 30% reserved for parachain bond again

730

1

			assert_eq!(

731

1

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

732

1

				910802725000000000000,

733

1

);

734

1

});

735

1

736

737

#[test]

738

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

739

1

	ExtBuilder::default()

740

1

		.with_balances(vec![

741

1

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

742

1

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

743

1

])

744

1

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

745

1

		.with_mappings(vec![(

746

1

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

747

1

			AccountId::from(ALICE),

748

1

)])

749

1

		.with_crowdloan_fund(3_000_000 * MOVR)

750

1

		.build()

751

1

		.execute_with(|| {

752

1

			// set parachain inherent data

753

1

			set_parachain_inherent_data();

754

1

			let init_block = CrowdloanRewards::init_vesting_block();

755

1

			// This matches the previous vesting

756

1

			let end_block = init_block + 48 * WEEKS;

757

1

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

758

1

			assert_ok!(

759

1

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

760

1

					calls: vec![

761

1

						RuntimeCall::CrowdloanRewards(

762

1

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

763

1

								rewards: vec![(

764

1

									[4u8; 32].into(),

765

1

									Some(AccountId::from(CHARLIE)),

766

1

									1_500_000 * MOVR

767

1

)]

768

1

769

1

),

770

1

						RuntimeCall::CrowdloanRewards(

771

1

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

772

1

								rewards: vec![(

773

1

									[5u8; 32].into(),

774

1

									Some(AccountId::from(DAVE)),

775

1

									1_500_000 * MOVR

776

1

)]

777

1

778

1

),

779

1

						RuntimeCall::CrowdloanRewards(

780

1

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

781

1

								lease_ending_block: end_block

782

1

783

1

784

1

785

1

})

786

1

				.dispatch(root_origin())

787

1

);

788

			// 30 percent initial payout

789

1

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

790

			// 30 percent initial payout

791

1

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

792

1

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

793

1

			assert_eq!(last_event(), expected);

794

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

795

1

			assert_ok!(

796

1

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

797

1

					calls: vec![RuntimeCall::CrowdloanRewards(

798

1

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

799

1

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

800

1

801

1

)]

802

1

})

803

1

				.dispatch(root_origin())

804

1

);

805

1

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

806

1

				index: 0,

807

1

				error: DispatchError::Module(ModuleError {

808

1

					index: 90,

809

1

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

810

1

					message: None,

811

1

}),

812

1

});

813

1

			assert_eq!(last_event(), expected_fail);

814

			// Claim 1 block.

815

1

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

816

1

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

817

818

1

			let vesting_period = 48 * WEEKS as u128;

819

1

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

820

1

821

1

			assert_eq!(

822

1

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

823

1

					.unwrap()

824

1

					.claimed_reward,

825

1

				(450_000 * MOVR) + per_block

826

1

);

827

1

			assert_eq!(

828

1

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

829

1

					.unwrap()

830

1

					.claimed_reward,

831

1

				(450_000 * MOVR) + per_block

832

1

);

833

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

834

1

			assert_eq!(

835

1

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

836

1

				(450_000 * MOVR) + per_block

837

1

);

838

1

			assert_eq!(

839

1

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

840

1

				(450_000 * MOVR) + per_block

841

1

);

842

1

			assert_noop!(

843

1

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

844

1

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

845

1

);

846

1

});

847

1

848

849

#[test]

850

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

851

1

	ExtBuilder::default()

852

1

		.with_balances(vec![

853

1

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

854

1

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

855

1

])

856

1

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

857

1

		.with_mappings(vec![(

858

1

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

859

1

			AccountId::from(ALICE),

860

1

)])

861

1

		.with_crowdloan_fund(3_000_000 * MOVR)

862

1

		.build()

863

1

		.execute_with(|| {

864

1

			// set parachain inherent data

865

1

			set_parachain_inherent_data();

866

1

			let init_block = CrowdloanRewards::init_vesting_block();

867

1

			// This matches the previous vesting

868

1

			let end_block = init_block + 4 * WEEKS;

869

1

870

1

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

871

1

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

872

1

873

1

			let public1 = pair1.public();

874

1

			let public2 = pair2.public();

875

1

876

1

			// signature:

877

1

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

878

1

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

879

1

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

880

1

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

881

1

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

882

1

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

883

1

			let signature1 = pair1.sign(&message);

884

1

			let signature2 = pair2.sign(&message);

885

1

886

1

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

887

1

			assert_ok!(

888

1

				// two relay accounts pointing at the same reward account

889

1

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

890

1

					calls: vec![

891

1

						RuntimeCall::CrowdloanRewards(

892

1

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

893

1

								rewards: vec![(

894

1

									public1.into(),

895

1

									Some(AccountId::from(CHARLIE)),

896

1

									1_500_000 * MOVR

897

1

)]

898

1

899

1

),

900

1

						RuntimeCall::CrowdloanRewards(

901

1

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

902

1

								rewards: vec![(

903

1

									public2.into(),

904

1

									Some(AccountId::from(CHARLIE)),

905

1

									1_500_000 * MOVR

906

1

)]

907

1

908

1

),

909

1

						RuntimeCall::CrowdloanRewards(

910

1

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

911

1

								lease_ending_block: end_block

912

1

913

1

914

1

915

1

})

916

1

				.dispatch(root_origin())

917

1

);

918

			// 30 percent initial payout

919

1

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

920

921

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

922

1

			assert_noop!(

923

1

				CrowdloanRewards::change_association_with_relay_keys(

924

1

					origin_of(AccountId::from(CHARLIE)),

925

1

					AccountId::from(DAVE),

926

1

					AccountId::from(CHARLIE),

927

1

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

928

1

),

929

1

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

930

1

);

931

932

			// this should be valid

933

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

934

1

				origin_of(AccountId::from(CHARLIE)),

935

1

				AccountId::from(DAVE),

936

1

				AccountId::from(CHARLIE),

937

1

				vec![

938

1

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

939

1

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

940

1

941

1

));

942

943

1

			assert_eq!(

944

1

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

945

1

					.unwrap()

946

1

					.claimed_reward,

947

1

				(900_000 * MOVR)

948

1

);

949

1

});

950

1

951

952

#[test]

953

1

fn claim_via_precompile() {

954

1

	ExtBuilder::default()

955

1

		.with_balances(vec![

956

1

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

957

1

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

958

1

])

959

1

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

960

1

		.with_mappings(vec![(

961

1

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

962

1

			AccountId::from(ALICE),

963

1

)])

964

1

		.with_crowdloan_fund(3_000_000 * MOVR)

965

1

		.build()

966

1

		.execute_with(|| {

967

1

			// set parachain inherent data

968

1

			set_parachain_inherent_data();

969

1

			let init_block = CrowdloanRewards::init_vesting_block();

970

1

			// This matches the previous vesting

971

1

			let end_block = init_block + 4 * WEEKS;

972

1

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

973

1

			assert_ok!(

974

1

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

975

1

					calls: vec![

976

1

						RuntimeCall::CrowdloanRewards(

977

1

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

978

1

								rewards: vec![(

979

1

									[4u8; 32].into(),

980

1

									Some(AccountId::from(CHARLIE)),

981

1

									1_500_000 * MOVR

982

1

)]

983

1

984

1

),

985

1

						RuntimeCall::CrowdloanRewards(

986

1

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

987

1

								rewards: vec![(

988

1

									[5u8; 32].into(),

989

1

									Some(AccountId::from(DAVE)),

990

1

									1_500_000 * MOVR

991

1

)]

992

1

993

1

),

994

1

						RuntimeCall::CrowdloanRewards(

995

1

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

996

1

								lease_ending_block: end_block

997

1

998

1

999

1

1000

1

})

1001

1

				.dispatch(root_origin())

1002

1

);

1003

1004

1

			assert!(CrowdloanRewards::initialized());

1005

1006

			// 30 percent initial payout

1007

1

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

1008

			// 30 percent initial payout

1009

1

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

1010

1011

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1012

1

1013

1

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

1014

1

			let gas_limit = 100000u64;

1015

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1016

1

1017

1

			// Construct the call data (selector, amount)

1018

1

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

1019

1

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

1020

1

1021

1

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

1022

1

				source: H160::from(CHARLIE),

1023

1

				target: crowdloan_precompile_address,

1024

1

				input: call_data,

1025

1

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

1026

1

				gas_limit,

1027

1

				max_fee_per_gas: gas_price,

1028

1

				max_priority_fee_per_gas: None,

1029

1

				nonce: None, // Use the next nonce

1030

1

				access_list: Vec::new(),

1031

1

				authorization_list: Vec::new(),

1032

1

})

1033

1

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

1034

1035

1

			let vesting_period = 4 * WEEKS as u128;

1036

1

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

1037

1

1038

1

			assert_eq!(

1039

1

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

1040

1

					.unwrap()

1041

1

					.claimed_reward,

1042

1

				(450_000 * MOVR) + per_block

1043

1

);

1044

1

})

1045

1

1046

1047

#[test]

1048

1

fn is_contributor_via_precompile() {

1049

1

	ExtBuilder::default()

1050

1

		.with_balances(vec![

1051

1

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

1052

1

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

1053

1

])

1054

1

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

1055

1

		.with_mappings(vec![(

1056

1

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

1057

1

			AccountId::from(ALICE),

1058

1

)])

1059

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1060

1

		.build()

1061

1

		.execute_with(|| {

1062

1

			// set parachain inherent data

1063

1

			set_parachain_inherent_data();

1064

1

			let init_block = CrowdloanRewards::init_vesting_block();

1065

1

			// This matches the previous vesting

1066

1

			let end_block = init_block + 4 * WEEKS;

1067

1

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

1068

1

			assert_ok!(

1069

1

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

1070

1

					calls: vec![

1071

1

						RuntimeCall::CrowdloanRewards(

1072

1

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

1073

1

								rewards: vec![(

1074

1

									[4u8; 32].into(),

1075

1

									Some(AccountId::from(CHARLIE)),

1076

1

									1_500_000 * MOVR

1077

1

)]

1078

1

1079

1

),

1080

1

						RuntimeCall::CrowdloanRewards(

1081

1

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

1082

1

								rewards: vec![(

1083

1

									[5u8; 32].into(),

1084

1

									Some(AccountId::from(DAVE)),

1085

1

									1_500_000 * MOVR

1086

1

)]

1087

1

1088

1

),

1089

1

						RuntimeCall::CrowdloanRewards(

1090

1

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

1091

1

								lease_ending_block: end_block

1092

1

1093

1

1094

1

1095

1

})

1096

1

				.dispatch(root_origin())

1097

1

);

1098

1099

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1100

1

1101

1

			// Assert precompile reports Bob is not a contributor

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(BOB).into()),

1108

1

},

1109

1

1110

1

				.expect_cost(3338)

1111

1

				.expect_no_logs()

1112

1

				.execute_returns(false);

1113

1

1114

1

			// Assert precompile reports Charlie is a nominator

1115

1

			Precompiles::new()

1116

1

				.prepare_test(

1117

1

					ALICE,

1118

1

					crowdloan_precompile_address,

1119

1

					CrowdloanRewardsPCall::is_contributor {

1120

1

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

1121

1

},

1122

1

1123

1

				.expect_cost(3338)

1124

1

				.expect_no_logs()

1125

1

				.execute_returns(true);

1126

1

})

1127

1

1128

1129

#[test]

1130

1

fn reward_info_via_precompile() {

1131

1

	ExtBuilder::default()

1132

1

		.with_balances(vec![

1133

1

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

1134

1

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

1135

1

])

1136

1

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

1137

1

		.with_mappings(vec![(

1138

1

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

1139

1

			AccountId::from(ALICE),

1140

1

)])

1141

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1142

1

		.build()

1143

1

		.execute_with(|| {

1144

1

			// set parachain inherent data

1145

1

			set_parachain_inherent_data();

1146

1

			let init_block = CrowdloanRewards::init_vesting_block();

1147

1

			// This matches the previous vesting

1148

1

			let end_block = init_block + 4 * WEEKS;

1149

1

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

1150

1

			assert_ok!(

1151

1

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

1152

1

					calls: vec![

1153

1

						RuntimeCall::CrowdloanRewards(

1154

1

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

1155

1

								rewards: vec![(

1156

1

									[4u8; 32].into(),

1157

1

									Some(AccountId::from(CHARLIE)),

1158

1

									1_500_000 * MOVR

1159

1

)]

1160

1

1161

1

),

1162

1

						RuntimeCall::CrowdloanRewards(

1163

1

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

1164

1

								rewards: vec![(

1165

1

									[5u8; 32].into(),

1166

1

									Some(AccountId::from(DAVE)),

1167

1

									1_500_000 * MOVR

1168

1

)]

1169

1

1170

1

),

1171

1

						RuntimeCall::CrowdloanRewards(

1172

1

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

1173

1

								lease_ending_block: end_block

1174

1

1175

1

1176

1

1177

1

})

1178

1

				.dispatch(root_origin())

1179

1

);

1180

1181

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1182

1

1183

1

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

1184

1

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

1185

1

1186

1

			// Assert precompile reports correct Charlie reward info.

1187

1

			Precompiles::new()

1188

1

				.prepare_test(

1189

1

					ALICE,

1190

1

					crowdloan_precompile_address,

1191

1

					CrowdloanRewardsPCall::reward_info {

1192

1

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

1193

1

},

1194

1

1195

1

				.expect_cost(3338)

1196

1

				.expect_no_logs()

1197

1

				.execute_returns((expected_total, expected_claimed));

1198

1

})

1199

1

1200

1201

#[test]

1202

1

fn update_reward_address_via_precompile() {

1203

1

	ExtBuilder::default()

1204

1

		.with_balances(vec![

1205

1

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

1206

1

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

1207

1

])

1208

1

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

1209

1

		.with_mappings(vec![(

1210

1

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

1211

1

			AccountId::from(ALICE),

1212

1

)])

1213

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1214

1

		.build()

1215

1

		.execute_with(|| {

1216

1

			// set parachain inherent data

1217

1

			set_parachain_inherent_data();

1218

1

			let init_block = CrowdloanRewards::init_vesting_block();

1219

1

			// This matches the previous vesting

1220

1

			let end_block = init_block + 4 * WEEKS;

1221

1

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

1222

1

			assert_ok!(

1223

1

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

1224

1

					calls: vec![

1225

1

						RuntimeCall::CrowdloanRewards(

1226

1

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

1227

1

								rewards: vec![(

1228

1

									[4u8; 32].into(),

1229

1

									Some(AccountId::from(CHARLIE)),

1230

1

									1_500_000 * MOVR

1231

1

)]

1232

1

1233

1

),

1234

1

						RuntimeCall::CrowdloanRewards(

1235

1

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

1236

1

								rewards: vec![(

1237

1

									[5u8; 32].into(),

1238

1

									Some(AccountId::from(DAVE)),

1239

1

									1_500_000 * MOVR

1240

1

)]

1241

1

1242

1

),

1243

1

						RuntimeCall::CrowdloanRewards(

1244

1

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

1245

1

								lease_ending_block: end_block

1246

1

1247

1

1248

1

1249

1

})

1250

1

				.dispatch(root_origin())

1251

1

);

1252

1253

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1254

1

1255

1

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

1256

1

			let gas_limit = 100000u64;

1257

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1258

1

1259

1

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

1260

1

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

1261

1

			call_data[0..4]

1262

1

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

1263

1

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

1264

1

1265

1

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

1266

1

				source: H160::from(CHARLIE),

1267

1

				target: crowdloan_precompile_address,

1268

1

				input: call_data,

1269

1

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

1270

1

				gas_limit,

1271

1

				max_fee_per_gas: gas_price,

1272

1

				max_priority_fee_per_gas: None,

1273

1

				nonce: None, // Use the next nonce

1274

1

				access_list: Vec::new(),

1275

1

				authorization_list: Vec::new(),

1276

1

})

1277

1

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

1278

1279

1

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

1280

1

			assert_eq!(

1281

1

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

1282

1

					.unwrap()

1283

1

					.claimed_reward,

1284

1

				(450_000 * MOVR)

1285

1

);

1286

1

})

1287

1

1288

1289

1

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

1290

1

where

1291

1

	F: FnMut() -> (),

1292

1

1293

1

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

1294

1

		.build_storage()

1295

1

		.unwrap()

1296

1

		.into();

1297

1

	t.execute_with(|| {

1298

1

		System::set_block_consumed_resources(w, 0);

1299

1

		assertions()

1300

1

});

1301

1

1302

1303

#[test]

1304

#[rustfmt::skip]

1305

1

fn length_fee_is_sensible() {

1306

	use sp_runtime::testing::TestXt;

1307

1308

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

1309

1

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

1310

1

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

1311

1

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

1312

1

1313

9

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

1314

9

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

1315

9

				.inclusion_fee

1316

9

				.expect("fee should be calculated")

1317

9

				.len_fee

1318

9

};

1319

1320

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

1321

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

1322

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

1323

		//                             |           |

1324

1

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

1325

1

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

1326

1

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

1327

1

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

1328

1

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

1329

1

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

1330

1

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

1331

1

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

1332

1

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

1333

1

});

1334

1

1335

1336

#[test]

1337

1

fn multiplier_can_grow_from_zero() {

1338

	use frame_support::traits::Get;

1339

1340

1

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

1341

1

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

1342

1

		* RuntimeBlockWeights::get()

1343

1

			.get(DispatchClass::Normal)

1344

1

			.max_total

1345

1

			.unwrap();

1346

1

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

1347

1

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

1348

1

	run_with_system_weight(target * 101 / 100, || {

1349

1

		let next =

1350

1

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

1351

1

		assert!(

1352

1

			next > minimum_multiplier,

1353

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

1354

			next,

1355

			minimum_multiplier

1356

);

1357

1

})

1358

1

1359

1360

#[test]

1361

1

fn ethereum_invalid_transaction() {

1362

1

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

1363

1

		set_parachain_inherent_data();

1364

1

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

1365

1

		// on chain is rejected.

1366

1

		assert_eq!(

1367

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1368

1

			Err(

1369

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1370

1

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

1371

1

1372

1

1373

1

);

1374

1

});

1375

1

1376

1377

#[test]

1378

1

fn initial_gas_fee_is_correct() {

1379

	use fp_evm::FeeCalculator;

1380

1381

1

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

1382

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1383

1

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

1384

1385

1

		assert_eq!(

1386

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1387

1

1388

1

				3_125_000_000u128.into(),

1389

1

				Weight::from_parts(41_742_000u64, 0)

1390

1

1391

1

);

1392

1

});

1393

1

1394

1395

#[test]

1396

1

fn min_gas_fee_is_correct() {

1397

	use fp_evm::FeeCalculator;

1398

	use frame_support::traits::Hooks;

1399

1400

1

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

1401

1

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

1402

1

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

1403

1

1404

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1405

1

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

1406

1407

1

		assert_eq!(

1408

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1409

1

			(312_500_000u128.into(), Weight::from_parts(41_742_000u64, 0))

1410

1

);

1411

1

});

1412

1

1413

1414

#[test]

1415

1

fn transfer_ed_0_substrate() {

1416

1

	ExtBuilder::default()

1417

1

		.with_balances(vec![

1418

1

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

1419

1

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

1420

1

])

1421

1

		.build()

1422

1

		.execute_with(|| {

1423

1

			// Substrate transfer

1424

1

			assert_ok!(Balances::transfer_allow_death(

1425

1

				origin_of(AccountId::from(ALICE)),

1426

1

				AccountId::from(BOB),

1427

1

				1 * MOVR,

1428

1

));

1429

			// 1 WEI is left in the account

1430

1

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

1431

1

});

1432

1

1433

1434

#[test]

1435

1

fn transfer_ed_0_evm() {

1436

1

	ExtBuilder::default()

1437

1

		.with_balances(vec![

1438

1

1439

1

				AccountId::from(ALICE),

1440

1

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

1441

1

),

1442

1

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

1443

1

])

1444

1

		.build()

1445

1

		.execute_with(|| {

1446

1

			set_parachain_inherent_data();

1447

1

			// EVM transfer

1448

1

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

1449

1

				source: H160::from(ALICE),

1450

1

				target: H160::from(BOB),

1451

1

				input: Vec::new(),

1452

1

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

1453

1

				gas_limit: 21_000u64,

1454

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1455

1

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

1456

1

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

1457

1

				access_list: Vec::new(),

1458

1

				authorization_list: Vec::new(),

1459

1

})

1460

1

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

1461

			// 1 WEI is left in the account

1462

1

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

1463

1

});

1464

1

1465

1466

#[test]

1467

1

fn refund_ed_0_evm() {

1468

1

	ExtBuilder::default()

1469

1

		.with_balances(vec![

1470

1

1471

1

				AccountId::from(ALICE),

1472

1

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

1473

1

),

1474

1

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

1475

1

])

1476

1

		.build()

1477

1

		.execute_with(|| {

1478

1

			set_parachain_inherent_data();

1479

1

			// EVM transfer that zeroes ALICE

1480

1

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

1481

1

				source: H160::from(ALICE),

1482

1

				target: H160::from(BOB),

1483

1

				input: Vec::new(),

1484

1

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

1485

1

				gas_limit: 21_777u64,

1486

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1487

1

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

1488

1

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

1489

1

				access_list: Vec::new(),

1490

1

				authorization_list: Vec::new(),

1491

1

})

1492

1

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

1493

			// ALICE is refunded

1494

1

			assert_eq!(

1495

1

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

1496

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

1497

1

);

1498

1

});

1499

1

1500

1501

#[test]

1502

1

fn author_does_receive_priority_fee() {

1503

1

	ExtBuilder::default()

1504

1

		.with_balances(vec![(

1505

1

			AccountId::from(BOB),

1506

1

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

1507

1

)])

1508

1

		.build()

1509

1

		.execute_with(|| {

1510

1

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

1511

1

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

1512

1

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

1513

1

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

1514

1

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

1515

1

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

1516

1

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

1517

1

1518

1

			// EVM transfer.

1519

1

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

1520

1

				source: H160::from(BOB),

1521

1

				target: H160::from(ALICE),

1522

1

				input: Vec::new(),

1523

1

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

1524

1

				gas_limit: 21_000u64,

1525

1

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

1526

1

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

1527

1

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

1528

1

				access_list: Vec::new(),

1529

1

				authorization_list: Vec::new(),

1530

1

})

1531

1

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

1532

1533

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1534

1

			// Author free balance increased by priority fee.

1535

1

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

1536

1

});

1537

1

1538

1539

#[test]

1540

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1541

	use fp_evm::FeeCalculator;

1542

1

	ExtBuilder::default()

1543

1

		.with_balances(vec![

1544

1

1545

1

				AccountId::from(BOB),

1546

1

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

1547

1

),

1548

1

1549

1

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

1550

1

				existential_deposit(),

1551

1

),

1552

1

])

1553

1

		.build()

1554

1

		.execute_with(|| {

1555

1

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

1556

1

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

1557

1

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

1558

1

			// EVM transfer.

1559

1

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

1560

1

				source: H160::from(BOB),

1561

1

				target: H160::from(ALICE),

1562

1

				input: Vec::new(),

1563

1

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

1564

1

				gas_limit: 21_000u64,

1565

1

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

1566

1

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

1567

1

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

1568

1

				access_list: Vec::new(),

1569

1

				authorization_list: Vec::new(),

1570

1

})

1571

1

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

1572

1573

1

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

1574

1

1575

1

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

1576

1

1577

1

			let base_fee: Balance = base_fee * 21_000;

1578

1

1579

1

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

1580

1

1581

1

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

1582

1

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

1583

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1584

1

1585

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1586

1587

1

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

1588

1

});

1589

1

1590

1591

#[test]

1592

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1593

	use fp_evm::FeeCalculator;

1594

1

	ExtBuilder::default()

1595

1

		.with_balances(vec![

1596

1

1597

1

				AccountId::from(BOB),

1598

1

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

1599

1

),

1600

1

1601

1

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

1602

1

				existential_deposit(),

1603

1

),

1604

1

])

1605

1

		.build()

1606

1

		.execute_with(|| {

1607

1

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

1608

1

			// EVM transfer.

1609

1

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

1610

1

				source: H160::from(BOB),

1611

1

				target: H160::from(ALICE),

1612

1

				input: Vec::new(),

1613

1

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

1614

1

				gas_limit: 21_000u64,

1615

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1616

1

				max_priority_fee_per_gas: None,

1617

1

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

1618

1

				access_list: Vec::new(),

1619

1

				authorization_list: Vec::new(),

1620

1

})

1621

1

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

1622

1623

1

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

1624

1

1625

1

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

1626

1

1627

1

			let base_fee: Balance = base_fee * 21_000;

1628

1

1629

1

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

1630

1

1631

1

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

1632

1

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

1633

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1634

1

1635

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1636

1637

1

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

1638

1

});

1639

1

1640

1641

#[test]

1642

1

fn root_can_change_default_xcm_vers() {

1643

1

	ExtBuilder::default()

1644

1

		.with_balances(vec![

1645

1

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

1646

1

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

1647

1

])

1648

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1649

1

			asset_id: 1,

1650

1

			xcm_location: AssetHubLocation::get(),

1651

1

			name: "Dot",

1652

1

			symbol: "Dot",

1653

1

			decimals: 12,

1654

1

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

1655

1

}])

1656

1

		.build()

1657

1

		.execute_with(|| {

1658

1

			let source_id: moonriver_runtime::AssetId = 1;

1659

1

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

1660

1

			let asset = Asset {

1661

1

				id: AssetId(

1662

1

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

1663

1

						currency_id,

1664

1

1665

1

					.unwrap(),

1666

1

),

1667

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1668

1

};

1669

1

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

1670

1

			// know with which version to send

1671

1

			assert_noop!(

1672

1

				PolkadotXcm::transfer_assets(

1673

1

					origin_of(AccountId::from(ALICE)),

1674

1

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

1675

1

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

1676

1

						parents: 0,

1677

1

						interior: [AccountId32 {

1678

1

							network: None,

1679

1

							id: [1u8; 32],

1680

1

}]

1681

1

						.into(),

1682

1

					})),

1683

1

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

1684

1

0,

1685

1

					WeightLimit::Unlimited

1686

1

),

1687

1

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

1688

1

);

1689

1690

			// Root sets the defaultXcm

1691

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1692

1

				root_origin(),

1693

1

				Some(3)

1694

1

));

1695

1696

			// Now transferring does not fail

1697

1

			assert_ok!(PolkadotXcm::transfer_assets(

1698

1

				origin_of(AccountId::from(ALICE)),

1699

1

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

1700

1

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

1701

1

					parents: 0,

1702

1

					interior: [AccountId32 {

1703

1

						network: None,

1704

1

						id: [1u8; 32],

1705

1

}]

1706

1

					.into(),

1707

1

				})),

1708

1

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

1709

1

0,

1710

1

				WeightLimit::Unlimited

1711

1

));

1712

1

})

1713

1

1714

1715

#[test]

1716

1

fn asset_can_be_registered() {

1717

1

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

1718

1

		let source_location = Location::parent();

1719

1

		let source_id = 1;

1720

1

1721

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1722

1

			moonriver_runtime::RuntimeOrigin::root(),

1723

1

			source_id,

1724

1

			source_location.clone(),

1725

1

12,

1726

1

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

1727

1

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

1728

1

));

1729

1730

		// Check that the asset was created

1731

		// First check if the asset ID exists

1732

1

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

1733

1

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

1734

1735

		// Then check the status using AssetsByLocation

1736

1

		let (asset_id, status) =

1737

1

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

1738

1

		assert_eq!(asset_id, source_id);

1739

1

		assert_eq!(status, AssetStatus::Active);

1740

1

});

1741

1

1742

1743

#[test]

1744

1

fn create_and_manipulate_foreign_asset_using_root() {

1745

1

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

1746

1

		let source_location = Location::parent();

1747

1

1748

1

		// Create foreign asset

1749

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1750

1

			moonriver_runtime::RuntimeOrigin::root(),

1751

1

1,

1752

1

			source_location.clone(),

1753

1

12,

1754

1

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

1755

1

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

1756

1

));

1757

1

		assert_eq!(

1758

1

			EvmForeignAssets::assets_by_id(1),

1759

1

			Some(source_location.clone())

1760

1

);

1761

1

		assert_eq!(

1762

1

			EvmForeignAssets::assets_by_location(&source_location),

1763

1

			Some((1, AssetStatus::Active))

1764

1

);

1765

1766

		// Freeze foreign asset

1767

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1768

1

			moonriver_runtime::RuntimeOrigin::root(),

1769

1

1,

1770

1

			true

1771

1

));

1772

1

		assert_eq!(

1773

1

			EvmForeignAssets::assets_by_location(&source_location),

1774

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1775

1

);

1776

1777

		// Unfreeze foreign asset

1778

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1779

1

			moonriver_runtime::RuntimeOrigin::root(),

1780

1

1,

1781

1

));

1782

1

		assert_eq!(

1783

1

			EvmForeignAssets::assets_by_location(&source_location),

1784

1

			Some((1, AssetStatus::Active))

1785

1

);

1786

1

});

1787

1

1788

1789

#[test]

1790

1

fn create_and_manipulate_foreign_asset_using_sibling() {

1791

1

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

1792

1

		let asset_location: Location = (Parent, Parachain(1), PalletInstance(3)).into();

1793

1

		let para_location = asset_location.chain_location();

1794

1

		let para_account =

1795

1

			LocationToAccountId::convert_location(&para_location).expect("Cannot convert location");

1796

1

1797

1

		let deposit = dynamic_params::xcm_config::ForeignAssetCreationDeposit::get();

1798

1

		Balances::make_free_balance_be(&para_account, deposit * 2);

1799

1

1800

1

		// Create foreign asset

1801

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1802

1

			pallet_xcm::Origin::Xcm(para_location.clone()).into(),

1803

1

1,

1804

1

			asset_location.clone(),

1805

1

12,

1806

1

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

1807

1

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

1808

1

));

1809

1810

		// deposit is taken from the account

1811

1

		assert_eq!(Balances::free_balance(&para_account), deposit);

1812

1813

1

		assert_eq!(

1814

1

			EvmForeignAssets::assets_by_id(1),

1815

1

			Some(asset_location.clone())

1816

1

);

1817

1

		assert_eq!(

1818

1

			EvmForeignAssets::assets_by_location(&asset_location),

1819

1

			Some((1, AssetStatus::Active))

1820

1

);

1821

1822

		// Freeze foreign asset

1823

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1824

1

			pallet_xcm::Origin::Xcm(para_location.clone()).into(),

1825

1

1,

1826

1

			true

1827

1

));

1828

1

		assert_eq!(

1829

1

			EvmForeignAssets::assets_by_location(&asset_location),

1830

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1831

1

);

1832

1833

		// Unfreeze foreign asset

1834

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1835

1

			pallet_xcm::Origin::Xcm(para_location.clone()).into(),

1836

1

1,

1837

1

));

1838

1

		assert_eq!(

1839

1

			EvmForeignAssets::assets_by_location(&asset_location),

1840

1

			Some((1, AssetStatus::Active))

1841

1

);

1842

1

});

1843

1

1844

1845

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

1846

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

1847

/*

1848

#[test]

1849

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1850

	ExtBuilder::default()

1851

		.with_xcm_assets(vec![XcmAssetInitialization {

1852

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

1853

			metadata: AssetRegistrarMetadata {

1854

				name: b"RelayToken".to_vec(),

1855

				symbol: b"Relay".to_vec(),

1856

				decimals: 12,

1857

				is_frozen: false,

1858

},

1859

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

1860

			is_sufficient: true,

1861

}])

1862

		.with_balances(vec![

1863

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

1864

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

1865

])

1866

		.build()

1867

		.execute_with(|| {

1868

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

1869

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

1870

1871

			// Its address is

1872

			let asset_precompile_address = Runtime::asset_id_to_account(

1873

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1874

				relay_asset_id,

1875

);

1876

1877

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

1878

			assert_eq!(

1879

				moonriver_runtime::Assets::total_supply(relay_asset_id),

1880

				1_000 * MOVR

1881

);

1882

1883

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

1884

			Precompiles::new()

1885

				.prepare_test(

1886

					ALICE,

1887

					asset_precompile_address,

1888

					ForeignAssetsPCall::total_supply {},

1889

1890

				.expect_cost(5007)

1891

				.expect_no_logs()

1892

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

1893

1894

			// Access balanceOf through precompile

1895

			Precompiles::new()

1896

				.prepare_test(

1897

					ALICE,

1898

					asset_precompile_address,

1899

					ForeignAssetsPCall::balance_of {

1900

						who: Address(ALICE.into()),

1901

},

1902

1903

				.expect_cost(5007)

1904

				.expect_no_logs()

1905

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

1906

});

1907

1908

1909

#[test]

1910

fn xcm_asset_erc20_precompiles_transfer() {

1911

	ExtBuilder::default()

1912

		.with_xcm_assets(vec![XcmAssetInitialization {

1913

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

1914

			metadata: AssetRegistrarMetadata {

1915

				name: b"RelayToken".to_vec(),

1916

				symbol: b"Relay".to_vec(),

1917

				decimals: 12,

1918

				is_frozen: false,

1919

},

1920

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

1921

			is_sufficient: true,

1922

}])

1923

		.with_balances(vec![

1924

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

1925

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

1926

])

1927

		.build()

1928

		.execute_with(|| {

1929

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

1930

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

1931

1932

			// Its address is

1933

			let asset_precompile_address = Runtime::asset_id_to_account(

1934

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1935

				relay_asset_id,

1936

);

1937

1938

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

1939

			Precompiles::new()

1940

				.prepare_test(

1941

					ALICE,

1942

					asset_precompile_address,

1943

					ForeignAssetsPCall::transfer {

1944

						to: Address(BOB.into()),

1945

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

1946

},

1947

1948

				.expect_cost(26587)

1949

				.expect_log(log3(

1950

					asset_precompile_address,

1951

					SELECTOR_LOG_TRANSFER,

1952

					H160::from(ALICE),

1953

					H160::from(BOB),

1954

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

1955

))

1956

				.execute_returns(true);

1957

1958

			// Make sure BOB has 400 MOVR

1959

			Precompiles::new()

1960

				.prepare_test(

1961

					BOB,

1962

					asset_precompile_address,

1963

					ForeignAssetsPCall::balance_of {

1964

						who: Address(BOB.into()),

1965

},

1966

1967

				.expect_cost(5007)

1968

				.expect_no_logs()

1969

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

1970

});

1971

1972

1973

#[test]

1974

fn xcm_asset_erc20_precompiles_approve() {

1975

	ExtBuilder::default()

1976

		.with_xcm_assets(vec![XcmAssetInitialization {

1977

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

1978

			metadata: AssetRegistrarMetadata {

1979

				name: b"RelayToken".to_vec(),

1980

				symbol: b"Relay".to_vec(),

1981

				decimals: 12,

1982

				is_frozen: false,

1983

},

1984

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

1985

			is_sufficient: true,

1986

}])

1987

		.with_balances(vec![

1988

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

1989

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

1990

])

1991

		.build()

1992

		.execute_with(|| {

1993

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

1994

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

1995

1996

			// Its address is

1997

			let asset_precompile_address = Runtime::asset_id_to_account(

1998

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1999

				relay_asset_id,

2000

);

2001

2002

			// Aprove Bob for spending 400 MOVR from Alice

2003

			Precompiles::new()

2004

				.prepare_test(

2005

					ALICE,

2006

					asset_precompile_address,

2007

					ForeignAssetsPCall::approve {

2008

						spender: Address(BOB.into()),

2009

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

2010

},

2011

2012

				.expect_cost(17323)

2013

				.expect_log(log3(

2014

					asset_precompile_address,

2015

					SELECTOR_LOG_APPROVAL,

2016

					H160::from(ALICE),

2017

					H160::from(BOB),

2018

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

2019

))

2020

				.execute_returns(true);

2021

2022

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

2023

			Precompiles::new()

2024

				.prepare_test(

2025

					BOB,

2026

					asset_precompile_address,

2027

					ForeignAssetsPCall::transfer_from {

2028

						from: Address(ALICE.into()),

2029

						to: Address(CHARLIE.into()),

2030

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

2031

},

2032

2033

				.expect_cost(31873)

2034

				.expect_log(log3(

2035

					asset_precompile_address,

2036

					SELECTOR_LOG_TRANSFER,

2037

					H160::from(ALICE),

2038

					H160::from(CHARLIE),

2039

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

2040

))

2041

				.execute_returns(true);

2042

2043

			// Make sure CHARLIE has 400 MOVR

2044

			Precompiles::new()

2045

				.prepare_test(

2046

					CHARLIE,

2047

					asset_precompile_address,

2048

					ForeignAssetsPCall::balance_of {

2049

						who: Address(CHARLIE.into()),

2050

},

2051

2052

				.expect_cost(5007)

2053

				.expect_no_logs()

2054

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

2055

});

2056

}*/

2057

2058

#[test]

2059

1

fn make_sure_polkadot_xcm_cannot_be_called() {

2060

1

	ExtBuilder::default()

2061

1

		.with_balances(vec![

2062

1

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

2063

1

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

2064

1

])

2065

1

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

2066

1

		.with_mappings(vec![(

2067

1

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

2068

1

			AccountId::from(ALICE),

2069

1

)])

2070

1

		.build()

2071

1

		.execute_with(|| {

2072

1

			let dest = Location {

2073

1

				parents: 1,

2074

1

				interior: [AccountId32 {

2075

1

					network: None,

2076

1

					id: [1u8; 32],

2077

1

}]

2078

1

				.into(),

2079

1

};

2080

1

			let assets: Assets = [Asset {

2081

1

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

2082

1

				fun: Fungible(1000),

2083

1

}]

2084

1

			.to_vec()

2085

1

			.into();

2086

1

			assert_noop!(

2087

1

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

2088

1

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

2089

1

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

2090

1

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

2091

1

					fee_asset_item: 0,

2092

1

})

2093

1

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

2094

1

					AccountId::from(ALICE)

2095

1

)),

2096

1

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

2097

1

);

2098

1

});

2099

1

2100

2101

#[test]

2102

1

fn transactor_cannot_use_more_than_max_weight() {

2103

1

	ExtBuilder::default()

2104

1

		.with_balances(vec![

2105

1

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

2106

1

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

2107

1

])

2108

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2109

1

			asset_id: 1,

2110

1

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

2111

1

			name: "RelayToken",

2112

1

			symbol: "Relay",

2113

1

			decimals: 12,

2114

1

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

2115

1

}])

2116

1

		.build()

2117

1

		.execute_with(|| {

2118

1

			let source_id: moonriver_runtime::AssetId = 1;

2119

1

			assert_ok!(XcmTransactor::register(

2120

1

				root_origin(),

2121

1

				AccountId::from(ALICE),

2122

1

0,

2123

1

));

2124

2125

			// Root can set transact info

2126

1

			assert_ok!(XcmTransactor::set_transact_info(

2127

1

				root_origin(),

2128

1

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

2129

1

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

2130

1

				3000.into(),

2131

1

				20000.into(),

2132

1

				None

2133

1

));

2134

			// Root can set transact info

2135

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2136

1

				root_origin(),

2137

1

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

2138

1

1,

2139

1

));

2140

2141

1

			assert_noop!(

2142

1

				XcmTransactor::transact_through_derivative(

2143

1

					origin_of(AccountId::from(ALICE)),

2144

1

					moonriver_runtime::xcm_config::Transactors::Relay,

2145

1

0,

2146

1

					CurrencyPayment {

2147

1

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

2148

1

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

2149

1

)),

2150

1

						fee_amount: None

2151

1

},

2152

1

					vec![],

2153

1

					// 20000 is the max

2154

1

					TransactWeights {

2155

1

						transact_required_weight_at_most: 17001.into(),

2156

1

						overall_weight: None

2157

1

},

2158

1

					false

2159

1

),

2160

1

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

2161

1

);

2162

1

			assert_noop!(

2163

1

				XcmTransactor::transact_through_derivative(

2164

1

					origin_of(AccountId::from(ALICE)),

2165

1

					moonriver_runtime::xcm_config::Transactors::Relay,

2166

1

0,

2167

1

					CurrencyPayment {

2168

1

						currency: Currency::AsCurrencyId(

2169

1

							moonriver_runtime::xcm_config::CurrencyId::ForeignAsset(source_id)

2170

1

),

2171

1

						fee_amount: None

2172

1

},

2173

1

					vec![],

2174

1

					// 20000 is the max

2175

1

					TransactWeights {

2176

1

						transact_required_weight_at_most: 17001.into(),

2177

1

						overall_weight: None

2178

1

},

2179

1

					false

2180

1

),

2181

1

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

2182

1

);

2183

1

})

2184

1

2185

2186

#[test]

2187

1

fn transact_through_signed_precompile_works_v2() {

2188

1

	ExtBuilder::default()

2189

1

		.with_balances(vec![

2190

1

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

2191

1

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

2192

1

])

2193

1

		.with_safe_xcm_version(3)

2194

1

		.build()

2195

1

		.execute_with(|| {

2196

1

			// Destination

2197

1

			let dest = Location::parent();

2198

1

2199

1

			let fee_payer_asset = Location::parent();

2200

1

2201

1

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

2202

1

2203

1

			let total_weight = 1_000_000_000u64;

2204

1

2205

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2206

1

2207

1

			Precompiles::new()

2208

1

				.prepare_test(

2209

1

					ALICE,

2210

1

					xcm_transactor_v2_precompile_address,

2211

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2212

1

						dest,

2213

1

						fee_asset: fee_payer_asset,

2214

1

						weight: 4_000_000,

2215

1

						call: bytes.into(),

2216

1

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

2217

1

						overall_weight: total_weight,

2218

1

},

2219

1

2220

1

				.expect_cost(23525)

2221

1

				.expect_no_logs()

2222

1

				.execute_returns(());

2223

1

});

2224

1

2225

2226

#[test]

2227

1

fn transact_through_signed_cannot_send_to_local_chain() {

2228

1

	ExtBuilder::default()

2229

1

		.with_balances(vec![

2230

1

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

2231

1

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

2232

1

])

2233

1

		.with_safe_xcm_version(3)

2234

1

		.build()

2235

1

		.execute_with(|| {

2236

1

			// Destination

2237

1

			let dest = Location::here();

2238

1

2239

1

			let fee_payer_asset = Location::parent();

2240

1

2241

1

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

2242

1

2243

1

			let total_weight = 1_000_000_000u64;

2244

1

2245

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2246

1

2247

1

			Precompiles::new()

2248

1

				.prepare_test(

2249

1

					ALICE,

2250

1

					xcm_transactor_v2_precompile_address,

2251

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2252

1

						dest,

2253

1

						fee_asset: fee_payer_asset,

2254

1

						weight: 4_000_000,

2255

1

						call: bytes.into(),

2256

1

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

2257

1

						overall_weight: total_weight,

2258

1

},

2259

1

2260

1

				.execute_reverts(|output| {

2261

1

					from_utf8(&output)

2262

1

						.unwrap()

2263

1

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

2264

1

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

2265

1

});

2266

1

});

2267

1

2268

2269

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

2270

#[test]

2271

1

fn call_pallet_xcm_with_fee() {

2272

1

	let asset_id = 1;

2273

1

	ExtBuilder::default()

2274

1

		.with_balances(vec![

2275

1

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

2276

1

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

2277

1

])

2278

1

		.with_safe_xcm_version(3)

2279

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2280

1

			asset_id,

2281

1

			xcm_location: AssetHubLocation::get(),

2282

1

			name: "Dot",

2283

1

			symbol: "Dot",

2284

1

			decimals: 12,

2285

1

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

2286

1

}])

2287

1

		.build()

2288

1

		.execute_with(|| {

2289

1

			let dest = Location {

2290

1

				parents: 1,

2291

1

				interior: [AccountId32 {

2292

1

					network: None,

2293

1

					id: [1u8; 32],

2294

1

}]

2295

1

				.into(),

2296

1

};

2297

1

2298

1

			let before_balance =

2299

1

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

2300

1

			let (chain_part, beneficiary) =

2301

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2302

1

			let asset_amount = 100_000_000_000_000u128;

2303

1

			let asset_fee_amount = 100u128;

2304

1

2305

1

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

2306

1

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

2307

1

2308

1

			// We are able to transfer with fee

2309

1

			assert_ok!(PolkadotXcm::transfer_assets(

2310

1

				origin_of(AccountId::from(ALICE)),

2311

1

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

2312

1

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

2313

1

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

2314

1

0,

2315

1

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

2316

1

			),);

2317

2318

1

			let after_balance =

2319

1

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

2320

1

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

2321

1

			assert_eq!(

2322

1

				before_balance

2323

1

					.saturating_sub(asset_amount.into())

2324

1

					.saturating_sub(asset_fee_amount.into()),

2325

1

				after_balance

2326

1

);

2327

1

});

2328

1

2329

2330

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

2331

#[test]

2332

1

fn call_pallet_xcm_with_fee_after_ahm() {

2333

1

	let asset_id = 1;

2334

1

	ExtBuilder::default()

2335

1

		.asset_hub_migration_has_started()

2336

1

		.with_balances(vec![

2337

1

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

2338

1

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

2339

1

])

2340

1

		.with_safe_xcm_version(3)

2341

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2342

1

			asset_id,

2343

1

			xcm_location: Location::parent(),

2344

1

			name: "RelayToken",

2345

1

			symbol: "Relay",

2346

1

			decimals: 12,

2347

1

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

2348

1

}])

2349

1

		.build()

2350

1

		.execute_with(|| {

2351

1

			let dest = Location {

2352

1

				parents: 1,

2353

1

				interior: [AccountId32 {

2354

1

					network: None,

2355

1

					id: [1u8; 32],

2356

1

}]

2357

1

				.into(),

2358

1

};

2359

1

2360

1

			let before_balance =

2361

1

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

2362

1

			let (chain_part, beneficiary) =

2363

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2364

1

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

2365

1

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

2366

1

2367

1

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

2368

1

			assert_noop!(

2369

1

				PolkadotXcm::transfer_assets(

2370

1

					origin_of(AccountId::from(ALICE)),

2371

1

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

2372

1

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

2373

1

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

2374

1

0,

2375

1

					WeightLimit::Limited(4000000000.into())

2376

1

),

2377

1

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

2378

1

);

2379

2380

1

			let after_balance =

2381

1

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

2382

1

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

2383

1

			assert_eq!(before_balance, after_balance);

2384

1

});

2385

1

2386

2387

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

2388

#[test]

2389

1

fn call_pallet_xcm_with_fee_before_ahm() {

2390

1

	let asset_id = 1;

2391

1

	ExtBuilder::default()

2392

1

		.with_balances(vec![

2393

1

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

2394

1

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

2395

1

])

2396

1

		.with_safe_xcm_version(3)

2397

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2398

1

			asset_id,

2399

1

			xcm_location: Location::parent(),

2400

1

			name: "RelayToken",

2401

1

			symbol: "Relay",

2402

1

			decimals: 12,

2403

1

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

2404

1

}])

2405

1

		.build()

2406

1

		.execute_with(|| {

2407

1

			let dest = Location {

2408

1

				parents: 1,

2409

1

				interior: [AccountId32 {

2410

1

					network: None,

2411

1

					id: [1u8; 32],

2412

1

}]

2413

1

				.into(),

2414

1

};

2415

1

2416

1

			let before_balance =

2417

1

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

2418

1

			let (chain_part, beneficiary) =

2419

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2420

1

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

2421

1

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

2422

1

			// We are able to transfer with fee

2423

1

			assert_ok!(PolkadotXcm::transfer_assets(

2424

1

				origin_of(AccountId::from(ALICE)),

2425

1

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

2426

1

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

2427

1

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

2428

1

0,

2429

1

				WeightLimit::Limited(4000000000.into())

2430

1

));

2431

2432

1

			let after_balance =

2433

1

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

2434

1

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

2435

1

			assert_eq!(

2436

1

				before_balance - 100_000_000_000_000u128 - 100u128,

2437

1

				after_balance

2438

1

);

2439

1

});

2440

1

2441

2442

#[test]

2443

1

fn test_xcm_utils_ml_tp_account() {

2444

1

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

2445

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2446

1

		let expected_address_parent: H160 =

2447

1

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

2448

1

				.unwrap()

2449

1

				.into();

2450

1

2451

1

		Precompiles::new()

2452

1

			.prepare_test(

2453

1

				ALICE,

2454

1

				xcm_utils_precompile_address,

2455

1

				XcmUtilsPCall::multilocation_to_address {

2456

1

					location: Location::parent(),

2457

1

},

2458

1

2459

1

			.expect_cost(3338)

2460

1

			.expect_no_logs()

2461

1

			.execute_returns(Address(expected_address_parent));

2462

1

2463

1

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

2464

1

		let expected_address_parachain: H160 =

2465

1

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

2466

1

				&parachain_2000_multilocation,

2467

1

2468

1

			.unwrap()

2469

1

			.into();

2470

1

2471

1

		Precompiles::new()

2472

1

			.prepare_test(

2473

1

				ALICE,

2474

1

				xcm_utils_precompile_address,

2475

1

				XcmUtilsPCall::multilocation_to_address {

2476

1

					location: parachain_2000_multilocation,

2477

1

},

2478

1

2479

1

			.expect_cost(3338)

2480

1

			.expect_no_logs()

2481

1

			.execute_returns(Address(expected_address_parachain));

2482

1

2483

1

		let alice_in_parachain_2000_location = Location::new(

2484

1

1,

2485

1

2486

1

				Parachain(2000),

2487

1

				AccountKey20 {

2488

1

					network: None,

2489

1

					key: ALICE,

2490

1

},

2491

1

],

2492

1

);

2493

1

		let expected_address_alice_in_parachain_2000 =

2494

1

			xcm_builder::HashedDescription::<

2495

1

				AccountId,

2496

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2497

1

			>::convert_location(&alice_in_parachain_2000_location)

2498

1

			.unwrap()

2499

1

			.into();

2500

1

2501

1

		Precompiles::new()

2502

1

			.prepare_test(

2503

1

				ALICE,

2504

1

				xcm_utils_precompile_address,

2505

1

				XcmUtilsPCall::multilocation_to_address {

2506

1

					location: alice_in_parachain_2000_location,

2507

1

},

2508

1

2509

1

			.expect_cost(3338)

2510

1

			.expect_no_logs()

2511

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2512

1

});

2513

1

2514

2515

#[test]

2516

1

fn test_nested_batch_calls_from_xcm_transact() {

2517

1

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

2518

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2519

1

		// in a future polkadot-sdk version

2520

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2521

2522

1

		let mut valid_nested_calls =

2523

1

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

2524

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2525

8

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

2526

8

				calls: vec![valid_nested_calls],

2527

8

});

2528

8

2529

2530

1

		let valid_message = Xcm(vec![Transact {

2531

1

			origin_kind: OriginKind::SovereignAccount,

2532

1

			fallback_max_weight: None,

2533

1

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

2534

1

		}]);

2535

1

2536

1

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

2537

2538

1

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

2539

1

			calls: vec![valid_nested_calls],

2540

1

});

2541

1

2542

1

		let invalid_message = Xcm(vec![Transact {

2543

1

			origin_kind: OriginKind::SovereignAccount,

2544

1

			fallback_max_weight: None,

2545

1

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

2546

1

		}]);

2547

1

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

2548

1

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

2549

1

});

2550

1

2551

2552

#[test]

2553

1

fn test_xcm_utils_weight_message() {

2554

1

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

2555

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2556

1

		let expected_weight =

2557

1

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

2558

1

2559

1

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

2560

1

2561

1

		let input = XcmUtilsPCall::weight_message {

2562

1

			message: message.into(),

2563

1

};

2564

1

2565

1

		Precompiles::new()

2566

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2567

1

			.expect_cost(1669)

2568

1

			.expect_no_logs()

2569

1

			.execute_returns(expected_weight);

2570

1

});

2571

1

2572

2573

#[test]

2574

1

fn test_xcm_utils_get_units_per_second() {

2575

1

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

2576

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2577

1

		let location = SelfReserve::get();

2578

1

2579

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2580

1

2581

1

		let expected_units =

2582

1

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

2583

1

2584

1

		Precompiles::new()

2585

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2586

1

			.expect_cost(3338)

2587

1

			.expect_no_logs()

2588

1

			.execute_returns(expected_units);

2589

1

});

2590

1

2591

2592

#[test]

2593

1

fn precompile_existence() {

2594

1

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

2595

1

		let precompiles = Precompiles::new();

2596

1

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

2597

1

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

2598

1

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

2599

1

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

2600

1

2601

1

		.into_iter()

2602

1

		.map(H160::from_low_u64_be)

2603

1

		.collect();

2604

2605

3001

		for i in 0..3000 {

2606

3000

			let address = H160::from_low_u64_be(i);

2607

3000

2608

3000

			if precompile_addresses.contains(&address) {

2609

47

				assert!(

2610

47

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

2611

					"is_precompile({}) should return true",

2612

2613

);

2614

2615

47

				assert!(

2616

47

					precompiles

2617

47

						.execute(&mut MockHandle::new(

2618

47

							address,

2619

47

							Context {

2620

47

								address,

2621

47

								caller: H160::zero(),

2622

47

								apparent_value: U256::zero()

2623

47

2624

47

),)

2625

47

						.is_some(),

2626

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

2627

2628

);

2629

			} else {

2630

2953

				assert!(

2631

2953

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

2632

					"is_precompile({}) should return false",

2633

2634

);

2635

2636

2953

				assert!(

2637

2953

					precompiles

2638

2953

						.execute(&mut MockHandle::new(

2639

2953

							address,

2640

2953

							Context {

2641

2953

								address,

2642

2953

								caller: H160::zero(),

2643

2953

								apparent_value: U256::zero()

2644

2953

2645

2953

),)

2646

2953

						.is_none(),

2647

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

2648

2649

);

2650

2651

2652

1

});

2653

1

2654

2655

#[test]

2656

1

fn removed_precompiles() {

2657

1

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

2658

1

		let precompiles = Precompiles::new();

2659

1

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

2660

2661

3000

		for i in 1..3000 {

2662

2999

			let address = H160::from_low_u64_be(i);

2663

2999

2664

2999

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

2665

2952

				continue;

2666

47

2667

47

2668

47

			if !removed_precompiles.contains(&i) {

2669

43

				assert!(

2670

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2671

43

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

2672

						_ => false,

2673

},

2674

					"{i} should be an active precompile"

2675

);

2676

43

				continue;

2677

4

2678

4

2679

4

			assert!(

2680

4

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

2681

4

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

2682

					_ => false,

2683

},

2684

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

2685

);

2686

2687

4

			precompiles

2688

4

				.prepare_test(Alice, address, [])

2689

4

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

2690

4

2691

1

})

2692

1

2693

2694

#[test]

2695

1

fn deal_with_fees_handles_tip() {

2696

	use frame_support::traits::OnUnbalanced;

2697

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2698

	use moonriver_runtime::Treasury;

2699

2700

1

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

2701

1

		set_parachain_inherent_data();

2702

1

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

2703

1

		// in the Moonriver runtime. It verifies that:

2704

1

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

2705

1

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

2706

1

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

2707

1

2708

1

		// The test details:

2709

1

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

2710

1

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

2711

1

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

2712

1

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

2713

1

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

2714

1

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

2715

1

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

2716

1

2717

1

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

2718

1

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

2719

1

			AccountId,

2720

1

		>>::issue(100);

2721

1

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

2722

1

			AccountId,

2723

1

		>>::issue(1000);

2724

1

2725

1

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

2726

1

		let total_supply_before = Balances::total_issuance();

2727

1

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

2728

1

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

2729

1

		assert_eq!(total_supply_before, 1_100);

2730

1

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

2731

2732

		// Step 3: Execute the fees handling logic.

2733

1

		DealWithSubstrateFeesAndTip::<

2734

1

			Runtime,

2735

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2736

1

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

2737

1

2738

1

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

2739

1

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

2740

1

2741

1

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

2742

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2743

1

2744

1

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

2745

1

		assert_eq!(

2746

1

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

2747

1

			treasury_fee_part,

2748

1

);

2749

2750

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

2751

1

		let total_supply_after = Balances::total_issuance();

2752

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2753

2754

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

2755

1

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

2756

1

		assert_eq!(

2757

1

			block_author_balance_after - block_author_balance_before,

2758

1

			1000,

2759

1

);

2760

1

});

2761

1

2762

2763

#[test]

2764

1

fn evm_revert_substrate_events() {

2765

1

	ExtBuilder::default()

2766

1

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

2767

1

		.build()

2768

1

		.execute_with(|| {

2769

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2770

1

2771

1

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

2772

1

			// Thus BatchAll will revert the transfer.

2773

1

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

2774

1

				source: ALICE.into(),

2775

1

				target: batch_precompile_address,

2776

1

				input: BatchPCall::batch_all {

2777

1

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

2778

1

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

2779

1

					call_data: vec![].into(),

2780

1

					gas_limit: vec![].into()

2781

1

2782

1

				.into(),

2783

1

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

2784

1

				gas_limit: 500_000,

2785

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2786

1

				max_priority_fee_per_gas: None,

2787

1

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

2788

1

				access_list: Vec::new(),

2789

1

				authorization_list: Vec::new(),

2790

1

})

2791

1

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

2792

2793

1

			let transfer_count = System::events()

2794

1

				.iter()

2795

4

				.filter(|r| match r.event {

2796

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

2797

6

					_ => false,

2798

6

})

2799

1

				.count();

2800

1

2801

1

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

2802

1

});

2803

1

2804

2805

#[test]

2806

1

fn evm_success_keeps_substrate_events() {

2807

1

	ExtBuilder::default()

2808

1

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

2809

1

		.build()

2810

1

		.execute_with(|| {

2811

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2812

1

2813

1

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

2814

1

				source: ALICE.into(),

2815

1

				target: batch_precompile_address,

2816

1

				input: BatchPCall::batch_all {

2817

1

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

2818

1

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

2819

1

					call_data: vec![].into(),

2820

1

					gas_limit: vec![].into()

2821

1

2822

1

				.into(),

2823

1

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

2824

1

				gas_limit: 500_000,

2825

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2826

1

				max_priority_fee_per_gas: None,

2827

1

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

2828

1

				access_list: Vec::new(),

2829

1

				authorization_list: Vec::new(),

2830

1

})

2831

1

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

2832

2833

1

			let transfer_count = System::events()

2834

1

				.iter()

2835

6

				.filter(|r| match r.event {

2836

1

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

2837

9

					_ => false,

2838

10

})

2839

1

				.count();

2840

1

2841

1

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

2842

1

});

2843

1

2844

2845

#[cfg(test)]

2846

mod bridge_tests {

2847

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

2848

	use crate::currency_to_asset;

2849

	use bp_messages::target_chain::DispatchMessageData;

2850

	use bp_messages::ReceptionResult;

2851

	use bp_runtime::messages::MessageDispatchResult;

2852

	use cumulus_primitives_core::AggregateMessageOrigin;

2853

	use frame_support::assert_ok;

2854

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

2855

	use moonbeam_core_primitives::AccountId;

2856

	use moonriver_runtime::bridge_config::{

2857

		PolkadotGlobalConsensusNetwork, WithPolkadotMessagesInstance,

2858

};

2859

	use moonriver_runtime::currency::MOVR;

2860

	use moonriver_runtime::xcm_config::CurrencyId;

2861

	use moonriver_runtime::{

2862

		Balances, BridgePolkadotMessages, BridgeXcmOverMoonbeam, MessageQueue, PolkadotXcm,

2863

		Runtime, RuntimeEvent, System,

2864

};

2865

	use pallet_bridge_messages::LanesManager;

2866

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

2867

	use parity_scale_codec::Encode;

2868

	use sp_core::H256;

2869

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

2870

	use xcm::latest::{

2871

		Asset, AssetFilter, AssetId, Junctions, Location, NetworkId, WeightLimit, WildAsset, Xcm,

2872

};

2873

	use xcm::prelude::{

2874

		AccountKey20, BuyExecution, ClearOrigin, DepositAsset, DescendOrigin, Fungible,

2875

		GlobalConsensus, PalletInstance, Parachain, ReserveAssetDeposited, UniversalOrigin,

2876

		XCM_VERSION,

2877

};

2878

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

2879

	use xcm_builder::BridgeMessage;

2880

2881

1

	fn next_block() {

2882

1

		System::reset_events();

2883

1

2884

1

		let next_block = System::block_number() + 1u32;

2885

1

2886

1

		System::set_block_number(next_block);

2887

1

		System::on_initialize(next_block);

2888

1

		MessageQueue::on_initialize(next_block);

2889

1

2890

2891

	#[test]

2892

1

	fn transfer_asset_moonriver_to_moonbeam() {

2893

1

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

2894

1

2895

1

		ExtBuilder::default()

2896

1

			.with_balances(vec![

2897

1

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

2898

1

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

2899

1

])

2900

1

			.with_safe_xcm_version(XCM_VERSION)

2901

1

			.with_open_bridges(vec![(

2902

1

				Location::new(

2903

1

1,

2904

1

					[Parachain(

2905

1

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

2906

1

)],

2907

1

),

2908

1

				Junctions::from([

2909

1

					NetworkId::Polkadot.into(),

2910

1

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

2911

1

]),

2912

1

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

2913

1

)])

2914

1

			.build()

2915

1

			.execute_with(|| {

2916

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2917

1

					root_origin(),

2918

1

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

2919

1

					XCM_VERSION

2920

1

));

2921

2922

1

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

2923

1

2924

1

				let message_data = BridgePolkadotMessages::outbound_message_data(

2925

1

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

2926

1

					1u64,

2927

1

);

2928

1

				assert!(message_data.is_none());

2929

2930

1

				assert_ok!(PolkadotXcm::transfer_assets(

2931

1

					origin_of(AccountId::from(ALICE)),

2932

1

					Box::new(VersionedLocation::V5(

2933

1

						bp_moonbeam::GlobalConsensusLocation::get()

2934

1

)),

2935

1

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

2936

1

						parents: 0,

2937

1

						interior: [AccountKey20 {

2938

1

							network: None,

2939

1

							key: ALICE,

2940

1

}]

2941

1

						.into(),

2942

1

					})),

2943

1

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

2944

1

0,

2945

1

					WeightLimit::Unlimited

2946

1

));

2947

2948

1

				let message_data = BridgePolkadotMessages::outbound_message_data(

2949

1

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

2950

1

					1u64,

2951

1

);

2952

1

				assert!(message_data.is_some());

2953

1

})

2954

1

2955

2956

	#[test]

2957

1

	fn receive_message_from_moonbeam() {

2958

1

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

2959

1

2960

1

		ExtBuilder::default()

2961

1

			.with_balances(vec![

2962

1

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

2963

1

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

2964

1

])

2965

1

			.with_xcm_assets(vec![XcmAssetInitialization {

2966

1

				asset_id: 1,

2967

1

				xcm_location: Location::new(

2968

1

2,

2969

1

2970

1

						GlobalConsensus(PolkadotGlobalConsensusNetwork::get()),

2971

1

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

2972

1

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

2973

1

2974

1

),

2975

1

				name: "xcGLMR",

2976

1

				symbol: "xcGLMR",

2977

1

				decimals: 18,

2978

1

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

2979

1

}])

2980

1

			.with_safe_xcm_version(XCM_VERSION)

2981

1

			.with_open_bridges(vec![(

2982

1

				Location::new(

2983

1

1,

2984

1

					[Parachain(

2985

1

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

2986

1

)],

2987

1

),

2988

1

				Junctions::from([

2989

1

					NetworkId::Polkadot.into(),

2990

1

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

2991

1

]),

2992

1

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

2993

1

)])

2994

1

			.build()

2995

1

			.execute_with(|| {

2996

1

				let bridge_message: BridgeMessage = BridgeMessage {

2997

1

					universal_dest: VersionedInteriorLocation::V5(

2998

1

2999

1

							GlobalConsensus(NetworkId::Kusama),

3000

1

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

3001

1

						].into()

3002

1

),

3003

1

					message: VersionedXcm::V5(

3004

1

						Xcm(

3005

1

3006

1

								UniversalOrigin(GlobalConsensus(NetworkId::Polkadot)),

3007

1

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

3008

1

								ReserveAssetDeposited(

3009

1

									vec![

3010

1

										Asset {

3011

1

											id: AssetId(

3012

1

												Location::new(

3013

1

2,

3014

1

3015

1

														GlobalConsensus(NetworkId::Polkadot),

3016

1

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

3017

1

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

3018

1

3019

1

3020

1

),

3021

1

											fun: Fungible(2 * MOVR)

3022

1

3023

1

									].into()

3024

1

),

3025

1

								ClearOrigin,

3026

1

								BuyExecution {

3027

1

									fees: Asset {

3028

1

										id: AssetId(

3029

1

											Location::new(

3030

1

2,

3031

1

3032

1

													GlobalConsensus(NetworkId::Polkadot),

3033

1

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

3034

1

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

3035

1

3036

1

3037

1

),

3038

1

										fun:  Fungible(MOVR / 2)

3039

1

},

3040

1

									weight_limit: WeightLimit::Unlimited

3041

1

},

3042

1

								DepositAsset {

3043

1

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

3044

1

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

3045

1

3046

1

							].into()

3047

1

3048

1

3049

1

};

3050

1

3051

1

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

3052

1

					.active_inbound_lane(Default::default())

3053

1

					.unwrap();

3054

1

3055

1

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

3056

1

				let result = inbound_lane.receive_message::<BridgeXcmOverMoonbeam>(

3057

1

					&AccountId::from(ALICE),

3058

1

1,

3059

1

					msg,

3060

1

);

3061

1

3062

1

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

3063

3064

				// Produce next block

3065

1

				next_block();

3066

1

				// Confirm that the xcm message was successfully processed

3067

7

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

3068

1

					matches!(

3069

1

						evt.event,

3070

						RuntimeEvent::MessageQueue(

3071

							pallet_message_queue::Event::Processed {

3072

								origin: AggregateMessageOrigin::Here,

3073

								success: true,

3074

..

3075

3076

3077

3078

7

				}));

3079

1

});

3080

1

3081

3082

3083

#[cfg(test)]

3084

mod treasury_tests {

3085

	use super::*;

3086

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

3087

	use moonriver_runtime::XcmWeightTrader;

3088

	use sp_core::bounded_vec;

3089

	use sp_runtime::traits::Hash;

3090

3091

4

	fn expect_events(events: Vec<RuntimeEvent>) {

3092

4

		let block_events: Vec<RuntimeEvent> =

3093

29

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

3094

4

3095

7

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

3096

4

3097

3098

7

	fn next_block() {

3099

7

		System::reset_events();

3100

7

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

3101

7

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

3102

7

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

3103

7

3104

3105

3

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

3106

3

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

3107

3

			.expect("failed to get account balance")

3108

3

3109

3110

	#[test]

3111

1

	fn test_treasury_spend_local_with_council_origin() {

3112

1

		let initial_treasury_balance = 1_000 * MOVR;

3113

1

		ExtBuilder::default()

3114

1

			.with_balances(vec![

3115

1

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

3116

1

				(Treasury::account_id(), initial_treasury_balance),

3117

1

])

3118

1

			.build()

3119

1

			.execute_with(|| {

3120

1

				let spend_amount = 100u128 * MOVR;

3121

1

				let spend_beneficiary = AccountId::from(BOB);

3122

1

3123

1

				next_block();

3124

1

3125

1

				// TreasuryCouncilCollective

3126

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3127

1

					root_origin(),

3128

1

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

3129

1

					Some(AccountId::from(ALICE)),

3130

1

3131

1

));

3132

3133

1

				next_block();

3134

1

3135

1

				// Perform treasury spending

3136

1

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

3137

1

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

3138

1

					amount: spend_amount,

3139

1

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

3140

1

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

3141

1

					valid_from: Some(valid_from),

3142

1

});

3143

1

				assert_ok!(TreasuryCouncilCollective::propose(

3144

1

					origin_of(AccountId::from(ALICE)),

3145

1

1,

3146

1

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

3147

1

					1_000

3148

1

));

3149

3150

1

				let payout_period =

3151

1

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

3152

1

				let expected_events = [

3153

1

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

3154

1

						index: 0,

3155

1

						asset_kind: NativeOrWithId::Native,

3156

1

						amount: spend_amount,

3157

1

						beneficiary: spend_beneficiary,

3158

1

						valid_from,

3159

1

						expire_at: payout_period + valid_from,

3160

1

}),

3161

1

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

3162

1

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

3163

1

						result: Ok(()),

3164

1

}),

3165

1

3166

1

				.to_vec();

3167

1

				expect_events(expected_events);

3168

3169

6

				while System::block_number() < valid_from {

3170

5

					next_block();

3171

5

3172

3173

1

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

3174

3175

1

				let expected_events = [

3176

1

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

3177

1

						index: 0,

3178

1

						payment_id: (),

3179

1

}),

3180

1

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

3181

1

						from: Treasury::account_id(),

3182

1

						to: spend_beneficiary,

3183

1

						amount: spend_amount,

3184

1

}),

3185

1

3186

1

				.to_vec();

3187

1

				expect_events(expected_events);

3188

1

});

3189

1

3190

3191

	#[test]

3192

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

3193

1

		let initial_treasury_balance = 1_000 * MOVR;

3194

1

		let asset_id = 1000100010001000u128;

3195

1

		ExtBuilder::default()

3196

1

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

3197

1

			.build()

3198

1

			.execute_with(|| {

3199

1

				let spend_amount = 100u128 * MOVR;

3200

1

				let spend_beneficiary = AccountId::from(BOB);

3201

1

3202

1

				let asset_location: Location = Location {

3203

1

					parents: 1,

3204

1

					interior: Junctions::Here,

3205

1

};

3206

1

3207

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

3208

1

					root_origin(),

3209

1

					asset_id,

3210

1

					asset_location.clone(),

3211

1

12,

3212

1

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

3213

1

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

3214

1

));

3215

3216

1

				assert_ok!(XcmWeightTrader::add_asset(

3217

1

					root_origin(),

3218

1

					asset_location,

3219

1

					1u128

3220

1

));

3221

3222

1

				assert_ok!(EvmForeignAssets::mint_into(

3223

1

					asset_id,

3224

1

					Treasury::account_id(),

3225

1

					initial_treasury_balance.into()

3226

1

));

3227

3228

1

				assert_eq!(

3229

1

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

3230

1

					initial_treasury_balance.into(),

3231

					"Treasury balance not updated"

3232

);

3233

3234

				// TreasuryCouncilCollective

3235

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3236

1

					root_origin(),

3237

1

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

3238

1

					Some(AccountId::from(ALICE)),

3239

1

3240

1

));

3241

3242

				// Perform treasury spending

3243

1

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

3244

1

					amount: spend_amount,

3245

1

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

3246

1

					beneficiary: Box::new(spend_beneficiary),

3247

1

					valid_from: None,

3248

1

});

3249

1

				assert_ok!(TreasuryCouncilCollective::propose(

3250

1

					origin_of(AccountId::from(ALICE)),

3251

1

1,

3252

1

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

3253

1

					1_000

3254

1

));

3255

3256

1

				let payout_period =

3257

1

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

3258

1

3259

1

				let current_block = System::block_number();

3260

1

				let expected_events = [

3261

1

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

3262

1

						index: 0,

3263

1

						asset_kind: NativeOrWithId::WithId(asset_id),

3264

1

						amount: spend_amount,

3265

1

						beneficiary: spend_beneficiary,

3266

1

						valid_from: current_block,

3267

1

						expire_at: current_block + payout_period,

3268

1

}),

3269

1

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

3270

1

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

3271

1

						result: Ok(()),

3272

1

}),

3273

1

3274

1

				.to_vec();

3275

1

				expect_events(expected_events);

3276

1

3277

1

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

3278

3279

1

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

3280

1

					index: 0,

3281

1

					payment_id: (),

3282

1

				})]);

3283

1

3284

1

				assert_eq!(

3285

1

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

3286

1

					(initial_treasury_balance - spend_amount).into(),

3287

					"Treasury balance not updated"

3288

);

3289

3290

1

				assert_eq!(

3291

1

					get_asset_balance(&asset_id, &spend_beneficiary),

3292

1

					spend_amount.into(),

3293

					"Treasury payout failed"

3294

);

3295

1

});

3296

1

3297

3298

3299

#[cfg(test)]

3300

mod fee_tests {

3301

	use super::*;

3302

	use fp_evm::FeeCalculator;

3303

	use frame_support::{

3304

		traits::{ConstU128, OnFinalize},

3305

		weights::{ConstantMultiplier, WeightToFee},

3306

};

3307

	use moonriver_runtime::{

3308

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

3309

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

3310

};

3311

	use sp_core::Get;

3312

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

3313

3314

1

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

3315

1

	where

3316

1

		F: FnMut() -> (),

3317

1

3318

1

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

3319

1

			.build_storage()

3320

1

			.unwrap()

3321

1

			.into();

3322

1

		t.execute_with(|| {

3323

1

			System::set_block_consumed_resources(w, 0);

3324

1

			assertions()

3325

1

});

3326

1

3327

3328

	#[test]

3329

1

	fn test_multiplier_can_grow_from_zero() {

3330

1

		let minimum_multiplier = MinimumMultiplier::get();

3331

1

		let target = TargetBlockFullness::get()

3332

1

			* RuntimeBlockWeights::get()

3333

1

				.get(DispatchClass::Normal)

3334

1

				.max_total

3335

1

				.unwrap();

3336

1

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

3337

1

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

3338

1

		run_with_system_weight(target * 101 / 100, || {

3339

1

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

3340

1

			assert!(

3341

1

				next > minimum_multiplier,

3342

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

3343

				next,

3344

				minimum_multiplier

3345

);

3346

1

})

3347

1

3348

3349

	#[test]

3350

1

	fn test_fee_calculation() {

3351

1

		let base_extrinsic = RuntimeBlockWeights::get()

3352

1

			.get(DispatchClass::Normal)

3353

1

			.base_extrinsic;

3354

1

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

3355

1

		let extrinsic_len = 100u32;

3356

1

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

3357

1

		let tip = 42u128;

3358

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

3359

		type LengthToFeeImpl = LengthToFee;

3360

3361

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

3362

1

		let expected_fee = WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3363

1

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

3364

1

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

3365

1

			+ tip;

3366

1

3367

1

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

3368

1

			.build_storage()

3369

1

			.unwrap()

3370

1

			.into();

3371

1

		t.execute_with(|| {

3372

1

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

3373

1

			let actual_fee = TransactionPayment::compute_fee(

3374

1

				extrinsic_len,

3375

1

				&frame_support::dispatch::DispatchInfo {

3376

1

					class: DispatchClass::Normal,

3377

1

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

3378

1

					call_weight: extrinsic_weight,

3379

1

					extension_weight: Weight::zero(),

3380

1

},

3381

1

				tip,

3382

1

);

3383

1

3384

1

			assert_eq!(

3385

				expected_fee,

3386

				actual_fee,

3387

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

3388

				actual_fee - expected_fee

3389

);

3390

1

});

3391

1

3392

3393

	#[test]

3394

1

	fn test_min_gas_price_is_deterministic() {

3395

1

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

3396

1

			.build_storage()

3397

1

			.unwrap()

3398

1

			.into();

3399

1

		t.execute_with(|| {

3400

1

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

3401

1

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

3402

1

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

3403

1

			let expected: U256 = multiplier

3404

1

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

3405

1

				.into();

3406

1

3407

1

			assert_eq!(expected, actual);

3408

1

});

3409

1

3410

3411

	#[test]

3412

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3413

1

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

3414

1

			.build_storage()

3415

1

			.unwrap()

3416

1

			.into();

3417

1

		t.execute_with(|| {

3418

1

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

3419

1

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

3420

1

3421

1

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

3422

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3423

1

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

3424

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3425

1

3426

1

			assert_ne!(

3427

				a, b,

3428

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

3429

);

3430

1

});

3431

1

3432

3433

	#[test]

3434

1

	fn test_fee_scenarios() {

3435

		use sp_runtime::FixedU128;

3436

1

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

3437

1

			.build_storage()

3438

1

			.unwrap()

3439

1

			.into();

3440

1

		t.execute_with(|| {

3441

1

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

3442

12

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

3443

12

				let start_multiplier =

3444

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3445

12

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

3446

12

3447

12

				let block_weight = NORMAL_WEIGHT * fullness;

3448

3449

60004

				for i in 0..num_blocks {

3450

60004

					System::set_block_number(i as u32);

3451

60004

					System::set_block_consumed_resources(block_weight, 0);

3452

60004

					TransactionPayment::on_finalize(i as u32);

3453

60004

3454

3455

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3456

12

};

3457

3458

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

3459

			// they are expected to change when parameters that influence

3460

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

3461

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

3462

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

3463

3464

1

			assert_eq!(

3465

1

				sim(100_000_000, Perbill::from_percent(0), 1),

3466

1

				U256::from(312_500_000u128), // lower bound enforced

3467

1

);

3468

1

			assert_eq!(

3469

1

				sim(100_000_000, Perbill::from_percent(25), 1),

3470

1

				U256::from(312_500_000u128),

3471

1

);

3472

1

			assert_eq!(

3473

1

				sim(100_000_000, Perbill::from_percent(50), 1),

3474

1

				U256::from(312_687_556u128), // slightly higher than lower bound

3475

1

);

3476

1

			assert_eq!(

3477

1

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

3478

1

				U256::from(313_313_556u128),

3479

1

);

3480

3481

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

3482

1

			assert_eq!(

3483

1

				sim(100_000_000, Perbill::from_percent(0), 600),

3484

1

				U256::from(312_500_000u128),

3485

1

);

3486

1

			assert_eq!(

3487

1

				sim(100_000_000, Perbill::from_percent(25), 600),

3488

1

				U256::from(312_500_000u128),

3489

1

);

3490

1

			assert_eq!(

3491

1

				sim(100_000_000, Perbill::from_percent(50), 600),

3492

1

				U256::from(447_915_432u128),

3493

1

);

3494

1

			assert_eq!(

3495

1

				sim(100_000_000, Perbill::from_percent(100), 600),

3496

1

				U256::from(1_487_129_030u128),

3497

1

);

3498

3499

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

3500

1

			assert_eq!(

3501

1

				sim(100_000_000, Perbill::from_percent(0), 14400),

3502

1

				U256::from(312_500_000u128), // lower bound enforced

3503

1

);

3504

1

			assert_eq!(

3505

1

				sim(100_000_000, Perbill::from_percent(25), 14400),

3506

1

				U256::from(312_500_000u128),

3507

1

);

3508

1

			assert_eq!(

3509

1

				sim(100_000_000, Perbill::from_percent(50), 14400),

3510

1

				U256::from(1_766_664_654_709u128),

3511

1

);

3512

1

			assert_eq!(

3513

1

				sim(100_000_000, Perbill::from_percent(100), 14400),

3514

1

				U256::from(31_250_000_000_000u128), // upper bound enforced

3515

1

);

3516

1

});

3517

1

3518

3519

3520

#[cfg(test)]

3521

mod balance_tests {

3522

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

3523

	use frame_support::assert_ok;

3524

	use frame_support::traits::LockableCurrency;

3525

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

3526

	use moonbeam_core_primitives::AccountId;

3527

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

3528

3529

	#[test]

3530

1

	fn reserve_should_work_for_frozen_balance() {

3531

1

		let alice = AccountId::from(ALICE);

3532

		const ID_1: LockIdentifier = *b"1       ";

3533

3534

1

		ExtBuilder::default()

3535

1

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

3536

1

			.build()

3537

1

			.execute_with(|| {

3538

1

				// Check balances

3539

1

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

3540

1

				assert_eq!(account.free, 10);

3541

1

				assert_eq!(account.frozen, 0);

3542

1

				assert_eq!(account.reserved, 0);

3543

3544

1

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

3545

1

3546

1

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

3547

1

				assert_eq!(account.free, 10);

3548

1

				assert_eq!(account.frozen, 9);

3549

1

				assert_eq!(account.reserved, 0);

3550

3551

1

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

3552

3553

1

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

3554

1

				assert_eq!(account.free, 5);

3555

1

				assert_eq!(account.frozen, 9);

3556

1

				assert_eq!(account.reserved, 5);

3557

3558

1

				let previous_reserved_amount = account.reserved;

3559

1

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

3560

1

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

3561

1

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

3562

3563

1

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

3564

1

				assert_eq!(account.free, ed);

3565

1

				assert_eq!(account.frozen, 9);

3566

1

				assert_eq!(

3567

1

					account.reserved,

3568

1

					previous_reserved_amount.saturating_add(next_reserve)

3569

1

);

3570

1

});

3571

1

3572