Grcov report - mod.rs

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

#![allow(dead_code)]

18

19

use cumulus_primitives_parachain_inherent::ParachainInherentData;

20

use fp_evm::GenesisAccount;

21

use frame_support::{

22

	assert_ok,

23

	traits::{OnFinalize, OnInitialize},

24

};

25

pub use moonriver_runtime::{

26

	asset_config::AssetRegistrarMetadata, currency::MOVR, xcm_config::AssetType, AccountId,

27

	AssetId, AssetManager, AsyncBacking, AuthorInherent, Balance, Ethereum, InflationInfo,

28

	ParachainStaking, Range, Runtime, RuntimeCall, RuntimeEvent, System, TransactionConverter,

29

	UncheckedExtrinsic, HOURS,

30

};

31

use nimbus_primitives::{NimbusId, NIMBUS_ENGINE_ID};

32

use polkadot_parachain::primitives::HeadData;

33

use sp_consensus_slots::Slot;

34

use sp_core::{Encode, H160};

35

use sp_runtime::{traits::Dispatchable, BuildStorage, Digest, DigestItem, Perbill, Percent};

36

37

use std::collections::BTreeMap;

38

39

use fp_rpc::ConvertTransaction;

40

use moonriver_runtime::bridge_config::XcmOverPolkadotInstance;

41

use moonriver_runtime::{Assets, EvmForeignAssets, XcmWeightTrader};

42

use pallet_transaction_payment::Multiplier;

43

use xcm::latest::{InteriorLocation, Location};

44

45

10

