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

use std::cell::Cell;

25

use std::rc::Rc;

26

27

use fp_evm::{Context, IsPrecompileResult};

28

use frame_support::{

29

	assert_noop, assert_ok,

30

	dispatch::DispatchClass,

31

	traits::{

32

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

33

		StorageInfo, StorageInfoTrait,

34

},

35

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

36

	StorageHasher, Twox128,

37

};

38

use moonkit_xcm_primitives::AccountIdAssetIdConversion;

39

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

40

use moonriver_runtime::runtime_params::dynamic_params;

41

use moonriver_runtime::xcm_config::XcmExecutor;

42

use moonriver_runtime::{

43

	asset_config::ForeignAssetInstance,

44

	moonriver_xcm_weights,

45

	xcm_config::{CurrencyId, SelfReserve},

46

	AssetId, Balances, CrowdloanRewards, EvmForeignAssets, Executive, OpenTechCommitteeCollective,

47

	PolkadotXcm, Precompiles, RuntimeBlockWeights, TransactionPayment,

48

	TransactionPaymentAsGasPrice, Treasury, TreasuryCouncilCollective, XcmTransactor,

49

	FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, WEEKS,

50

};

51

use moonriver_xcm_weights::XcmWeight;

52

use nimbus_primitives::NimbusId;

53

use pallet_evm::PrecompileSet;

54

use pallet_evm_precompileset_assets_erc20::{SELECTOR_LOG_APPROVAL, SELECTOR_LOG_TRANSFER};

55

use pallet_transaction_payment::Multiplier;

56

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

57

use parity_scale_codec::Encode;

58

use polkadot_parachain::primitives::Sibling;

59

use precompile_utils::{

60

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

61

	prelude::*,

62

	testing::*,

63

};

64

use sha3::{Digest, Keccak256};

65

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

66

use sp_runtime::{

67

	traits::{Convert, Dispatchable},

68

	BuildStorage, DispatchError, ModuleError,

69

};

70

use std::str::from_utf8;

71

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

72

use xcm::{VersionedAssets, VersionedLocation};

73

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

74

use xcm_executor::traits::ConvertLocation;

75

use xcm_primitives::split_location_into_chain_part_and_beneficiary;

76

77

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

78

type CrowdloanRewardsPCall =

79

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

80

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

81

	Runtime,

82

	moonriver_runtime::xcm_config::XcmExecutorConfig,

83

>;

84

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

85

type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

86

	Runtime,

87

	ForeignAssetInstance,

88

>;

89

type XcmTransactorV2PCall =

90

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

91

92

const BASE_FEE_GENESIS: u128 = 100 * GIGAWEI;

93

94

3

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

95

