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

		Contains, Currency as CurrencyT, EnsureOrigin, OnInitialize, PalletInfo, StorageInfo,

31

		StorageInfoTrait,

32

},

33

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

34

	StorageHasher, Twox128,

35

};

36

use 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, EvmForeignAssets, Executive, NormalFilter, OpenTechCommitteeCollective, PolkadotXcm,

43

	Precompiles, ProxyType, RuntimeBlockWeights, TransactionPayment, TransactionPaymentAsGasPrice,

44

	Treasury, TreasuryCouncilCollective, XcmTransactor, WEIGHT_PER_GAS,

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 sp_core::{bounded_vec, ByteArray, Get, H160, U256};

61

use sp_runtime::{

62

	traits::{Convert, Dispatchable},

63

	BuildStorage, DispatchError, ModuleError, Percent,

64

};

65

use std::str::from_utf8;

66

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

67

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

68

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

69

use xcm_executor::traits::{ConvertLocation, TransferType};

70

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

71

72

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

73

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

74

	Runtime,

75

	moonriver_runtime::xcm_config::XcmExecutorConfig,

76

>;

77

type XcmTransactorV2PCall =

78

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

79

80

const BASE_FEE_GENESIS: u128 = 100 * GIGAWEI;

81

82

3

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

83

3

	Asset {

84

3

		id: AssetId(

85

3

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

86

3

				currency_id,

87

3

88

3

			.unwrap(),

89

3

),

90

3

		fun: Fungibility::Fungible(amount),

91

3

92

3

93

94

#[test]

95

1

fn xcmp_queue_controller_origin_is_root() {

96

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

97

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

98

1

	assert_ok!(

99

1

		<moonriver_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

100

1

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

101

);

102

1

103

104

#[test]

105

1

fn verify_pallet_prefixes() {

106

31

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

107

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

108

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

109

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

110

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

111

		// expand/storage.rs#L389-L401

112

31

		assert_eq!(

113

31

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

114

31

			Some(name)

115

);

116

31

117

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

118

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

119

1

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

120

1

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

121

1

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

122

1

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

123

1

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

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

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

130

1

	is_pallet_prefix::<moonriver_runtime::OpenTechCommitteeCollective>(

131

1

		"OpenTechCommitteeCollective",

132

);

133

1

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

134

1

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

135

1

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

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

153

14

	let prefix = |pallet_name, storage_name| {

154

14

		let mut res = [0u8; 32];

155

14

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

156

14

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

157

14

		res.to_vec()

158

14

};

159

1

	assert_eq!(

160

1

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

161

1

		vec![

162

1

			StorageInfo {

163

1

				pallet_name: b"Timestamp".to_vec(),

164

1

				storage_name: b"Now".to_vec(),

165

1

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

166

1

				max_values: Some(1),

167

1

				max_size: Some(8),

168

1

},

169

1

			StorageInfo {

170

1

				pallet_name: b"Timestamp".to_vec(),

171

1

				storage_name: b"DidUpdate".to_vec(),

172

1

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

173

1

				max_values: Some(1),

174

1

				max_size: Some(1),

175

1

176

177

);

178

1

	assert_eq!(

179

1

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

180

1

		vec![

181

1

			StorageInfo {

182

1

				pallet_name: b"Balances".to_vec(),

183

1

				storage_name: b"TotalIssuance".to_vec(),

184

1

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

185

1

				max_values: Some(1),

186

1

				max_size: Some(16),

187

1

},

188

1

			StorageInfo {

189

1

				pallet_name: b"Balances".to_vec(),

190

1

				storage_name: b"InactiveIssuance".to_vec(),

191

1

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

192

1

				max_values: Some(1),

193

1

				max_size: Some(16),

194

1

},

195

1

			StorageInfo {

196

1

				pallet_name: b"Balances".to_vec(),

197

1

				storage_name: b"Account".to_vec(),

198

1

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

199

1

				max_values: None,

200

1

				max_size: Some(100),

201

1

},

202

1

			StorageInfo {

203

1

				pallet_name: b"Balances".to_vec(),

204

1

				storage_name: b"Locks".to_vec(),

205

1

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

206

1

				max_values: None,

207

1

				max_size: Some(1287),

208

1

},

209

1

			StorageInfo {

210

1

				pallet_name: b"Balances".to_vec(),

211

1

				storage_name: b"Reserves".to_vec(),

212

1

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

213

1

				max_values: None,

214

1

				max_size: Some(1037),

215

1

},

216

1

			StorageInfo {

217

1

				pallet_name: b"Balances".to_vec(),

218

1

				storage_name: b"Holds".to_vec(),

219

1

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

220

1

				max_values: None,

221

1

				max_size: Some(91),

222

1

},

223

1

			StorageInfo {

224

1

				pallet_name: b"Balances".to_vec(),

225

1

				storage_name: b"Freezes".to_vec(),

226

1

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

227

1

				max_values: None,

228

1

				max_size: Some(73),

229

1

},

230

231

);

232

1

	assert_eq!(

233

1

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

234

1

		vec![

235

1

			StorageInfo {

236

1

				pallet_name: b"Proxy".to_vec(),

237

1

				storage_name: b"Proxies".to_vec(),

238

1

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

239

1

				max_values: None,

240

1

				max_size: Some(845),

241

1

},

242

1

			StorageInfo {

243

1

				pallet_name: b"Proxy".to_vec(),

244

1

				storage_name: b"Announcements".to_vec(),

245

1

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

246

1

				max_values: None,

247

1

				max_size: Some(1837),

248

1

249

250

);

251

1

	assert_eq!(

252

1

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

253

1

		vec![StorageInfo {

254

1

			pallet_name: b"MaintenanceMode".to_vec(),

255

1

			storage_name: b"MaintenanceMode".to_vec(),

256

1

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

257

1

			max_values: Some(1),

258

1

			max_size: None,

259

1

},]

260

);

261

1

	assert_eq!(

262

1

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

263

1

		vec![

264

1

			StorageInfo {

265

1

				pallet_name: b"RelayStorageRoots".to_vec(),

266

1

				storage_name: b"RelayStorageRoot".to_vec(),

267

1

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

268

1

				max_values: None,

269

1

				max_size: Some(44),

270

1

},

271

1

			StorageInfo {

272

1

				pallet_name: b"RelayStorageRoots".to_vec(),

273

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

274

1

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

275

1

				max_values: Some(1),

276

1

				max_size: Some(121),

277

1

},

278

279

);

280

1

281

282

#[test]

283

1

fn test_collectives_storage_item_prefixes() {

284

7

	for StorageInfo { pallet_name, .. } in

285

1

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

286

287

7

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

288

289

290

7

	for StorageInfo { pallet_name, .. } in

291

1

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

292

293

7

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

294

295

1

296

297

#[test]

298

1

fn collective_set_members_root_origin_works() {

299

1

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

300

		// TreasuryCouncilCollective

301

1

		assert_ok!(TreasuryCouncilCollective::set_members(

302

1

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

303

1

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

304

1

			Some(AccountId::from(ALICE)),

305

306

));

307

		// OpenTechCommitteeCollective

308

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

309

1

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

310

1

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

311

1

			Some(AccountId::from(ALICE)),

312

313

));

314

1

});

315

1

316

317

#[test]

318

1

fn collective_set_members_general_admin_origin_works() {

319

	use moonriver_runtime::{

320

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

321

};

322

323

1

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

324

1

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

325

1

		let alice = AccountId::from(ALICE);

326

327

		// TreasuryCouncilCollective

328

1

		let _ = Utility::dispatch_as(

329

1

			root_caller.clone(),

330

1

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

331

1

			Box::new(

332

1

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

333

1

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

334

1

					prime: Some(alice),

335

1

					old_count: 2,

336

1

337

1

				.into(),

338

1

),

339

1

);

340

		// OpenTechCommitteeCollective

341

1

		let _ = Utility::dispatch_as(

342

1

			root_caller,

343

1

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

344

1

			Box::new(

345

1

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

346

1

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

347

1

					prime: Some(alice),

348

1

					old_count: 2,

349

1

350

1

				.into(),

351

1

),

352

1

);

353

354

1

		assert_eq!(

355

1

			System::events()

356

1

				.into_iter()

357

2

				.filter_map(|r| {

358

2

					match r.event {

359

2

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

360

2

							if result.is_ok() =>

361

362

2

							Some(true)

363

364

						_ => None,

365

366

2

})

367

1

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

368

1

				.len(),

369

370

371

1

});

372

1

373

374

#[test]

375

1

fn collective_set_members_signed_origin_does_not_work() {

376

1

	let alice = AccountId::from(ALICE);

377

1

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

378

		// TreasuryCouncilCollective

379

1

		assert!(TreasuryCouncilCollective::set_members(

380

1

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

381

1

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

382

1

			Some(AccountId::from(ALICE)),

383

1

384

1

385

1

		.is_err());

386

		// OpenTechCommitteeCollective

387

1

		assert!(OpenTechCommitteeCollective::set_members(

388

1

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

389

1

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

390

1

			Some(AccountId::from(ALICE)),

391

1

392

1

393

1

		.is_err());

394

1

});

395

1

396

397

#[test]

398

1

fn verify_pallet_indices() {

399

33

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

400

33

		assert_eq!(

401

33

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

402

33

			Some(index)

403

);

404

33

405

	// System support

406

1

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

407

1

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

408

1

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

409

1

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

410

	// Monetary

411

1

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

412

1

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

413

	// Consensus support

414

1

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

415

1

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

416

1

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

417

1

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

418

1

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

419

	// Handy utilities

420

1

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

421

1

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

422

1

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

423

1

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

424

1

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

425

1

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

426

	// Ethereum compatibility

427

1

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

428

1

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

429

1

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

430

	// Governance

431

1

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

432

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

433

	// Council

434

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

435

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

436

1

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

437

1

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

438

	// Treasury

439

1

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

440

	// Crowdloan

441

1

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

442

	// XCM Stuff

443

1

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

444

1

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

445

1

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

446

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

447

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

448

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

449

1

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

450

1

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

451

1

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

452

1

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

453

1

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

454

1

455

456

#[test]

457

1

fn verify_reserved_indices() {

458

1

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

459

1

		.build_storage()

460

1

		.unwrap()

461

1

		.into();

462

463

1

	t.execute_with(|| {

464

		use frame_metadata::*;

465

1

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

466

1

		let metadata = match metadata.1 {

467

1

			RuntimeMetadata::V14(metadata) => metadata,

468

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

469

};

470

		// 40: Sudo

471

		// 53: BaseFee

472

		// 108: pallet_assets::<Instance1>

473

1

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

474

1

		let existing = metadata

475

1

			.pallets

476

1

			.iter()

477

1

			.map(|p| p.index)

478

1

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

479

3

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

480

1

});

481

1

482

483

#[test]

484

1

fn verify_proxy_type_indices() {

485

1

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

486

1

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

487

1

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

488

1

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

489

1

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

490

1

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

491

1

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

492

1

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

493

1

494

495

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

496

#[test]

497

1

fn verify_normal_filter_allow_pure_proxy() {

498

1

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

499

1

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

500

1

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

501

1

				proxy_type: ProxyType::Any,

502

1

				delay: 0,

503

1

				index: 0,

504

1

505

1

		)));

506

1

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

507

1

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

508

1

				spawner: AccountId::from(ALICE),

509

1

				proxy_type: ProxyType::Any,

510

1

				index: 0,

511

1

				height: 0,

512

1

				ext_index: 0,

513

1

514

1

		)));

515

1

});

516

1

517

518

#[test]

519

1

fn join_collator_candidates() {

520

1

	ExtBuilder::default()

521

1

		.with_balances(vec![

522

1

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

523

1

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

524

1

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

525

1

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

526

1

])

527

1

		.with_collators(vec![

528

1

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

529

1

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

530

1

])

531

1

		.with_delegations(vec![

532

1

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

533

1

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

534

1

])

535

1

		.build()

536

1

		.execute_with(|| {

537

1

			assert_noop!(

538

1

				ParachainStaking::join_candidates(

539

1

					origin_of(AccountId::from(ALICE)),

540

1

					10_000 * MOVR,

541

					2u32

542

),

543

1

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

544

);

545

1

			assert_noop!(

546

1

				ParachainStaking::join_candidates(

547

1

					origin_of(AccountId::from(CHARLIE)),

548

1

					10_000 * MOVR,

549

					2u32

550

),

551

1

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

552

);

553

1

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

554

1

			assert_ok!(ParachainStaking::join_candidates(

555

1

				origin_of(AccountId::from(DAVE)),

556

1

				10_000 * MOVR,

557

				2u32

558

));

559

1

			assert_eq!(

560

1

				last_event(),

561

1

				RuntimeEvent::ParachainStaking(

562

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

563

1

						account: AccountId::from(DAVE),

564

1

						amount_locked: 10_000 * MOVR,

565

1

						new_total_amt_locked: 30_100 * MOVR

566

1

567

1

568

);

569

1

			let candidates = ParachainStaking::candidate_pool();

570

1

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

571

1

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

572

1

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

573

1

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

574

1

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

575

1

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

576

1

});

577

1

578

579

#[test]

580

1

fn transfer_through_evm_to_stake() {

581

1

	ExtBuilder::default()

582

1

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

583

1

		.build()

584

1

		.execute_with(|| {

585

			// Charlie has no balance => fails to stake

586

1

			assert_noop!(

587

1

				ParachainStaking::join_candidates(

588

1

					origin_of(AccountId::from(CHARLIE)),

589

1

					10_000 * MOVR,

590

					2u32

591

),

592

1

				DispatchError::Module(ModuleError {

593

1

					index: 20,

594

1

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

595

1

					message: Some("InsufficientBalance")

596

1

})

597

);

598

			// Alice transfer from free balance 20000 MOVR to Bob

599

1

			assert_ok!(Balances::transfer_allow_death(

600

1

				origin_of(AccountId::from(ALICE)),

601

1

				AccountId::from(BOB),

602

1

				20_000 * MOVR,

603

));

604

1

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

605

606

1

			let gas_limit = 100000u64;

607

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

608

			// Bob transfers 10000 MOVR to Charlie via EVM

609

1

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

610

1

				source: H160::from(BOB),

611

1

				target: H160::from(CHARLIE),

612

1

				input: vec![],

613

1

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

614

1

				gas_limit,

615

1

				max_fee_per_gas: gas_price,

616

1

				max_priority_fee_per_gas: None,

617

1

				nonce: None,

618

1

				access_list: Vec::new(),

619

1

				authorization_list: Vec::new(),

620

1

})

621

1

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

622

1

			assert_eq!(

623

1

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

624

				10_000 * MOVR,

625

);

626

627

			// Charlie can stake now

628

1

			assert_ok!(ParachainStaking::join_candidates(

629

1

				origin_of(AccountId::from(CHARLIE)),

630

1

				10_000 * MOVR,

631

				2u32,

632

			),);

633

1

			let candidates = ParachainStaking::candidate_pool();

634

1

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

635

1

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

636

1

});

637

1

638

639

#[test]

640

1

fn reward_block_authors() {

641

1

	ExtBuilder::default()

642

1

		.with_balances(vec![

643

1

			// Alice gets 100 extra tokens for her mapping deposit

644

1

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

645

1

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

646

1

])

647

1

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

648

1

		.with_delegations(vec![(

649

1

			AccountId::from(BOB),

650

1

			AccountId::from(ALICE),

651

1

			500 * MOVR,

652

1

)])

653

1

		.with_mappings(vec![(

654

1

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

655

1

			AccountId::from(ALICE),

656

1

)])

657

1

		.build()

658

1

		.execute_with(|| {

659

1

			increase_last_relay_slot_number(1);

660

661

			// Just before round 3

662

1

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

663

664

			// no rewards doled out yet

665

1

			assert_eq!(

666

1

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

667

				10_100 * MOVR,

668

);

669

1

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

670

1

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

671

672

			// rewards minted and distributed

673

1

			assert_eq!(

674

1

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

675

				11547666666208000000000,

676

);

677

1

			assert_eq!(

678

1

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

679

				9557333332588000000000,

680

);

681

1

});

682

1

683

684

#[test]

685

1

fn reward_block_authors_with_parachain_bond_reserved() {

686

1

	ExtBuilder::default()

687

1

		.with_balances(vec![

688

1

			// Alice gets 100 extra tokens for her mapping deposit

689

1

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

690

1

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

691

1

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

692

1

])

693

1

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

694

1

		.with_delegations(vec![(

695

1

			AccountId::from(BOB),

696

1

			AccountId::from(ALICE),

697

1

			500 * MOVR,

698

1

)])

699

1

		.with_mappings(vec![(

700

1

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

701

1

			AccountId::from(ALICE),

702

1

)])

703

1

		.build()

704

1

		.execute_with(|| {

705

1

			increase_last_relay_slot_number(1);

706

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

707

1

				root_origin(),

708

1

709

1

					InflationDistributionAccount {

710

1

						account: AccountId::from(CHARLIE),

711

1

						percent: Percent::from_percent(30),

712

1

},

713

1

					InflationDistributionAccount::default(),

714

1

715

1

				.into()

716

));

717

718

			// Stop just before round 2

719

1

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

720

721

			// no collator rewards doled out yet

722

1

			assert_eq!(

723

1

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

724

				10_100 * MOVR,

725

);

726

1

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

727

728

			// Go to round 2

729

1

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

730

731

			// 30% reserved for parachain bond

732

1

			assert_eq!(

733

1

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

734

				452515000000000000000,

735

);

736

737

			// Go to round 3

738

1

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

739

740

			// rewards minted and distributed

741

1

			assert_eq!(

742

1

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

743

				11117700475903800000000,

744

);

745

1

			assert_eq!(

746

1

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

747

				9535834523343675000000,

748

);

749

			// 30% reserved for parachain bond again

750

1

			assert_eq!(

751

1

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

752

				910802725000000000000,

753

);

754

1

});

755

1

756

757

1

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

758

1

where

759

1

	F: FnMut() -> (),

760

761

1

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

762

1

		.build_storage()

763

1

		.unwrap()

764

1

		.into();

765

1

	t.execute_with(|| {

766

1

		System::set_block_consumed_resources(w, 0);

767

1

		assertions()

768

1

});

769

1

770

771

#[test]

772

#[rustfmt::skip]

773

1

fn length_fee_is_sensible() {

774

	use sp_runtime::testing::TestXt;

775

776

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

777

1

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

778

1

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

779

1

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

780

781

9

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

782

9

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

783

9

				.inclusion_fee

784

9

				.expect("fee should be calculated")

785

9

				.len_fee

786

9

};

787

788

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

789

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

790

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

791

		//                             |           |

792

1

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

793

1

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

794

1

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

795

1

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

796

1

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

797

1

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

798

1

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

799

1

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

800

1

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

801

1

});

802

1

803

804

#[test]

805

1

fn multiplier_can_grow_from_zero() {

806

	use frame_support::traits::Get;

807

808

1

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

809

1

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

810

1

		* RuntimeBlockWeights::get()

811

1

			.get(DispatchClass::Normal)

812

1

			.max_total

813

1

			.unwrap();

814

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

815

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

816

1

	run_with_system_weight(target * 101 / 100, || {

817

1

		let next =

818

1

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

819

1

		assert!(

820

1

			next > minimum_multiplier,

821

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

822

			next,

823

			minimum_multiplier

824

);

825

1

})

826

1

827

828

#[test]

829

1

fn ethereum_invalid_transaction() {

830

1

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

831

1

		set_parachain_inherent_data();

832

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

833

		// on chain is rejected.

834

1

		assert_eq!(

835

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

836

			Err(

837

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

838

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

839

840

841

);

842

1

});

843

1

844

845

#[test]

846

1

fn initial_gas_fee_is_correct() {

847

	use fp_evm::FeeCalculator;

848

849

1

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

850

1

		let multiplier = TransactionPayment::next_fee_multiplier();

851

1

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

852

853

1

		assert_eq!(

854

1

			TransactionPaymentAsGasPrice::min_gas_price(),

855

1

856

1

				3_125_000_000u128.into(),

857

1

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

858

1

859

);

860

1

});

861

1

862

863

#[test]

864

1

fn min_gas_fee_is_correct() {

865

	use fp_evm::FeeCalculator;

866

	use frame_support::traits::Hooks;

867

868

1

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

869

1

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

870

1

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

871

872

1

		let multiplier = TransactionPayment::next_fee_multiplier();

873

1

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

874

875

1

		assert_eq!(

876

1

			TransactionPaymentAsGasPrice::min_gas_price(),

877

1

878

1

				312_500_000u128.into(),

879

1

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

880

1

881

);

882

1

});

883

1

884

885

#[test]

886

1

fn transfer_ed_0_substrate() {

887

1

	ExtBuilder::default()

888

1

		.with_balances(vec![

889

1

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

890

1

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

891

1

])

892

1

		.build()

893

1

		.execute_with(|| {

894

			// Substrate transfer

895

1

			assert_ok!(Balances::transfer_allow_death(

896

1

				origin_of(AccountId::from(ALICE)),

897

1

				AccountId::from(BOB),

898

1

				1 * MOVR,

899

));

900

			// 1 WEI is left in the account

901

1

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

902

1

});

903

1

904

905

#[test]

906

1

fn transfer_ed_0_evm() {

907

1

	ExtBuilder::default()

908

1

		.with_balances(vec![

909

1

910

1

				AccountId::from(ALICE),

911

1

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

912

1

),

913

1

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

914

1

])

915

1

		.build()

916

1

		.execute_with(|| {

917

1

			set_parachain_inherent_data();

918

			// EVM transfer

919

1

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

920

1

				source: H160::from(ALICE),

921

1

				target: H160::from(BOB),

922

1

				input: Vec::new(),

923

1

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

924

1

				gas_limit: 21_000u64,

925

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

926

1

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

927

1

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

928

1

				access_list: Vec::new(),

929

1

				authorization_list: Vec::new(),

930

1

})

931

1

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

932

			// 1 WEI is left in the account

933

1

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

934

1

});

935

1

936

937

#[test]

938

1

fn refund_ed_0_evm() {

939

1

	ExtBuilder::default()

940

1

		.with_balances(vec![

941

1

942

1

				AccountId::from(ALICE),

943

1

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

944

1

),

945

1

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

946

1

])

947

1

		.build()

948

1

		.execute_with(|| {

949

1

			set_parachain_inherent_data();

950

			// EVM transfer that zeroes ALICE

951

1

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

952

1

				source: H160::from(ALICE),

953

1

				target: H160::from(BOB),

954

1

				input: Vec::new(),

955

1

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

956

1

				gas_limit: 21_777u64,

957

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

958

1

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

959

1

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

960

1

				access_list: Vec::new(),

961

1

				authorization_list: Vec::new(),

962

1

})

963

1

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

964

			// ALICE is refunded

965

1

			assert_eq!(

966

1

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

967

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

968

);

969

1

});

