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

/// Helper function to set fee per second for an asset location (for compatibility with old tests).

95

/// Converts fee_per_second to relative_price and adds/edits the asset in the weight-trader.

96

1

fn set_fee_per_second_for_location(location: Location, fee_per_second: u128) -> Result<(), ()> {

97

	use frame_support::weights::WeightToFee as _;

98

1

	let native_amount_per_second: u128 =

99

1

		<moonriver_runtime::Runtime as pallet_xcm_weight_trader::Config>::WeightToFee::weight_to_fee(

100

1

			&Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, 0),

101

102

1

		.try_into()

103

1

		.map_err(|_| ())?;

104

1

	let precision_factor = 10u128.pow(pallet_xcm_weight_trader::RELATIVE_PRICE_DECIMALS);

105

1

	let relative_price: u128 = if fee_per_second > 0u128 {

106

1

		native_amount_per_second

107

1

			.saturating_mul(precision_factor)

108

1

			.saturating_div(fee_per_second)

109

	} else {

110

		0u128

111

};

112

1

	if pallet_xcm_weight_trader::SupportedAssets::<moonriver_runtime::Runtime>::contains_key(

113

1

		&location,

114

) {

115

1

		let enabled =

116

1

			pallet_xcm_weight_trader::SupportedAssets::<moonriver_runtime::Runtime>::get(&location)

117

1

				.ok_or(())?

118

.0;

119

1

		pallet_xcm_weight_trader::SupportedAssets::<moonriver_runtime::Runtime>::insert(

120

1

			&location,

121

1

			(enabled, relative_price),

122

);

123

	} else {

124

		pallet_xcm_weight_trader::SupportedAssets::<moonriver_runtime::Runtime>::insert(

125

			&location,

126

			(true, relative_price),

127

);

128

129

1

	Ok(())

130

1

131

132

#[test]

133

1

fn xcmp_queue_controller_origin_is_root() {

134

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

135

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

136

1

	assert_ok!(

137

1

		<moonriver_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

138

1

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

139

);

140

1

141

142

#[test]

143

1

fn verify_pallet_prefixes() {

144

31

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

145

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

146

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

147

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

148

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

149

		// expand/storage.rs#L389-L401

150

31

		assert_eq!(

151

31

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

152

31

			Some(name)

153

);

154

31

155

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

156

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

157

1

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

158

1

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

159

1

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

160

1

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

161

1

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

162

1

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

163

1

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

164

1

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

165

1

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

166

1

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

167

1

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

168

1

	is_pallet_prefix::<moonriver_runtime::OpenTechCommitteeCollective>(

169

1

		"OpenTechCommitteeCollective",

170

);

171

1

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

172

1

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

173

1

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

174

1

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

175

1

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

176

1

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

177

1

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

178

1

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

179

1

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

180

1

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

181

1

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

182

1

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

183

1

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

184

1

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

185

1

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

186

1

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

187

1

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

188

1

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

189

1

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

190

191

14

	let prefix = |pallet_name, storage_name| {

192

14

		let mut res = [0u8; 32];

193

14

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

194

14

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

195

14

		res.to_vec()

196

14

};

197

1

	assert_eq!(

198

1

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

199

1

		vec![

200

1

			StorageInfo {

201

1

				pallet_name: b"Timestamp".to_vec(),

202

1

				storage_name: b"Now".to_vec(),

203

1

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

204

1

				max_values: Some(1),

205

1

				max_size: Some(8),

206

1

},

207

1

			StorageInfo {

208

1

				pallet_name: b"Timestamp".to_vec(),

209

1

				storage_name: b"DidUpdate".to_vec(),

210

1

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

211

1

				max_values: Some(1),

212

1

				max_size: Some(1),

213

1

214

215

);

216

1

	assert_eq!(

217

1

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

218

1

		vec![

219

1

			StorageInfo {

220

1

				pallet_name: b"Balances".to_vec(),

221

1

				storage_name: b"TotalIssuance".to_vec(),

222

1

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

223

1

				max_values: Some(1),

224

1

				max_size: Some(16),

225

1

},

226

1

			StorageInfo {

227

1

				pallet_name: b"Balances".to_vec(),

228

1

				storage_name: b"InactiveIssuance".to_vec(),

229

1

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

230

1

				max_values: Some(1),

231

1

				max_size: Some(16),

232

1

},

233

1

			StorageInfo {

234

1

				pallet_name: b"Balances".to_vec(),

235

1

				storage_name: b"Account".to_vec(),

236

1

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

237

1

				max_values: None,

238

1

				max_size: Some(100),

239

1

},

240

1

			StorageInfo {

241

1

				pallet_name: b"Balances".to_vec(),

242

1

				storage_name: b"Locks".to_vec(),

243

1

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

244

1

				max_values: None,

245

1

				max_size: Some(1287),

246

1

},

247

1

			StorageInfo {

248

1

				pallet_name: b"Balances".to_vec(),

249

1

				storage_name: b"Reserves".to_vec(),

250

1

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

251

1

				max_values: None,

252

1

				max_size: Some(1037),

253

1

},

254

1

			StorageInfo {

255

1

				pallet_name: b"Balances".to_vec(),

256

1

				storage_name: b"Holds".to_vec(),

257

1

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

258

1

				max_values: None,

259

1

				max_size: Some(91),

260

1

},

261

1

			StorageInfo {

262

1

				pallet_name: b"Balances".to_vec(),

263

1

				storage_name: b"Freezes".to_vec(),

264

1

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

265

1

				max_values: None,

266

1

				max_size: Some(73),

267

1

},

268

269

);

270

1

	assert_eq!(

271

1

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

272

1

		vec![

273

1

			StorageInfo {

274

1

				pallet_name: b"Proxy".to_vec(),

275

1

				storage_name: b"Proxies".to_vec(),

276

1

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

277

1

				max_values: None,

278

1

				max_size: Some(845),

279

1

},

280

1

			StorageInfo {

281

1

				pallet_name: b"Proxy".to_vec(),

282

1

				storage_name: b"Announcements".to_vec(),

283

1

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

284

1

				max_values: None,

285

1

				max_size: Some(1837),

286

1

287

288

);

289

1

	assert_eq!(

290

1

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

291

1

		vec![StorageInfo {

292

1

			pallet_name: b"MaintenanceMode".to_vec(),

293

1

			storage_name: b"MaintenanceMode".to_vec(),

294

1

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

295

1

			max_values: Some(1),

296

1

			max_size: None,

297

1

},]

298

);

299

1

	assert_eq!(

300

1

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

301

1

		vec![

302

1

			StorageInfo {

303

1

				pallet_name: b"RelayStorageRoots".to_vec(),

304

1

				storage_name: b"RelayStorageRoot".to_vec(),

305

1

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

306

1

				max_values: None,

307

1

				max_size: Some(44),

308

1

},

309

1

			StorageInfo {

310

1

				pallet_name: b"RelayStorageRoots".to_vec(),

311

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

312

1

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

313

1

				max_values: Some(1),

314

1

				max_size: Some(121),

315

1

},

316

317

);

318

1

319

320

#[test]

321

1

fn test_collectives_storage_item_prefixes() {

322

7

	for StorageInfo { pallet_name, .. } in

323

1

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

324

325

7

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

326

327

328

7

	for StorageInfo { pallet_name, .. } in

329

1

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

330

331

7

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

332

333

1

334

335

#[test]

336

1

fn collective_set_members_root_origin_works() {

337

1

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

338

		// TreasuryCouncilCollective

339

1

		assert_ok!(TreasuryCouncilCollective::set_members(

340

1

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

341

1

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

342

1

			Some(AccountId::from(ALICE)),

343

344

));

345

		// OpenTechCommitteeCollective

346

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

347

1

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

348

1

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

349

1

			Some(AccountId::from(ALICE)),

350

351

));

352

1

});

353

1

354

355

#[test]

356

1

fn collective_set_members_general_admin_origin_works() {

357

	use moonriver_runtime::{

358

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

359

};

360

361

1

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

362

1

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

363

1

		let alice = AccountId::from(ALICE);

364

365

		// TreasuryCouncilCollective

366

1

		let _ = Utility::dispatch_as(

367

1

			root_caller.clone(),

368

1

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

369

1

			Box::new(

370

1

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

371

1

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

372

1

					prime: Some(alice),

373

1

					old_count: 2,

374

1

375

1

				.into(),

376

1

),

377

1

);

378

		// OpenTechCommitteeCollective

379

1

		let _ = Utility::dispatch_as(

380

1

			root_caller,

381

1

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

382

1

			Box::new(

383

1

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

384

1

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

385

1

					prime: Some(alice),

386

1

					old_count: 2,

387

1

388

1

				.into(),

389

1

),

390

1

);

391

392

1

		assert_eq!(

393

1

			System::events()

394

1

				.into_iter()

395

2

				.filter_map(|r| {

396

2

					match r.event {

397

2

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

398

2

							if result.is_ok() =>

399

400

2

							Some(true)

401

402

						_ => None,

403

404

2

})

405

1

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

406

1

				.len(),

407

408

409

1

});

410

1

411

412

#[test]

413

1

fn collective_set_members_signed_origin_does_not_work() {

414

1

	let alice = AccountId::from(ALICE);

415

1

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

416

		// TreasuryCouncilCollective

417

1

		assert!(TreasuryCouncilCollective::set_members(

418

1

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

419

1

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

420

1

			Some(AccountId::from(ALICE)),

421

1

422

1

423

1

		.is_err());

424

		// OpenTechCommitteeCollective

425

1

		assert!(OpenTechCommitteeCollective::set_members(

426

1

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

427

1

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

428

1

			Some(AccountId::from(ALICE)),

429

1

430

1

431

1

		.is_err());

432

1

});

433

1

434

435

#[test]

436

1

fn verify_pallet_indices() {

437

33

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

438

33

		assert_eq!(

439

33

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

440

33

			Some(index)

441

);

442

33

443

	// System support

444

1

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

445

1

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

446

1

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

447

1

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

448

	// Monetary

449

1

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

450

1

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

451

	// Consensus support

452

1

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

453

1

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

454

1

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

455

1

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

456

1

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

457

	// Handy utilities

458

1

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

459

1

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

460

1

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

461

1

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

462

1

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

463

1

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

464

	// Ethereum compatibility

465

1

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

466

1

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

467

1

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

468

	// Governance

469

1

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

470

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

471

	// Council

472

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

473

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

474

1

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

475

1

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

476

	// Treasury

477

1

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

478

	// Crowdloan

479

1

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

480

	// XCM Stuff

481

1

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

482

1

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

483

1

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

484

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

485

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

486

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

487

1

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

488

1

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

489

1

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

490

1

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

491

1

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

492

1

493

494

#[test]

495

1

fn verify_reserved_indices() {

496

1

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

497

1

		.build_storage()

498

1

		.unwrap()

499

1

		.into();

500

501

1

	t.execute_with(|| {

502

		use frame_metadata::*;

503

1

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

504

1

		let metadata = match metadata.1 {

505

1

			RuntimeMetadata::V14(metadata) => metadata,

506

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

507

};

508

		// 40: Sudo

509

		// 53: BaseFee

510

		// 108: pallet_assets::<Instance1>

511

1

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

512

1

		let existing = metadata

513

1

			.pallets

514

1

			.iter()

515

1

			.map(|p| p.index)

516

1

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

517

3

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

518

1

});

519

1

520

521

#[test]

522

1

fn verify_proxy_type_indices() {

523

1

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

524

1

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

525

1

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

526

1

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

527

1

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

528

1

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

529

1

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

530

1

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

531

1

532

533

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

534

#[test]

535

1

fn verify_normal_filter_allow_pure_proxy() {

536

1

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

537

1

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

538

1

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

539

1

				proxy_type: ProxyType::Any,

540

1

				delay: 0,

541

1

				index: 0,

542

1

543

1

		)));

544

1

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

545

1

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

546

1

				spawner: AccountId::from(ALICE),

547

1

				proxy_type: ProxyType::Any,

548

1

				index: 0,

549

1

				height: 0,

550

1

				ext_index: 0,

551

1

552

1

		)));

553

1

});

554

1

555

556

#[test]

557

1

fn join_collator_candidates() {

558

1

	ExtBuilder::default()

559

1

		.with_balances(vec![

560

1

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

561

1

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

562

1

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

563

1

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

564

1

])

565

1

		.with_collators(vec![

566

1

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

567

1

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

568

1

])

569

1

		.with_delegations(vec![

570

1

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

571

1

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

572

1

])

573

1

		.build()

574

1

		.execute_with(|| {

575

1

			assert_noop!(

576

1

				ParachainStaking::join_candidates(

577

1

					origin_of(AccountId::from(ALICE)),

578

1

					10_000 * MOVR,

579

					2u32

580

),

581

1

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

582

);

583

1

			assert_noop!(

584

1

				ParachainStaking::join_candidates(

585

1

					origin_of(AccountId::from(CHARLIE)),

586

1

					10_000 * MOVR,

587

					2u32

588

),

589

1

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

590

);

591

1

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

592

1

			assert_ok!(ParachainStaking::join_candidates(

593

1

				origin_of(AccountId::from(DAVE)),

594

1

				10_000 * MOVR,

595

				2u32

596

));

597

1

			assert_eq!(

598

1

				last_event(),

599

1

				RuntimeEvent::ParachainStaking(

600

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

601

1

						account: AccountId::from(DAVE),

602

1

						amount_locked: 10_000 * MOVR,

603

1

						new_total_amt_locked: 30_100 * MOVR

604

1

605

1

606

);

607

1

			let candidates = ParachainStaking::candidate_pool();

608

1

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

609

1

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

610

1

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

611

1

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

612

1

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

613

1

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

614

1

});

615

1

616

617

#[test]

618

1

fn transfer_through_evm_to_stake() {

619

1

	ExtBuilder::default()

620

1

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

621

1

		.build()

622

1

		.execute_with(|| {

623

			// Charlie has no balance => fails to stake

624

1

			assert_noop!(

625

1

				ParachainStaking::join_candidates(

626

1

					origin_of(AccountId::from(CHARLIE)),

627

1

					10_000 * MOVR,

628

					2u32

629

),

630

1

				DispatchError::Module(ModuleError {

631

1

					index: 20,

632

1

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

633

1

					message: Some("InsufficientBalance")

634

1

})

635

);

636

			// Alice transfer from free balance 20000 MOVR to Bob

637

1

			assert_ok!(Balances::transfer_allow_death(

638

1

				origin_of(AccountId::from(ALICE)),

639

1

				AccountId::from(BOB),

640

1

				20_000 * MOVR,

641

));

642

1

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

643

644

1

			let gas_limit = 100000u64;

645

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

646

			// Bob transfers 10000 MOVR to Charlie via EVM

647

1

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

648

1

				source: H160::from(BOB),

649

1

				target: H160::from(CHARLIE),

650

1

				input: vec![],

651

1

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

652

1

				gas_limit,

653

1

				max_fee_per_gas: gas_price,

654

1

				max_priority_fee_per_gas: None,

655

1

				nonce: None,

656

1

				access_list: Vec::new(),

657

1

				authorization_list: Vec::new(),

658

1

})

659

1

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

660

1

			assert_eq!(

661

1

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

662

				10_000 * MOVR,

663

);

664

665

			// Charlie can stake now

666

1

			assert_ok!(ParachainStaking::join_candidates(

667

1

				origin_of(AccountId::from(CHARLIE)),

668

1

				10_000 * MOVR,

669

				2u32,

670

			),);

671

1

			let candidates = ParachainStaking::candidate_pool();

672

1

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

673

1

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

674

1

});

675

1

676

677

#[test]

678

1

fn reward_block_authors() {

679

1

	ExtBuilder::default()

680

1

		.with_balances(vec![

681

1

			// Alice gets 100 extra tokens for her mapping deposit

682

1

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

683

1

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

684

1

])

685

1

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

686

1

		.with_delegations(vec![(

687

1

			AccountId::from(BOB),

688

1

			AccountId::from(ALICE),

689

1

			500 * MOVR,

690

1

)])

691

1

		.with_mappings(vec![(

692

1

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

693

1

			AccountId::from(ALICE),

694

1

)])

695

1

		.build()

696

1

		.execute_with(|| {

697

1

			increase_last_relay_slot_number(1);

698

699

			// Just before round 3

700

1

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

701

702

			// no rewards doled out yet

703

1

			assert_eq!(

704

1

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

705

				10_100 * MOVR,

706

);

707

1

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

708

1

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

709

710

			// rewards minted and distributed

711

1

			assert_eq!(

712

1

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

713

				11547666666208000000000,

714

);

715

1

			assert_eq!(

716

1

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

717

				9557333332588000000000,

718

);

719

1

});

720

1

721

722

#[test]

723

1

fn reward_block_authors_with_parachain_bond_reserved() {

724

1

	ExtBuilder::default()

725

1

		.with_balances(vec![

726

1

			// Alice gets 100 extra tokens for her mapping deposit

727

1

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

728

1

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

729

1

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

730

1

])

731

1

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

732

1

		.with_delegations(vec![(

733

1

			AccountId::from(BOB),

734

1

			AccountId::from(ALICE),

735

1

			500 * MOVR,

736

1

)])

737

1

		.with_mappings(vec![(

738

1

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

739

1

			AccountId::from(ALICE),

740

1

)])

741

1

		.build()

742

1

		.execute_with(|| {

743

1

			increase_last_relay_slot_number(1);

744

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

745

1

				root_origin(),

746

1

747

1

					InflationDistributionAccount {

748

1

						account: AccountId::from(CHARLIE),

749

1

						percent: Percent::from_percent(30),

750

1

},

751

1

					InflationDistributionAccount::default(),

752

1

753

1

				.into()

754

));

755

756

			// Stop just before round 2

757

1

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

758

759

			// no collator rewards doled out yet

760

1

			assert_eq!(

761

1

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

762

				10_100 * MOVR,

763

);

764

1

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

765

766

			// Go to round 2

767

1

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

768

769

			// 30% reserved for parachain bond

770

1

			assert_eq!(

771

1

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

772

				452515000000000000000,

773

);

774

775

			// Go to round 3

776

1

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

777

778

			// rewards minted and distributed

779

1

			assert_eq!(

780

1

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

781

				11117700475903800000000,

782

);

783

1

			assert_eq!(

784

1

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

785

				9535834523343675000000,

786

);

787

			// 30% reserved for parachain bond again

788

1

			assert_eq!(

789

1

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

790

				910802725000000000000,

791

);

792

1

});

793

1

794

795

1

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

796

1

where

797

1

	F: FnMut() -> (),

798

799

1

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

800

1

		.build_storage()

801

1

		.unwrap()

802

1

		.into();

803

1

	t.execute_with(|| {

804

1

		System::set_block_consumed_resources(w, 0);

805

1

		assertions()

806

1

});

807

1

808

809

#[test]

810

#[rustfmt::skip]

811

1

fn length_fee_is_sensible() {

812

	use sp_runtime::testing::TestXt;

813

814

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

815

1

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

816

1

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

817

1

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

818

819

9

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

820

9

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

821

9

				.inclusion_fee

822

9

				.expect("fee should be calculated")

823

9

				.len_fee

824

9

};

825

826

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

827

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

828

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

829

		//                             |           |

830

1

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

831

1

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

832

1

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

833

1

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

834

1

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

835

1

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

836

1

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

837

1

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

838

1

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

839

1

});

840

1

841

842

#[test]

843

1

fn multiplier_can_grow_from_zero() {

844

	use frame_support::traits::Get;

845

846

1

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

847

1

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

848

1

		* RuntimeBlockWeights::get()

849

1

			.get(DispatchClass::Normal)

850

1

			.max_total

851

1

			.unwrap();

852

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

853

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

854

1

	run_with_system_weight(target * 101 / 100, || {

855

1

		let next =

856

1

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

857

1

		assert!(

858

1

			next > minimum_multiplier,

859

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

860

			next,

861

			minimum_multiplier

862

);

863

1

})

864

1

865

866

#[test]

867

1

fn ethereum_invalid_transaction() {

868

1

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

869

1

		set_parachain_inherent_data();

870

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

871

		// on chain is rejected.

872

1

		assert_eq!(

873

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

874

			Err(

875

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

876

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

877

878

879

);

880

1

});

881

1

882

883

#[test]

884

1

fn initial_gas_fee_is_correct() {

885

	use fp_evm::FeeCalculator;

886

887

1

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

888

1

		let multiplier = TransactionPayment::next_fee_multiplier();

889

1

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

890

891

1

		assert_eq!(

892

1

			TransactionPaymentAsGasPrice::min_gas_price(),

893

1

894

1

				3_125_000_000u128.into(),

895

1

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

896

1

897

);

898

1

});

899

1

900

901

#[test]

902

1

fn min_gas_fee_is_correct() {

903

	use fp_evm::FeeCalculator;

904

	use frame_support::traits::Hooks;

905

906

1

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

907

1

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

908

1

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

909

910

1

		let multiplier = TransactionPayment::next_fee_multiplier();

911

1

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

912

913

1

		assert_eq!(

914

1

			TransactionPaymentAsGasPrice::min_gas_price(),

915

1

916

1

				312_500_000u128.into(),

917

1

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

918

1

919

);

920

1

});

921

1

922

923

#[test]

924

1

fn transfer_ed_0_substrate() {

925

1

	ExtBuilder::default()

926

1

		.with_balances(vec![

927

1

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

928

1

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

929

1

])

930

1

		.build()

931

1

		.execute_with(|| {

932

			// Substrate transfer

933

1

			assert_ok!(Balances::transfer_allow_death(

934

1

				origin_of(AccountId::from(ALICE)),

935

1

				AccountId::from(BOB),

936

1

				1 * MOVR,

937

));

938

			// 1 WEI is left in the account

939

1

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

940

1

});

941

1

942

943

#[test]

944

1

fn transfer_ed_0_evm() {

945

1

	ExtBuilder::default()

946

1

		.with_balances(vec![

947

1

948

1

				AccountId::from(ALICE),

949

1

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

950

1

),

951

1

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

952

1

])

953

1

		.build()

954

1

		.execute_with(|| {

955

1

			set_parachain_inherent_data();

956

			// EVM transfer

957

1

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

958

1

				source: H160::from(ALICE),

959

1

				target: H160::from(BOB),

960

1

				input: Vec::new(),

961

1

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

962

1

				gas_limit: 21_000u64,

963

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

964

1

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

965

1

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

966

1

				access_list: Vec::new(),

967

1

				authorization_list: Vec::new(),

968

1

})

969

1

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

970

			// 1 WEI is left in the account

971

1

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

972

1

});

973

1

974

975

#[test]

976

1

fn refund_ed_0_evm() {

977

1

	ExtBuilder::default()

978

1

		.with_balances(vec![

979

1

980

1

				AccountId::from(ALICE),

981

1

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

982

1

),

983

1

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

984

1

])

985

1

		.build()

986

1

		.execute_with(|| {

987

1

			set_parachain_inherent_data();

988

			// EVM transfer that zeroes ALICE

989

1

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

990

1

				source: H160::from(ALICE),

991

1

				target: H160::from(BOB),

992

1

				input: Vec::new(),

993

1

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

994

1

				gas_limit: 21_777u64,

995

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

996

1

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

997

1

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

998

1

				access_list: Vec::new(),

999

1

				authorization_list: Vec::new(),

1000

1

})

1001

1

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

1002

			// ALICE is refunded

1003

1

			assert_eq!(

1004

1

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

1005

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

1006

);

1007

1

});

1008

1

1009

1010

#[test]

1011

1

fn author_does_receive_priority_fee() {

1012

1

	ExtBuilder::default()

1013

1

		.with_balances(vec![(

1014

1

			AccountId::from(BOB),

1015

1

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

1016

1

)])

1017

1

		.build()

1018

1

		.execute_with(|| {

1019

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

1020

1

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

1021

1

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

1022

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

1023

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

1024

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

1025

1

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

1026

1027

			// EVM transfer.

1028

1

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

1029

1

				source: H160::from(BOB),

1030

1

				target: H160::from(ALICE),

1031

1

				input: Vec::new(),

1032

1

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

1033

1

				gas_limit: 21_000u64,

1034

1

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

1035

1

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

1036

1

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

1037

1

				access_list: Vec::new(),

1038

1

				authorization_list: Vec::new(),

1039

1

})

1040

1

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

1041

1042

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1043

			// Author free balance increased by priority fee.

1044

1

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

1045

1

});