3

	Asset {

96

3

		id: AssetId(

97

3

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

98

3

				currency_id,

99

3

100

3

			.unwrap(),

101

3

),

102

3

		fun: Fungibility::Fungible(amount),

103

3

104

3

105

106

#[test]

107

1

fn xcmp_queue_controller_origin_is_root() {

108

1

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

109

1

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

110

1

	assert_ok!(

111

1

		<moonriver_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

112

1

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

113

1

);

114

1

115

116

#[test]

117

1

fn verify_pallet_prefixes() {

118

30

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

119

30

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

120

30

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

121

30

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

122

30

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

123

30

		// expand/storage.rs#L389-L401

124

30

		assert_eq!(

125

30

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

126

30

			Some(name)

127

30

);

128

30

129

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

130

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

131

1

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

132

1

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

133

1

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

134

1

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

135

1

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

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

	is_pallet_prefix::<moonriver_runtime::OpenTechCommitteeCollective>(

143

1

		"OpenTechCommitteeCollective",

144

1

);

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

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

155

1

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

156

1

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

157

1

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

158

1

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

159

1

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

160

1

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

161

1

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

162

1

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

163

1

164

14

	let prefix = |pallet_name, storage_name| {

165

14

		let mut res = [0u8; 32];

166

14

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

167

14

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

168

14

		res.to_vec()

169

14

};

170

1

	assert_eq!(

171

1

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

172

1

		vec![

173

1

			StorageInfo {

174

1

				pallet_name: b"Timestamp".to_vec(),

175

1

				storage_name: b"Now".to_vec(),

176

1

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

177

1

				max_values: Some(1),

178

1

				max_size: Some(8),

179

1

},

180

1

			StorageInfo {

181

1

				pallet_name: b"Timestamp".to_vec(),

182

1

				storage_name: b"DidUpdate".to_vec(),

183

1

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

184

1

				max_values: Some(1),

185

1

				max_size: Some(1),

186

1

187

1

188

1

);

189

1

	assert_eq!(

190

1

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

191

1

		vec![

192

1

			StorageInfo {

193

1

				pallet_name: b"Balances".to_vec(),

194

1

				storage_name: b"TotalIssuance".to_vec(),

195

1

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

196

1

				max_values: Some(1),

197

1

				max_size: Some(16),

198

1

},

199

1

			StorageInfo {

200

1

				pallet_name: b"Balances".to_vec(),

201

1

				storage_name: b"InactiveIssuance".to_vec(),

202

1

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

203

1

				max_values: Some(1),

204

1

				max_size: Some(16),

205

1

},

206

1

			StorageInfo {

207

1

				pallet_name: b"Balances".to_vec(),

208

1

				storage_name: b"Account".to_vec(),

209

1

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

210

1

				max_values: None,

211

1

				max_size: Some(100),

212

1

},

213

1

			StorageInfo {

214

1

				pallet_name: b"Balances".to_vec(),

215

1

				storage_name: b"Locks".to_vec(),

216

1

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

217

1

				max_values: None,

218

1

				max_size: Some(1287),

219

1

},

220

1

			StorageInfo {

221

1

				pallet_name: b"Balances".to_vec(),

222

1

				storage_name: b"Reserves".to_vec(),

223

1

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

224

1

				max_values: None,

225

1

				max_size: Some(1037),

226

1

},

227

1

			StorageInfo {

228

1

				pallet_name: b"Balances".to_vec(),

229

1

				storage_name: b"Holds".to_vec(),

230

1

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

231

1

				max_values: None,

232

1

				max_size: Some(55),

233

1

},

234

1

			StorageInfo {

235

1

				pallet_name: b"Balances".to_vec(),

236

1

				storage_name: b"Freezes".to_vec(),

237

1

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

238

1

				max_values: None,

239

1

				max_size: Some(37),

240

1

},

241

1

242

1

);

243

1

	assert_eq!(

244

1

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

245

1

		vec![

246

1

			StorageInfo {

247

1

				pallet_name: b"Proxy".to_vec(),

248

1

				storage_name: b"Proxies".to_vec(),

249

1

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

250

1

				max_values: None,

251

1

				max_size: Some(845),

252

1

},

253

1

			StorageInfo {

254

1

				pallet_name: b"Proxy".to_vec(),

255

1

				storage_name: b"Announcements".to_vec(),

256

1

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

257

1

				max_values: None,

258

1

				max_size: Some(1837),

259

1

260

1

261

1

);

262

1

	assert_eq!(

263

1

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

264

1

		vec![StorageInfo {

265

1

			pallet_name: b"MaintenanceMode".to_vec(),

266

1

			storage_name: b"MaintenanceMode".to_vec(),

267

1

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

268

1

			max_values: Some(1),

269

1

			max_size: None,

270

1

},]

271

1

);

272

1

	assert_eq!(

273

1

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

274

1

		vec![

275

1

			StorageInfo {

276

1

				pallet_name: b"RelayStorageRoots".to_vec(),

277

1

				storage_name: b"RelayStorageRoot".to_vec(),

278

1

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

279

1

				max_values: None,

280

1

				max_size: Some(44),

281

1

},

282

1

			StorageInfo {

283

1

				pallet_name: b"RelayStorageRoots".to_vec(),

284

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

285

1

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

286

1

				max_values: Some(1),

287

1

				max_size: Some(121),

288

1

},

289

1

290

1

);

291

1

292

293

#[test]

294

1

fn test_collectives_storage_item_prefixes() {

295

7

	for StorageInfo { pallet_name, .. } in

296

8

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

297

298

7

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

299

300

301

7

	for StorageInfo { pallet_name, .. } in

302

8

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

303

304

7

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

305

306

1

307

308

#[test]

309

1

fn collective_set_members_root_origin_works() {

310

1

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

311

1

		// TreasuryCouncilCollective

312

1

		assert_ok!(TreasuryCouncilCollective::set_members(

313

1

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

314

1

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

315

1

			Some(AccountId::from(ALICE)),

316

1

317

1

));

318

		// OpenTechCommitteeCollective

319

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

320

1

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

321

1

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

322

1

			Some(AccountId::from(ALICE)),

323

1

324

1

));

325

1

});

326

1

327

328

#[test]

329

1

fn collective_set_members_general_admin_origin_works() {

330

	use moonriver_runtime::{

331

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

332

};

333

334

1

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

335

1

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

336

1

		let alice = AccountId::from(ALICE);

337

1

338

1

		// TreasuryCouncilCollective

339

1

		let _ = Utility::dispatch_as(

340

1

			root_caller.clone(),

341

1

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

342

1

			Box::new(

343

1

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

344

1

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

345

1

					prime: Some(alice),

346

1

					old_count: 2,

347

1

348

1

				.into(),

349

1

),

350

1

);

351

1

		// OpenTechCommitteeCollective

352

1

		let _ = Utility::dispatch_as(

353

1

			root_caller,

354

1

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

355

1

			Box::new(

356

1

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

357

1

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

358

1

					prime: Some(alice),

359

1

					old_count: 2,

360

1

361

1

				.into(),

362

1

),

363

1

);

364

1

365

1

		assert_eq!(

366

1

			System::events()

367

1

				.into_iter()

368

2

				.filter_map(|r| {

369

2

					match r.event {

370

2

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

371

2

							if result.is_ok() =>

372

2

373

2

							Some(true)

374

375

						_ => None,

376

377

2

})

378

1

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

379

1

				.len(),

380

1

381

1

382

1

});

383

1

384

385

#[test]

386

1

fn collective_set_members_signed_origin_does_not_work() {

387

1

	let alice = AccountId::from(ALICE);

388

1

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

389

1

		// TreasuryCouncilCollective

390

1

		assert!(TreasuryCouncilCollective::set_members(

391

1

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

392

1

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

393

1

			Some(AccountId::from(ALICE)),

394

1

395

1

396

1

		.is_err());

397

		// OpenTechCommitteeCollective

398

1

		assert!(OpenTechCommitteeCollective::set_members(

399

1

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

400

1

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

401

1

			Some(AccountId::from(ALICE)),

402

1

403

1

404

1

		.is_err());

405

1

});

406

1

407

408

#[test]

409

1

fn verify_pallet_indices() {

410

32

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

411

32

		assert_eq!(

412

32

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

413

32

			Some(index)

414

32

);

415

32

416

	// System support

417

1

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

418

1

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

419

1

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

420

1

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

421

1

	// Monetary

422

1

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

423

1

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

424

1

	// Consensus support

425

1

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

426

1

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

427

1

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

428

1

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

429

1

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

430

1

	// Handy utilities

431

1

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

432

1

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

433

1

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

434

1

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

435

1

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

436

1

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

437

1

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

438

1

	// Ethereum compatibility

439

1

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

440

1

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

441

1

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

442

1

	// Governance

443

1

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

444

1

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

445

1

	// Council

446

1

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

447

1

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

448

1

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

449

1

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

450

1

	// Treasury

451

1

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

452

1

	// Crowdloan

453

1

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

454

1

	// XCM Stuff

455

1

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

456

1

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

457

1

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

458

1

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

459

1

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

460

1

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

461

1

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

462

1

463

464

#[test]

465

1

fn verify_reserved_indices() {

466

1

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

467

1

		.build_storage()

468

1

		.unwrap()

469

1

		.into();

470

1

471

1

	t.execute_with(|| {

472

		use frame_metadata::*;

473

1

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

474

1

		let metadata = match metadata.1 {

475

1

			RuntimeMetadata::V14(metadata) => metadata,

476

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

477

};

478

		// 40: Sudo

479

		// 53: BaseFee

480

		// 108: pallet_assets::<Instance1>

481

1

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

482

1

		let existing = metadata

483

1

			.pallets

484

1

			.iter()

485

50

			.map(|p| p.index)

486

1

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

487

3

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

488

1

});

489

1

490

491

#[test]

492

1

fn verify_proxy_type_indices() {

493

1

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

494

1

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

495

1

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

496

1

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

497

1

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

498

1

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

499

1

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

500

1

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

501

1

502

503

#[test]

504

1

fn join_collator_candidates() {

505

1

	ExtBuilder::default()

506

1

		.with_balances(vec![

507

1

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

508

1

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

509

1

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

510

1

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

511

1

])

512

1

		.with_collators(vec![

513

1

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

514

1

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

515

1

])

516

1

		.with_delegations(vec![

517

1

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

518

1

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

519

1

])

520

1

		.build()

521

1

		.execute_with(|| {

522

1

			assert_noop!(

523

1

				ParachainStaking::join_candidates(

524

1

					origin_of(AccountId::from(ALICE)),

525

1

					10_000 * MOVR,

526

1

					2u32

527

1

),

528

1

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

529

1

);

530

1

			assert_noop!(

531

1

				ParachainStaking::join_candidates(

532

1

					origin_of(AccountId::from(CHARLIE)),

533

1

					10_000 * MOVR,

534

1

					2u32

535

1

),

536

1

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

537

1

);

538

1

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

539

1

			assert_ok!(ParachainStaking::join_candidates(

540

1

				origin_of(AccountId::from(DAVE)),

541

1

				10_000 * MOVR,

542

1

				2u32

543

1

));

544

1

			assert_eq!(

545

1

				last_event(),

546

1

				RuntimeEvent::ParachainStaking(

547

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

548

1

						account: AccountId::from(DAVE),

549

1

						amount_locked: 10_000 * MOVR,

550

1

						new_total_amt_locked: 30_100 * MOVR

551

1

552

1

553

1

);

554

1

			let candidates = ParachainStaking::candidate_pool();

555

1

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

556

1

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

557

1

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

558

1

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

559

1

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

560

1

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

561

1

});

562

1

563

564

#[test]

565

1

fn transfer_through_evm_to_stake() {

566

1

	ExtBuilder::default()

567

1

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

568

1

		.build()

569

1

		.execute_with(|| {

570

1

			// Charlie has no balance => fails to stake

571

1

			assert_noop!(

572

1

				ParachainStaking::join_candidates(

573

1

					origin_of(AccountId::from(CHARLIE)),

574

1

					10_000 * MOVR,

575

1

					2u32

576

1

),

577

1

				DispatchError::Module(ModuleError {

578

1

					index: 20,

579

1

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

580

1

					message: Some("InsufficientBalance")

581

1

})

582

1

);

583

			// Alice transfer from free balance 20000 MOVR to Bob

584

1

			assert_ok!(Balances::transfer_allow_death(

585

1

				origin_of(AccountId::from(ALICE)),

586

1

				AccountId::from(BOB),

587

1

				20_000 * MOVR,

588

1

));

589

1

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

590

591

1

			let gas_limit = 100000u64;

592

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

593

1

			// Bob transfers 10000 MOVR to Charlie via EVM

594

1

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

595

1

				source: H160::from(BOB),

596

1

				target: H160::from(CHARLIE),

597

1

				input: vec![],

598

1

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

599

1

				gas_limit,

600

1

				max_fee_per_gas: gas_price,

601

1

				max_priority_fee_per_gas: None,

602

1

				nonce: None,

603

1

				access_list: Vec::new(),

604

1

})

605

1

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

606

1

			assert_eq!(

607

1

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

608

1

				10_000 * MOVR,

609

1

);

610

611

			// Charlie can stake now

612

1

			assert_ok!(ParachainStaking::join_candidates(

613

1

				origin_of(AccountId::from(CHARLIE)),

614

1

				10_000 * MOVR,

615

1

				2u32,

616

1

			),);

617

1

			let candidates = ParachainStaking::candidate_pool();

618

1

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

619

1

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

620

1

});

621

1

622

623

#[test]

624

1

fn reward_block_authors() {

625

1

	ExtBuilder::default()

626

1

		.with_balances(vec![

627

1

			// Alice gets 100 extra tokens for her mapping deposit

628

1

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

629

1

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

630

1

])

631

1

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

632

1

		.with_delegations(vec![(

633

1

			AccountId::from(BOB),

634

1

			AccountId::from(ALICE),

635

1

			500 * MOVR,

636

1

)])

637

1

		.with_mappings(vec![(

638

1

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

639

1

			AccountId::from(ALICE),

640

1

)])

641

1

		.build()

642

1

		.execute_with(|| {

643

1

			increase_last_relay_slot_number(1);

644

1

645

1

			// Just before round 3

646

1

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

647

1

648

1

			// no rewards doled out yet

649

1

			assert_eq!(

650

1

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

651

1

				10_100 * MOVR,

652

1

);

653

1

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

654

1

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

655

1

656

1

			// rewards minted and distributed

657

1

			assert_eq!(

658

1

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

659

1

				11547666666208000000000,

660

1

);

661

1

			assert_eq!(

662

1

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

663

1

				9557333332588000000000,

664

1

);

665

1

});

666

1

667

668

#[test]

669

1

fn reward_block_authors_with_parachain_bond_reserved() {

670

1

	ExtBuilder::default()

671

1

		.with_balances(vec![

672

1

			// Alice gets 100 extra tokens for her mapping deposit

673

1

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

674

1

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

675

1

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

676

1

])

677

1

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

678

1

		.with_delegations(vec![(

679

1

			AccountId::from(BOB),

680

1

			AccountId::from(ALICE),

681

1

			500 * MOVR,

682

1

)])

683

1

		.with_mappings(vec![(

684

1

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

685

1

			AccountId::from(ALICE),

686

1

)])

687

1

		.build()

688

1

		.execute_with(|| {

689

1

			increase_last_relay_slot_number(1);

690

1

			assert_ok!(ParachainStaking::set_parachain_bond_account(

691

1

				root_origin(),

692

1

				AccountId::from(CHARLIE),

693

1

			),);

694

695

			// Stop just before round 2

696

1

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

697

1

698

1

			// no collator rewards doled out yet

699

1

			assert_eq!(

700

1

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

701

1

				10_100 * MOVR,

702

1

);

703

1

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

704

705

			// Go to round 2

706

1

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

707

1

708

1

			// 30% reserved for parachain bond

709

1

			assert_eq!(

710

1

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

711

1

				452515000000000000000,

712

1

);

713

714

			// Go to round 3

715

1

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

716

1

717

1

			// rewards minted and distributed

718

1

			assert_eq!(

719

1

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

720

1

				11117700475903800000000,

721

1

);

722

1

			assert_eq!(

723

1

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

724

1

				9535834523343675000000,

725

1

);

726

			// 30% reserved for parachain bond again

727

1

			assert_eq!(

728

1

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

729

1

				910802725000000000000,

730

1

);

731

1

});

732

1

733

734

#[test]

735

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

736

1

	ExtBuilder::default()

737

1

		.with_balances(vec![

738

1

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

739

1

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

740

1

])

741

1

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

742

1

		.with_mappings(vec![(

743

1

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

744

1

			AccountId::from(ALICE),

745

1

)])

746

1

		.with_crowdloan_fund(3_000_000 * MOVR)

747

1

		.build()

748

1

		.execute_with(|| {

749

1

			// set parachain inherent data

750

1

			set_parachain_inherent_data();

751

1

			let init_block = CrowdloanRewards::init_vesting_block();

752

1

			// This matches the previous vesting

753

1

			let end_block = init_block + 48 * WEEKS;

754

1

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

755

1

			assert_ok!(

756

1

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

757

1

					calls: vec![

758

1

						RuntimeCall::CrowdloanRewards(

759

1

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

760

1

								rewards: vec![(

761

1

									[4u8; 32].into(),

762

1

									Some(AccountId::from(CHARLIE)),

763

1

									1_500_000 * MOVR

764

1

)]

765

1

766

1

),

767

1

						RuntimeCall::CrowdloanRewards(

768

1

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

769

1

								rewards: vec![(

770

1

									[5u8; 32].into(),

771

1

									Some(AccountId::from(DAVE)),

772

1

									1_500_000 * MOVR

773

1

)]

774

1

775

1

),

776

1

						RuntimeCall::CrowdloanRewards(

777

1

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

778

1

								lease_ending_block: end_block

779

1

780

1

781

1

782

1

})

783

1

				.dispatch(root_origin())

784

1

);

785

			// 30 percent initial payout

786

1

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

787

			// 30 percent initial payout

788

1

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

789

1

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

790

1

			assert_eq!(last_event(), expected);

791

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

792

1

			assert_ok!(

793

1

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

794

1

					calls: vec![RuntimeCall::CrowdloanRewards(

795

1

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

796

1

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

797

1

798

1

)]

799

1

})

800

1

				.dispatch(root_origin())

801

1

);

802

1

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

803

1

				index: 0,

804

1

				error: DispatchError::Module(ModuleError {

805

1

					index: 90,

806

1

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

807

1

					message: None,

808

1

}),

809

1

});

810

1

			assert_eq!(last_event(), expected_fail);

811

			// Claim 1 block.

812

1

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

813

1

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

814

815

1

			let vesting_period = 48 * WEEKS as u128;

816

1

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

817

1

818

1

			assert_eq!(

819

1

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

820

1

					.unwrap()

821

1

					.claimed_reward,

822

1

				(450_000 * MOVR) + per_block

823

1

);

824

1

			assert_eq!(

825

1

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

826

1

					.unwrap()

827

1

					.claimed_reward,

828

1

				(450_000 * MOVR) + per_block

829

1

);

830

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

831

1

			assert_eq!(

832

1

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

833

1

				(450_000 * MOVR) + per_block

834

1

);

835

1

			assert_eq!(

836

1

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

837

1

				(450_000 * MOVR) + per_block

838

1

);

839

1

			assert_noop!(

840

1

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

841

1

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

842

1

);

843

1

});

844

1

845

846

#[test]

847

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

848

1

	ExtBuilder::default()

849

1

		.with_balances(vec![

850

1

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

851

1

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

852

1

])

853

1

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

854

1

		.with_mappings(vec![(

855

1

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

856

1

			AccountId::from(ALICE),

857

1

)])

858

1

		.with_crowdloan_fund(3_000_000 * MOVR)

859

1

		.build()

860

1

		.execute_with(|| {

861

1

			// set parachain inherent data

862

1

			set_parachain_inherent_data();

863

1

			let init_block = CrowdloanRewards::init_vesting_block();

864

1

			// This matches the previous vesting

865

1

			let end_block = init_block + 4 * WEEKS;

866

1

867

1

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

868

1

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

869

1

870

1

			let public1 = pair1.public();

871

1

			let public2 = pair2.public();

872

1

873

1

			// signature:

874

1

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

875

1

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

876

1

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

877

1

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

878

1

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

879

1

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

880

1

			let signature1 = pair1.sign(&message);

881

1

			let signature2 = pair2.sign(&message);

882

1

883

1

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

884

1

			assert_ok!(

885

1

				// two relay accounts pointing at the same reward account

886

1

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

887

1

					calls: vec![

888

1

						RuntimeCall::CrowdloanRewards(

889

1

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

890

1

								rewards: vec![(

891

1

									public1.into(),

892

1

									Some(AccountId::from(CHARLIE)),

893

1

									1_500_000 * MOVR

894

1

)]

895

1

896

1

),

897

1

						RuntimeCall::CrowdloanRewards(

898

1

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

899

1

								rewards: vec![(

900

1

									public2.into(),

901

1

									Some(AccountId::from(CHARLIE)),

902

1

									1_500_000 * MOVR

903

1

)]

904

1

905

1

),

906

1

						RuntimeCall::CrowdloanRewards(

907

1

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

908

1

								lease_ending_block: end_block

909

1

910

1

911

1

912

1

})

913

1

				.dispatch(root_origin())

914

1

);

915

			// 30 percent initial payout

916

1

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

917

918

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

919

1

			assert_noop!(

920

1

				CrowdloanRewards::change_association_with_relay_keys(

921

1

					origin_of(AccountId::from(CHARLIE)),

922

1

					AccountId::from(DAVE),

923

1

					AccountId::from(CHARLIE),

924

1

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

925

1

),

926

1

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

927

1

);

928

929

			// this should be valid

930

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

931

1

				origin_of(AccountId::from(CHARLIE)),

932

1

				AccountId::from(DAVE),

933

1

				AccountId::from(CHARLIE),

934

1

				vec![

935

1

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

936

1

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

937

1

938

1

));

939

940

1

			assert_eq!(

941

1

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

942

1

					.unwrap()

943

1

					.claimed_reward,

944

1

				(900_000 * MOVR)

945

1

);

946

1

});

947

1

948

949

#[test]

950

1

fn claim_via_precompile() {

951

1

	ExtBuilder::default()

952

1

		.with_balances(vec![

953

1

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

954

1

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

955

1

])

956

1

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

957

1

		.with_mappings(vec![(

958

1

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

959

1

			AccountId::from(ALICE),

960

1

)])

961

1

		.with_crowdloan_fund(3_000_000 * MOVR)

962

1

		.build()

963

1

		.execute_with(|| {

964

1

			// set parachain inherent data

965

1

			set_parachain_inherent_data();

966

1

			let init_block = CrowdloanRewards::init_vesting_block();

967

1

			// This matches the previous vesting

968

1

			let end_block = init_block + 4 * WEEKS;

969

1

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

970

1

			assert_ok!(

971

1

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

972

1

					calls: vec![

973

1

						RuntimeCall::CrowdloanRewards(

974

1

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

975

1

								rewards: vec![(

976

1

									[4u8; 32].into(),

977

1

									Some(AccountId::from(CHARLIE)),

978

1

									1_500_000 * MOVR

979

1

)]

980

1

981

1

),

982

1

						RuntimeCall::CrowdloanRewards(

983

1

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

984

1

								rewards: vec![(

985

1

									[5u8; 32].into(),

986

1

									Some(AccountId::from(DAVE)),

987

1

									1_500_000 * MOVR

988

1

)]

989

1

990

1

),

991

1

						RuntimeCall::CrowdloanRewards(

992

1

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

993

1

								lease_ending_block: end_block

994

1

995

1

996

1

997

1

})

998

1

				.dispatch(root_origin())

999

1

);

1000

1001

1

			assert!(CrowdloanRewards::initialized());

1002

1003

			// 30 percent initial payout

1004

1

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

1005

			// 30 percent initial payout

1006

1

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

1007

1008

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1009

1

1010

1

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

1011

1

			let gas_limit = 100000u64;

1012

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1013

1

1014

1

			// Construct the call data (selector, amount)

1015

1

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

1016

1

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

1017

1

1018

1

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

1019

1

				source: H160::from(CHARLIE),

1020

1

				target: crowdloan_precompile_address,

1021

1

				input: call_data,

1022

1

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

1023

1

				gas_limit,

1024

1

				max_fee_per_gas: gas_price,

1025

1

				max_priority_fee_per_gas: None,

1026

1

				nonce: None, // Use the next nonce

1027

1

				access_list: Vec::new(),

1028

1

})

1029

1

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

1030

1031

1

			let vesting_period = 4 * WEEKS as u128;

1032

1

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

1033

1

1034

1

			assert_eq!(

1035

1

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

1036

1

					.unwrap()

1037

1

					.claimed_reward,

1038

1

				(450_000 * MOVR) + per_block

1039

1

);

1040

1

})

1041

1

1042

1043

#[test]

1044

1

fn is_contributor_via_precompile() {

1045

1

	ExtBuilder::default()

1046

1

		.with_balances(vec![

1047

1

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

1048

1

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

1049

1

])

1050

1

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

1051

1

		.with_mappings(vec![(

1052

1

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

1053

1

			AccountId::from(ALICE),

1054

1

)])

1055

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1056

1

		.build()

1057

1

		.execute_with(|| {

1058

1

			// set parachain inherent data

1059

1

			set_parachain_inherent_data();

1060

1

			let init_block = CrowdloanRewards::init_vesting_block();

1061

1

			// This matches the previous vesting

1062

1

			let end_block = init_block + 4 * WEEKS;

1063

1

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

1064

1

			assert_ok!(

1065

1

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

1066

1

					calls: vec![

1067

1

						RuntimeCall::CrowdloanRewards(

1068

1

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

1069

1

								rewards: vec![(

1070

1

									[4u8; 32].into(),

1071

1

									Some(AccountId::from(CHARLIE)),

1072

1

									1_500_000 * MOVR

1073

1

)]

1074

1

1075

1

),

1076

1

						RuntimeCall::CrowdloanRewards(

1077

1

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

1078

1

								rewards: vec![(

1079

1

									[5u8; 32].into(),

1080

1

									Some(AccountId::from(DAVE)),

1081

1

									1_500_000 * MOVR

1082

1

)]

1083

1

1084

1

),

1085

1

						RuntimeCall::CrowdloanRewards(

1086

1

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

1087

1

								lease_ending_block: end_block

1088

1

1089

1

1090

1

1091

1

})

1092

1

				.dispatch(root_origin())

1093

1

);

1094

1095

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1096

1

1097

1

			// Assert precompile reports Bob is not a contributor

1098

1

			Precompiles::new()

1099

1

				.prepare_test(

1100

1

					ALICE,

1101

1

					crowdloan_precompile_address,

1102

1

					CrowdloanRewardsPCall::is_contributor {

1103

1

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

1104

1

},

1105

1

1106

1

				.expect_cost(3338)

1107

1

				.expect_no_logs()

1108

1

				.execute_returns(false);

1109

1

1110

1

			// Assert precompile reports Charlie is a nominator

1111

1

			Precompiles::new()

1112

1

				.prepare_test(

1113

1

					ALICE,

1114

1

					crowdloan_precompile_address,

1115

1

					CrowdloanRewardsPCall::is_contributor {

1116

1

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

1117

1

},

1118

1

1119

1

				.expect_cost(3338)

1120

1

				.expect_no_logs()

1121

1

				.execute_returns(true);

1122

1

})

1123

1

1124

1125

#[test]

1126

1

fn reward_info_via_precompile() {

1127

1

	ExtBuilder::default()

1128

1

		.with_balances(vec![

1129

1

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

1130

1

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

1131

1

])

1132

1

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

1133

1

		.with_mappings(vec![(

1134

1

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

1135

1

			AccountId::from(ALICE),

1136

1

)])

1137

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1138

1

		.build()

1139

1

		.execute_with(|| {

1140

1

			// set parachain inherent data

1141

1

			set_parachain_inherent_data();

1142

1

			let init_block = CrowdloanRewards::init_vesting_block();

1143

1

			// This matches the previous vesting

1144

1

			let end_block = init_block + 4 * WEEKS;

1145

1

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

1146

1

			assert_ok!(

1147

1

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

1148

1

					calls: vec![

1149

1

						RuntimeCall::CrowdloanRewards(

1150

1

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

1151

1

								rewards: vec![(

1152

1

									[4u8; 32].into(),

1153

1

									Some(AccountId::from(CHARLIE)),

1154

1

									1_500_000 * MOVR

1155

1

)]

1156

1

1157

1

),

1158

1

						RuntimeCall::CrowdloanRewards(

1159

1

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

1160

1

								rewards: vec![(

1161

1

									[5u8; 32].into(),

1162

1

									Some(AccountId::from(DAVE)),

1163

1

									1_500_000 * MOVR

1164

1

)]

1165

1

1166

1

),

1167

1

						RuntimeCall::CrowdloanRewards(

1168

1

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

1169

1

								lease_ending_block: end_block

1170

1

1171

1

1172

1

1173

1

})

1174

1

				.dispatch(root_origin())

1175

1

);

1176

1177

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1178

1

1179

1

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

1180

1

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

1181

1

1182

1

			// Assert precompile reports correct Charlie reward info.

1183

1

			Precompiles::new()

1184

1

				.prepare_test(

1185

1

					ALICE,

1186

1

					crowdloan_precompile_address,

1187

1

					CrowdloanRewardsPCall::reward_info {

1188

1

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

1189

1

},

1190

1

1191

1

				.expect_cost(3338)

1192

1

				.expect_no_logs()

1193

1

				.execute_returns((expected_total, expected_claimed));

1194

1

})

1195

1

1196

1197

#[test]

1198

1

fn update_reward_address_via_precompile() {

1199

1

	ExtBuilder::default()

1200

1

		.with_balances(vec![

1201

1

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

1202

1

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

1203

1

])

1204

1

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

1205

1

		.with_mappings(vec![(

1206

1

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

1207

1

			AccountId::from(ALICE),

1208

1

)])

1209

1

		.with_crowdloan_fund(3_000_000 * MOVR)

1210

1

		.build()

1211

1

		.execute_with(|| {

1212

1

			// set parachain inherent data

1213

1

			set_parachain_inherent_data();

1214

1

			let init_block = CrowdloanRewards::init_vesting_block();

1215

1

			// This matches the previous vesting

1216

1

			let end_block = init_block + 4 * WEEKS;

1217

1

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

1218

1

			assert_ok!(

1219

1

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

1220

1

					calls: vec![

1221

1

						RuntimeCall::CrowdloanRewards(

1222

1

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

1223

1

								rewards: vec![(

1224

1

									[4u8; 32].into(),

1225

1

									Some(AccountId::from(CHARLIE)),

1226

1

									1_500_000 * MOVR

1227

1

)]

1228

1

1229

1

),

1230

1

						RuntimeCall::CrowdloanRewards(

1231

1

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

1232

1

								rewards: vec![(

1233

1

									[5u8; 32].into(),

1234

1

									Some(AccountId::from(DAVE)),

1235

1

									1_500_000 * MOVR

1236

1

)]

1237

1

1238

1

),

1239

1

						RuntimeCall::CrowdloanRewards(

1240

1

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

1241

1

								lease_ending_block: end_block

1242

1

1243

1

1244

1

1245

1

})

1246

1

				.dispatch(root_origin())

1247

1

);

1248

1249

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1250

1

1251

1

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

1252

1

			let gas_limit = 100000u64;

1253

1

			let gas_price: U256 = BASE_FEE_GENESIS.into();

1254

1

1255

1

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

1256

1

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

1257

1

			call_data[0..4]

1258

1

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

1259

1

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

1260

1

1261

1

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

1262

1

				source: H160::from(CHARLIE),

1263

1

				target: crowdloan_precompile_address,

1264

1

				input: call_data,

1265

1

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

1266

1

				gas_limit,

1267

1

				max_fee_per_gas: gas_price,

1268

1

				max_priority_fee_per_gas: None,

1269

1

				nonce: None, // Use the next nonce

1270

1

				access_list: Vec::new(),

1271

1

})

1272

1

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

1273

1274

1

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

1275

1

			assert_eq!(

1276

1

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

1277

1

					.unwrap()

1278

1

					.claimed_reward,

1279

1

				(450_000 * MOVR)

1280

1

);

1281

1

})

1282

1

1283

1284

1

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

1285

1

where

1286

1

	F: FnMut() -> (),

1287

1

1288

1

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

1289

1

		.build_storage()

1290

1

		.unwrap()

1291

1

		.into();

1292

1

	t.execute_with(|| {

1293

1

		System::set_block_consumed_resources(w, 0);

1294

1

		assertions()

1295

1

});

1296

1

1297

1298

#[test]

1299

#[rustfmt::skip]

1300

1

fn length_fee_is_sensible() {

1301

	use sp_runtime::testing::TestXt;

1302

1303

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

1304

1

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

1305

1

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

1306

1

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

1307

1

1308

9

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

1309

9

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

1310

9

				.inclusion_fee

1311

9

				.expect("fee should be calculated")

1312

9

				.len_fee

1313

9

};

1314

1315

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

1316

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

1317

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

1318

		//                             |           |

1319

1

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

1320

1

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

1321

1

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

1322

1

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

1323

1

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

1324

1

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

1325

1

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

1326

1

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

1327

1

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

1328

1

});

1329

1

1330

1331

#[test]

1332

1

fn multiplier_can_grow_from_zero() {

1333

	use frame_support::traits::Get;

1334

1335

1

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

1336

1

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

1337

1

		* RuntimeBlockWeights::get()

1338

1

			.get(DispatchClass::Normal)

1339

1

			.max_total

1340

1

			.unwrap();

1341

1

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

1342

1

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

1343

1

	run_with_system_weight(target * 101 / 100, || {

1344

1

		let next =

1345

1

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

1346

1

		assert!(

1347

1

			next > minimum_multiplier,

1348

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

1349

			next,

1350

			minimum_multiplier

1351

);

1352

1

})

1353

1

1354

1355

#[test]

1356

1

fn ethereum_invalid_transaction() {

1357

1

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

1358

1

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

1359

1

		// on chain is rejected.

1360

1

		assert_eq!(

1361

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1362

1

			Err(

1363

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1364

1

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

1365

1

1366

1

1367

1

);

1368

1

});

1369

1

1370

1371

#[test]

1372

1

fn initial_gas_fee_is_correct() {

1373

	use fp_evm::FeeCalculator;

1374

1375

1

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

1376

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1377

1

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

1378

1379

1

		assert_eq!(

1380

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1381

1

1382

1

				3_125_000_000u128.into(),

1383

1

				Weight::from_parts(41_742_000u64, 0)

1384

1

1385

1

);

1386

1

});

1387

1

1388

1389

#[test]

1390

1

fn min_gas_fee_is_correct() {

1391

	use fp_evm::FeeCalculator;

1392

	use frame_support::traits::Hooks;

1393

1394

1

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

1395

1

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

1396

1

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

1397

1

1398

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1399

1

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

1400

1401

1

		assert_eq!(

1402

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1403

1

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

1404

1

);

1405

1

});

1406

1

1407

1408

#[test]

1409

1

fn transfer_ed_0_substrate() {

1410

1

	ExtBuilder::default()

1411

1

		.with_balances(vec![

1412

1

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

1413

1

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

1414

1

])

1415

1

		.build()

1416

1

		.execute_with(|| {

1417

1

			// Substrate transfer

1418

1

			assert_ok!(Balances::transfer_allow_death(

1419

1

				origin_of(AccountId::from(ALICE)),

1420

1

				AccountId::from(BOB),

1421

1

				1 * MOVR,

1422

1

));

1423

			// 1 WEI is left in the account

1424

1

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

1425

1

});

1426

1

1427

1428

#[test]

1429

1

fn transfer_ed_0_evm() {

1430

1

	ExtBuilder::default()

1431

1

		.with_balances(vec![

1432

1

1433

1

				AccountId::from(ALICE),

1434

1

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

1435

1

),

1436

1

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

1437

1

])

1438

1

		.build()

1439

1

		.execute_with(|| {

1440

1

			set_parachain_inherent_data();

1441

1

			// EVM transfer

1442

1

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

1443

1

				source: H160::from(ALICE),

1444

1

				target: H160::from(BOB),

1445

1

				input: Vec::new(),

1446

1

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

1447

1

				gas_limit: 21_000u64,

1448

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1449

1

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

1450

1

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

1451

1

				access_list: Vec::new(),

1452

1

})

1453

1

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

1454

			// 1 WEI is left in the account

1455

1

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

1456

1

});

1457

1

1458

1459

#[test]

1460

1

fn refund_ed_0_evm() {

1461

1

	ExtBuilder::default()

1462

1

		.with_balances(vec![

1463

1

1464

1

				AccountId::from(ALICE),

1465

1

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

1466

1

),

1467

1

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

1468

1

])

1469

1

		.build()

1470

1

		.execute_with(|| {

1471

1

			set_parachain_inherent_data();

1472

1

			// EVM transfer that zeroes ALICE

1473

1

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

1474

1

				source: H160::from(ALICE),

1475

1

				target: H160::from(BOB),

1476

1

				input: Vec::new(),

1477

1

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

1478

1

				gas_limit: 21_777u64,

1479

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1480

1

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

1481

1

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

1482

1

				access_list: Vec::new(),

1483

1

})

1484

1

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

1485

			// ALICE is refunded

1486

1

			assert_eq!(

1487

1

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

1488

1

				777 * BASE_FEE_GENESIS + existential_deposit(),

1489

1

);

1490

1

});

1491

1

1492

1493

#[test]

1494

1

fn author_does_receive_priority_fee() {

1495

1

	ExtBuilder::default()

1496

1

		.with_balances(vec![(

1497

1

			AccountId::from(BOB),

1498

1

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

1499

1

)])

1500

1

		.build()

1501

1

		.execute_with(|| {

1502

1

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

1503

1

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

1504

1

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

1505

1

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

1506

1

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

1507

1

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

1508

1

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

1509

1

1510

1

			// EVM transfer.

1511

1

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

1512

1

				source: H160::from(BOB),

1513

1

				target: H160::from(ALICE),

1514

1

				input: Vec::new(),

1515

1

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

1516

1

				gas_limit: 21_000u64,

1517

1

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

1518

1

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

1519

1

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

1520

1

				access_list: Vec::new(),

1521

1

})

1522

1

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

1523

1524

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1525

1

			// Author free balance increased by priority fee.

1526

1

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

1527

1

});

1528

1

1529

1530

#[test]

1531

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1532

	use fp_evm::FeeCalculator;

1533

1

	ExtBuilder::default()

1534

1

		.with_balances(vec![

1535

1

1536

1

				AccountId::from(BOB),

1537

1

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

1538

1

),

1539

1

1540

1

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

1541

1

				existential_deposit(),

1542

1

),

1543

1

])

1544

1

		.build()

1545

1

		.execute_with(|| {

1546

1

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

1547

1

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

1548

1

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

1549

1

			// EVM transfer.

1550

1

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

1551

1

				source: H160::from(BOB),

1552

1

				target: H160::from(ALICE),

1553

1

				input: Vec::new(),

1554

1

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

1555

1

				gas_limit: 21_000u64,

1556

1

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

1557

1

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

1558

1

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

1559

1

				access_list: Vec::new(),

1560

1

})

1561

1

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

1562

1563

1

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

1564

1

1565

1

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

1566

1

1567

1

			let base_fee: Balance = base_fee * 21_000;

1568

1

1569

1

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

1570

1

1571

1

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

1572

1

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

1573

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1574

1

1575

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1576

1577

1

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

1578

1

});

1579

1

1580

1581

#[test]

1582

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1583

	use fp_evm::FeeCalculator;

1584

1

	ExtBuilder::default()

1585

1

		.with_balances(vec![

1586

1

1587

1

				AccountId::from(BOB),

1588

1

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

1589

1

),

1590

1

1591

1

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

1592

1

				existential_deposit(),

1593

1

),

1594

1

])