970

1

971

972

#[test]

973

1

fn author_does_receive_priority_fee() {

974

1

	ExtBuilder::default()

975

1

		.with_balances(vec![(

976

1

			AccountId::from(BOB),

977

1

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

978

1

)])

979

1

		.build()

980

1

		.execute_with(|| {

981

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

982

1

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

983

1

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

984

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

985

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

986

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

987

1

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

988

989

			// EVM transfer.

990

1

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

991

1

				source: H160::from(BOB),

992

1

				target: H160::from(ALICE),

993

1

				input: Vec::new(),

994

1

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

995

1

				gas_limit: 21_000u64,

996

1

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

997

1

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

998

1

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

999

1

				access_list: Vec::new(),

1000

1

				authorization_list: Vec::new(),

1001

1

})

1002

1

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

1003

1004

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1005

			// Author free balance increased by priority fee.

1006

1

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

1007

1

});

1008

1

1009

1010

#[test]

1011

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1012

	use fp_evm::FeeCalculator;

1013

1

	ExtBuilder::default()

1014

1

		.with_balances(vec![

1015

1

1016

1

				AccountId::from(BOB),

1017

1

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

1018

1

),

1019

1

1020

1

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

1021

1

				existential_deposit(),

1022

1

),

1023

1

])

1024