1046

1

1047

1048

#[test]

1049

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1050

	use fp_evm::FeeCalculator;

1051

1

	ExtBuilder::default()

1052

1

		.with_balances(vec![

1053

1

1054

1

				AccountId::from(BOB),

1055

1

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

1056

1

),

1057

1

1058

1

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

1059

1

				existential_deposit(),

1060

1

),

1061

1

])

1062

1

		.build()

1063

1

		.execute_with(|| {

1064

1

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

1065

1

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

1066

1

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

1067

			// EVM transfer.

1068

1

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

1069

1

				source: H160::from(BOB),

1070

1

				target: H160::from(ALICE),

1071

1

				input: Vec::new(),

1072

1

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

1073

1

				gas_limit: 21_000u64,

1074

1

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

1075

1

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

1076

1

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

1077

1

				access_list: Vec::new(),

1078

1

				authorization_list: Vec::new(),

1079

1

})

1080

1

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

1081

1082

1

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

1083

1084

1

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

1085

1086

1

			let base_fee: Balance = base_fee * 21_000;

1087

1088

1

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

1089

1090

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

1091

1

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

1092

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1093

1094

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1095

1096

1

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

1097

1

});

1098

1

1099

1100

#[test]

1101

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1102

	use fp_evm::FeeCalculator;