1595

1

		.build()

1596

1

		.execute_with(|| {

1597

1

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

1598

1

			// EVM transfer.

1599

1

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

1600

1

				source: H160::from(BOB),

1601

1

				target: H160::from(ALICE),

1602

1

				input: Vec::new(),

1603

1

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

1604

1

				gas_limit: 21_000u64,

1605

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

1606

1

				max_priority_fee_per_gas: None,

1607

1

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

1608

1

				access_list: Vec::new(),

1609

1

})

1610

1

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

1611

1612

1

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

1613

1

1614

1

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

1615

1

1616

1

			let base_fee: Balance = base_fee * 21_000;

1617

1

1618

1

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

1619

1

1620

1

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

1621

1

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

1622

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1623

1

1624

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1625

1626

1

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

1627

1

});

1628

1

1629

1630

#[test]

1631

1

fn root_can_change_default_xcm_vers() {

1632

1

	ExtBuilder::default()

1633

1

		.with_balances(vec![

1634

1

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

1635

1

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

1636

1

])

1637

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1638

1

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

1639

1

			metadata: AssetRegistrarMetadata {

1640

1

				name: b"RelayToken".to_vec(),

1641

1

				symbol: b"Relay".to_vec(),

1642

1

				decimals: 12,

1643

1

				is_frozen: false,

1644

1

},

1645

1

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

1646

1

			is_sufficient: true,

1647

1

}])