1

		.build()

1025

1

		.execute_with(|| {

1026

1

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

1027

1

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

1028

1

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

1029

			// EVM transfer.

1030

1

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

1031

1

				source: H160::from(BOB),

1032

1

				target: H160::from(ALICE),

1033

1

				input: Vec::new(),

1034

1

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

1035

1

				gas_limit: 21_000u64,

1036

1

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

1037

1

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

1038

1

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

1039

1

				access_list: Vec::new(),

1040

1

				authorization_list: Vec::new(),

1041

1

})

1042

1

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

1043

1044

1

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

1045

1046

1

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

1047

1048

1

			let base_fee: Balance = base_fee * 21_000;

1049

1050

1

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

1051

1052

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

1053

1

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

1054

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1055

1056

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1057

1058

1

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

1059

1

});

1060

1

1061

1062

#[test]

1063

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1064

	use fp_evm::FeeCalculator;

1065

1

	ExtBuilder::default()

1066

1

		.with_balances(vec![

1067

1

1068

1

				AccountId::from(BOB),

1069

1

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

1070

1

),

1071

1

1072

1

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

1073

1

				existential_deposit(),

1074

1

),

1075

1

])

1076

1

		.build()

1077

1

		.execute_with(|| {

1078

1

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

1079

			// EVM transfer.

1080

1

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

1081

1

				source: H160::from(BOB),

1082

1

				target: H160::from(ALICE),

1083

1

				input: Vec::new(),

1084

1

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

1085

1

				gas_limit: 21_000u64,

1086

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1087

1

				max_priority_fee_per_gas: None,

1088

1

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

1089

1

				access_list: Vec::new(),

1090

1

				authorization_list: Vec::new(),

1091

1

})

1092

1

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

1093

1094

1

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

1095

1096

1

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

1097

1098

1

			let base_fee: Balance = base_fee * 21_000;

1099

1100

1

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

1101

1102

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

1103

1

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

1104

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1105

1106

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1107

1108

1

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

1109

1

});

1110

1

1111

1112

#[test]

1113

1

fn root_can_change_default_xcm_vers() {

1114

1

	ExtBuilder::default()

1115

1

		.with_balances(vec![

1116

1

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

1117

1

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

1118

1

])

1119

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1120

1

			asset_id: 1,

1121

1

			xcm_location: AssetHubLocation::get(),

1122

1

			name: "Dot",

1123

1

			symbol: "Dot",

1124

1

			decimals: 12,

1125

1

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

1126

1

}])

1127

1

		.build()

1128

1

		.execute_with(|| {

1129

1

			let source_id: moonriver_runtime::AssetId = 1;

1130

1

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

1131

1

			let asset = Asset {

1132

1

				id: AssetId(

1133

1

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

1134

1

						currency_id,

1135

1

1136

1

					.unwrap(),

1137

1

),

1138

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1139

1

};

1140

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

1141

			// know with which version to send

1142

1

			assert_noop!(

1143

1

				PolkadotXcm::transfer_assets(

1144

1

					origin_of(AccountId::from(ALICE)),

1145

1

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

1146

1

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

1147

1

						parents: 0,

1148

1

						interior: [AccountId32 {

1149

1

							network: None,

1150

1

							id: [1u8; 32],

1151

1

}]

1152

1

						.into(),

1153

1

					})),

1154

1

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

1155

0,

1156

1

					WeightLimit::Unlimited,

1157

),

1158

1

				pallet_xcm::Error::<Runtime>::LocalExecutionIncompleteWithError {

1159

1

					index: 2,

1160

1

					error: pallet_xcm::ExecutionError::DestinationUnsupported

1161

1

1162

);

1163

1164

			// Root sets the defaultXcm

1165

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1166

1

				root_origin(),

1167

1

				Some(3)

1168

));

1169

1170

			// Now transferring does not fail

1171

1

			assert_ok!(PolkadotXcm::transfer_assets(

1172

1

				origin_of(AccountId::from(ALICE)),

1173

1

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

1174

1

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

1175

1

					parents: 0,

1176

1

					interior: [AccountId32 {

1177

1

						network: None,

1178

1

						id: [1u8; 32],

1179

1

}]

1180

1

					.into(),

1181

1

				})),

1182

1

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

1183

0,

1184

1

				WeightLimit::Unlimited

1185

));

1186

1

})

1187

1

1188

1189

#[test]

1190

1

fn asset_can_be_registered() {

1191

1

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

1192

1

		let source_location = Location::parent();

1193

1

		let source_id = 1;

1194

1195

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1196

1

			moonriver_runtime::RuntimeOrigin::root(),

1197

1

			source_id,

1198

1

			source_location.clone(),

1199

12,

1200

1

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

1201

1

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

1202

));

1203

1204

		// Check that the asset was created

1205

		// First check if the asset ID exists

1206

1

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

1207

1

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

1208

1209

		// Then check the status using AssetsByLocation

1210

1

		let (asset_id, status) =

1211

1

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

1212

1

		assert_eq!(asset_id, source_id);

1213

1

		assert_eq!(status, AssetStatus::Active);

1214

1

});

1215

1

1216

1217

#[test]

1218

1