1103

1

	ExtBuilder::default()

1104

1

		.with_balances(vec![

1105

1

1106

1

				AccountId::from(BOB),

1107

1

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

1108

1

),

1109

1

1110

1

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

1111

1

				existential_deposit(),

1112

1

),

1113

1

])

1114

1

		.build()

1115

1

		.execute_with(|| {

1116

1

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

1117

			// EVM transfer.

1118

1

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

1119

1

				source: H160::from(BOB),

1120

1

				target: H160::from(ALICE),

1121

1

				input: Vec::new(),

1122

1

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

1123

1

				gas_limit: 21_000u64,

1124

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1125

1

				max_priority_fee_per_gas: None,

1126

1

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

1127

1

				access_list: Vec::new(),

1128

1

				authorization_list: Vec::new(),

1129

1

})

1130

1

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

1131

1132

1

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

1133

1134

1

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

1135

1136

1

			let base_fee: Balance = base_fee * 21_000;

1137

1138

1

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

1139

1140

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

1141

1

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

1142

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1143

1144

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1145

1146

1

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

1147

1

});

1148

1

1149

1150

#[test]

1151

1

fn root_can_change_default_xcm_vers() {

1152

1

	ExtBuilder::default()

1153

1

		.with_balances(vec![

1154

1

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

1155

1

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

1156

1

])

1157

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1158

1

			asset_id: 1,

1159

1

			xcm_location: AssetHubLocation::get(),

1160

1

			name: "Dot",

1161

1

			symbol: "Dot",

1162

1

			decimals: 12,

1163

1

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

1164

1

}])

1165

1

		.build()

1166

1

		.execute_with(|| {

1167

1

			let source_id: moonriver_runtime::AssetId = 1;

1168

1

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

1169

1

			let asset = Asset {

1170

1

				id: AssetId(

1171

1

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

1172

1

						currency_id,

1173

1

1174

1

					.unwrap(),

1175

1

),

1176

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1177

1

};

1178

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

1179

			// know with which version to send

1180

1

			assert_noop!(

1181

1

				PolkadotXcm::transfer_assets(

1182

1

					origin_of(AccountId::from(ALICE)),

1183

1

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

1184

1

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

1185

1

						parents: 0,

1186

1

						interior: [AccountId32 {

1187

1

							network: None,

1188

1

							id: [1u8; 32],

1189

1

}]

1190

1

						.into(),

1191

1

					})),

1192

1

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

1193

0,

1194

1

					WeightLimit::Unlimited,

1195

),

1196

1

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

1197

1

					index: 2,

1198

1

					error: pallet_xcm::ExecutionError::DestinationUnsupported

1199

1

1200

);

1201

1202

			// Root sets the defaultXcm

1203

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1204

1

				root_origin(),

1205

1

				Some(3)

1206

));

1207

1208

			// Now transferring does not fail

1209

1

			assert_ok!(PolkadotXcm::transfer_assets(

1210

1

				origin_of(AccountId::from(ALICE)),

1211

1

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

1212

1

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

1213

1

					parents: 0,

1214

1

					interior: [AccountId32 {

1215

1

						network: None,

1216

1

						id: [1u8; 32],

1217

1

}]

1218

1

					.into(),

1219

1

				})),

1220

1

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

1221

0,

1222

1

				WeightLimit::Unlimited

1223

));

1224

1

})

1225

1

1226

1227

#[test]

1228

1

fn asset_can_be_registered() {

1229

1

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

1230

1

		let source_location = Location::parent();

1231

1

		let source_id = 1;

1232

1233

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1234

1

			moonriver_runtime::RuntimeOrigin::root(),

1235

1

			source_id,

1236

1

			source_location.clone(),

1237

12,

1238

1

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

1239

1

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

1240

));