1648

1

		.build()

1649

1

		.execute_with(|| {

1650

1

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

1651

1

			let dest = Location {

1652

1

				parents: 1,

1653

1

				interior: [AccountId32 {

1654

1

					network: None,

1655

1

					id: [1u8; 32],

1656

1

}]

1657

1

				.into(),

1658

1

};

1659

1

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

1660

1

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

1661

1

			let (chain_part, beneficiary) =

1662

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

1663

1

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

1664

1

			// know with which version to send

1665

1

			assert_noop!(

1666

1

				PolkadotXcm::transfer_assets(

1667

1

					origin_of(AccountId::from(ALICE)),

1668

1

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

1669

1

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

1670

1

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

1671

1

0,

1672

1

					WeightLimit::Limited(4000000000.into())

1673

1

),

1674

1

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

1675

1

);

1676

1677

			// Root sets the defaultXcm

1678

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1679

1

				root_origin(),

1680

1

				Some(3)

1681

1

));

1682

1683

			// Now transferring does not fail

1684

1

			assert_ok!(PolkadotXcm::transfer_assets(

1685

1

				origin_of(AccountId::from(ALICE)),

1686

1

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

1687

1

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

1688

1

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

1689

1

0,

1690

1

				WeightLimit::Limited(4000000000.into())

1691

1

));