fn create_and_manipulate_foreign_asset_using_root() {

1219

1

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

1220

1

		let source_location = Location::parent();

1221

1222

		// Create foreign asset

1223

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1224

1

			moonriver_runtime::RuntimeOrigin::root(),

1225

1,

1226

1

			source_location.clone(),

1227

12,

1228

1

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

1229

1

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

1230

));

1231

1

		assert_eq!(

1232

1

			EvmForeignAssets::assets_by_id(1),

1233

1

			Some(source_location.clone())

1234

);

1235

1

		assert_eq!(

1236

1

			EvmForeignAssets::assets_by_location(&source_location),

1237

			Some((1, AssetStatus::Active))

1238

);

1239

1240

		// Freeze foreign asset

1241

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1242

1

			moonriver_runtime::RuntimeOrigin::root(),

1243

1,

1244

			true

1245

));

1246

1

		assert_eq!(

1247

1

			EvmForeignAssets::assets_by_location(&source_location),

1248

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1249

);

1250

1251

		// Unfreeze foreign asset

1252

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1253

1

			moonriver_runtime::RuntimeOrigin::root(),

1254

1,

1255

));

1256

1

		assert_eq!(

1257

1

			EvmForeignAssets::assets_by_location(&source_location),

1258

			Some((1, AssetStatus::Active))

1259

);

1260

1

});

1261

1

1262

1263

#[test]

1264

1

fn create_and_manipulate_foreign_asset_using_sibling() {

1265

1

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

1266

1

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

1267

1

		let para_location = asset_location.chain_location();

1268

1

		let para_account =

1269

1

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

1270

1271

1

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

1272

1

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

1273

1274

		// Create foreign asset

1275

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1276

1

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

1277

1,

1278

1

			asset_location.clone(),

1279

12,

1280

1

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

1281

1

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

1282

));

1283

1284

		// deposit is taken from the account

1285

1

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

1286

1287

1

		assert_eq!(

1288

1

			EvmForeignAssets::assets_by_id(1),

1289

1

			Some(asset_location.clone())

1290

);

1291

1

		assert_eq!(

1292

1

			EvmForeignAssets::assets_by_location(&asset_location),

1293

			Some((1, AssetStatus::Active))

1294

);

1295

1296

		// Freeze foreign asset

1297

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1298

1

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

1299

1,

1300

			true

1301

));

1302

1

		assert_eq!(

1303

1

			EvmForeignAssets::assets_by_location(&asset_location),

1304

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1305

);

1306

1307

		// Unfreeze foreign asset

1308

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1309

1

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

1310

1,

1311

));

1312

1

		assert_eq!(

1313

1

			EvmForeignAssets::assets_by_location(&asset_location),

1314

			Some((1, AssetStatus::Active))

1315

);

1316

1

});

1317

1

1318

1319

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

1320

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

1321

/*

1322

#[test]

1323

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1324

	ExtBuilder::default()

1325

		.with_xcm_assets(vec![XcmAssetInitialization {

1326

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

1327

			metadata: AssetRegistrarMetadata {

1328

				name: b"RelayToken".to_vec(),

1329

				symbol: b"Relay".to_vec(),

1330

				decimals: 12,

1331

				is_frozen: false,

1332

},

1333

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

1334

			is_sufficient: true,

1335

}])

1336

		.with_balances(vec![

1337

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

1338

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

1339

])

1340

		.build()

1341

		.execute_with(|| {

1342

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

1343

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

1344

1345

			// Its address is

1346

			let asset_precompile_address = Runtime::asset_id_to_account(

1347

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1348

				relay_asset_id,

1349

);

1350

1351

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

1352

			assert_eq!(

1353

				moonriver_runtime::Assets::total_supply(relay_asset_id),

1354

				1_000 * MOVR

1355

);

1356

1357

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

1358

			Precompiles::new()

1359

				.prepare_test(

1360

					ALICE,

1361

					asset_precompile_address,

1362

					ForeignAssetsPCall::total_supply {},

1363

1364

				.expect_cost(5007)

1365

				.expect_no_logs()

1366

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

1367

1368

			// Access balanceOf through precompile

1369

			Precompiles::new()

1370

				.prepare_test(

1371

					ALICE,

1372

					asset_precompile_address,

1373

					ForeignAssetsPCall::balance_of {

1374

						who: Address(ALICE.into()),

1375

},

1376

1377

				.expect_cost(5007)

1378

				.expect_no_logs()

1379

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

1380

});

1381

1382

1383

#[test]

1384

fn xcm_asset_erc20_precompiles_transfer() {

1385

	ExtBuilder::default()

1386

		.with_xcm_assets(vec![XcmAssetInitialization {

1387

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

1388

			metadata: AssetRegistrarMetadata {

1389

				name: b"RelayToken".to_vec(),

1390

				symbol: b"Relay".to_vec(),

1391

				decimals: 12,

1392

				is_frozen: false,

1393

},

1394

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

1395

			is_sufficient: true,

1396

}])

1397

		.with_balances(vec![

1398

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

1399

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

1400

])

1401

		.build()

1402

		.execute_with(|| {

1403

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

1404

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

1405

1406

			// Its address is

1407

			let asset_precompile_address = Runtime::asset_id_to_account(

1408

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1409

				relay_asset_id,

1410

);

1411

1412

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

1413

			Precompiles::new()

1414

				.prepare_test(

1415

					ALICE,

1416

					asset_precompile_address,

1417

					ForeignAssetsPCall::transfer {

1418

						to: Address(BOB.into()),

1419

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

1420

},

1421

1422

				.expect_cost(26587)

1423

				.expect_log(log3(

1424

					asset_precompile_address,

1425

					SELECTOR_LOG_TRANSFER,

1426

					H160::from(ALICE),

1427

					H160::from(BOB),

1428

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

1429

))

1430

				.execute_returns(true);

1431

1432

			// Make sure BOB has 400 MOVR

1433

			Precompiles::new()

1434

				.prepare_test(

1435

					BOB,

1436

					asset_precompile_address,

1437

					ForeignAssetsPCall::balance_of {

1438

						who: Address(BOB.into()),

1439

},

1440

1441

				.expect_cost(5007)

1442

				.expect_no_logs()

1443

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

1444

});

1445

1446

1447

#[test]

1448

fn xcm_asset_erc20_precompiles_approve() {

1449

	ExtBuilder::default()

1450

		.with_xcm_assets(vec![XcmAssetInitialization {

1451

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

1452

			metadata: AssetRegistrarMetadata {

1453

				name: b"RelayToken".to_vec(),

1454

				symbol: b"Relay".to_vec(),

1455

				decimals: 12,

1456

				is_frozen: false,

1457

},

1458

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

1459

			is_sufficient: true,

1460

}])

1461

		.with_balances(vec![

1462

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

1463

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

1464

])

1465

		.build()

1466

		.execute_with(|| {

1467

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

1468

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

1469

1470

			// Its address is

1471

			let asset_precompile_address = Runtime::asset_id_to_account(

1472

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1473

				relay_asset_id,

1474

);

1475

1476

			// Aprove Bob for spending 400 MOVR from Alice

1477

			Precompiles::new()

1478

				.prepare_test(

1479

					ALICE,

1480

					asset_precompile_address,

1481

					ForeignAssetsPCall::approve {

1482

						spender: Address(BOB.into()),

1483

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

1484

},

1485

1486

				.expect_cost(17323)

1487

				.expect_log(log3(

1488

					asset_precompile_address,

1489

					SELECTOR_LOG_APPROVAL,

1490

					H160::from(ALICE),

1491

					H160::from(BOB),

1492

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

1493

))

1494

				.execute_returns(true);

1495

1496

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

1497

			Precompiles::new()

1498

				.prepare_test(

1499

					BOB,

1500

					asset_precompile_address,

1501

					ForeignAssetsPCall::transfer_from {

1502

						from: Address(ALICE.into()),

1503

						to: Address(CHARLIE.into()),

1504

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

1505

},

1506

1507

				.expect_cost(31873)

1508

				.expect_log(log3(

1509

					asset_precompile_address,

1510

					SELECTOR_LOG_TRANSFER,

1511

					H160::from(ALICE),

1512

					H160::from(CHARLIE),

1513

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

1514

))

1515

				.execute_returns(true);

1516

1517

			// Make sure CHARLIE has 400 MOVR

1518

			Precompiles::new()

1519

				.prepare_test(

1520

					CHARLIE,

1521

					asset_precompile_address,

1522

					ForeignAssetsPCall::balance_of {

1523

						who: Address(CHARLIE.into()),

1524

},

1525

1526

				.expect_cost(5007)

1527

				.expect_no_logs()

1528

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

1529

});

1530

}*/

1531

1532

#[test]

1533

1

fn make_sure_polkadot_xcm_cannot_be_called() {

1534

1

	ExtBuilder::default()

1535

1

		.with_balances(vec![

1536

1

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

1537

1

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

1538

1

])

1539

1

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

1540

1

		.with_mappings(vec![(

1541

1

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

1542

1

			AccountId::from(ALICE),

1543

1

)])

1544

1

		.build()

1545

1

		.execute_with(|| {

1546

1

			let dest = Location {

1547

1

				parents: 1,

1548

1

				interior: [AccountId32 {

1549

1

					network: None,

1550

1

					id: [1u8; 32],

1551

1

}]

1552

1

				.into(),

1553

1

};

1554

1

			let assets: Assets = [Asset {

1555

1

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

1556

1

				fun: Fungible(1000),

1557

1

}]

1558

1

			.to_vec()

1559

1

			.into();

1560

1

			assert_noop!(

1561

1

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

1562

1

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

1563

1

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

1564

1

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

1565

1

					fee_asset_item: 0,

1566

1

})

1567

1

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

1568

1

					AccountId::from(ALICE)

1569

)),

1570

1

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

1571

);

1572

1

});

1573

1

1574

1575

#[test]

1576