1241

1242

		// Check that the asset was created

1243

		// First check if the asset ID exists

1244

1

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

1245

1

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

1246

1247

		// Then check the status using AssetsByLocation

1248

1

		let (asset_id, status) =

1249

1

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

1250

1

		assert_eq!(asset_id, source_id);

1251

1

		assert_eq!(status, AssetStatus::Active);

1252

1

});

1253

1

1254

1255

#[test]

1256

1

fn create_and_manipulate_foreign_asset_using_root() {

1257

1

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

1258

1

		let source_location = Location::parent();

1259

1260

		// Create foreign asset

1261

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1262

1

			moonriver_runtime::RuntimeOrigin::root(),

1263

1,

1264

1

			source_location.clone(),

1265

12,

1266

1

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

1267

1

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

1268

));

1269

1

		assert_eq!(

1270

1

			EvmForeignAssets::assets_by_id(1),

1271

1

			Some(source_location.clone())

1272

);

1273

1

		assert_eq!(

1274

1

			EvmForeignAssets::assets_by_location(&source_location),

1275

			Some((1, AssetStatus::Active))

1276

);

1277

1278

		// Freeze foreign asset

1279

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1280

1

			moonriver_runtime::RuntimeOrigin::root(),

1281

1,

1282

			true

1283

));

1284

1

		assert_eq!(

1285

1

			EvmForeignAssets::assets_by_location(&source_location),

1286

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1287

);

1288

1289

		// Unfreeze foreign asset

1290

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1291

1

			moonriver_runtime::RuntimeOrigin::root(),

1292

1,

1293

));

1294

1

		assert_eq!(

1295

1

			EvmForeignAssets::assets_by_location(&source_location),

1296

			Some((1, AssetStatus::Active))

1297

);

1298

1

});

1299

1

1300

1301

#[test]

1302

1

fn create_and_manipulate_foreign_asset_using_sibling() {

1303

1

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

1304

1

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

1305

1

		let para_location = asset_location.chain_location();

1306

1

		let para_account =

1307

1

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

1308

1309

1

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

1310

1

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

1311

1312

		// Create foreign asset

1313

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1314

1

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

1315

1,

1316

1

			asset_location.clone(),

1317

12,

1318

1

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

1319

1

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

1320

));

1321

1322

		// deposit is taken from the account

1323

1

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

1324

1325

1

		assert_eq!(

1326

1

			EvmForeignAssets::assets_by_id(1),

1327

1

			Some(asset_location.clone())

1328

);

1329

1

		assert_eq!(

1330

1

			EvmForeignAssets::assets_by_location(&asset_location),

1331

			Some((1, AssetStatus::Active))

1332

);

1333

1334

		// Freeze foreign asset

1335

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1336

1

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

1337

1,

1338

			true

1339

));

1340

1

		assert_eq!(

1341

1

			EvmForeignAssets::assets_by_location(&asset_location),

1342

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1343

);

1344

1345

		// Unfreeze foreign asset

1346

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1347

1

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

1348

1,

1349

));

1350

1

		assert_eq!(

1351

1

			EvmForeignAssets::assets_by_location(&asset_location),

1352

			Some((1, AssetStatus::Active))

1353

);

1354

1

});

1355

1

1356

1357

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

1358

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

1359

/*

1360

#[test]

1361

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1362

	ExtBuilder::default()

1363

		.with_xcm_assets(vec![XcmAssetInitialization {

1364

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

1365

			metadata: AssetRegistrarMetadata {

1366

				name: b"RelayToken".to_vec(),

1367

				symbol: b"Relay".to_vec(),

1368

				decimals: 12,

1369

				is_frozen: false,

1370

},

1371

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

1372

			is_sufficient: true,

1373

}])

1374

		.with_balances(vec![

1375

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

1376

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

1377

])

1378

		.build()

1379

		.execute_with(|| {

1380

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

1381

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

1382

1383

			// Its address is

1384

			let asset_precompile_address = Runtime::asset_id_to_account(

1385

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1386

				relay_asset_id,

1387

);

1388

1389

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

1390

			assert_eq!(

1391

				moonriver_runtime::Assets::total_supply(relay_asset_id),

1392

				1_000 * MOVR

1393

);

1394

1395

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

1396

			Precompiles::new()

1397

				.prepare_test(

1398

					ALICE,

1399

					asset_precompile_address,

1400

					ForeignAssetsPCall::total_supply {},

1401

1402

				.expect_cost(5007)

1403

				.expect_no_logs()

1404

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

1405

1406

			// Access balanceOf through precompile

1407

			Precompiles::new()

1408

				.prepare_test(

1409

					ALICE,

1410

					asset_precompile_address,

1411

					ForeignAssetsPCall::balance_of {

1412

						who: Address(ALICE.into()),

1413

},

1414

1415

				.expect_cost(5007)

1416

				.expect_no_logs()

1417

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

1418

});

1419

1420

1421

#[test]

1422

fn xcm_asset_erc20_precompiles_transfer() {

1423

	ExtBuilder::default()

1424

		.with_xcm_assets(vec![XcmAssetInitialization {

1425

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

1426

			metadata: AssetRegistrarMetadata {

1427

				name: b"RelayToken".to_vec(),

1428

				symbol: b"Relay".to_vec(),

1429

				decimals: 12,

1430

				is_frozen: false,

1431

},

1432

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

1433

			is_sufficient: true,

1434

}])

1435

		.with_balances(vec![

1436

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

1437

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

1438

])

1439

		.build()

1440

		.execute_with(|| {

1441

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

1442

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

1443

1444

			// Its address is

1445

			let asset_precompile_address = Runtime::asset_id_to_account(

1446

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1447

				relay_asset_id,

1448

);

1449

1450

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

1451

			Precompiles::new()

1452

				.prepare_test(

1453

					ALICE,

1454

					asset_precompile_address,

1455

					ForeignAssetsPCall::transfer {

1456

						to: Address(BOB.into()),

1457

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

1458

},

1459

1460

				.expect_cost(26587)

1461

				.expect_log(log3(

1462

					asset_precompile_address,

1463

					SELECTOR_LOG_TRANSFER,

1464

					H160::from(ALICE),

1465

					H160::from(BOB),

1466

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

1467

))

1468

				.execute_returns(true);

1469

1470

			// Make sure BOB has 400 MOVR

1471

			Precompiles::new()

1472

				.prepare_test(

1473

					BOB,

1474

					asset_precompile_address,

1475

					ForeignAssetsPCall::balance_of {

1476

						who: Address(BOB.into()),

1477

},

1478

1479

				.expect_cost(5007)

1480

				.expect_no_logs()

1481

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

1482

});

1483

1484

1485

#[test]

1486

fn xcm_asset_erc20_precompiles_approve() {

1487

	ExtBuilder::default()

1488

		.with_xcm_assets(vec![XcmAssetInitialization {

1489

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

1490

			metadata: AssetRegistrarMetadata {

1491

				name: b"RelayToken".to_vec(),

1492

				symbol: b"Relay".to_vec(),

1493

				decimals: 12,

1494

				is_frozen: false,

1495

},

1496

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

1497

			is_sufficient: true,

1498

}])

1499

		.with_balances(vec![

1500

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

1501

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

1502

])

1503

		.build()

1504

		.execute_with(|| {

1505

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

1506

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

1507

1508

			// Its address is

1509

			let asset_precompile_address = Runtime::asset_id_to_account(

1510

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1511

				relay_asset_id,

1512

);

1513

1514

			// Aprove Bob for spending 400 MOVR from Alice

1515

			Precompiles::new()

1516

				.prepare_test(

1517

					ALICE,

1518

					asset_precompile_address,

1519

					ForeignAssetsPCall::approve {

1520

						spender: Address(BOB.into()),

1521

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

1522

},

1523

1524

				.expect_cost(17323)

1525

				.expect_log(log3(

1526

					asset_precompile_address,

1527

					SELECTOR_LOG_APPROVAL,

1528

					H160::from(ALICE),

1529

					H160::from(BOB),

1530

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

1531

))

1532

				.execute_returns(true);

1533

1534

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

1535

			Precompiles::new()

1536

				.prepare_test(

1537

					BOB,

1538

					asset_precompile_address,

1539

					ForeignAssetsPCall::transfer_from {

1540

						from: Address(ALICE.into()),

1541

						to: Address(CHARLIE.into()),

1542

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

1543

},

1544

1545

				.expect_cost(31873)

1546

				.expect_log(log3(

1547

					asset_precompile_address,

1548

					SELECTOR_LOG_TRANSFER,

1549

					H160::from(ALICE),

1550

					H160::from(CHARLIE),

1551

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

1552

))

1553

				.execute_returns(true);

1554

1555

			// Make sure CHARLIE has 400 MOVR

1556

			Precompiles::new()

1557

				.prepare_test(

1558

					CHARLIE,

1559

					asset_precompile_address,

1560

					ForeignAssetsPCall::balance_of {

1561

						who: Address(CHARLIE.into()),

1562

},

1563

1564

				.expect_cost(5007)

1565

				.expect_no_logs()

1566

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

1567

});

1568

}*/

1569

1570

#[test]

1571

1

fn make_sure_polkadot_xcm_cannot_be_called() {

1572

1

	ExtBuilder::default()

1573

1

		.with_balances(vec![

1574

1

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

1575

1

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

1576

1

])

1577

1

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

1578

1

		.with_mappings(vec![(

1579

1

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

1580

1

			AccountId::from(ALICE),

1581

1

)])

1582

1

		.build()

1583

1

		.execute_with(|| {

1584

1

			let dest = Location {

1585

1

				parents: 1,

1586

1

				interior: [AccountId32 {

1587

1

					network: None,

1588

1

					id: [1u8; 32],

1589

1

}]

1590

1

				.into(),

1591

1

};

1592

1

			let assets: Assets = [Asset {

1593

1

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

1594

1

				fun: Fungible(1000),

1595

1

}]

1596

1

			.to_vec()

1597

1

			.into();

1598

1

			assert_noop!(

1599

1

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

1600

1

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

1601

1

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

1602

1

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

1603

1

					fee_asset_item: 0,

1604

1

})

1605

1

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

1606

1

					AccountId::from(ALICE)

1607

)),