1692

1

})

1693

1

1694

1695

#[test]

1696

1

fn asset_can_be_registered() {

1697

1

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

1698

1

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

1699

1

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

1700

1

		let asset_metadata = AssetRegistrarMetadata {

1701

1

			name: b"RelayToken".to_vec(),

1702

1

			symbol: b"Relay".to_vec(),

1703

1

			decimals: 12,

1704

1

			is_frozen: false,

1705

1

};

1706

1

		assert_ok!(AssetManager::register_foreign_asset(

1707

1

			moonriver_runtime::RuntimeOrigin::root(),

1708

1

			source_location,

1709

1

			asset_metadata,

1710

1

			1u128,

1711

1

			true

1712

1

));

1713

1

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

1714

1

});

1715

1

1716

1717

#[test]

1718

1

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1719

1

	ExtBuilder::default()

1720

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1721

1

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

1722

1

			metadata: AssetRegistrarMetadata {

1723

1

				name: b"RelayToken".to_vec(),

1724

1

				symbol: b"Relay".to_vec(),

1725

1

				decimals: 12,

1726

1

				is_frozen: false,

1727

1

},

1728

1

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

1729

1

			is_sufficient: true,

1730

1

}])

1731

1

		.with_balances(vec![

1732

1

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

1733

1

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

1734

1

])

1735

1

		.build()

1736

1

		.execute_with(|| {

1737

1

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

1738

1

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

1739

1

1740

1

			// Its address is

1741

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1742

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1743

1

				relay_asset_id,

1744

1

);

1745

1

1746

1

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

1747

1

			assert_eq!(

1748

1

				moonriver_runtime::Assets::total_supply(relay_asset_id),

1749

1

				1_000 * MOVR

1750

1

);

1751

1752

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

1753

1

			Precompiles::new()

1754

1

				.prepare_test(

1755

1

					ALICE,

1756

1

					asset_precompile_address,

1757

1

					ForeignAssetsPCall::total_supply {},

1758

1

1759

1

				.expect_cost(5007)

1760

1

				.expect_no_logs()

1761

1

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

1762

1

1763

1

			// Access balanceOf through precompile

1764

1

			Precompiles::new()

1765

1

				.prepare_test(

1766

1

					ALICE,

1767

1

					asset_precompile_address,

1768

1

					ForeignAssetsPCall::balance_of {

1769

1

						who: Address(ALICE.into()),

1770

1

},

1771

1

1772

1

				.expect_cost(5007)

1773

1

				.expect_no_logs()

1774

1

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

1775

1

});

1776

1

1777

1778

#[test]

1779

1

fn xcm_asset_erc20_precompiles_transfer() {

1780

1

	ExtBuilder::default()

1781

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1782

1

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

1783

1

			metadata: AssetRegistrarMetadata {

1784

1

				name: b"RelayToken".to_vec(),

1785

1

				symbol: b"Relay".to_vec(),

1786

1

				decimals: 12,

1787

1

				is_frozen: false,

1788

1

},

1789

1

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

1790

1

			is_sufficient: true,

1791

1

}])

1792

1

		.with_balances(vec![

1793

1

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

1794

1

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

1795

1

])

1796

1

		.build()

1797

1

		.execute_with(|| {

1798

1

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

1799

1

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

1800

1

1801

1

			// Its address is

1802

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1803

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1804

1

				relay_asset_id,

1805

1

);

1806

1

1807

1

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

1808

1

			Precompiles::new()

1809

1

				.prepare_test(

1810

1

					ALICE,

1811

1

					asset_precompile_address,

1812

1

					ForeignAssetsPCall::transfer {

1813

1

						to: Address(BOB.into()),

1814

1

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

1815

1

},

1816

1

1817

1

				.expect_cost(26682)

1818

1

				.expect_log(log3(

1819

1

					asset_precompile_address,

1820

1

					SELECTOR_LOG_TRANSFER,

1821

1

					H160::from(ALICE),

1822

1

					H160::from(BOB),

1823

1

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

1824

1

))

1825

1

				.execute_returns(true);

1826

1

1827

1

			// Make sure BOB has 400 MOVR

1828

1

			Precompiles::new()

1829

1

				.prepare_test(

1830

1

					BOB,

1831

1

					asset_precompile_address,

1832

1

					ForeignAssetsPCall::balance_of {

1833

1

						who: Address(BOB.into()),

1834

1

},

1835

1

1836

1

				.expect_cost(5007)

1837

1

				.expect_no_logs()

1838

1

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

1839

1

});

1840

1

1841

1842

#[test]

1843

1

fn xcm_asset_erc20_precompiles_approve() {

1844

1

	ExtBuilder::default()

1845

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1846

1

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

1847

1

			metadata: AssetRegistrarMetadata {

1848

1

				name: b"RelayToken".to_vec(),

1849

1

				symbol: b"Relay".to_vec(),

1850

1

				decimals: 12,

1851

1

				is_frozen: false,

1852

1

},

1853

1

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

1854

1

			is_sufficient: true,

1855

1

}])

1856

1

		.with_balances(vec![

1857

1

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

1858

1

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

1859

1

])

1860

1

		.build()

1861