1

fn transactor_cannot_use_more_than_max_weight() {

1577

1

	ExtBuilder::default()

1578

1

		.with_balances(vec![

1579

1

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

1580

1

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

1581

1

])

1582

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1583

1

			asset_id: 1,

1584

1

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

1585

1

			name: "RelayToken",

1586

1

			symbol: "Relay",

1587

1

			decimals: 12,

1588

1

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

1589

1

}])

1590

1

		.build()

1591

1

		.execute_with(|| {

1592

1

			let source_id: moonriver_runtime::AssetId = 1;

1593

1

			assert_ok!(XcmTransactor::register(

1594

1

				root_origin(),

1595

1

				AccountId::from(ALICE),

1596

0,

1597

));

1598

1599

			// Root can set transact info

1600

1

			assert_ok!(XcmTransactor::set_transact_info(

1601

1

				root_origin(),

1602

1

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

1603

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

1604

1

				3000.into(),

1605

1

				20000.into(),

1606

1

				None

1607

));

1608

			// Root can set transact info

1609

1

			assert_ok!(XcmTransactor::set_fee_per_second(

1610

1

				root_origin(),

1611

1

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

1612

1,

1613

));

1614

1615

1

			assert_noop!(

1616

1

				XcmTransactor::transact_through_derivative(

1617

1

					origin_of(AccountId::from(ALICE)),

1618

1

					moonriver_runtime::xcm_config::Transactors::Relay,

1619

0,

1620

1

					CurrencyPayment {

1621

1

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

1622

1

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

1623

1

)),

1624

1

						fee_amount: None

1625

1

},

1626

1

					vec![],

1627

					// 20000 is the max

1628

1

					TransactWeights {

1629

1

						transact_required_weight_at_most: 17001.into(),

1630

1

						overall_weight: None

1631

1

},

1632

					false

1633

),

1634

1

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

1635

);

1636

1

			assert_noop!(

1637

1

				XcmTransactor::transact_through_derivative(

1638

1

					origin_of(AccountId::from(ALICE)),

1639

1

					moonriver_runtime::xcm_config::Transactors::Relay,

1640

0,

1641

1

					CurrencyPayment {

1642

1

						currency: Currency::AsCurrencyId(

1643

1

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

1644

1

),

1645

1

						fee_amount: None

1646

1

},

1647

1

					vec![],

1648

					// 20000 is the max

1649

1

					TransactWeights {

1650

1

						transact_required_weight_at_most: 17001.into(),

1651

1

						overall_weight: None

1652

1

},

1653

					false

1654

),

1655

1

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

1656

);

1657

1

})

1658

1

1659

1660

#[test]

1661

1

fn transact_through_signed_precompile_works_v2() {

1662

1

	ExtBuilder::default()

1663

1

		.with_balances(vec![

1664

1

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

1665

1

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

1666

1

])

1667

1

		.with_safe_xcm_version(3)

1668

1

		.build()

1669

1

		.execute_with(|| {

1670

			// Destination

1671

1

			let dest = Location::parent();

1672

1673

1

			let fee_payer_asset = Location::parent();

1674

1675

1

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

1676

1677

1

			let total_weight = 1_000_000_000u64;

1678

1679

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1680

1681

1

			Precompiles::new()

1682

1

				.prepare_test(

1683

					ALICE,

1684

1

					xcm_transactor_v2_precompile_address,

1685

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1686

1

						dest,

1687

1

						fee_asset: fee_payer_asset,

1688

1

						weight: 4_000_000,

1689

1

						call: bytes.into(),

1690

1

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

1691

1

						overall_weight: total_weight,

1692

1

},

1693

1694

1

				.expect_cost(31020)

1695

1

				.expect_no_logs()

1696

1

				.execute_returns(());

1697

1

});

1698

1

1699

1700

#[test]

1701

1

fn transact_through_signed_cannot_send_to_local_chain() {

1702

1

	ExtBuilder::default()

1703

1

		.with_balances(vec![

1704

1

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

1705

1

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

1706

1

])

1707

1

		.with_safe_xcm_version(3)

1708

1

		.build()

1709

1

		.execute_with(|| {

1710

			// Destination

1711

1

			let dest = Location::here();

1712

1713

1

			let fee_payer_asset = Location::parent();

1714

1715

1

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

1716

1717

1

			let total_weight = 1_000_000_000u64;

1718

1719

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1720

1721

1

			Precompiles::new()

1722

1

				.prepare_test(

1723

					ALICE,

1724

1

					xcm_transactor_v2_precompile_address,

1725

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1726

1

						dest,

1727

1

						fee_asset: fee_payer_asset,

1728

1

						weight: 4_000_000,

1729

1

						call: bytes.into(),

1730

1

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

1731

1

						overall_weight: total_weight,

1732

1

},

1733

1734

1

				.execute_reverts(|output| {

1735

1

					from_utf8(&output)

1736

1

						.unwrap()

1737

1

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

1738

1

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

1739

1

});

1740

1

});

1741

1

1742

1743

#[test]

1744

1

fn call_pallet_xcm_with_fee() {

1745

1

	let asset_id = 1;

1746

1

	ExtBuilder::default()

1747

1

		.with_balances(vec![

1748

1

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

1749

1

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

1750

1

])

1751

1

		.with_safe_xcm_version(3)

1752

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1753

1

			asset_id,

1754

1

			xcm_location: Location::parent(),

1755

1

			name: "RelayToken",

1756

1

			symbol: "Relay",

1757

1

			decimals: 12,

1758

1

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

1759

1

}])

1760

1

		.build()

1761

1

		.execute_with(|| {

1762

1

			let dest = Location {

1763

1

				parents: 1,

1764

1

				interior: [AccountId32 {

1765

1

					network: None,

1766

1

					id: [1u8; 32],

1767

1

}]

1768

1

				.into(),

1769

1

};

1770

1771

1

			let before_balance =

1772

1

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

1773

1

			let (chain_part, beneficiary) =

1774

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1775

1

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

1776

1

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

1777

1

			let fees_id: VersionedAssetId = AssetId(Location::parent()).into();

1778

1

			let xcm_on_dest = Xcm::<()>(vec![DepositAsset {

1779

1

				assets: Wild(All),

1780

1

				beneficiary: beneficiary.clone(),

1781

1

			}]);

1782

1

			assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1783

1

				origin_of(AccountId::from(ALICE)),

1784

1

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

1785

1

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

1786

1

				Box::new(TransferType::DestinationReserve),

1787

1

				Box::new(fees_id),

1788

1

				Box::new(TransferType::DestinationReserve),

1789

1

				Box::new(VersionedXcm::V5(xcm_on_dest)),

1790

1

				WeightLimit::Limited(4000000000.into())

1791

));

1792

1793

1

			let after_balance =

1794

1

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

1795

			// Balance should have been reduced by the transfer amount plus fees

1796

1

			assert!(after_balance < before_balance);

1797

1

});

1798

1

1799

1800

#[test]

1801

1

fn test_xcm_utils_ml_tp_account() {

1802

1

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

1803

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1804

1

		let expected_address_parent: H160 =

1805

1

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

1806

1

				.unwrap()

1807

1

				.into();

1808

1809

1

		Precompiles::new()

1810

1

			.prepare_test(

1811

				ALICE,

1812

1

				xcm_utils_precompile_address,

1813

1

				XcmUtilsPCall::multilocation_to_address {

1814

1

					location: Location::parent(),

1815

1

},

1816

1817

1

			.expect_cost(

1818

1

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

1819

1

					.read

1820

1

					.saturating_div(WEIGHT_PER_GAS)

1821

1

					.saturating_mul(2),

1822

1823

1

			.expect_no_logs()

1824

1

			.execute_returns(Address(expected_address_parent));

1825

1826

1

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

1827

1

		let expected_address_parachain: H160 =

1828

1

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

1829

1

				&parachain_2000_multilocation,

1830

1831

1

			.unwrap()

1832

1

			.into();

1833

1834

1

		Precompiles::new()

1835

1

			.prepare_test(

1836

				ALICE,

1837

1

				xcm_utils_precompile_address,

1838

1

				XcmUtilsPCall::multilocation_to_address {

1839

1

					location: parachain_2000_multilocation,

1840

1

},

1841

1842

1

			.expect_cost(

1843

1

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

1844

1

					.read

1845

1

					.saturating_div(WEIGHT_PER_GAS)

1846

1

					.saturating_mul(2),

1847

1848

1

			.expect_no_logs()

1849

1

			.execute_returns(Address(expected_address_parachain));

1850

1851

1

		let alice_in_parachain_2000_location = Location::new(

1852

1,

1853

1

1854

1

				Parachain(2000),

1855

1

				AccountKey20 {

1856

1

					network: None,

1857

1

					key: ALICE,

1858

1

},

1859

1

],

1860

);

1861

1

		let expected_address_alice_in_parachain_2000 =

1862

1

			xcm_builder::HashedDescription::<

1863

1

				AccountId,

1864

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

1865

1

			>::convert_location(&alice_in_parachain_2000_location)

1866

1

			.unwrap()

1867

1

			.into();

1868

1869

1

		Precompiles::new()

1870

1

			.prepare_test(

1871

				ALICE,

1872

1

				xcm_utils_precompile_address,

1873

1

				XcmUtilsPCall::multilocation_to_address {

1874

1

					location: alice_in_parachain_2000_location,

1875

1

},

1876

1877

1

			.expect_cost(

1878

1

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

1879

1

					.read

1880

1

					.saturating_div(WEIGHT_PER_GAS)

1881

1

					.saturating_mul(2),

1882

1883

1

			.expect_no_logs()

1884

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

1885

1

});

1886

1

1887

1888

#[test]

1889

1

fn test_nested_batch_calls_from_xcm_transact() {

1890

1

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

1891

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

1892

		// in a future polkadot-sdk version

1893

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

1894

1895

1

		let mut valid_nested_calls =

1896

1

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

1897

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

1898

8

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

1899

8

				calls: vec![valid_nested_calls],

1900

8

});

1901

8

1902

1903

1

		let valid_message = Xcm(vec![Transact {

1904

1

			origin_kind: OriginKind::SovereignAccount,

1905

1

			fallback_max_weight: None,

1906

1

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

1907

1

		}]);

1908

1909

1

		assert!(XcmExecutor::prepare(valid_message, Weight::MAX).is_ok());

1910

1911

1

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

1912

1

			calls: vec![valid_nested_calls],

1913

1

});

1914

1915

1

		let invalid_message = Xcm(vec![Transact {

1916

1

			origin_kind: OriginKind::SovereignAccount,

1917

1

			fallback_max_weight: None,

1918

1

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

1919

1

		}]);

1920

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

1921

1

		assert!(XcmExecutor::prepare(invalid_message, Weight::MAX).is_err());

1922

1

});