1608

1

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

1609

);

1610

1

});

1611

1

1612

1613

#[test]

1614

1

fn transactor_cannot_use_more_than_max_weight() {

1615

1

	ExtBuilder::default()

1616

1

		.with_balances(vec![

1617

1

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

1618

1

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

1619

1

])

1620

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1621

1

			asset_id: 1,

1622

1

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

1623

1

			name: "RelayToken",

1624

1

			symbol: "Relay",

1625

1

			decimals: 12,

1626

1

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

1627

1

}])

1628

1

		.build()

1629

1

		.execute_with(|| {

1630

1

			let source_id: moonriver_runtime::AssetId = 1;

1631

1

			assert_ok!(XcmTransactor::register(

1632

1

				root_origin(),

1633

1

				AccountId::from(ALICE),

1634

0,

1635

));

1636

1637

			// Root can set transact info

1638

1

			assert_ok!(XcmTransactor::set_transact_info(

1639

1

				root_origin(),

1640

1

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

1641

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

1642

1

				3000.into(),

1643

1

				20000.into(),

1644

1

				None

1645

));

1646

			// Set fee per second using weight-trader (replaces old set_fee_per_second)

1647

1

			set_fee_per_second_for_location(Location::parent(), 1).expect("must succeed");

1648

1649

1

			assert_noop!(

1650

1

				XcmTransactor::transact_through_derivative(

1651

1

					origin_of(AccountId::from(ALICE)),

1652

1

					moonriver_runtime::xcm_config::Transactors::Relay,

1653

0,

1654

1

					CurrencyPayment {

1655

1

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

1656

1

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

1657

1

)),

1658

1

						fee_amount: None

1659

1

},

1660

1

					vec![],

1661

					// 20000 is the max

1662

1

					TransactWeights {

1663

1

						transact_required_weight_at_most: 17001.into(),

1664

1

						overall_weight: None

1665

1

},

1666

					false

1667

),

1668

1

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

1669

);

1670

1

			assert_noop!(

1671

1

				XcmTransactor::transact_through_derivative(

1672

1

					origin_of(AccountId::from(ALICE)),

1673

1

					moonriver_runtime::xcm_config::Transactors::Relay,

1674

0,

1675

1

					CurrencyPayment {

1676

1

						currency: Currency::AsCurrencyId(

1677

1

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

1678

1

),

1679

1

						fee_amount: None

1680

1

},

1681

1

					vec![],

1682

					// 20000 is the max

1683

1

					TransactWeights {

1684

1

						transact_required_weight_at_most: 17001.into(),

1685

1

						overall_weight: None

1686

1

},

1687

					false

1688

),

1689

1

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

1690

);

1691

1

})

1692

1

1693

1694

#[test]

1695

1

fn transact_through_signed_precompile_works_v2() {

1696

1

	ExtBuilder::default()

1697

1

		.with_balances(vec![

1698

1

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

1699

1

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

1700

1

])

1701

1

		.with_safe_xcm_version(3)

1702

1

		.build()

1703

1

		.execute_with(|| {

1704

			// Destination

1705

1

			let dest = Location::parent();

1706

1707

1

			let fee_payer_asset = Location::parent();

1708

1709

1

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

1710

1711

1

			let total_weight = 1_000_000_000u64;

1712

1713

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1714

1715

1

			Precompiles::new()

1716

1

				.prepare_test(

1717

					ALICE,

1718

1

					xcm_transactor_v2_precompile_address,

1719

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1720

1

						dest,

1721

1

						fee_asset: fee_payer_asset,

1722

1

						weight: 4_000_000,

1723

1

						call: bytes.into(),

1724

1

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

1725

1

						overall_weight: total_weight,

1726

1

},

1727

1728

1

				.expect_cost(31240)

1729

1

				.expect_no_logs()

1730

1

				.execute_returns(());

1731

1

});

1732

1

1733

1734

#[test]

1735

1

fn transact_through_signed_cannot_send_to_local_chain() {

1736

1

	ExtBuilder::default()

1737

1

		.with_balances(vec![

1738

1

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

1739

1

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

1740

1

])

1741

1

		.with_safe_xcm_version(3)

1742

1

		.build()

1743

1

		.execute_with(|| {

1744

			// Destination

1745

1

			let dest = Location::here();

1746

1747

1

			let fee_payer_asset = Location::parent();

1748

1749

1

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

1750

1751

1

			let total_weight = 1_000_000_000u64;

1752

1753

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1754

1755

1

			Precompiles::new()

1756

1

				.prepare_test(

1757

					ALICE,

1758

1

					xcm_transactor_v2_precompile_address,

1759

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1760

1

						dest,

1761

1

						fee_asset: fee_payer_asset,

1762

1

						weight: 4_000_000,

1763

1

						call: bytes.into(),

1764

1

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

1765

1

						overall_weight: total_weight,

1766

1

},

1767

1768

1

				.execute_reverts(|output| {

1769

1

					from_utf8(&output)

1770

1

						.unwrap()

1771

1

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

1772

1

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

1773

1

});

1774

1

});

1775

1

1776

1777

#[test]

1778

1

fn call_pallet_xcm_with_fee() {

1779

1

	let asset_id = 1;

1780

1

	ExtBuilder::default()

1781

1

		.with_balances(vec![

1782

1

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

1783

1

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

1784

1

])

1785

1

		.with_safe_xcm_version(3)

1786

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1787

1

			asset_id,

1788

1

			xcm_location: Location::parent(),

1789

1

			name: "RelayToken",

1790

1

			symbol: "Relay",

1791

1

			decimals: 12,

1792

1

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

1793

1

}])

1794

1

		.build()

1795

1

		.execute_with(|| {

1796

1

			let dest = Location {

1797

1

				parents: 1,

1798

1

				interior: [AccountId32 {

1799

1

					network: None,

1800

1

					id: [1u8; 32],

1801

1

}]

1802

1

				.into(),

1803

1

};

1804

1805

1

			let before_balance =

1806

1

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

1807

1

			let (chain_part, beneficiary) =

1808

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1809

1

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

1810

1

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

1811

1

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

1812

1

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

1813

1

				assets: Wild(All),

1814

1

				beneficiary: beneficiary.clone(),

1815

1

			}]);

1816

1

			assert_ok!(PolkadotXcm::transfer_assets_using_type_and_then(

1817

1

				origin_of(AccountId::from(ALICE)),

1818

1

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

1819

1

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

1820

1

				Box::new(TransferType::DestinationReserve),

1821

1

				Box::new(fees_id),

1822

1

				Box::new(TransferType::DestinationReserve),

1823

1

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

1824

1

				WeightLimit::Limited(4000000000.into())

1825

));

1826

1827

1

			let after_balance =

1828

1

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

1829

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

1830

1

			assert!(after_balance < before_balance);

1831

1

});

1832

1

1833

1834

#[test]

1835

1

fn test_xcm_utils_ml_tp_account() {

1836

1

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

1837

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1838

1

		let expected_address_parent: H160 =

1839

1

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

1840

1

				.unwrap()

1841

1

				.into();

1842

1843

1

		Precompiles::new()

1844

1

			.prepare_test(

1845

				ALICE,

1846

1

				xcm_utils_precompile_address,

1847

1

				XcmUtilsPCall::multilocation_to_address {

1848

1

					location: Location::parent(),

1849

1

},

1850

1851

1

			.expect_cost(

1852

1

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

1853

1

					.read

1854

1

					.saturating_div(WEIGHT_PER_GAS)

1855

1

					.saturating_mul(2),

1856

1857

1

			.expect_no_logs()

1858

1

			.execute_returns(Address(expected_address_parent));

1859

1860

1

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

1861

1

		let expected_address_parachain: H160 =

1862

1

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

1863

1

				&parachain_2000_multilocation,

1864

1865

1

			.unwrap()

1866

1

			.into();

1867

1868

1

		Precompiles::new()

1869

1

			.prepare_test(

1870

				ALICE,

1871

1

				xcm_utils_precompile_address,

1872

1

				XcmUtilsPCall::multilocation_to_address {

1873

1

					location: parachain_2000_multilocation,

1874

1

},

1875

1876

1

			.expect_cost(

1877

1

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

1878

1

					.read

1879

1

					.saturating_div(WEIGHT_PER_GAS)

1880

1

					.saturating_mul(2),

1881

1882

1

			.expect_no_logs()

1883

1

			.execute_returns(Address(expected_address_parachain));

1884

1885

1

		let alice_in_parachain_2000_location = Location::new(

1886

1,

1887

1

1888

1

				Parachain(2000),

1889

1

				AccountKey20 {

1890

1

					network: None,

1891

1

					key: ALICE,

1892

1

},

1893

1

],

1894

);

1895

1

		let expected_address_alice_in_parachain_2000 =

1896

1

			xcm_builder::HashedDescription::<

1897

1

				AccountId,

1898

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

1899

1

			>::convert_location(&alice_in_parachain_2000_location)

1900

1

			.unwrap()

1901

1

			.into();

1902

1903

1

		Precompiles::new()

1904

1

			.prepare_test(

1905

				ALICE,

1906

1

				xcm_utils_precompile_address,

1907

1

				XcmUtilsPCall::multilocation_to_address {

1908

1

					location: alice_in_parachain_2000_location,

1909

1

},

1910

1911

1

			.expect_cost(

1912

1

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

1913

1

					.read

1914

1

					.saturating_div(WEIGHT_PER_GAS)

1915

1

					.saturating_mul(2),

1916

1917

1

			.expect_no_logs()

1918

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

1919

1

});

1920

1

1921

1922

#[test]

1923

1

fn test_nested_batch_calls_from_xcm_transact() {

1924

1

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

1925

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

1926

		// in a future polkadot-sdk version

1927

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

1928

1929

1

		let mut valid_nested_calls =

1930

1

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

1931

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

1932

8

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

1933

8

				calls: vec![valid_nested_calls],

1934

8

});

1935

8

1936

1937

1

		let valid_message = Xcm(vec![Transact {

1938

1

			origin_kind: OriginKind::SovereignAccount,

1939

1

			fallback_max_weight: None,

1940

1

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

1941

1

		}]);

1942

1943

1

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

1944

1945

1

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

1946

1

			calls: vec![valid_nested_calls],

1947

1

});

1948

1949

1

		let invalid_message = Xcm(vec![Transact {

1950

1

			origin_kind: OriginKind::SovereignAccount,

1951

1

			fallback_max_weight: None,

1952

1

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

1953

1

		}]);

1954

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

1955

1

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

1956

1

});