1

		.execute_with(|| {

1862

1

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

1863

1

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

1864

1

1865

1

			// Its address is

1866

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1867

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1868

1

				relay_asset_id,

1869

1

);

1870

1

1871

1

			// Aprove Bob for spending 400 MOVR from Alice

1872

1

			Precompiles::new()

1873

1

				.prepare_test(

1874

1

					ALICE,

1875

1

					asset_precompile_address,

1876

1

					ForeignAssetsPCall::approve {

1877

1

						spender: Address(BOB.into()),

1878

1

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

1879

1

},

1880

1

1881

1

				.expect_cost(17333)

1882

1

				.expect_log(log3(

1883

1

					asset_precompile_address,

1884

1

					SELECTOR_LOG_APPROVAL,

1885

1

					H160::from(ALICE),

1886

1

					H160::from(BOB),

1887

1

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

1888

1

))

1889

1

				.execute_returns(true);

1890

1

1891

1

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

1892

1

			Precompiles::new()

1893

1

				.prepare_test(

1894

1

					BOB,

1895

1

					asset_precompile_address,

1896

1

					ForeignAssetsPCall::transfer_from {

1897

1

						from: Address(ALICE.into()),

1898

1

						to: Address(CHARLIE.into()),

1899

1

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

1900

1

},

1901

1

1902

1

				.expect_cost(31980)

1903

1

				.expect_log(log3(

1904

1

					asset_precompile_address,

1905

1

					SELECTOR_LOG_TRANSFER,

1906

1

					H160::from(ALICE),

1907

1

					H160::from(CHARLIE),

1908

1

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

1909

1

))

1910

1

				.execute_returns(true);

1911

1

1912

1

			// Make sure CHARLIE has 400 MOVR

1913

1

			Precompiles::new()

1914

1

				.prepare_test(

1915

1

					CHARLIE,

1916

1

					asset_precompile_address,

1917

1

					ForeignAssetsPCall::balance_of {

1918

1

						who: Address(CHARLIE.into()),

1919

1

},

1920

1

1921

1

				.expect_cost(5007)

1922

1

				.expect_no_logs()

1923

1

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

1924

1

});

1925

1

1926

1927

#[test]

1928

1

fn xtokens_precompiles_transfer() {

1929

2

	fn run_test_variant(evm_native: bool) {

1930

2

		let mut builder = ExtBuilder::default();

1931

2

1932

2

		if evm_native {

1933

1

			builder = builder.with_evm_native_foreign_assets();

1934

1

1935

1936

2

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

1937

2

		builder

1938

2

			.with_xcm_assets(vec![XcmAssetInitialization {

1939

2

				asset_type: asset_type.clone(),

1940

2

				metadata: AssetRegistrarMetadata {

1941

2

					name: b"RelayToken".to_vec(),

1942

2

					symbol: b"Relay".to_vec(),

1943

2

					decimals: 12,

1944

2

					is_frozen: false,

1945

2

},

1946

2

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

1947

2

				is_sufficient: true,

1948

2

}])

1949

2

			.with_balances(vec![

1950

2

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

1951

2

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

1952

2

])

1953

2

			.with_safe_xcm_version(3)

1954

2

			.build()

1955

2

			.execute_with(|| {

1956

2

				let xtokens_precompile_address = H160::from_low_u64_be(2052);

1957

2

1958

2

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

1959

2

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

1960

2

1961

2

				// Its address is

1962

2

				let asset_precompile_address = Runtime::asset_id_to_account(

1963

2

					FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1964

2

					relay_asset_id,

1965

2

);

1966

2

1967

2

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

1968

2

				let destination = Location::new(

1969

2

1,

1970

2

					[Junction::AccountId32 {

1971

2

						network: None,

1972

2

						id: [1u8; 32],

1973

2

}],

1974

2

);

1975

2

1976

2

				let inside = Rc::new(Cell::new(false));

1977

2

				let inside2 = inside.clone();

1978

2

1979

2

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

1980

2

				Precompiles::new()

1981

2

					.prepare_test(

1982

2

						ALICE,

1983

2

						xtokens_precompile_address,

1984

2

						XtokensPCall::transfer {

1985

2

							currency_address: Address(asset_precompile_address.into()),

1986

2

							amount: 500_000_000_000_000u128.into(),

1987

2

							destination,

1988

2

							weight: 4_000_000,

1989

2

},

1990

2

1991

2

					.expect_cost(if evm_native { 178519 } else { 26919 })

1992

2

					.expect_no_logs()

1993

2

					// We expect an evm subcall ERC20.burnFrom

1994

2

					.with_subcall_handle(move |subcall| {

1995

1

						let Subcall {

1996

1

							address,

1997

1

							transfer,

1998

1

							input,

1999

1

							target_gas: _,

2000

1

							is_static,

2001

1

							context,

2002

1

						} = subcall;

2003

1

2004

1

						assert_eq!(context.caller, EvmForeignAssets::account_id().into());

2005

2006

1

						let asset_id: u128 = asset_type.clone().into();

2007

1

						let expected_address: H160 = Runtime::asset_id_to_account(

2008

1

							FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

2009

1

							asset_id,

2010

1

2011

1

						.into();

2012

1

						assert_eq!(address, expected_address);

2013

1

						assert_eq!(is_static, false);

2014

2015

1

						assert!(transfer.is_none());

2016

2017

1

						assert_eq!(context.address, expected_address);

2018

1

						assert_eq!(context.apparent_value, 0u8.into());

2019

2020

1

						assert_eq!(&input[..4], &keccak256!("burnFrom(address,uint256)")[..4]);

2021

1

						assert_eq!(&input[4..16], &[0u8; 12]);

2022

1

						assert_eq!(&input[16..36], ALICE);

2023

2024

1

						inside2.set(true);

2025

1

2026

1

						SubcallOutput {

2027

1

							output: Default::default(),

2028

1

							cost: 149_000,

2029

1

							logs: vec![],

2030

1

							..SubcallOutput::succeed()

2031

1

2032

2

})

2033

2

					.execute_returns(())

2034

2

})

2035

2

2036

2037

1

	run_test_variant(false);

2038

1

	run_test_variant(true);

2039

1

2040

2041

#[test]

2042

1

fn xtokens_precompiles_transfer_multiasset() {

2043

1

	ExtBuilder::default()

2044

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2045

1

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

2046

1

			metadata: AssetRegistrarMetadata {

2047

1

				name: b"RelayToken".to_vec(),

2048

1

				symbol: b"Relay".to_vec(),

2049

1

				decimals: 12,

2050

1

				is_frozen: false,

2051

1

},

2052

1

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

2053

1

			is_sufficient: true,

2054

1

}])

2055

1

		.with_balances(vec![

2056

1

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

2057

1

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

2058

1

])

2059

1

		.with_safe_xcm_version(3)

2060

1

		.build()

2061

1

		.execute_with(|| {

2062

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

2063

1

2064

1

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

2065

1

			let destination = Location::new(

2066

1

1,

2067

1

				[Junction::AccountId32 {

2068

1

					network: None,

2069

1

					id: [1u8; 32],

2070

1

}],

2071

1

);

2072

1

2073

1

			// This time we transfer it through TransferMultiAsset

2074

1

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

2075

1

			Precompiles::new()

2076

1

				.prepare_test(

2077

1

					ALICE,

2078

1

					xtokens_precompile_address,

2079

1

					XtokensPCall::transfer_multiasset {

2080

1

						// We want to transfer the relay token

2081

1

						asset: Location::parent(),

2082

1

						amount: 500_000_000_000_000u128.into(),

2083

1

						destination,

2084

1

						weight: 4_000_000,

2085

1

},

2086

1

2087

1

				.expect_cost(26919)

2088

1

				.expect_no_logs()

2089

1

				.execute_returns(());

2090

1

})

2091

1

2092

2093

#[test]

2094

1

fn make_sure_polkadot_xcm_cannot_be_called() {

2095

1

	ExtBuilder::default()

2096

1

		.with_balances(vec![

2097

1

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

2098

1

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

2099

1

])

2100

1

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

2101

1

		.with_mappings(vec![(

2102

1

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

2103

1

			AccountId::from(ALICE),

2104

1

)])

2105

1

		.build()

2106

1

		.execute_with(|| {

2107

1

			let dest = Location {

2108

1

				parents: 1,

2109

1

				interior: [AccountId32 {

2110

1

					network: None,

2111

1

					id: [1u8; 32],

2112

1

}]

2113

1

				.into(),

2114

1

};

2115

1

			let assets: Assets = [Asset {

2116

1

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

2117

1

				fun: Fungible(1000),

2118

1

}]

2119

1

			.to_vec()

2120

1

			.into();

2121

1

			assert_noop!(

2122

1

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

2123

1

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

2124

1

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

2125

1

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

2126

1

					fee_asset_item: 0,

2127

1

})

2128

1

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

2129

1

					AccountId::from(ALICE)

2130

1

)),

2131

1

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

2132

1

);

2133

1

});

2134

1

2135

2136

#[test]

2137

1

fn transactor_cannot_use_more_than_max_weight() {

2138

1

	ExtBuilder::default()

2139

1

		.with_balances(vec![

2140

1

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

2141

1

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

2142

1

])

2143

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2144

1

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

2145

1

			metadata: AssetRegistrarMetadata {

2146

1

				name: b"RelayToken".to_vec(),

2147

1

				symbol: b"Relay".to_vec(),

2148

1

				decimals: 12,

2149

1

				is_frozen: false,

2150

1

},

2151

1

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

2152

1

			is_sufficient: true,

2153

1

}])

2154

1

		.build()

2155

1

		.execute_with(|| {

2156

1

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

2157

1

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

2158

1

			assert_ok!(XcmTransactor::register(

2159

1

				root_origin(),

2160

1

				AccountId::from(ALICE),

2161

1

0,

2162

1

));

2163

2164

			// Root can set transact info

2165

1

			assert_ok!(XcmTransactor::set_transact_info(

2166

1

				root_origin(),

2167

1

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

2168

1

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

2169

1

				3000.into(),

2170

1

				20000.into(),

2171

1

				None

2172

1

));

2173

2174

			// Root can set transact info

2175

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2176

1

				root_origin(),

2177

1

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

2178

1

2179

1

));

2180

2181

1

			assert_noop!(

2182

1

				XcmTransactor::transact_through_derivative(

2183

1

					origin_of(AccountId::from(ALICE)),

2184

1

					moonriver_runtime::xcm_config::Transactors::Relay,

2185

1

0,

2186

1

					CurrencyPayment {

2187

1

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

2188

1

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

2189

1

)),

2190

1

						fee_amount: None

2191

1

},

2192

1

					vec![],

2193

1

					// 2000 is the max

2194

1

					TransactWeights {

2195

1

						transact_required_weight_at_most: 17001.into(),

2196

1

						overall_weight: None

2197

1

},

2198

1

					false

2199

1

),

2200

1

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

2201

1

);

2202

1

			assert_noop!(

2203

1

				XcmTransactor::transact_through_derivative(

2204

1

					origin_of(AccountId::from(ALICE)),

2205

1

					moonriver_runtime::xcm_config::Transactors::Relay,

2206

1

0,

2207

1

					CurrencyPayment {

2208

1

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

2209

1

						fee_amount: None

2210

1

},

2211

1

					vec![],

2212

1

					// 20000 is the max

2213

1

					TransactWeights {

2214

1

						transact_required_weight_at_most: 17001.into(),

2215

1

						overall_weight: None

2216

1

},

2217

1

					false

2218

1

),

2219

1

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

2220

1

);

2221

1

})

2222

1

2223

2224

#[test]

2225

1

fn transact_through_signed_precompile_works_v2() {

2226

1

	ExtBuilder::default()

2227

1

		.with_balances(vec![

2228

1

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

2229

1

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

2230

1

])

2231

1

		.with_safe_xcm_version(3)

2232

1

		.build()

2233

1

		.execute_with(|| {

2234

1

			// Destination

2235

1

			let dest = Location::parent();

2236

1

2237

1

			let fee_payer_asset = Location::parent();

2238

1

2239

1

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

2240

1

2241

1

			let total_weight = 1_000_000_000u64;

2242

1

2243

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2244

1

2245

1

			Precompiles::new()

2246

1

				.prepare_test(

2247

1

					ALICE,

2248

1

					xcm_transactor_v2_precompile_address,

2249

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2250

1

						dest,

2251

1

						fee_asset: fee_payer_asset,

2252

1

						weight: 4_000_000,

2253

1

						call: bytes.into(),

2254

1

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

2255

1

						overall_weight: total_weight,

2256

1

},

2257

1

2258

1

				.expect_cost(25383)

2259

1

				.expect_no_logs()

2260

1

				.execute_returns(());

2261

1

});

2262

1

2263

2264

#[test]

2265

1

fn transact_through_signed_cannot_send_to_local_chain() {

2266

1

	ExtBuilder::default()

2267

1

		.with_balances(vec![

2268

1

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

2269

1

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

2270

1

])

2271

1

		.with_safe_xcm_version(3)

2272

1

		.build()

2273

1

		.execute_with(|| {

2274

1

			// Destination

2275

1

			let dest = Location::here();

2276

1

2277

1

			let fee_payer_asset = Location::parent();

2278

1

2279

1

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

2280

1

2281

1

			let total_weight = 1_000_000_000u64;

2282

1

2283

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2284

1

2285

1

			Precompiles::new()

2286

1

				.prepare_test(

2287

1

					ALICE,

2288

1

					xcm_transactor_v2_precompile_address,

2289

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2290

1

						dest,

2291

1

						fee_asset: fee_payer_asset,

2292

1

						weight: 4_000_000,

2293

1

						call: bytes.into(),

2294

1

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

2295

1

						overall_weight: total_weight,

2296

1

},

2297

1

2298

1

				.execute_reverts(|output| {

2299

1

					from_utf8(&output)

2300

1

						.unwrap()

2301

1

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

2302

1

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

2303

1

});

2304

1

});

2305

1

2306

2307

#[test]

2308

1

fn call_xtokens_with_fee() {

2309

1

	ExtBuilder::default()

2310

1

		.with_balances(vec![

2311

1

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

2312

1

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

2313

1

])

2314

1

		.with_safe_xcm_version(3)

2315

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2316

1

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

2317

1

			metadata: AssetRegistrarMetadata {

2318

1

				name: b"RelayToken".to_vec(),

2319

1

				symbol: b"Relay".to_vec(),

2320

1

				decimals: 12,

2321

1

				is_frozen: false,

2322

1

},

2323

1

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

2324

1

			is_sufficient: true,

2325

1

}])

2326

1

		.build()

2327

1

		.execute_with(|| {

2328

1

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

2329

1

			let dest = Location {

2330

1

				parents: 1,

2331

1

				interior: [AccountId32 {

2332

1

					network: None,

2333

1

					id: [1u8; 32],

2334

1

}]

2335

1

				.into(),

2336

1

};

2337

1

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

2338

1

2339

1

			let before_balance =

2340

1

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

2341

1

2342

1

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

2343

1

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

2344

1

			let (chain_part, beneficiary) =

2345

1

				split_location_into_chain_part_and_beneficiary(dest).unwrap();

2346

1

2347

1

			// We are able to transfer with fee

2348

1

			assert_ok!(PolkadotXcm::transfer_assets(

2349

1

				origin_of(AccountId::from(ALICE)),

2350

1

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

2351

1

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

2352

1

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

2353

1

0,

2354

1

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

2355

1

			),);

2356

2357

1

			let after_balance =

2358

1

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

2359

1

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

2360

1

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

2361

1

});

2362

1

2363

2364

#[test]

2365

1