1923

1

1924

1925

#[test]

1926

1

fn test_xcm_utils_weight_message() {

1927

1

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

1928

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1929

1

		let expected_weight =

1930

1

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

1931

1932

1

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

1933

1934

1

		let input = XcmUtilsPCall::weight_message {

1935

1

			message: message.into(),

1936

1

};

1937

1938

1

		Precompiles::new()

1939

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1940

1

			.expect_cost(

1941

1

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

1942

1

					.read

1943

1

					.saturating_div(WEIGHT_PER_GAS),

1944

1945

1

			.expect_no_logs()

1946

1

			.execute_returns(expected_weight);

1947

1

});

1948

1

1949

1950

#[test]

1951

1

fn test_xcm_utils_get_units_per_second() {

1952

1

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

1953

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1954

1

		let location = SelfReserve::get();

1955

1956

1

		let input = XcmUtilsPCall::get_units_per_second { location };

1957

1958

1

		let expected_units =

1959

1

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

1960

1961

1

		Precompiles::new()

1962

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1963

1

			.expect_cost(

1964

1

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

1965

1

					.read

1966

1

					.saturating_div(WEIGHT_PER_GAS)

1967

1

					.saturating_mul(2),

1968

1969

1

			.expect_no_logs()

1970

1

			.execute_returns(expected_units);

1971

1

});

1972

1

1973

1974

#[test]

1975

1

fn precompile_existence() {

1976

1

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

1977

1

		let precompiles = Precompiles::new();

1978

1

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

1979

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

1980

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

1981

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

1982

1983

1

		.into_iter()

1984

1

		.map(H160::from_low_u64_be)

1985

1

		.collect();

1986

1987

3001

		for i in 0..3000 {

1988

3000

			let address = H160::from_low_u64_be(i);

1989

1990

3000

			if precompile_addresses.contains(&address) {

1991

47

				assert!(

1992

47

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

1993

					"is_precompile({}) should return true",

1994

1995

);

1996

1997

47

				assert!(

1998

47

					precompiles

1999

47

						.execute(&mut MockHandle::new(

2000

47

							address,

2001

47

							Context {

2002

47

								address,

2003

47

								caller: H160::zero(),

2004

47

								apparent_value: U256::zero()

2005

47

2006

47

),)

2007

47

						.is_some(),

2008

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

2009

2010

);

2011

			} else {

2012

2953

				assert!(

2013

2953

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

2014

					"is_precompile({}) should return false",

2015

2016

);

2017

2018

2953

				assert!(

2019

2953

					precompiles

2020

2953

						.execute(&mut MockHandle::new(

2021

2953

							address,

2022

2953

							Context {

2023

2953

								address,

2024

2953

								caller: H160::zero(),

2025

2953

								apparent_value: U256::zero()

2026

2953

2027

2953

),)

2028

2953

						.is_none(),

2029

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

2030

2031

);

2032

2033

2034

1

});

2035

1

2036

2037

#[test]

2038

1

fn removed_precompiles() {

2039

1

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

2040

1

		let precompiles = Precompiles::new();

2041

1

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

2042

2043

3000

		for i in 1..3000 {

2044

2999

			let address = H160::from_low_u64_be(i);

2045

2046

2999

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

2047

2952

				continue;

2048

47

2049

2050

47

			if !removed_precompiles.contains(&i) {

2051

43

				assert!(

2052

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2053

43

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

2054

						_ => false,

2055

},

2056

					"{i} should be an active precompile"

2057

);

2058

43

				continue;

2059

4

2060

2061

4

			assert!(

2062

4

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

2063

4

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

2064

					_ => false,

2065

},

2066

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

2067

);

2068

2069

4

			precompiles

2070

4

				.prepare_test(Alice, address, [])

2071

4

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

2072

2073

1

})

2074

1

2075

2076

#[test]

2077

1

fn deal_with_fees_handles_tip() {

2078

	use frame_support::traits::OnUnbalanced;

2079

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2080

	use moonriver_runtime::Treasury;

2081

2082

1

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

2083

1

		set_parachain_inherent_data();

2084

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

2085

		// in the Moonriver runtime. It verifies that:

2086

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

2087

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

2088

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

2089

2090

		// The test details:

2091

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

2092

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

2093

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

2094

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

2095

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

2096

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

2097

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

2098

2099

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

2100

1

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

2101

1

			AccountId,

2102

1

		>>::issue(100);

2103

1

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

2104

1

			AccountId,

2105

1

		>>::issue(1000);

2106

2107

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

2108

1

		let total_supply_before = Balances::total_issuance();

2109

1

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

2110

1

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

2111

1

		assert_eq!(total_supply_before, 1_100);

2112

1

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

2113

2114

		// Step 3: Execute the fees handling logic.

2115

1

		DealWithSubstrateFeesAndTip::<

2116

1

			Runtime,

2117

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2118

1

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

2119

2120

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

2121

1

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

2122

2123

1

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

2124

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2125

2126

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

2127

1

		assert_eq!(

2128

1

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

2129

			treasury_fee_part,

2130

);

2131

2132

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

2133

1

		let total_supply_after = Balances::total_issuance();

2134

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2135

2136

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

2137

1

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

2138

1

		assert_eq!(

2139

1

			block_author_balance_after - block_author_balance_before,

2140

			1000,

2141

);

2142

1

});

2143

1

2144

2145

#[test]

2146

1

fn evm_revert_substrate_events() {

2147

1

	ExtBuilder::default()

2148

1

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

2149

1

		.build()

2150

1

		.execute_with(|| {

2151

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2152

2153

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

2154

			// Thus BatchAll will revert the transfer.

2155

1

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

2156

1

				source: ALICE.into(),

2157

1

				target: batch_precompile_address,

2158

1

				input: BatchPCall::batch_all {

2159

1

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

2160

1

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

2161

1

					call_data: vec![].into(),

2162

1

					gas_limit: vec![].into()

2163

1

2164

1

				.into(),

2165

1

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

2166

1

				gas_limit: 500_000,

2167

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2168

1

				max_priority_fee_per_gas: None,

2169

1

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

2170

1

				access_list: Vec::new(),

2171

1

				authorization_list: Vec::new(),

2172

1

})

2173

1

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

2174

2175

1

			let transfer_count = System::events()

2176

1

				.iter()

2177

4

				.filter(|r| match r.event {

2178

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

2179

6

					_ => false,

2180

6

})

2181

1

				.count();

2182

2183

1

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

2184

1

});

2185

1

2186

2187

#[test]

2188

1

fn evm_success_keeps_substrate_events() {

2189

1

	ExtBuilder::default()

2190

1

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

2191

1

		.build()

2192

1

		.execute_with(|| {

2193

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2194

2195

1

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

2196

1

				source: ALICE.into(),

2197

1

				target: batch_precompile_address,

2198

1

				input: BatchPCall::batch_all {

2199

1

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

2200

1

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

2201

1

					call_data: vec![].into(),

2202

1

					gas_limit: vec![].into()

2203

1

2204

1

				.into(),

2205

1

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

2206

1

				gas_limit: 500_000,

2207

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2208

1

				max_priority_fee_per_gas: None,

2209

1

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

2210

1

				access_list: Vec::new(),

2211

1

				authorization_list: Vec::new(),

2212

1

})

2213

1

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

2214

2215

1

			let transfer_count = System::events()

2216

1

				.iter()

2217

6

				.filter(|r| match r.event {

2218

1

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

2219

9

					_ => false,

2220

10

})

2221

1

				.count();

2222

2223

1

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

2224

1

});

2225

1

2226

2227

#[cfg(test)]

2228

mod bridge_tests {

2229

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

2230

	use crate::currency_to_asset;

2231

	use bp_messages::target_chain::DispatchMessageData;

2232

	use bp_messages::ReceptionResult;

2233

	use bp_runtime::messages::MessageDispatchResult;

2234

	use cumulus_primitives_core::AggregateMessageOrigin;

2235

	use frame_support::assert_ok;

2236

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

2237

	use moonbeam_core_primitives::AccountId;

2238

	use moonriver_runtime::bridge_config::{

2239

		PolkadotGlobalConsensusNetwork, WithPolkadotMessagesInstance,

2240

};

2241

	use moonriver_runtime::currency::MOVR;

2242

	use moonriver_runtime::xcm_config::CurrencyId;

2243

	use moonriver_runtime::{

2244

		Balances, BridgePolkadotMessages, BridgeXcmOverMoonbeam, MessageQueue, PolkadotXcm,

2245

		Runtime, RuntimeEvent, System,

2246

};

2247

	use pallet_bridge_messages::LanesManager;

2248

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

2249

	use parity_scale_codec::Encode;

2250

	use sp_core::H256;

2251

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

2252

	use xcm::latest::{

2253

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

2254

};

2255

	use xcm::prelude::{

2256

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

2257

		GlobalConsensus, PalletInstance, Parachain, ReserveAssetDeposited, UniversalOrigin,

2258

		XCM_VERSION,

2259

};

2260

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

2261

	use xcm_builder::BridgeMessage;

2262

2263

1

	fn next_block() {

2264

1

		System::reset_events();

2265

2266

1

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

2267

2268

1

		System::set_block_number(next_block);

2269

1

		System::on_initialize(next_block);

2270

1

		MessageQueue::on_initialize(next_block);

2271

1

2272

2273

	#[test]

2274

1

	fn transfer_asset_moonriver_to_moonbeam() {

2275

1

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

2276

2277

1

		ExtBuilder::default()

2278

1

			.with_balances(vec![

2279

1

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

2280

1

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

2281

1

])

2282

1

			.with_safe_xcm_version(XCM_VERSION)

2283

1

			.with_open_bridges(vec![(

2284

1

				Location::new(

2285

1

1,

2286

1

					[Parachain(

2287

1

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

2288

1

)],

2289

1

),

2290

1

				Junctions::from([

2291

1

					NetworkId::Polkadot.into(),

2292

1

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

2293

1

]),

2294

1

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

2295

1

)])

2296

1

			.build()

2297

1

			.execute_with(|| {

2298

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2299

1

					root_origin(),

2300

1

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

2301

					XCM_VERSION

2302

));

2303

2304

1

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

2305

2306

1

				let message_data = BridgePolkadotMessages::outbound_message_data(

2307

1

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

2308

					1u64,

2309

);

2310

1

				assert!(message_data.is_none());

2311

2312

1

				assert_ok!(PolkadotXcm::transfer_assets(

2313

1

					origin_of(AccountId::from(ALICE)),

2314

1

					Box::new(VersionedLocation::V5(

2315

1

						bp_moonbeam::GlobalConsensusLocation::get()

2316

1

)),

2317

1

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

2318

1

						parents: 0,

2319

1

						interior: [AccountKey20 {

2320

1

							network: None,

2321

1

							key: ALICE,

2322

1

}]

2323

1

						.into(),

2324

1

					})),

2325

1

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

2326

0,

2327

1

					WeightLimit::Unlimited

2328

));

2329

2330

1

				let message_data = BridgePolkadotMessages::outbound_message_data(

2331

1

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

2332

					1u64,

2333

);

2334

1

				assert!(message_data.is_some());

2335

1

})