1957

1

1958

1959

#[test]

1960

1

fn test_xcm_utils_weight_message() {

1961

1

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

1962

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1963

1

		let expected_weight =

1964

1

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

1965

1966

1

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

1967

1968

1

		let input = XcmUtilsPCall::weight_message {

1969

1

			message: message.into(),

1970

1

};

1971

1972

1

		Precompiles::new()

1973

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1974

1

			.expect_cost(

1975

1

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

1976

1

					.read

1977

1

					.saturating_div(WEIGHT_PER_GAS),

1978

1979

1

			.expect_no_logs()

1980

1

			.execute_returns(expected_weight);

1981

1

});

1982

1

1983

1984

#[test]

1985

1

fn test_xcm_utils_get_units_per_second() {

1986

1

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

1987

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

1988

1

		let location = SelfReserve::get();

1989

1990

1

		let input = XcmUtilsPCall::get_units_per_second { location };

1991

1992

1

		let expected_units =

1993

1

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

1994

1995

1

		Precompiles::new()

1996

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

1997

1

			.expect_cost(

1998

1

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

1999

1

					.read

2000

1

					.saturating_div(WEIGHT_PER_GAS)

2001

1

					.saturating_mul(2),

2002

2003

1

			.expect_no_logs()

2004

1

			.execute_returns(expected_units);

2005

1

});

2006

1

2007

2008

#[test]

2009

1