fn test_xcm_utils_ml_tp_account() {

2366

1

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

2367

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2368

1

		let expected_address_parent: H160 =

2369

1

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

2370

1

				.unwrap()

2371

1

				.into();

2372

1

2373

1

		Precompiles::new()

2374

1

			.prepare_test(

2375

1

				ALICE,

2376

1

				xcm_utils_precompile_address,

2377

1

				XcmUtilsPCall::multilocation_to_address {

2378

1

					location: Location::parent(),

2379

1

},

2380

1

2381

1

			.expect_cost(3338)

2382

1

			.expect_no_logs()

2383

1

			.execute_returns(Address(expected_address_parent));

2384

1

2385

1

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

2386

1

		let expected_address_parachain: H160 =

2387

1

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

2388

1

				&parachain_2000_multilocation,

2389

1

2390

1

			.unwrap()

2391

1

			.into();

2392

1

2393

1

		Precompiles::new()

2394

1

			.prepare_test(

2395

1

				ALICE,

2396

1

				xcm_utils_precompile_address,

2397

1

				XcmUtilsPCall::multilocation_to_address {

2398

1

					location: parachain_2000_multilocation,

2399

1

},

2400

1

2401

1

			.expect_cost(3338)

2402

1

			.expect_no_logs()

2403

1

			.execute_returns(Address(expected_address_parachain));

2404

1

2405

1

		let alice_in_parachain_2000_location = Location::new(

2406

1

1,

2407

1

2408

1

				Parachain(2000),

2409

1

				AccountKey20 {

2410

1

					network: None,

2411

1

					key: ALICE,

2412

1

},

2413

1

],

2414

1

);

2415

1

		let expected_address_alice_in_parachain_2000 =

2416

1

			xcm_builder::HashedDescription::<

2417

1

				AccountId,

2418

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2419

1

			>::convert_location(&alice_in_parachain_2000_location)

2420

1

			.unwrap()

2421

1

			.into();

2422

1

2423

1

		Precompiles::new()

2424

1

			.prepare_test(

2425

1

				ALICE,

2426

1

				xcm_utils_precompile_address,

2427

1

				XcmUtilsPCall::multilocation_to_address {

2428

1

					location: alice_in_parachain_2000_location,

2429

1

},

2430

1

2431

1

			.expect_cost(3338)

2432

1

			.expect_no_logs()

2433

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2434

1

});

2435

1

2436

2437

#[test]

2438

1

fn test_nested_batch_calls_from_xcm_transact() {

2439

1

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

2440

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2441

1

		// in a future polkadot-sdk version

2442

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2443

2444

1

		let mut valid_nested_calls =

2445

1

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

2446

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2447

8

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

2448

8

				calls: vec![valid_nested_calls],

2449

8

});

2450

8

2451

2452

1

		let valid_message = Xcm(vec![Transact {

2453

1

			origin_kind: OriginKind::SovereignAccount,

2454

1

			fallback_max_weight: None,

2455

1

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

2456

1

		}]);

2457

1

2458

1

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

2459

2460

1

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

2461

1

			calls: vec![valid_nested_calls],

2462

1

});

2463

1

2464

1

		let invalid_message = Xcm(vec![Transact {

2465

1

			origin_kind: OriginKind::SovereignAccount,

2466

1

			fallback_max_weight: None,

2467

1

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

2468

1

		}]);

2469

1

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

2470

1

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

2471

1

});

2472

1

2473

2474

#[test]

2475

1

fn test_xcm_utils_weight_message() {

2476

1

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

2477

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2478

1

		let expected_weight =

2479

1

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

2480

1

2481

1

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

2482

1

2483

1

		let input = XcmUtilsPCall::weight_message {

2484

1

			message: message.into(),

2485

1

};

2486

1

2487

1

		Precompiles::new()

2488

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2489

1

			.expect_cost(1669)

2490

1

			.expect_no_logs()

2491

1

			.execute_returns(expected_weight);

2492

1

});

2493

1

2494

2495

#[test]

2496

1

fn test_xcm_utils_get_units_per_second() {

2497

1

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

2498

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2499

1

		let location = SelfReserve::get();

2500

1

2501

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2502

1

2503

1

		let expected_units =

2504

1

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

2505

1

2506

1

		Precompiles::new()

2507

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2508

1

			.expect_cost(3338)

2509

1

			.expect_no_logs()

2510

1

			.execute_returns(expected_units);

2511

1

});

2512

1

2513

2514

#[test]

2515

1

fn precompile_existence() {

2516

1

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

2517

1

		let precompiles = Precompiles::new();

2518

1

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

2519

1

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

2520

1

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

2521

1

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

2522

1

2523

1

		.into_iter()

2524

1

		.map(H160::from_low_u64_be)

2525

1

		.collect();

2526

2527

3001

		for i in 0..3000 {

2528

3000

			let address = H160::from_low_u64_be(i);

2529

3000

2530

3000

			if precompile_addresses.contains(&address) {

2531

40

				assert!(

2532

40

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

2533

					"is_precompile({}) should return true",

2534

2535

);

2536

2537

40

				assert!(

2538

40

					precompiles

2539

40

						.execute(&mut MockHandle::new(

2540

40

							address,

2541

40

							Context {

2542

40

								address,

2543

40

								caller: H160::zero(),

2544

40

								apparent_value: U256::zero()

2545

40

2546

40

),)

2547

40

						.is_some(),

2548

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

2549

2550

);

2551

			} else {

2552

2960

				assert!(

2553

2960

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

2554

					"is_precompile({}) should return false",

2555

2556

);

2557

2558

2960

				assert!(

2559

2960

					precompiles

2560

2960

						.execute(&mut MockHandle::new(

2561

2960

							address,

2562

2960

							Context {

2563

2960

								address,

2564

2960

								caller: H160::zero(),

2565

2960

								apparent_value: U256::zero()

2566

2960

2567

2960

),)

2568

2960

						.is_none(),

2569

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

2570

2571

);

2572

2573

2574

1

});

2575

1

2576

2577

#[test]

2578

1

fn removed_precompiles() {

2579

1

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

2580

1

		let precompiles = Precompiles::new();

2581

1

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

2582

2583

3000

		for i in 1..3000 {

2584

2999

			let address = H160::from_low_u64_be(i);

2585

2999

2586

2999

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

2587

2959

				continue;

2588

40

2589

40

2590

40

			if !removed_precompiles.contains(&i) {

2591

36

				assert!(

2592

36

					match precompiles.is_active_precompile(address, 100_000u64) {

2593

36

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

2594

						_ => false,

2595

},

2596

					"{i} should be an active precompile"

2597

);

2598

36

				continue;

2599

4

2600

4

2601

4

			assert!(

2602

4

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

2603

4

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

2604

					_ => false,

2605

},

2606

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

2607

);

2608

2609

4

			precompiles

2610

4

				.prepare_test(Alice, address, [])

2611

4

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

2612

4

2613

1

})

2614

1

2615

2616

#[test]

2617

1

fn deal_with_fees_handles_tip() {

2618

	use frame_support::traits::OnUnbalanced;

2619

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2620

	use moonriver_runtime::Treasury;

2621

2622

1

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

2623

1

		set_parachain_inherent_data();

2624

1

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

2625

1

		// in the Moonriver runtime. It verifies that:

2626

1

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

2627

1

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

2628

1

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

2629

1

2630

1

		// The test details:

2631

1

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

2632

1

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

2633

1

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

2634

1

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

2635

1

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

2636

1

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

2637

1

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

2638

1

2639

1

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

2640

1

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

2641

1

			AccountId,

2642

1

		>>::issue(100);

2643

1

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

2644

1

			AccountId,

2645

1

		>>::issue(1000);

2646

1

2647

1

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

2648

1

		let total_supply_before = Balances::total_issuance();

2649

1

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

2650

1

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

2651

1

		assert_eq!(total_supply_before, 1_100);

2652

1

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

2653

2654

		// Step 3: Execute the fees handling logic.

2655

1

		DealWithSubstrateFeesAndTip::<

2656

1

			Runtime,

2657

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2658

1

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

2659

1

2660

1

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

2661

1

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

2662

1

2663

1

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

2664

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2665

1

2666

1

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

2667

1

		assert_eq!(

2668

1

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

2669

1

			treasury_fee_part,

2670

1

);

2671

2672

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

2673

1

		let total_supply_after = Balances::total_issuance();

2674

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2675

2676

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

2677

1

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

2678

1

		assert_eq!(

2679

1

			block_author_balance_after - block_author_balance_before,

2680

1

			1000,

2681

1

);

2682

1

});

2683

1

2684

2685

#[test]

2686

1

fn evm_revert_substrate_events() {

2687

1

	ExtBuilder::default()

2688

1

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

2689

1

		.build()

2690

1

		.execute_with(|| {

2691

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2692

1

2693

1

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

2694

1

			// Thus BatchAll will revert the transfer.

2695

1

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

2696

1

				source: ALICE.into(),

2697

1

				target: batch_precompile_address,

2698

1

				input: BatchPCall::batch_all {

2699

1

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

2700

1

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

2701

1

					call_data: vec![].into(),

2702

1

					gas_limit: vec![].into()

2703

1

2704

1

				.into(),

2705

1

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

2706

1

				gas_limit: 500_000,

2707

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2708

1

				max_priority_fee_per_gas: None,

2709

1

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

2710

1

				access_list: Vec::new(),

2711

1

})

2712

1

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

2713

2714

1

			let transfer_count = System::events()

2715

1

				.iter()

2716

6

				.filter(|r| match r.event {

2717

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

2718

6

					_ => false,

2719

6

})

2720

1

				.count();

2721

1

2722

1

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

2723

1

});

2724

1

2725

2726

#[test]

2727

1

fn evm_success_keeps_substrate_events() {

2728

1

	ExtBuilder::default()

2729

1

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

2730

1

		.build()

2731

1

		.execute_with(|| {

2732

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2733

1

2734

1

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

2735

1

				source: ALICE.into(),

2736

1

				target: batch_precompile_address,

2737

1

				input: BatchPCall::batch_all {

2738

1

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

2739

1

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

2740

1

					call_data: vec![].into(),

2741

1

					gas_limit: vec![].into()

2742

1

2743

1

				.into(),

2744

1

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

2745

1

				gas_limit: 500_000,

2746

1

				max_fee_per_gas: U256::from(BASE_FEE_GENESIS),

2747

1

				max_priority_fee_per_gas: None,

2748

1

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

2749

1

				access_list: Vec::new(),

2750

1

})

2751

1

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

2752

2753

1

			let transfer_count = System::events()

2754

1

				.iter()

2755

10

				.filter(|r| match r.event {

2756

1

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

2757

9

					_ => false,

2758

10

})

2759

1

				.count();

2760

1

2761

1

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

2762

1

});

2763

1

2764

2765

#[cfg(test)]

2766

mod treasury_tests {

2767

	use super::*;

2768

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

2769

	use moonriver_runtime::XcmWeightTrader;

2770

	use sp_core::bounded_vec;

2771

	use sp_runtime::traits::Hash;

2772

2773

4

	fn expect_events(events: Vec<RuntimeEvent>) {

2774

4

		let block_events: Vec<RuntimeEvent> =

2775

29

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

2776

4

2777

7

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

2778

4

2779

2780

7

	fn next_block() {

2781

7

		System::reset_events();

2782

7

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

2783

7

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

2784

7

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

2785

7

2786

2787

3

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

2788

3

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

2789

3

			.expect("failed to get account balance")

2790

3

2791

2792

	#[test]

2793

1

	fn test_treasury_spend_local_with_council_origin() {

2794

1

		let initial_treasury_balance = 1_000 * MOVR;

2795

1

		ExtBuilder::default()

2796

1

			.with_balances(vec![

2797

1

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

2798

1

				(Treasury::account_id(), initial_treasury_balance),

2799

1

])

2800

1

			.build()

2801

1

			.execute_with(|| {

2802

1

				let spend_amount = 100u128 * MOVR;

2803

1

				let spend_beneficiary = AccountId::from(BOB);

2804

1

2805

1

				next_block();

2806

1

2807

1

				// TreasuryCouncilCollective

2808

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2809

1

					root_origin(),

2810

1

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

2811

1

					Some(AccountId::from(ALICE)),

2812

1

2813

1

));

2814

2815

1

				next_block();

2816

1

2817

1

				// Perform treasury spending

2818

1

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

2819

1

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

2820

1

					amount: spend_amount,

2821

1

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

2822

1

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

2823

1

					valid_from: Some(valid_from),

2824

1

});

2825

1

				assert_ok!(TreasuryCouncilCollective::propose(

2826

1

					origin_of(AccountId::from(ALICE)),

2827

1

1,

2828

1

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

2829

1

					1_000

2830

1

));

2831

2832

1

				let payout_period =

2833

1

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

2834

1

				let expected_events = [

2835

1

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

2836

1

						index: 0,

2837

1

						asset_kind: NativeOrWithId::Native,

2838

1

						amount: spend_amount,

2839

1

						beneficiary: spend_beneficiary,

2840

1

						valid_from,

2841

1

						expire_at: payout_period + valid_from,

2842

1

}),

2843

1

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

2844

1

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

2845

1

						result: Ok(()),

2846

1

}),

2847

1

2848

1

				.to_vec();

2849

1

				expect_events(expected_events);

2850

2851

6

				while System::block_number() < valid_from {

2852

5

					next_block();

2853

5

2854

2855

1

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

2856

2857

1

				let expected_events = [

2858

1

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

2859

1

						index: 0,

2860

1

						payment_id: (),

2861

1

}),

2862

1

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

2863

1

						from: Treasury::account_id(),

2864

1

						to: spend_beneficiary,

2865

1

						amount: spend_amount,

2866

1

}),

