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 moonbeam_runtime::{

26

	asset_config::AssetRegistrarMetadata, currency::GLMR, 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 moonbeam_runtime::EvmForeignAssets;

41

use sp_runtime::traits::MaybeEquivalence;

42

43

10

pub fn existential_deposit() -> u128 {

44

10

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

45

10

46

47

// A valid signed Alice transfer.

48

pub const VALID_ETH_TX: &str =

49

	"02f869820501808085e8d4a51000825208943cd0a705a2dc65e5b1e1205896baa2be8a07c6e00180c\

50

	001a061087911e877a5802142a89a40d231d50913db399eb50839bb2d04e612b22ec8a01aa313efdf2\

51

	793bea76da6813bda611444af16a6207a8cfef2d9c8aa8f8012f7";

52

53

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

54

pub const INVALID_ETH_TX: &str =

55

	"f8628085174876e800809412cb274aad8251c875c0bf6872b67d9983e53fdd01801ba011110796057\

56

	0e2d49fcc2afbc582e1abd3eeb027242b92abcebcec7cdefab63ea001732f6fac84acdd5b096554230\

57

	75003e7f07430652c3d6722e18f50b3d34e29";

58

59

3

pub fn rpc_run_to_block(n: u32) {

60

6

	while System::block_number() < n {

61

3

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

62

3

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

63

3

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

64

3

65

3

66

67

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

68

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

69

8

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

70

8

	// Finalize the first block

71

8

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

72

16208

	while System::block_number() < n {

73

		// Set the new block number and author

74

16200

		match author {

75

16200

			Some(ref author) => {

76

16200

				let pre_digest = Digest {

77

16200

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

78

16200

};

79

16200

				System::reset_events();

80

16200

				System::initialize(

81

16200

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

82

16200

					&System::parent_hash(),

83

16200

					&pre_digest,

84

16200

);

85

16200

86

			None => {

87

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

88

89

90

91

16200

		increase_last_relay_slot_number(1);

92

16200

93

16200

		// Initialize the new block

94

16200

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

95

16200

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

96

16200

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

97

16200

98

16200

		// Finalize the block

99

16200

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

100

16200

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

101

102

8

103

104

3

pub fn last_event() -> RuntimeEvent {

105

3

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

106

3

107

108

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

109

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

110

// is in our dependency graph.

111

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

112

	fp_evm::Context {

113

		address: Default::default(),

114

		caller: Default::default(),

115

		apparent_value: From::from(0),

116

117

118

119

// Test struct with the purpose of initializing xcm assets

120

#[derive(Clone)]

121

pub struct XcmAssetInitialization {

122

	pub asset_type: AssetType,

123

	pub metadata: AssetRegistrarMetadata,

124

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

125

	pub is_sufficient: bool,

126

127

128

pub struct ExtBuilder {

129

	// endowed accounts with balances

130

	balances: Vec<(AccountId, Balance)>,

131

	// [collator, amount]

132

	collators: Vec<(AccountId, Balance)>,

133

	// [delegator, collator, nomination_amount]

134

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

135

	// per-round inflation config

136

	inflation: InflationInfo<Balance>,

137

	// AuthorId -> AccountId mappings

138

	mappings: Vec<(NimbusId, AccountId)>,

139

	// Crowdloan fund

140

	crowdloan_fund: Balance,

141

	// Chain id

142

	chain_id: u64,

143

	// EVM genesis accounts

144

	evm_accounts: BTreeMap<H160, GenesisAccount>,

145

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

146

	xcm_assets: Vec<XcmAssetInitialization>,

147

	evm_native_foreign_assets: bool,

148

	safe_xcm_version: Option<u32>,

149

150

151

impl Default for ExtBuilder {

152

63

	fn default() -> ExtBuilder {

153

63

		ExtBuilder {

154

63

			balances: vec![],

155

63

			delegations: vec![],

156

63

			collators: vec![],

157

63

			inflation: InflationInfo {

158

63

				expect: Range {

159

63

					min: 100_000 * GLMR,

160

63

					ideal: 200_000 * GLMR,

161

63

					max: 500_000 * GLMR,

162

63

},

163

63

				// not used

164

63

				annual: Range {

165

63

					min: Perbill::from_percent(50),

166

63

					ideal: Perbill::from_percent(50),

167

63

					max: Perbill::from_percent(50),

168

63

},

169

63

				// unrealistically high parameterization, only for testing

170

63

				round: Range {

171

63

					min: Perbill::from_percent(5),

172

63

					ideal: Perbill::from_percent(5),

173

63

					max: Perbill::from_percent(5),

174

63

},

175

63

},

176

63

			mappings: vec![],

177

63

			crowdloan_fund: 0,

178

63

			chain_id: CHAIN_ID,

179

63

			evm_accounts: BTreeMap::new(),

180

63

			xcm_assets: vec![],

181

63

			evm_native_foreign_assets: false,

182

63

			safe_xcm_version: None,

183

63

184

63

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

44

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

194

44

		self.balances = balances;

195

44

		self

196

44

197

198

17

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

199

17

		self.collators = collators;

200

17

		self

201

17

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

16

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

217

16

		self.mappings = mappings;

218

16

		self

219

16

220

221

9

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

222

9

		self.xcm_assets = xcm_assets;

223

9

		self

224

9

225

226

1

	pub fn with_evm_native_foreign_assets(mut self) -> Self {

227

1

		self.evm_native_foreign_assets = true;

228

1

		self

229

1

230

231

8

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

232

8

		self.safe_xcm_version = Some(safe_xcm_version);

233

8

		self

234

8

235

236

	#[allow(dead_code)]

237

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

238

		self.inflation = inflation;

239

		self

240

241

242

63

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

243

63

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

244

63

			.build_storage()

245

63

			.unwrap();

246

63

247

63

		pallet_balances::GenesisConfig::<Runtime> {

248

63

			balances: self.balances,

249

63

250

63

		.assimilate_storage(&mut t)

251

63

		.unwrap();

252

63

253

63

		pallet_parachain_staking::GenesisConfig::<Runtime> {

254

63

			candidates: self.collators,

255

63

			delegations: self.delegations,

256

63

			inflation_config: self.inflation,

257

63

			collator_commission: Perbill::from_percent(20),

258

63

			parachain_bond_reserve_percent: Percent::from_percent(30),

259

63

			blocks_per_round: 6 * HOURS,

260

63

			num_selected_candidates: 8,

261

63

262

63

		.assimilate_storage(&mut t)

263

63

		.unwrap();

264

63

265

63

		pallet_crowdloan_rewards::GenesisConfig::<Runtime> {

266

63

			funded_amount: self.crowdloan_fund,

267

63

268

63

		.assimilate_storage(&mut t)

269

63

		.unwrap();

270

63

271

63

		pallet_author_mapping::GenesisConfig::<Runtime> {

272

63

			mappings: self.mappings,

273

63

274

63

		.assimilate_storage(&mut t)

275

63

		.unwrap();

276

63

277

63

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

278

63

			chain_id: self.chain_id,

279

63

			..Default::default()

280

63

};

281

63

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

282

63

283

63

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

284

63

			accounts: self.evm_accounts,

285

63

			..Default::default()

286

63

};

287

63

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

288

63

289

63

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

290

63

			..Default::default()

291

63

};

292

63

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

293

63

294

63

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

295

63

			safe_xcm_version: self.safe_xcm_version,

296

63

			..Default::default()

297

63

};

298

63

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

299

63

300

63

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

301

63

		let xcm_assets = self.xcm_assets.clone();

302

63

		ext.execute_with(|| {

303

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

304

72

			for xcm_asset_initialization in xcm_assets {

305

9

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

306

9

				if self.evm_native_foreign_assets {

307

1

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

308

1

					let metadata = xcm_asset_initialization.metadata.clone();

309

1

					EvmForeignAssets::register_foreign_asset(

310

1

						asset_id,

311

1

						xcm_builder::WithLatestLocationConverter::convert_back(&location).unwrap(),

312

1

						metadata.decimals,

313

1

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

314

1

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

315

1

316

1

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

317

318

2

					for (account, balance) in xcm_asset_initialization.balances {

319

1

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

320

1

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

321

1

322

				} else {

323

8

					AssetManager::register_foreign_asset(

324

8

						root_origin(),

325

8

						xcm_asset_initialization.asset_type,

326

8

						xcm_asset_initialization.metadata,

327

8

1,

328

8

						xcm_asset_initialization.is_sufficient,

329

8

330

8

					.unwrap();

331

16

					for (account, balance) in xcm_asset_initialization.balances {

332

8

						moonbeam_runtime::Assets::mint(

333

8

							origin_of(AssetManager::account_id()),

334

8

							asset_id.into(),

335

8

							account,

336

8

							balance,

337

8

338

8

						.unwrap();

339

8

340

341

342

63

			System::set_block_number(1);

343

63

});

344

63

ext

345

63

346

347

348

pub const CHAIN_ID: u64 = 1281;

349

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

350

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

351

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

352

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

353

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

354

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

355

356

30

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

357

30

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

358

30

359

360

15

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

361

15

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

362

15

363

364

22

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

365

22

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

366

22

367

368

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

369

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

370

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

371

15

pub fn set_parachain_inherent_data() {

372

15

	use cumulus_primitives_core::PersistedValidationData;

373

15

	use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;

374

15

375

15

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

376

15

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

377

15

378

15

	let mut relay_sproof = RelayStateSproofBuilder::default();

379

15

	relay_sproof.para_id = 100u32.into();

380

15

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

381

15

382

15

	let additional_key_values = vec![(

383

15

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

384

15

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

385

15

)];

386

15

387

15

	relay_sproof.additional_key_values = additional_key_values;

388

15

389

15

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

390

15

391

15

	let vfp = PersistedValidationData {

392

15

		relay_parent_number: 1u32,

393

15

		relay_parent_storage_root,

394

15

		..Default::default()

395

15

};

396

15

	let parachain_inherent_data = ParachainInherentData {

397

15

		validation_data: vfp,

398

15

		relay_chain_state: relay_chain_state,

399

15

		downward_messages: Default::default(),

400

15

		horizontal_messages: Default::default(),

401

15

};

402

15

	assert_ok!(RuntimeCall::ParachainSystem(

403

15

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

404

15

			data: parachain_inherent_data

405

15

406

15

407

15

	.dispatch(inherent_origin()));

408

15

409

410

7

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

411

7

	let converter = TransactionConverter;

412

7

	converter.convert_transaction(ethereum_transaction(raw_hex_tx))

413

7

414

415

9

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

416

9

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

417

9

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

418

9

	assert!(transaction.is_ok());

419

9

	transaction.unwrap()

420

9

421

422

16202

pub fn increase_last_relay_slot_number(amount: u64) {

423

16202

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

424

16202

	frame_support::storage::unhashed::put(

425

16202

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

426

16202

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

427

16202

);

428

16202