fn precompile_existence() {

2010

1

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

2011

1

		let precompiles = Precompiles::new();

2012

1

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

2013

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

2014

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

2015

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

2016

2017

1

		.into_iter()

2018

1

		.map(H160::from_low_u64_be)

2019

1

		.collect();

2020

2021

3001

		for i in 0..3000 {

2022

3000

			let address = H160::from_low_u64_be(i);

2023

2024

3000

			if precompile_addresses.contains(&address) {

2025

47

				assert!(

2026

47

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

2027

					"is_precompile({}) should return true",

2028

2029

);

2030

2031

47

				assert!(

2032

47

					precompiles

2033

47

						.execute(&mut MockHandle::new(

2034

47

							address,

2035

47

							Context {

2036

47

								address,

2037

47

								caller: H160::zero(),

2038

47

								apparent_value: U256::zero()

2039

47

2040

47

),)

2041

47

						.is_some(),

2042

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

2043

2044

);

2045

			} else {

2046

2953

				assert!(

2047

2953

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

2048

					"is_precompile({}) should return false",

2049

2050

);

2051

2052

2953

				assert!(

2053

2953

					precompiles

2054

2953

						.execute(&mut MockHandle::new(

2055

2953

							address,

2056

2953

							Context {

2057

2953

								address,

2058

2953

								caller: H160::zero(),

2059

2953

								apparent_value: U256::zero()

2060

2953

2061

2953

),)

2062

2953

						.is_none(),

2063

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

2064

2065

);

2066

2067

2068

1

});

2069

1

2070

2071

#[test]

2072

1

fn removed_precompiles() {

2073

1

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

2074

1

		let precompiles = Precompiles::new();

2075

1

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

2076

2077

3000

		for i in 1..3000 {

2078

2999

			let address = H160::from_low_u64_be(i);

2079

2080

2999

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

2081

2952

				continue;

2082

47

2083

2084

47

			if !removed_precompiles.contains(&i) {

2085

43

				assert!(

2086

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2087

43

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

2088

						_ => false,

2089

},

2090

					"{i} should be an active precompile"

2091

);

2092

43

				continue;

2093

4

2094

2095

4

			assert!(

2096

4

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

2097

4

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

2098

					_ => false,

2099

},

2100

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

2101

);

2102

2103

4

			precompiles

2104

4

				.prepare_test(Alice, address, [])

2105

4

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

2106

2107

1

})

2108

1

2109

2110

#[test]

2111

1

fn deal_with_fees_handles_tip() {

2112

	use frame_support::traits::OnUnbalanced;

2113

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2114

	use moonriver_runtime::Treasury;

2115

2116

1

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

2117

1

		set_parachain_inherent_data();

2118

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

2119

		// in the Moonriver runtime. It verifies that:

2120

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

2121

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

2122

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

2123

2124

		// The test details:

2125

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

2126

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

2127

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

2128

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

2129

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

2130

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

2131

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

2132

2133

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

2134

1

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

2135

1

			AccountId,

2136

1

		>>::issue(100);

2137

1

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

2138

1

			AccountId,

2139

1

		>>::issue(1000);

2140

2141

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

2142

1

		let total_supply_before = Balances::total_issuance();

2143

1

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

2144

1

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

2145

1

		assert_eq!(total_supply_before, 1_100);

2146

1

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

2147

2148

		// Step 3: Execute the fees handling logic.

2149

1

		DealWithSubstrateFeesAndTip::<

2150

1

			Runtime,

2151

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2152

1

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

2153

2154

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

2155

1

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

2156

2157

1

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

2158

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2159

2160

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

2161

1

		assert_eq!(

2162

1

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

2163

			treasury_fee_part,

2164

);

2165

2166

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

2167

1

		let total_supply_after = Balances::total_issuance();

2168

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2169

2170

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

2171

1

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

2172

1

		assert_eq!(

2173

1

			block_author_balance_after - block_author_balance_before,

2174

			1000,

2175

);

2176

1

});

2177

1

2178

2179

#[test]

2180

1

fn evm_revert_substrate_events() {

2181

1

	ExtBuilder::default()

2182

1

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

2183

1

		.build()

2184

1

		.execute_with(|| {

2185

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2186

2187

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

2188

			// Thus BatchAll will revert the transfer.

2189

1

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

2190

1

				source: ALICE.into(),

2191

1

				target: batch_precompile_address,

2192

1

				input: BatchPCall::batch_all {

2193

1

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

2194

1

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

2195

1

					call_data: vec![].into(),

2196

1

					gas_limit: vec![].into()

2197

1

2198

1

				.into(),

2199

1

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

2200

1

				gas_limit: 500_000,

2201

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2202

1

				max_priority_fee_per_gas: None,

2203

1

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

2204

1

				access_list: Vec::new(),

2205

1

				authorization_list: Vec::new(),

2206

1

})

2207

1

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

2208

2209

1

			let transfer_count = System::events()

2210

1

				.iter()

2211

4

				.filter(|r| match r.event {

2212

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

2213

6

					_ => false,

2214

6

})

2215

1

				.count();

2216

2217

1

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

2218

1

});

2219

1

2220

2221

#[test]

2222

1

fn evm_success_keeps_substrate_events() {

2223

1

	ExtBuilder::default()

2224

1

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

2225

1

		.build()

2226

1

		.execute_with(|| {

2227

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2228

2229

1

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

2230

1

				source: ALICE.into(),

2231

1

				target: batch_precompile_address,

2232

1

				input: BatchPCall::batch_all {

2233

1

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

2234

1

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

2235

1

					call_data: vec![].into(),

2236

1

					gas_limit: vec![].into()

2237

1

2238

1

				.into(),

2239

1

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

2240

1

				gas_limit: 500_000,

2241

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2242

1

				max_priority_fee_per_gas: None,

2243

1

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

2244

1

				access_list: Vec::new(),

2245

1

				authorization_list: Vec::new(),

2246

1

})

2247

1

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

2248

2249

1

			let transfer_count = System::events()

2250

1

				.iter()

2251

6

				.filter(|r| match r.event {

2252

1

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

2253

9

					_ => false,

2254

10

})

2255

1

				.count();

2256

2257

1

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

2258

1

});

2259

1

2260

2261

#[cfg(test)]

2262

mod bridge_tests {

2263

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

2264

	use crate::currency_to_asset;

2265

	use bp_messages::target_chain::DispatchMessageData;

2266

	use bp_messages::ReceptionResult;

2267

	use bp_runtime::messages::MessageDispatchResult;

2268

	use cumulus_primitives_core::AggregateMessageOrigin;

2269

	use frame_support::assert_ok;

2270

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

2271

	use moonbeam_core_primitives::AccountId;

2272

	use moonriver_runtime::bridge_config::{

2273

		PolkadotGlobalConsensusNetwork, WithPolkadotMessagesInstance,

2274

};

2275

	use moonriver_runtime::currency::MOVR;

2276

	use moonriver_runtime::xcm_config::CurrencyId;

2277

	use moonriver_runtime::{

2278

		Balances, BridgePolkadotMessages, BridgeXcmOverMoonbeam, MessageQueue, PolkadotXcm,

2279

		Runtime, RuntimeEvent, System,

2280

};

2281

	use pallet_bridge_messages::LanesManager;

2282

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

2283

	use parity_scale_codec::Encode;

2284

	use sp_core::H256;

2285

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

2286

	use xcm::latest::{

2287

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

2288

};

2289

	use xcm::prelude::{

2290

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

2291

		GlobalConsensus, PalletInstance, Parachain, ReserveAssetDeposited, UniversalOrigin,

2292

		XCM_VERSION,

2293

};

2294

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

2295

	use xcm_builder::BridgeMessage;

2296

2297

1

	fn next_block() {

2298

1

		System::reset_events();

2299

2300

1

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

2301

2302

1

		System::set_block_number(next_block);

2303

1

		System::on_initialize(next_block);

2304

1

		MessageQueue::on_initialize(next_block);

2305

1

2306

2307

	#[test]

2308

1

	fn transfer_asset_moonriver_to_moonbeam() {

2309

1

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

2310

2311

1

		ExtBuilder::default()

2312

1

			.with_balances(vec![

2313

1

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

2314

1

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

2315

1

])

2316

1

			.with_safe_xcm_version(XCM_VERSION)

2317

1

			.with_open_bridges(vec![(

2318

1

				Location::new(

2319

1

1,

2320

1

					[Parachain(

2321

1

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

2322

1

)],

2323

1

),

2324

1

				Junctions::from([

2325

1

					NetworkId::Polkadot.into(),

2326

1

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

2327

1

]),

2328

1

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

2329

1

)])

2330

1

			.build()

2331

1

			.execute_with(|| {

2332

1

				assert_ok!(PolkadotXcm::force_xcm_version(

2333

1

					root_origin(),

2334

1

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

2335

					XCM_VERSION

2336

));

2337

2338

1

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

2339

2340

1

				let message_data = BridgePolkadotMessages::outbound_message_data(

2341

1

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

2342

					1u64,

2343

);

2344

1

				assert!(message_data.is_none());

2345

2346

1

				assert_ok!(PolkadotXcm::transfer_assets(

2347

1

					origin_of(AccountId::from(ALICE)),

2348

1

					Box::new(VersionedLocation::V5(

2349

1

						bp_moonbeam::GlobalConsensusLocation::get()

2350

1

)),

2351

1

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

2352

1

						parents: 0,

2353

1

						interior: [AccountKey20 {

2354

1

							network: None,

2355

1

							key: ALICE,

2356

1

}]

2357

1

						.into(),

2358

1

					})),

2359

1

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

2360

0,

2361

1

					WeightLimit::Unlimited

2362

));

2363

2364

1

				let message_data = BridgePolkadotMessages::outbound_message_data(

2365

1

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

2366

					1u64,

2367

);

2368

1

				assert!(message_data.is_some());

2369

1

})

2370

1

2371

2372

	#[test]

2373

1

	fn receive_message_from_moonbeam() {

2374

1

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

2375

2376

1

		ExtBuilder::default()

2377

1

			.with_balances(vec![

2378

1

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

2379

1

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

2380

1

])

2381

1

			.with_xcm_assets(vec![XcmAssetInitialization {

2382

1

				asset_id: 1,

2383

1

				xcm_location: Location::new(

2384

1

2,

2385

1

2386

1

						GlobalConsensus(PolkadotGlobalConsensusNetwork::get()),

2387

1

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

2388

1

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

2389

1

2390

1

),

2391

1

				name: "xcGLMR",

2392

1

				symbol: "xcGLMR",

2393

1

				decimals: 18,

2394

1

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

2395

1

}])

2396

1

			.with_safe_xcm_version(XCM_VERSION)

2397

1

			.with_open_bridges(vec![(

2398

1

				Location::new(

2399

1

1,

2400

1

					[Parachain(

2401

1

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

2402

1

)],

2403

1

),

2404

1

				Junctions::from([

2405

1

					NetworkId::Polkadot.into(),

2406

1

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

2407

1

]),

2408

1

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

2409

1

)])

2410

1

			.build()

2411

1

			.execute_with(|| {

2412

1

				let bridge_message: BridgeMessage = BridgeMessage {

2413

1

					universal_dest: VersionedInteriorLocation::V5(

2414

1

2415

1

							GlobalConsensus(NetworkId::Kusama),

2416

1

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

2417

1

						].into()

2418

1

),

2419

1

					message: VersionedXcm::V5(

2420

1

						Xcm(

2421

1

2422

1

								UniversalOrigin(GlobalConsensus(NetworkId::Polkadot)),

2423

1

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

2424

1

								ReserveAssetDeposited(

2425

1

									vec![

2426

1

										Asset {

2427

1

											id: AssetId(

2428

1

												Location::new(

2429

1

2,

2430

1

2431

1

														GlobalConsensus(NetworkId::Polkadot),

2432

1

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

2433

1

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

2434

1

2435

1

2436

1

),

2437

1

											fun: Fungible(2 * MOVR)

2438

1

2439

1

									].into()

2440

1

),

2441

1

								ClearOrigin,

2442

1

								BuyExecution {

2443

1

									fees: Asset {

2444

1

										id: AssetId(

2445

1

											Location::new(

2446

1

2,

2447

1

2448

1

													GlobalConsensus(NetworkId::Polkadot),

2449

1

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

2450

1

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

2451

1

2452

1

2453

1

),

2454

1

										fun:  Fungible(MOVR / 2)

2455

1

},

2456

1

									weight_limit: WeightLimit::Unlimited

2457

1

},

2458

1

								DepositAsset {

2459

1

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

2460

1

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

2461

1

2462

1

							].into()

2463

1

2464

1

2465

1

};

2466

2467

1

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

2468

1

					.active_inbound_lane(Default::default())

2469

1

					.unwrap();

2470

2471

1

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

2472

1

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

2473

1

					&AccountId::from(ALICE),

2474

1,

2475

1

					msg,

2476

);

2477

2478

1

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

2479

2480

				// Produce next block

2481

1

				next_block();

2482

				// Confirm that the xcm message was successfully processed

2483

7

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

2484

1

					matches!(

2485

1

						evt.event,

2486

						RuntimeEvent::MessageQueue(

2487

							pallet_message_queue::Event::Processed {

2488

								origin: AggregateMessageOrigin::Here,

2489

								success: true,

2490

..

2491

2492

2493

2494

7

				}));

2495

1

});

2496

1

2497

2498

2499

#[cfg(test)]

2500

mod treasury_tests {

2501

	use super::*;

2502

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

2503

	use moonriver_runtime::XcmWeightTrader;

2504

	use sp_core::bounded_vec;

2505

	use sp_runtime::traits::Hash;

2506

2507

4

	fn expect_events(events: Vec<RuntimeEvent>) {

2508

4

		let block_events: Vec<RuntimeEvent> =

2509

4

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

2510

2511

7

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

2512

4

2513

2514

7

	fn next_block() {

2515

7

		System::reset_events();

2516

7

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

2517

7

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

2518

7

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

2519

7

2520

2521

3

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

2522

3

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

2523

3

			.expect("failed to get account balance")

2524

3

2525

2526

	#[test]

2527

1

	fn test_treasury_spend_local_with_council_origin() {

2528

1

		let initial_treasury_balance = 1_000 * MOVR;

2529

1

		ExtBuilder::default()

2530

1

			.with_balances(vec![

2531

1

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

2532

1

				(Treasury::account_id(), initial_treasury_balance),

2533

1

])

2534

1

			.build()

2535

1

			.execute_with(|| {

2536

1

				let spend_amount = 100u128 * MOVR;

2537

1

				let spend_beneficiary = AccountId::from(BOB);

2538

2539

1

				next_block();

2540

2541

				// TreasuryCouncilCollective

2542

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2543

1

					root_origin(),

2544

1

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

2545

1

					Some(AccountId::from(ALICE)),

2546

2547

));

2548

2549

1

				next_block();

2550

2551

				// Perform treasury spending

2552

1

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

2553

1

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

2554

1

					amount: spend_amount,

2555

1

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

2556

1

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

2557

1

					valid_from: Some(valid_from),

2558

1

});

2559

1

				assert_ok!(TreasuryCouncilCollective::propose(

2560

1

					origin_of(AccountId::from(ALICE)),

2561

1,

2562

1

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

2563

					1_000

2564

));

2565

2566

1

				let payout_period =

2567

1

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

2568

1

				let expected_events = [

2569

1

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

2570

1

						index: 0,

2571

1

						asset_kind: NativeOrWithId::Native,

2572

1

						amount: spend_amount,

2573

1

						beneficiary: spend_beneficiary,

2574

1

						valid_from,

2575

1

						expire_at: payout_period + valid_from,

2576

1

}),

2577

1

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

2578

1

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

2579

1

						result: Ok(()),

2580

1

}),

2581

1

2582

1

				.to_vec();

2583

1

				expect_events(expected_events);

2584

2585

6

				while System::block_number() < valid_from {

2586

5

					next_block();

2587

5

2588

2589

1

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

2590

2591

1

				let expected_events = [

2592

1

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

2593

1

						index: 0,

2594

1

						payment_id: (),

2595

1

}),

2596

1

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

2597

1

						from: Treasury::account_id(),

2598

1

						to: spend_beneficiary,

2599

1

						amount: spend_amount,

2600

1

}),

2601

1

2602

1

				.to_vec();

2603

1

				expect_events(expected_events);

2604

1

});

2605

1

2606

2607

	#[test]

2608

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2609

1

		let initial_treasury_balance = 1_000 * MOVR;

2610

1

		let asset_id = 1000100010001000u128;

2611

1

		ExtBuilder::default()

2612

1

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

2613

1

			.build()

2614

1

			.execute_with(|| {

2615

1

				let spend_amount = 100u128 * MOVR;

2616

1

				let spend_beneficiary = AccountId::from(BOB);

2617

2618

1

				let asset_location: Location = Location {

2619

1

					parents: 1,

2620

1

					interior: Junctions::Here,

2621

1

};

2622

2623

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2624

1

					root_origin(),

2625

1

					asset_id,

2626

1

					asset_location.clone(),

2627

12,

2628

1

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

2629

1

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

2630

));

2631

2632

1

				assert_ok!(XcmWeightTrader::add_asset(

2633

1

					root_origin(),

2634

1

					asset_location,

2635

					1u128

2636

));