2867

1

2868

1

				.to_vec();

2869

1

				expect_events(expected_events);

2870

1

});

2871

1

2872

2873

	#[test]

2874

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2875

1

		let initial_treasury_balance = 1_000 * MOVR;

2876

1

		let asset_id = 1000100010001000u128;

2877

1

		ExtBuilder::default()

2878

1

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

2879

1

			.build()

2880

1

			.execute_with(|| {

2881

1

				let spend_amount = 100u128 * MOVR;

2882

1

				let spend_beneficiary = AccountId::from(BOB);

2883

1

2884

1

				let asset_location: Location = Location {

2885

1

					parents: 1,

2886

1

					interior: Junctions::Here,

2887

1

};

2888

1

2889

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2890

1

					root_origin(),

2891

1

					asset_id,

2892

1

					asset_location.clone(),

2893

1

12,

2894

1

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

2895

1

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

2896

1

));

2897

2898

1

				assert_ok!(XcmWeightTrader::add_asset(

2899

1

					root_origin(),

2900

1

					asset_location,

2901

1

					1u128

2902

1

));

2903

2904

1

				assert_ok!(EvmForeignAssets::mint_into(

2905

1

					asset_id,

2906

1

					Treasury::account_id(),

2907

1

					initial_treasury_balance.into()

2908

1

));

2909

2910

1

				assert_eq!(

2911

1

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

2912

1

					initial_treasury_balance.into(),

2913

					"Treasury balance not updated"

2914

);

2915

2916

				// TreasuryCouncilCollective

2917

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2918

1

					root_origin(),

2919

1

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

2920

1

					Some(AccountId::from(ALICE)),

2921

1

2922

1

));

2923

2924

				// Perform treasury spending

2925

1

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

2926

1

					amount: spend_amount,

2927

1

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

2928

1

					beneficiary: Box::new(spend_beneficiary),

2929

1

					valid_from: None,

2930

1

});

2931

1

				assert_ok!(TreasuryCouncilCollective::propose(

2932

1

					origin_of(AccountId::from(ALICE)),

2933

1

1,

2934

1

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

2935

1

					1_000

2936

1

));

2937

2938

1

				let payout_period =

2939

1

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

2940

1

2941

1

				let current_block = System::block_number();

2942

1

				let expected_events = [

2943

1

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

2944

1

						index: 0,

2945

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2946

1

						amount: spend_amount,

2947

1

						beneficiary: spend_beneficiary,

2948

1

						valid_from: current_block,

2949

1

						expire_at: current_block + payout_period,

2950

1

}),

2951

1

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

2952

1

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

2953

1

						result: Ok(()),

2954

1

}),

2955

1

2956

1

				.to_vec();

2957

1

				expect_events(expected_events);

2958

1

2959

1

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

2960

2961

1

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

2962

1

					index: 0,

2963

1

					payment_id: (),

2964

1

				})]);

2965

1

2966

1

				assert_eq!(

2967

1

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

2968

1

					(initial_treasury_balance - spend_amount).into(),

2969

					"Treasury balance not updated"

2970

);

2971

2972

1

				assert_eq!(

2973

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2974

1

					spend_amount.into(),

2975

					"Treasury payout failed"

2976

);

2977

1

});

2978

1

2979

2980

2981

#[cfg(test)]

2982

mod fee_tests {

2983

	use super::*;

2984

	use fp_evm::FeeCalculator;

2985

	use frame_support::{

2986

		traits::{ConstU128, OnFinalize},

2987

		weights::{ConstantMultiplier, WeightToFee},

2988

};

2989

	use moonriver_runtime::{

2990

		currency, LengthToFee, MinimumMultiplier, RuntimeBlockWeights, SlowAdjustingFeeUpdate,

2991

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2992

};

2993

	use sp_core::Get;

2994

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

2995

2996

1

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

2997

1

	where

2998

1

		F: FnMut() -> (),

2999

1

3000

1

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

3001

1

			.build_storage()

3002

1

			.unwrap()

3003

1

			.into();

3004

1

		t.execute_with(|| {

3005

1

			System::set_block_consumed_resources(w, 0);

3006

1

			assertions()

3007

1

});

3008

1

3009

3010

	#[test]

3011

1

	fn test_multiplier_can_grow_from_zero() {

3012

1

		let minimum_multiplier = MinimumMultiplier::get();

3013

1

		let target = TargetBlockFullness::get()

3014

1

			* RuntimeBlockWeights::get()

3015

1

				.get(DispatchClass::Normal)

3016

1

				.max_total

3017

1

				.unwrap();

3018

1

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

3019

1

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

3020

1

		run_with_system_weight(target * 101 / 100, || {

3021

1

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

3022

1

			assert!(

3023

1

				next > minimum_multiplier,

3024

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

3025

				next,

3026

				minimum_multiplier

3027

);

3028

1

})

3029

1

3030

3031

	#[test]

3032

1

	fn test_fee_calculation() {

3033

1

		let base_extrinsic = RuntimeBlockWeights::get()

3034

1

			.get(DispatchClass::Normal)

3035

1

			.base_extrinsic;

3036

1

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

3037

1

		let extrinsic_len = 100u32;

3038

1

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

3039

1

		let tip = 42u128;

3040

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

3041

		type LengthToFeeImpl = LengthToFee;

3042

3043

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

3044

1

		let expected_fee = WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3045

1

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

3046

1

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

3047

1

			+ tip;

3048

1

3049

1

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

3050

1

			.build_storage()

3051

1

			.unwrap()

3052

1

			.into();

3053

1

		t.execute_with(|| {

3054

1

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

3055

1

			let actual_fee = TransactionPayment::compute_fee(

3056

1

				extrinsic_len,

3057

1

				&frame_support::dispatch::DispatchInfo {

3058

1

					class: DispatchClass::Normal,

3059

1

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

3060

1

					call_weight: extrinsic_weight,

3061

1

					extension_weight: Weight::zero(),

3062

1

},

3063

1

				tip,

3064

1

);

3065

1

3066

1

			assert_eq!(

3067

				expected_fee,

3068

				actual_fee,

3069

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

3070

				actual_fee - expected_fee

3071

);

3072

1

});

3073

1

3074

3075

	#[test]

3076

1

	fn test_min_gas_price_is_deterministic() {

3077

1

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

3078

1

			.build_storage()

3079

1

			.unwrap()

3080

1

			.into();

3081

1

		t.execute_with(|| {

3082

1

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

3083

1

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

3084

1

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

3085

1

			let expected: U256 = multiplier

3086

1

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

3087

1

				.into();

3088

1

3089

1

			assert_eq!(expected, actual);

3090

1

});

3091

1

3092

3093

	#[test]

3094

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3095

1

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

3096

1

			.build_storage()

3097

1

			.unwrap()

3098

1

			.into();

3099

1

		t.execute_with(|| {

3100

1

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

3101

1

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

3102

1

3103

1

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

3104

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3105

1

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

3106

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3107

1

3108

1

			assert_ne!(

3109

				a, b,

3110

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

3111

);

3112

1

});

3113

1

3114

3115

	#[test]

3116

1

	fn test_fee_scenarios() {

3117

		use sp_runtime::FixedU128;

3118

1

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

3119

1

			.build_storage()

3120

1

			.unwrap()

3121

1

			.into();

3122

1

		t.execute_with(|| {

3123

1

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

3124

12

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

3125

12

				let start_multiplier =

3126

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3127

12

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

3128

12

3129

12

				let block_weight = NORMAL_WEIGHT * fullness;

3130

3131

60004

				for i in 0..num_blocks {

3132

60004

					System::set_block_number(i as u32);

3133

60004

					System::set_block_consumed_resources(block_weight, 0);

3134

60004

					TransactionPayment::on_finalize(i as u32);

3135

60004

3136

3137

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3138

12

};

3139

3140

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

3141

			// they are expected to change when parameters that influence

3142

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

3143

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

3144

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

3145

3146

1

			assert_eq!(

3147

1

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

3148

1

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

3149

1

);

3150

1

			assert_eq!(

3151

1

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

3152

1

				U256::from(312_500_000u128),

3153

1

);

3154

1

			assert_eq!(

3155

1

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

3156

1

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

3157

1

);

3158

1

			assert_eq!(

3159

1

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

3160

1

				U256::from(313_313_556u128),

3161

1

);

3162

3163

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

3164

1

			assert_eq!(

3165

1

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

3166

1

				U256::from(312_500_000u128),

3167

1

);

3168

1

			assert_eq!(

3169

1

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

3170

1

				U256::from(312_500_000u128),

3171

1

);

3172

1

			assert_eq!(

3173

1

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

3174

1

				U256::from(447_915_432u128),

3175

1

);

3176

1

			assert_eq!(

3177

1

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

3178

1

				U256::from(1_487_129_030u128),

3179

1

);

3180

3181

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

3182

1

			assert_eq!(

3183

1

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

3184

1

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

3185

1

);

3186

1

			assert_eq!(

3187

1

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

3188

1

				U256::from(312_500_000u128),

3189

1

);

3190

1

			assert_eq!(

3191

1

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

3192

1

				U256::from(1_766_664_654_709u128),

3193

1

);

3194

1

			assert_eq!(

3195

1

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

3196

1

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

3197

1

);

3198

1

});

3199

1

3200