2336

1

2337

2338

	#[test]

2339

1

	fn receive_message_from_moonbeam() {

2340

1

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

2341

2342

1

		ExtBuilder::default()

2343

1

			.with_balances(vec![

2344

1

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

2345

1

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

2346

1

])

2347

1

			.with_xcm_assets(vec![XcmAssetInitialization {

2348

1

				asset_id: 1,

2349

1

				xcm_location: Location::new(

2350

1

2,

2351

1

2352

1

						GlobalConsensus(PolkadotGlobalConsensusNetwork::get()),

2353

1

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

2354

1

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

2355

1

2356

1

),

2357

1

				name: "xcGLMR",

2358

1

				symbol: "xcGLMR",

2359

1

				decimals: 18,

2360

1

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

2361

1

}])

2362

1

			.with_safe_xcm_version(XCM_VERSION)

2363

1

			.with_open_bridges(vec![(

2364

1

				Location::new(

2365

1

1,

2366

1

					[Parachain(

2367

1

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

2368

1

)],

2369

1

),

2370

1

				Junctions::from([

2371

1

					NetworkId::Polkadot.into(),

2372

1

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

2373

1

]),

2374

1

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

2375

1

)])

2376

1

			.build()

2377

1

			.execute_with(|| {

2378

1

				let bridge_message: BridgeMessage = BridgeMessage {

2379

1

					universal_dest: VersionedInteriorLocation::V5(

2380

1

2381

1

							GlobalConsensus(NetworkId::Kusama),

2382

1

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

2383

1

						].into()

2384

1

),

2385

1

					message: VersionedXcm::V5(

2386

1

						Xcm(

2387

1

2388

1

								UniversalOrigin(GlobalConsensus(NetworkId::Polkadot)),

2389

1

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

2390

1

								ReserveAssetDeposited(

2391

1

									vec![

2392

1

										Asset {

2393

1

											id: AssetId(

2394

1

												Location::new(

2395

1

2,

2396

1

2397

1

														GlobalConsensus(NetworkId::Polkadot),

2398

1

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

2399

1

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

2400

1

2401

1

2402

1

),

2403

1

											fun: Fungible(2 * MOVR)

2404

1

2405

1

									].into()

2406

1

),

2407

1

								ClearOrigin,

2408

1

								BuyExecution {

2409

1

									fees: Asset {

2410

1

										id: AssetId(

2411

1

											Location::new(

2412

1

2,

2413

1

2414

1

													GlobalConsensus(NetworkId::Polkadot),

2415

1

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

2416

1

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

2417

1

2418

1

2419

1

),

2420

1

										fun:  Fungible(MOVR / 2)

2421

1

},

2422

1

									weight_limit: WeightLimit::Unlimited

2423

1

},

2424

1

								DepositAsset {

2425

1

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

2426

1

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

2427

1

2428

1

							].into()

2429

1

2430

1

2431

1

};

2432

2433

1

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

2434

1

					.active_inbound_lane(Default::default())

2435

1

					.unwrap();

2436

2437

1

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

2438

1

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

2439

1

					&AccountId::from(ALICE),

2440

1,

2441

1

					msg,

2442

);

2443

2444

1

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

2445

2446

				// Produce next block

2447

1

				next_block();

2448

				// Confirm that the xcm message was successfully processed

2449

7

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

2450

1

					matches!(

2451

1

						evt.event,

2452

						RuntimeEvent::MessageQueue(

2453

							pallet_message_queue::Event::Processed {

2454

								origin: AggregateMessageOrigin::Here,

2455

								success: true,

2456

..

2457

2458

2459

2460

7

				}));

2461

1

});

2462

1

2463

2464

2465

#[cfg(test)]

2466

mod treasury_tests {

2467

	use super::*;

2468

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

2469

	use moonriver_runtime::XcmWeightTrader;

2470

	use sp_core::bounded_vec;

2471

	use sp_runtime::traits::Hash;

2472

2473

4

	fn expect_events(events: Vec<RuntimeEvent>) {

2474

4

		let block_events: Vec<RuntimeEvent> =

2475

4

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

2476

2477

7

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

2478

4

2479

2480

7

	fn next_block() {

2481

7

		System::reset_events();

2482

7

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

2483

7

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

2484

7

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

2485

7

2486

2487

3

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

2488

3

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

2489

3

			.expect("failed to get account balance")

2490

3

2491

2492

	#[test]

2493

1

	fn test_treasury_spend_local_with_council_origin() {

2494

1

		let initial_treasury_balance = 1_000 * MOVR;

2495

1

		ExtBuilder::default()

2496

1

			.with_balances(vec![

2497

1

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

2498

1

				(Treasury::account_id(), initial_treasury_balance),

2499

1

])

2500

1

			.build()

2501

1

			.execute_with(|| {

2502

1

				let spend_amount = 100u128 * MOVR;

2503

1

				let spend_beneficiary = AccountId::from(BOB);

2504

2505

1

				next_block();

2506

2507

				// TreasuryCouncilCollective

2508

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2509

1

					root_origin(),

2510

1

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

2511

1

					Some(AccountId::from(ALICE)),

2512

2513

));

2514

2515

1

				next_block();

2516

2517

				// Perform treasury spending

2518

1

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

2519

1

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

2520

1

					amount: spend_amount,

2521

1

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

2522

1

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

2523

1

					valid_from: Some(valid_from),

2524

1

});

2525

1

				assert_ok!(TreasuryCouncilCollective::propose(

2526

1

					origin_of(AccountId::from(ALICE)),

2527

1,

2528

1

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

2529

					1_000

2530

));

2531

2532

1

				let payout_period =

2533

1

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

2534

1

				let expected_events = [

2535

1

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

2536

1

						index: 0,

2537

1

						asset_kind: NativeOrWithId::Native,

2538

1

						amount: spend_amount,

2539

1

						beneficiary: spend_beneficiary,

2540

1

						valid_from,

2541

1

						expire_at: payout_period + valid_from,

2542

1

}),

2543

1

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

2544

1

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

2545

1

						result: Ok(()),

2546

1

}),

2547

1

2548

1

				.to_vec();

2549

1

				expect_events(expected_events);

2550

2551

6

				while System::block_number() < valid_from {

2552

5

					next_block();

2553

5

2554

2555

1

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

2556

2557

1

				let expected_events = [

2558

1

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

2559

1

						index: 0,

2560

1

						payment_id: (),

2561

1

}),

2562

1

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

2563

1

						from: Treasury::account_id(),

2564

1

						to: spend_beneficiary,

2565

1

						amount: spend_amount,

2566

1

}),

2567

1

2568

1

				.to_vec();

2569

1

				expect_events(expected_events);

2570

1

});

2571

1

2572

2573

	#[test]

2574

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2575

1

		let initial_treasury_balance = 1_000 * MOVR;

2576

1

		let asset_id = 1000100010001000u128;

2577

1

		ExtBuilder::default()

2578

1

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

2579

1

			.build()

2580

1

			.execute_with(|| {

2581

1

				let spend_amount = 100u128 * MOVR;

2582

1

				let spend_beneficiary = AccountId::from(BOB);

2583

2584

1

				let asset_location: Location = Location {

2585

1

					parents: 1,

2586

1

					interior: Junctions::Here,

2587

1

};

2588

2589

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2590

1

					root_origin(),

2591

1

					asset_id,

2592

1

					asset_location.clone(),

2593

12,

2594

1

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

2595

1

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

2596

));

2597

2598

1

				assert_ok!(XcmWeightTrader::add_asset(

2599

1

					root_origin(),

2600

1

					asset_location,

2601

					1u128

2602

));