2637

2638

1

				assert_ok!(EvmForeignAssets::mint_into(

2639

1

					asset_id,

2640

1

					Treasury::account_id(),

2641

1

					initial_treasury_balance.into()

2642

));

2643

2644

1

				assert_eq!(

2645

1

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

2646

1

					initial_treasury_balance.into(),

2647

					"Treasury balance not updated"

2648

);

2649

2650

				// TreasuryCouncilCollective

2651

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2652

1

					root_origin(),

2653

1

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

2654

1

					Some(AccountId::from(ALICE)),

2655

2656

));

2657

2658

				// Perform treasury spending

2659

1

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

2660

1

					amount: spend_amount,

2661

1

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

2662

1

					beneficiary: Box::new(spend_beneficiary),

2663

1

					valid_from: None,

2664

1

});

2665

1

				assert_ok!(TreasuryCouncilCollective::propose(

2666

1

					origin_of(AccountId::from(ALICE)),

2667

1,

2668

1

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

2669

					1_000

2670

));

2671

2672

1

				let payout_period =

2673

1

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

2674

2675

1

				let current_block = System::block_number();

2676

1

				let expected_events = [

2677

1

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

2678

1

						index: 0,

2679

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2680

1

						amount: spend_amount,

2681

1

						beneficiary: spend_beneficiary,

2682

1

						valid_from: current_block,

2683

1

						expire_at: current_block + payout_period,

2684

1

}),

2685

1

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

2686

1

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

2687

1

						result: Ok(()),

2688

1

}),

2689

1

2690

1

				.to_vec();

2691

1

				expect_events(expected_events);

2692

2693

1

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

2694

2695

1

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

2696

1

					index: 0,

2697

1

					payment_id: (),

2698

1

				})]);

2699

2700

1

				assert_eq!(

2701

1

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

2702

1

					(initial_treasury_balance - spend_amount).into(),

2703

					"Treasury balance not updated"

2704

);

2705

2706

1

				assert_eq!(

2707

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2708

1

					spend_amount.into(),

2709

					"Treasury payout failed"

2710

);

2711

1

});

2712

1

2713

2714

2715

#[cfg(test)]

2716

mod fee_tests {

2717

	use super::*;

2718

	use fp_evm::FeeCalculator;

2719

	use frame_support::{

2720

		traits::{ConstU128, OnFinalize},

2721

		weights::{ConstantMultiplier, WeightToFee},

2722

};

2723

	use moonriver_runtime::{

2724

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2725

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2726

};

2727

	use sp_core::Get;

2728

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

2729

2730

1

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

2731

1

	where

2732

1

		F: FnMut() -> (),

2733

2734

1

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

2735

1

			.build_storage()

2736

1

			.unwrap()

2737

1

			.into();

2738

1

		t.execute_with(|| {

2739

1

			System::set_block_consumed_resources(w, 0);

2740

1

			assertions()

2741

1

});

2742

1

2743

2744

	#[test]

2745

1

	fn test_multiplier_can_grow_from_zero() {

2746

1

		let minimum_multiplier = MinimumMultiplier::get();

2747

1

		let target = TargetBlockFullness::get()

2748

1

			* RuntimeBlockWeights::get()

2749

1

				.get(DispatchClass::Normal)

2750

1

				.max_total

2751

1

				.unwrap();

2752

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

2753

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

2754

1

		run_with_system_weight(target * 101 / 100, || {

2755

1

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

2756

1

			assert!(

2757

1

				next > minimum_multiplier,

2758

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

2759

				next,

2760

				minimum_multiplier

2761

);

2762

1

})

2763

1

2764

2765

	#[test]

2766

1

	fn test_fee_calculation() {

2767

1

		let base_extrinsic = RuntimeBlockWeights::get()

2768

1

			.get(DispatchClass::Normal)

2769

1

			.base_extrinsic;

2770

1

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

2771

1

		let extrinsic_len = 100u32;

2772

1

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

2773

1

		let tip = 42u128;

2774

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

2775

		type LengthToFeeImpl = LengthToFee;

2776

2777

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

2778

1

		let expected_fee = WeightToFeeImpl::weight_to_fee(&base_extrinsic)

2779

1

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

2780

1

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

2781

1

			+ tip;

2782

2783

1

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

2784

1

			.build_storage()

2785

1

			.unwrap()

2786

1

			.into();

2787

1

		t.execute_with(|| {

2788

1

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

2789

1

			let actual_fee = TransactionPayment::compute_fee(

2790

1

				extrinsic_len,

2791

1

				&frame_support::dispatch::DispatchInfo {

2792

1

					class: DispatchClass::Normal,

2793

1

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

2794

1

					call_weight: extrinsic_weight,

2795

1

					extension_weight: Weight::zero(),

2796

1

},

2797

1

				tip,

2798

);

2799

2800

1

			assert_eq!(

2801

				expected_fee,

2802

				actual_fee,

2803

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

2804

				actual_fee - expected_fee

2805

);

2806

1

});

2807

1

2808

2809

	#[test]

2810

1

	fn test_min_gas_price_is_deterministic() {

2811

1

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

2812

1

			.build_storage()

2813

1

			.unwrap()

2814

1

			.into();

2815

1

		t.execute_with(|| {

2816

1

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

2817

1

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

2818

1

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

2819

1

			let expected: U256 = multiplier

2820

1

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

2821

1

				.into();

2822

2823

1

			assert_eq!(expected, actual);

2824

1

});

2825

1

2826

2827

	#[test]

2828

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

2829

1

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

2830

1

			.build_storage()

2831

1

			.unwrap()

2832

1

			.into();

2833

1

		t.execute_with(|| {

2834

1

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

2835

1

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

2836

2837

1

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

2838

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

2839

1

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

2840

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

2841

2842

1

			assert_ne!(

2843

				a, b,

2844

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

2845

);

2846

1

});

2847

1

2848

2849

	#[test]

2850

1

	fn test_fee_scenarios() {

2851

		use sp_runtime::FixedU128;

2852

1

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

2853

1

			.build_storage()

2854

1

			.unwrap()

2855

1

			.into();

2856

1

		t.execute_with(|| {

2857

1

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

2858

12

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

2859

12

				let start_multiplier =

2860

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

2861

12

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

2862

2863

12

				let block_weight = NORMAL_WEIGHT * fullness;

2864

2865

60004

				for i in 0..num_blocks {

2866

60004

					System::set_block_number(i as u32);

2867

60004

					System::set_block_consumed_resources(block_weight, 0);

2868

60004

					TransactionPayment::on_finalize(i as u32);

2869

60004

2870

2871

12

				TransactionPaymentAsGasPrice::min_gas_price().0

2872

12

};

2873

2874

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

2875

			// they are expected to change when parameters that influence

2876

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

2877

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

2878

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

2879

2880

1

			assert_eq!(

2881

1

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

2882

1

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

2883

);

2884

1

			assert_eq!(

2885

1

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

2886

1

				U256::from(312_500_000u128),

2887

);

2888

1

			assert_eq!(

2889

1

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

2890

1

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

2891

);

2892

1

			assert_eq!(

2893

1

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

2894

1

				U256::from(313_313_556u128),

2895

);

2896

2897

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

2898

1

			assert_eq!(

2899

1

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

2900

1

				U256::from(312_500_000u128),

2901

);

2902

1

			assert_eq!(

2903

1

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

2904

1

				U256::from(312_500_000u128),

2905

);

2906

1

			assert_eq!(

2907

1

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

2908

1

				U256::from(447_915_432u128),

2909

);

2910

1

			assert_eq!(

2911

1

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

2912

1

				U256::from(1_487_129_030u128),

2913

);

2914

2915

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

2916

1

			assert_eq!(

2917

1

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

2918

1

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

2919

);

2920

1

			assert_eq!(

2921

1

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

2922

1

				U256::from(312_500_000u128),

2923

);

2924

1

			assert_eq!(

2925

1

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

2926

1

				U256::from(1_766_664_654_709u128),

2927

);

2928

1

			assert_eq!(

2929

1

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

2930

1

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

2931

);

2932

1

});

2933

1

2934

2935

2936

#[cfg(test)]

2937

mod balance_tests {

2938

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

2939

	use frame_support::assert_ok;

2940

	use frame_support::traits::LockableCurrency;

2941

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

2942

	use moonbeam_core_primitives::AccountId;

2943

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

2944

2945

	#[test]

2946

1

	fn reserve_should_work_for_frozen_balance() {

2947

1

		let alice = AccountId::from(ALICE);

2948

		const ID_1: LockIdentifier = *b"1       ";

2949

2950

1

		ExtBuilder::default()

2951

1

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

2952

1

			.build()

2953

1

			.execute_with(|| {

2954

				// Check balances

2955

1

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

2956

1

				assert_eq!(account.free, 10);

2957

1

				assert_eq!(account.frozen, 0);

2958

1

				assert_eq!(account.reserved, 0);

2959

2960

1

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

2961

2962

1

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

2963

1

				assert_eq!(account.free, 10);

2964

1

				assert_eq!(account.frozen, 9);

2965

1

				assert_eq!(account.reserved, 0);

2966

2967

1

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

2968

2969

1

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

2970

1

				assert_eq!(account.free, 5);

2971

1

				assert_eq!(account.frozen, 9);

2972

1

				assert_eq!(account.reserved, 5);

2973

2974

1

				let previous_reserved_amount = account.reserved;

2975

1

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

2976

1

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

2977

1

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

2978

2979

1

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

2980

1

				assert_eq!(account.free, ed);

2981

1

				assert_eq!(account.frozen, 9);

2982

1

				assert_eq!(

2983

					account.reserved,

2984

1

					previous_reserved_amount.saturating_add(next_reserve)

2985

);

2986

1

});

2987

1

2988

2989

2990

moonbeam_runtime_common::generate_common_xcm_tests!(moonriver_runtime);