pub fn existential_deposit() -> u128 {

46

10

	<Runtime as pallet_balances::Config>::ExistentialDeposit::get()

47

10

48

49

// A valid signed Alice transfer.

50

pub const VALID_ETH_TX: &str =

51

	"02f86d8205018085174876e80085e8d4a5100082520894f24ff3a9cf04c71dbc94d0b566f7a27b9456\

52

	6cac8080c001a0e1094e1a52520a75c0255db96132076dd0f1263089f838bea548cbdbfc64a4d19f031c\

53

	92a8cb04e2d68d20a6158d542a07ac440cc8d07b6e36af02db046d92df";

54

55

// An invalid signed Alice transfer with a gas limit artifically set to 0.

56

pub const INVALID_ETH_TX: &str =

57

	"f86180843b9aca00809412cb274aad8251c875c0bf6872b67d9983e53fdd01801ca00e28ba2dd3c5a\

58

	3fd467d4afd7aefb4a34b373314fff470bb9db743a84d674a0aa06e5994f2d07eafe1c37b4ce5471ca\

59

	ecec29011f6f5bf0b1a552c55ea348df35f";

60

61

3

pub fn rpc_run_to_block(n: u32) {

62

6

	while System::block_number() < n {

63

3

		Ethereum::on_finalize(System::block_number());

64

3

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

65

3

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

66

3

67

3

68

69

/// Utility function that advances the chain to the desired block number.

70

/// If an author is provided, that author information is injected to all the blocks in the meantime.

71

9

pub fn run_to_block(n: u32, author: Option<NimbusId>) {

72

6609

	while System::block_number() < n {

73

		// Set the new block number and author

74

6600

		match author {

75

6600

			Some(ref author) => {

76

6600

				let pre_digest = Digest {

77

6600

					logs: vec![DigestItem::PreRuntime(NIMBUS_ENGINE_ID, author.encode())],

78

6600

};

79

6600

				System::reset_events();

80

6600

				System::initialize(

81

6600

					&(System::block_number() + 1),

82

6600

					&System::parent_hash(),

83

6600

					&pre_digest,

84

6600

);

85

6600

86

			None => {

87

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

88

89

90

91

6600

		increase_last_relay_slot_number(1);

92

6600

93

6600

		// Initialize the new block

94

6600

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

95

6600

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

96

6600

97

6600

		// Finalize the block

98

6600

		ParachainStaking::on_finalize(System::block_number());

99

100

9

101

102

3

pub fn last_event() -> RuntimeEvent {

103

3

	System::events().pop().expect("Event expected").event

104

3

105

106

// Helper function to give a simple evm context suitable for tests.

107

// We can remove this once https://github.com/rust-blockchain/evm/pull/35

108

// is in our dependency graph.

109

pub fn evm_test_context() -> fp_evm::Context {

110

	fp_evm::Context {

111

		address: Default::default(),

112

		caller: Default::default(),

113

		apparent_value: From::from(0),

114

115

116

117

// Test struct with the purpose of initializing xcm assets

118

#[derive(Clone)]

119

pub struct XcmAssetInitialization {

120

	pub asset_type: AssetType,

121

	pub metadata: AssetRegistrarMetadata,

122

	pub balances: Vec<(AccountId, Balance)>,

123

	pub is_sufficient: bool,

124

125

126

pub struct ExtBuilder {

127

	// endowed accounts with balances

128

	balances: Vec<(AccountId, Balance)>,

129

	// [collator, amount]

130

	collators: Vec<(AccountId, Balance)>,

131

	// [delegator, collator, nomination_amount]

132

	delegations: Vec<(AccountId, AccountId, Balance, Percent)>,

133

	// per-round inflation config

134

	inflation: InflationInfo<Balance>,

135

	// AuthorId -> AccoutId mappings

136

	mappings: Vec<(NimbusId, AccountId)>,

137

	// Crowdloan fund

138

	crowdloan_fund: Balance,

139

	// Chain id

140

	chain_id: u64,

141

	// EVM genesis accounts

142

	evm_accounts: BTreeMap<H160, GenesisAccount>,

143

	// [assettype, metadata, Vec<Account, Balance,>, is_sufficient]

144

	xcm_assets: Vec<XcmAssetInitialization>,

145

	evm_native_foreign_assets: bool,

146

	safe_xcm_version: Option<u32>,

147

	opened_bridges: Vec<(Location, InteriorLocation, Option<bp_moonbeam::LaneId>)>,

148

149

150

impl Default for ExtBuilder {

151

65

	fn default() -> ExtBuilder {

152

65

		ExtBuilder {

153

65

			balances: vec![],

154

65

			delegations: vec![],

155

65

			collators: vec![],

156

65

			inflation: InflationInfo {

157

65

				expect: Range {

158

65

					min: 100_000 * MOVR,

159

65

					ideal: 200_000 * MOVR,

160

65

					max: 500_000 * MOVR,

161

65

},

162

65

				// not used

163

65

				annual: Range {

164

65

					min: Perbill::from_percent(50),

165

65

					ideal: Perbill::from_percent(50),

166

65

					max: Perbill::from_percent(50),

167

65

},

168

65

				// unrealistically high parameterization, only for testing

169

65

				round: Range {

170

65

					min: Perbill::from_percent(5),

171

65

					ideal: Perbill::from_percent(5),

172

65

					max: Perbill::from_percent(5),

173

65

},

174

65

},

175

65

			mappings: vec![],

176

65

			crowdloan_fund: 0,

177

65

			chain_id: CHAIN_ID,

178

65

			evm_accounts: BTreeMap::new(),

179

65

			xcm_assets: vec![],

180

65

			evm_native_foreign_assets: false,

181

65

			safe_xcm_version: None,

182

65

			opened_bridges: vec![],

183

65

184

65

185

186

187

impl ExtBuilder {

188

2

	pub fn with_evm_accounts(mut self, accounts: BTreeMap<H160, GenesisAccount>) -> Self {

189

2

		self.evm_accounts = accounts;

190

2

		self

191

2

192

193

45

	pub fn with_balances(mut self, balances: Vec<(AccountId, Balance)>) -> Self {

194

45

		self.balances = balances;

195

45

		self

196

45

197

198

15

	pub fn with_collators(mut self, collators: Vec<(AccountId, Balance)>) -> Self {

199

15

		self.collators = collators;

200

15

		self

201

15

202

203

7

	pub fn with_delegations(mut self, delegations: Vec<(AccountId, AccountId, Balance)>) -> Self {

204

7

		self.delegations = delegations

205

7

			.into_iter()

206

8

			.map(|d| (d.0, d.1, d.2, Percent::zero()))

207

7

			.collect();

208

7

		self

209

7

210

211

6

	pub fn with_crowdloan_fund(mut self, crowdloan_fund: Balance) -> Self {

212

6

		self.crowdloan_fund = crowdloan_fund;

213

6

		self

214

6

215

216

14

	pub fn with_mappings(mut self, mappings: Vec<(NimbusId, AccountId)>) -> Self {

217

14

		self.mappings = mappings;

218

14

		self

219

14

220

221

	#[allow(dead_code)]

222

	pub fn with_inflation(mut self, inflation: InflationInfo<Balance>) -> Self {

223

		self.inflation = inflation;

224

		self

225

226

227

10

	pub fn with_xcm_assets(mut self, xcm_assets: Vec<XcmAssetInitialization>) -> Self {

228

10

		self.xcm_assets = xcm_assets;

229

10

		self

230

10

231

232

2

	pub fn with_evm_native_foreign_assets(mut self) -> Self {

233

2

		self.evm_native_foreign_assets = true;

234

2

		self

235

2

236

237

8

	pub fn with_safe_xcm_version(mut self, safe_xcm_version: u32) -> Self {

238

8

		self.safe_xcm_version = Some(safe_xcm_version);

239

8

		self

240

8

241

242

2

	pub fn with_open_bridges(

243

2

		mut self,

244

2

		opened_bridges: Vec<(Location, InteriorLocation, Option<bp_moonbeam::LaneId>)>,

245

2

	) -> Self {

246

2

		self.opened_bridges = opened_bridges;

247

2

		self

248

2

249

250

65

	pub fn build(self) -> sp_io::TestExternalities {

251

65

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

252

65

			.build_storage()

253

65

			.unwrap();

254

65

255

65

		parachain_info::GenesisConfig::<Runtime> {

256

65

			parachain_id: <bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID.into(),

257

65

			_config: Default::default(),

258

65

259

65

		.assimilate_storage(&mut t)

260

65

		.unwrap();

261

65

262

65

		pallet_balances::GenesisConfig::<Runtime> {

263

65

			balances: self.balances,

264

65

265

65

		.assimilate_storage(&mut t)

266

65

		.unwrap();

267

65

268

65

		pallet_parachain_staking::GenesisConfig::<Runtime> {

269

65

			candidates: self.collators,

270

65

			delegations: self.delegations,

271

65

			inflation_config: self.inflation,

272

65

			collator_commission: Perbill::from_percent(20),

273

65

			parachain_bond_reserve_percent: Percent::from_percent(30),

274

65

			blocks_per_round: 2 * HOURS,

275

65

			num_selected_candidates: 8,

276

65

277

65

		.assimilate_storage(&mut t)

278

65

		.unwrap();

279

65

280

65

		pallet_crowdloan_rewards::GenesisConfig::<Runtime> {

281

65

			funded_amount: self.crowdloan_fund,

282

65

283

65

		.assimilate_storage(&mut t)

284

65

		.unwrap();

285

65

286

65

		pallet_author_mapping::GenesisConfig::<Runtime> {

287

65

			mappings: self.mappings,

288

65

289

65

		.assimilate_storage(&mut t)

290

65

		.unwrap();

291

65

292

65

		let genesis_config = pallet_evm_chain_id::GenesisConfig::<Runtime> {

293

65

			chain_id: self.chain_id,

294

65

			..Default::default()

295

65

};

296

65

		genesis_config.assimilate_storage(&mut t).unwrap();

297

65

298

65

		let genesis_config = pallet_evm::GenesisConfig::<Runtime> {

299

65

			accounts: self.evm_accounts,

300

65

			..Default::default()

301

65

};

302

65

		genesis_config.assimilate_storage(&mut t).unwrap();

303

65

304

65

		let genesis_config = pallet_ethereum::GenesisConfig::<Runtime> {

305

65

			..Default::default()

306

65

};

307

65

		genesis_config.assimilate_storage(&mut t).unwrap();

308

65

309

65

		let genesis_config = pallet_xcm::GenesisConfig::<Runtime> {

310

65

			safe_xcm_version: self.safe_xcm_version,

311

65

			..Default::default()

312

65

};

313

65

		genesis_config.assimilate_storage(&mut t).unwrap();

314

65

315

65

		let genesis_config = pallet_transaction_payment::GenesisConfig::<Runtime> {

316

65

			multiplier: Multiplier::from(10u128),

317

65

			..Default::default()

318

65

};

319

65

		genesis_config.assimilate_storage(&mut t).unwrap();

320

65

321

65

		let genesis_config = pallet_xcm_bridge::GenesisConfig::<Runtime, XcmOverPolkadotInstance> {

322

65

			opened_bridges: self.opened_bridges,

323

65

			_phantom: Default::default(),

324

65

};

325

65

		genesis_config.assimilate_storage(&mut t).unwrap();

326

65

327

65

		let mut ext = sp_io::TestExternalities::new(t);

328

65

		let xcm_assets = self.xcm_assets.clone();

329

65

		ext.execute_with(|| {

330

			// If any xcm assets specified, we register them here

331

75

			for xcm_asset_initialization in xcm_assets {

332

10

				let asset_id: AssetId = xcm_asset_initialization.asset_type.clone().into();

333

10

				if self.evm_native_foreign_assets {

334

2

					let AssetType::Xcm(location) = xcm_asset_initialization.asset_type;

335

2

					let metadata = xcm_asset_initialization.metadata.clone();

336

2

					EvmForeignAssets::register_foreign_asset(

337

2

						asset_id,

338

2

						xcm::VersionedLocation::from(location).try_into().unwrap(),

339

2

						metadata.decimals,

340

2

						metadata.symbol.try_into().unwrap(),

341

2

						metadata.name.try_into().unwrap(),

342

2

343

2

					.expect("register evm native foreign asset");

344

2

345

2

					if xcm_asset_initialization.is_sufficient {

346

2

						XcmWeightTrader::add_asset(

347

2

							root_origin(),

348

2

							xcm::VersionedLocation::from(location).try_into().unwrap(),

349

2

							MOVR, // 1 to 1 ratio

350

2

351

2

						.expect("register evm native foreign asset as sufficient");

352

2

353

354

4

					for (account, balance) in xcm_asset_initialization.balances {

355

2

						EvmForeignAssets::mint_into(asset_id.into(), account, balance.into())

356

2

							.expect("mint evm native foreign asset");

357

2

358

				} else {

359

8

					AssetManager::register_foreign_asset(

360

8

						root_origin(),

361

8

						xcm_asset_initialization.asset_type,

362

8

						xcm_asset_initialization.metadata,

363

8

1,

364

8

						xcm_asset_initialization.is_sufficient,

365

8

366

8

					.unwrap();

367

16

					for (account, balance) in xcm_asset_initialization.balances {

368

8

						Assets::mint(

369

8

							origin_of(AssetManager::account_id()),

370

8

							asset_id.into(),

371

8

							account,

372

8

							balance,

373

8

374

8

						.unwrap();

375

8

376

377

378

65

			System::set_block_number(1);

379

65

});

380

65

ext

381

65

382

383

384

pub const CHAIN_ID: u64 = 1281;

385

pub const ALICE: [u8; 20] = [4u8; 20];

386

pub const ALICE_NIMBUS: [u8; 32] = [4u8; 32];

387

pub const BOB: [u8; 20] = [5u8; 20];

388

pub const CHARLIE: [u8; 20] = [6u8; 20];

389

pub const DAVE: [u8; 20] = [7u8; 20];

390

pub const EVM_CONTRACT: [u8; 20] = [8u8; 20];

391

392

31

pub fn origin_of(account_id: AccountId) -> <Runtime as frame_system::Config>::RuntimeOrigin {

393

31

	<Runtime as frame_system::Config>::RuntimeOrigin::signed(account_id)

394

31

395

396

14

pub fn inherent_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

397

14

	<Runtime as frame_system::Config>::RuntimeOrigin::none()

398

14

399

400

28

pub fn root_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

401

28

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

402

28

403

404

/// Mock the inherent that sets validation data in ParachainSystem, which

405

/// contains the `relay_chain_block_number`, which is used in `author-filter` as a

406

/// source of randomness to filter valid authors at each block.

407

14

pub fn set_parachain_inherent_data() {

408

	use cumulus_primitives_core::PersistedValidationData;

409

	use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;

410

411

14

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

412

14

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

413

14

414

14

	let mut relay_sproof = RelayStateSproofBuilder::default();

415

14

	relay_sproof.para_id = bp_moonriver::PARACHAIN_ID.into();

416

14

	relay_sproof.included_para_head = Some(HeadData(vec![1, 2, 3]));

417

14

418

14

	let additional_key_values = vec![(

419

14

		moonbeam_core_primitives::well_known_relay_keys::TIMESTAMP_NOW.to_vec(),

420

14

		sp_timestamp::Timestamp::default().encode(),

421

14

)];

422

14

423

14

	relay_sproof.additional_key_values = additional_key_values;

424

14

425

14

	let (relay_parent_storage_root, relay_chain_state) = relay_sproof.into_state_root_and_proof();

426

14

427

14

	let vfp = PersistedValidationData {

428

14

		relay_parent_number: 1u32,

429

14

		relay_parent_storage_root,

430

14

		..Default::default()

431

14

};

432

14

	let parachain_inherent_data = ParachainInherentData {

433

14

		validation_data: vfp,

434

14

		relay_chain_state: relay_chain_state,

435

14

		downward_messages: Default::default(),

436

14

		horizontal_messages: Default::default(),

437

14

};

438

14

	assert_ok!(RuntimeCall::ParachainSystem(

439

14

		cumulus_pallet_parachain_system::Call::<Runtime>::set_validation_data {

440

14

			data: parachain_inherent_data

441

14

442

14

443

14

	.dispatch(inherent_origin()));

444

14

445

446

7

pub fn unchecked_eth_tx(raw_hex_tx: &str) -> UncheckedExtrinsic {

447

7

	let converter = TransactionConverter;

448

7

	converter.convert_transaction(ethereum_transaction(raw_hex_tx))

449

7

450

451

9

pub fn ethereum_transaction(raw_hex_tx: &str) -> pallet_ethereum::Transaction {

452

9

	let bytes = hex::decode(raw_hex_tx).expect("Transaction bytes.");

453

9

	let transaction = ethereum::EnvelopedDecodable::decode(&bytes[..]);

454

9

	assert!(transaction.is_ok());

455

9

	transaction.unwrap()

456

9

457

458

6602

pub(crate) fn increase_last_relay_slot_number(amount: u64) {

459

6602

	let last_relay_slot = u64::from(AsyncBacking::slot_info().unwrap_or_default().0);

460

6602

	frame_support::storage::unhashed::put(

461

6602

		&frame_support::storage::storage_prefix(b"AsyncBacking", b"SlotInfo"),

462

6602

		&((Slot::from(last_relay_slot + amount), 0)),

463

6602

);

464

6602