2603

2604

1

				assert_ok!(EvmForeignAssets::mint_into(

2605

1

					asset_id,

2606

1

					Treasury::account_id(),

2607

1

					initial_treasury_balance.into()

2608

));

2609

2610

1

				assert_eq!(

2611

1

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

2612

1

					initial_treasury_balance.into(),

2613

					"Treasury balance not updated"

2614

);

2615

2616

				// TreasuryCouncilCollective

2617

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2618

1

					root_origin(),

2619

1

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

2620

1

					Some(AccountId::from(ALICE)),

2621

2622

));

2623

2624

				// Perform treasury spending

2625

1

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

2626

1

					amount: spend_amount,

2627

1

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

2628

1

					beneficiary: Box::new(spend_beneficiary),

2629

1

					valid_from: None,

2630

1

});

2631

1

				assert_ok!(TreasuryCouncilCollective::propose(

2632

1

					origin_of(AccountId::from(ALICE)),

2633

1,

2634

1

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

2635

					1_000

2636

));

2637

2638

1

				let payout_period =

2639

1

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

2640

2641

1

				let current_block = System::block_number();

2642

1

				let expected_events = [

2643

1

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

2644

1

						index: 0,

2645

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2646

1

						amount: spend_amount,

2647

1

						beneficiary: spend_beneficiary,

2648

1

						valid_from: current_block,

2649

1

						expire_at: current_block + payout_period,

2650

1

}),

2651

1

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

2652

1

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

2653

1

						result: Ok(()),

2654

1

}),

2655

1

2656

1

				.to_vec();

2657

1

				expect_events(expected_events);

2658

2659

1

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

2660

2661

1

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

2662

1

					index: 0,

2663

1

					payment_id: (),

2664

1

				})]);

2665

2666

1

				assert_eq!(

2667

1

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

2668

1

					(initial_treasury_balance - spend_amount).into(),

2669

					"Treasury balance not updated"

2670

);

2671

2672

1

				assert_eq!(

2673

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2674

1

					spend_amount.into(),

2675

					"Treasury payout failed"

2676

);

2677

1

});

2678

1

2679

2680

2681

#[cfg(test)]

2682

mod fee_tests {

2683

	use super::*;

2684

	use fp_evm::FeeCalculator;

2685

	use frame_support::{

2686

		traits::{ConstU128, OnFinalize},

2687

		weights::{ConstantMultiplier, WeightToFee},

2688

};

2689

	use moonriver_runtime::{

2690

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2691

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2692

};

2693

	use sp_core::Get;

2694

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

2695

2696

1

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

2697

1

	where

2698

1

		F: FnMut() -> (),

2699

2700

1

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

2701

1

			.build_storage()

2702

1

			.unwrap()

2703

1

			.into();

2704

1

		t.execute_with(|| {

2705

1

			System::set_block_consumed_resources(w, 0);

2706

1

			assertions()

2707

1

});

2708

1

2709

2710

	#[test]

2711

1

	fn test_multiplier_can_grow_from_zero() {

2712

1

		let minimum_multiplier = MinimumMultiplier::get();

2713

1

		let target = TargetBlockFullness::get()

2714

1

			* RuntimeBlockWeights::get()

2715

1

				.get(DispatchClass::Normal)

2716

1

				.max_total

2717

1

				.unwrap();

2718

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

2719

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

2720

1

		run_with_system_weight(target * 101 / 100, || {

2721

1

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

2722

1

			assert!(

2723

1

				next > minimum_multiplier,

2724

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

2725

				next,

2726

				minimum_multiplier

2727

);

2728

1

})

2729

1

2730

2731

	#[test]

2732

1

	fn test_fee_calculation() {

2733

1

		let base_extrinsic = RuntimeBlockWeights::get()

2734

1

			.get(DispatchClass::Normal)

2735

1

			.base_extrinsic;

2736

1

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

2737

1

		let extrinsic_len = 100u32;

2738

1

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

2739

1

		let tip = 42u128;

2740

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

2741

		type LengthToFeeImpl = LengthToFee;

2742

2743

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

2744

1

		let expected_fee = WeightToFeeImpl::weight_to_fee(&base_extrinsic)

2745

1

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

2746

1

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

2747

1

			+ tip;

2748

2749

1

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

2750

1

			.build_storage()

2751

1

			.unwrap()

2752

1

			.into();

2753

1

		t.execute_with(|| {

2754

1

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

2755

1

			let actual_fee = TransactionPayment::compute_fee(

2756

1

				extrinsic_len,

2757

1

				&frame_support::dispatch::DispatchInfo {

2758

1

					class: DispatchClass::Normal,

2759

1

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

2760

1

					call_weight: extrinsic_weight,

2761

1

					extension_weight: Weight::zero(),

2762

1

},

2763

1

				tip,

2764

);

2765

2766

1

			assert_eq!(

2767

				expected_fee,

2768

				actual_fee,

2769

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

2770

				actual_fee - expected_fee

2771

);

2772

1

});

2773

1

2774

2775

	#[test]

2776

1

	fn test_min_gas_price_is_deterministic() {

2777

1

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

2778

1

			.build_storage()

2779

1

			.unwrap()

2780

1

			.into();

2781

1

		t.execute_with(|| {

2782

1

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

2783

1

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

2784

1

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

2785

1

			let expected: U256 = multiplier

2786

1

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

2787

1

				.into();

2788

2789

1

			assert_eq!(expected, actual);

2790

1

});

2791

1

2792

2793

	#[test]

2794

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

2795

1

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

2796

1

			.build_storage()

2797

1

			.unwrap()

2798

1

			.into();

2799

1

		t.execute_with(|| {

2800

1

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

2801

1

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

2802

2803

1

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

2804

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

2805

1

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

2806

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

2807

2808

1

			assert_ne!(

2809

				a, b,

2810

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

2811

);

2812

1

});

2813

1

2814

2815

	#[test]

2816

1

	fn test_fee_scenarios() {

2817

		use sp_runtime::FixedU128;

2818

1

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

2819

1

			.build_storage()

2820

1

			.unwrap()

2821

1

			.into();

2822

1

		t.execute_with(|| {

2823

1

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

2824

12

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

2825

12

				let start_multiplier =

2826

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

2827

12

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

2828

2829

12

				let block_weight = NORMAL_WEIGHT * fullness;

2830

2831

60004

				for i in 0..num_blocks {

2832

60004

					System::set_block_number(i as u32);

2833

60004

					System::set_block_consumed_resources(block_weight, 0);

2834

60004

					TransactionPayment::on_finalize(i as u32);

2835

60004

2836

2837

12

				TransactionPaymentAsGasPrice::min_gas_price().0

2838

12

};

2839

2840

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

2841

			// they are expected to change when parameters that influence

2842

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

2843

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

2844

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

2845

2846

1

			assert_eq!(

2847

1

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

2848

1

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

2849

);

2850

1

			assert_eq!(

2851

1

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

2852

1

				U256::from(312_500_000u128),

2853

);

2854

1

			assert_eq!(

2855

1

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

2856

1

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

2857

);

2858

1

			assert_eq!(

2859

1

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

2860

1

				U256::from(313_313_556u128),

2861

);

2862

2863

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

2864

1

			assert_eq!(

2865

1

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

2866

1

				U256::from(312_500_000u128),

2867

);

2868

1

			assert_eq!(

2869

1

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

2870

1

				U256::from(312_500_000u128),

2871

);

2872

1

			assert_eq!(

2873

1

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

2874

1

				U256::from(447_915_432u128),

2875

);

2876

1

			assert_eq!(

2877

1

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

2878

1

				U256::from(1_487_129_030u128),

2879

);

2880

2881

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

2882

1

			assert_eq!(

2883

1

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

2884

1

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

2885

);

2886

1

			assert_eq!(

2887

1

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

2888

1

				U256::from(312_500_000u128),

2889

);

2890

1

			assert_eq!(

2891

1

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

2892

1

				U256::from(1_766_664_654_709u128),

2893

);

2894

1

			assert_eq!(

2895

1

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

2896

1

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

2897

);

2898

1

});

2899

1

2900

2901

2902

#[cfg(test)]

2903

mod balance_tests {

2904

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

2905

	use frame_support::assert_ok;

2906

	use frame_support::traits::LockableCurrency;

2907

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

2908

	use moonbeam_core_primitives::AccountId;

2909

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

2910

2911

	#[test]

2912

1

	fn reserve_should_work_for_frozen_balance() {

2913

1

		let alice = AccountId::from(ALICE);

2914

		const ID_1: LockIdentifier = *b"1       ";

2915

2916

1

		ExtBuilder::default()

2917

1

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

2918

1

			.build()

2919

1

			.execute_with(|| {

2920

				// Check balances

2921

1

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

2922

1

				assert_eq!(account.free, 10);

2923

1

				assert_eq!(account.frozen, 0);

2924

1

				assert_eq!(account.reserved, 0);

2925

2926

1

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

2927

2928

1

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

2929

1

				assert_eq!(account.free, 10);

2930

1

				assert_eq!(account.frozen, 9);

2931

1

				assert_eq!(account.reserved, 0);

2932

2933

1

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

2934

2935

1

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

2936

1

				assert_eq!(account.free, 5);

2937

1

				assert_eq!(account.frozen, 9);

2938

1

				assert_eq!(account.reserved, 5);

2939

2940

1

				let previous_reserved_amount = account.reserved;

2941

1

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

2942

1

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

2943

1

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

2944

2945

1

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

2946

1

				assert_eq!(account.free, ed);

2947

1

				assert_eq!(account.frozen, 9);

2948

1

				assert_eq!(

2949

					account.reserved,

2950

1

					previous_reserved_amount.saturating_add(next_reserve)

2951

);

2952

1

});

2953

1

2954

2955

2956

moonbeam_runtime_common::generate_common_xcm_tests!(moonriver_runtime);