Grcov report - mod.rs

1

// Copyright 2019-2022 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 pallet_transaction_payment::Multiplier;

41

42

// A valid signed Alice transfer.

43

pub const VALID_ETH_TX: &str =

44

	"02f86d8205018085174876e80085e8d4a5100082520894f24ff3a9cf04c71dbc94d0b566f7a27b9456\

45

	6cac8080c001a0e1094e1a52520a75c0255db96132076dd0f1263089f838bea548cbdbfc64a4d19f031c\

46

	92a8cb04e2d68d20a6158d542a07ac440cc8d07b6e36af02db046d92df";

47

48

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

49

pub const INVALID_ETH_TX: &str =

50

	"f86180843b9aca00809412cb274aad8251c875c0bf6872b67d9983e53fdd01801ca00e28ba2dd3c5a\

51

	3fd467d4afd7aefb4a34b373314fff470bb9db743a84d674a0aa06e5994f2d07eafe1c37b4ce5471ca\

52

	ecec29011f6f5bf0b1a552c55ea348df35f";

53

54

3

pub fn rpc_run_to_block(n: u32) {

55

6

	while System::block_number() < n {

56

3

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

57

3

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

58

3

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

59

3

60

3

61

62

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

63

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

64

9

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

65

9

	// Finalize the first block

66

9

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

67

6609

	while System::block_number() < n {

68

		// Set the new block number and author

69

6600

		match author {

70

6600

			Some(ref author) => {

71

6600

				let pre_digest = Digest {

72

6600

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

73

6600

};

74

6600

				System::reset_events();

75

6600

				System::initialize(

76

6600

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

77

6600

					&System::parent_hash(),

78

6600

					&pre_digest,

79

6600

);

80

6600

81

			None => {

82

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

83

84

85

86

6600

		increase_last_relay_slot_number(1);

87

6600

88

6600

		// Initialize the new block

89

6600

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

90

6600

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

91

6600

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

92

6600

93

6600

		// Finalize the block

94

6600

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

95

6600

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

96

97

9

98

99

3

pub fn last_event() -> RuntimeEvent {

100

3

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

101

3

102

103

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

104

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

105

// is in our dependency graph.

106

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

107

	fp_evm::Context {

108

		address: Default::default(),

109

		caller: Default::default(),

110

		apparent_value: From::from(0),

111

112

113

114

// Test struct with the purpose of initializing xcm assets

115

#[derive(Clone)]

116

pub struct XcmAssetInitialization {

117

	pub asset_type: AssetType,

118

	pub metadata: AssetRegistrarMetadata,

119

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

120

	pub is_sufficient: bool,

121

122

123

pub struct ExtBuilder {

124

	// endowed accounts with balances

125

	balances: Vec<(AccountId, Balance)>,

126

	// [collator, amount]

127

	collators: Vec<(AccountId, Balance)>,

128

	// [delegator, collator, nomination_amount]

129

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

130

	// per-round inflation config

131

	inflation: InflationInfo<Balance>,

132

	// AuthorId -> AccoutId mappings

133

	mappings: Vec<(NimbusId, AccountId)>,

134

	// Crowdloan fund

135

	crowdloan_fund: Balance,

136

	// Chain id

137

	chain_id: u64,

138

	// EVM genesis accounts

139

	evm_accounts: BTreeMap<H160, GenesisAccount>,

140

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

141

	xcm_assets: Vec<XcmAssetInitialization>,

142

	safe_xcm_version: Option<u32>,

143

144

145

impl Default for ExtBuilder {

146

59

	fn default() -> ExtBuilder {

147

59

		ExtBuilder {

148

59

			balances: vec![],

149

59

			delegations: vec![],

150

59

			collators: vec![],

151

59

			inflation: InflationInfo {

152

59

				expect: Range {

153

59

					min: 100_000 * MOVR,

154

59

					ideal: 200_000 * MOVR,

155

59

					max: 500_000 * MOVR,

156

59

},

157

59

				// not used

158

59

				annual: Range {

159

59

					min: Perbill::from_percent(50),

160

59

					ideal: Perbill::from_percent(50),

161

59

					max: Perbill::from_percent(50),

162

59

},

163

59

				// unrealistically high parameterization, only for testing

164

59

				round: Range {

165

59

					min: Perbill::from_percent(5),

166

59

					ideal: Perbill::from_percent(5),

167

59

					max: Perbill::from_percent(5),

168

59

},

169

59

},

170

59

			mappings: vec![],

171

59

			crowdloan_fund: 0,

172

59

			chain_id: CHAIN_ID,

173

59

			evm_accounts: BTreeMap::new(),

174

59

			xcm_assets: vec![],

175

59

			safe_xcm_version: None,

176

59

177

59

178

179

180

impl ExtBuilder {

181

2

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

182

2

		self.evm_accounts = accounts;

183

2

		self

184

2

185

186

40

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

187

40

		self.balances = balances;

188

40

		self

189

40

190

191

15

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

192

15

		self.collators = collators;

193

15

		self

194

15

195

196

7

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

197

7

		self.delegations = delegations

198

7

			.into_iter()

199

8

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

200

7

			.collect();

201

7

		self

202

7

203

204

6

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

205

6

		self.crowdloan_fund = crowdloan_fund;

206

6

		self

207

6

208

209

14

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

210

14

		self.mappings = mappings;

211

14

		self

212

14

213

214

	#[allow(dead_code)]

215

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

216

		self.inflation = inflation;

217

		self

218

219

220

8

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

221

8

		self.xcm_assets = xcm_assets;

222

8

		self

223

8

224

225

5

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

226

5

		self.safe_xcm_version = Some(safe_xcm_version);

227

5

		self

228

5

229

230

59

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

231

59

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

232

59

			.build_storage()

233

59

			.unwrap();

234

59

235

59

		pallet_balances::GenesisConfig::<Runtime> {

236

59

			balances: self.balances,

237

59

238

59

		.assimilate_storage(&mut t)

239

59

		.unwrap();

240

59

241

59

		pallet_parachain_staking::GenesisConfig::<Runtime> {

242

59

			candidates: self.collators,

243

59

			delegations: self.delegations,

244

59

			inflation_config: self.inflation,

245

59

			collator_commission: Perbill::from_percent(20),

246

59

			parachain_bond_reserve_percent: Percent::from_percent(30),

247

59

			blocks_per_round: 2 * HOURS,

248

59

			num_selected_candidates: 8,

249

59

250

59

		.assimilate_storage(&mut t)

251

59

		.unwrap();

252

59

253

59

		pallet_crowdloan_rewards::GenesisConfig::<Runtime> {

254

59

			funded_amount: self.crowdloan_fund,

255

59

256

59

		.assimilate_storage(&mut t)

257

59

		.unwrap();

258

59

259

59

		pallet_author_mapping::GenesisConfig::<Runtime> {

260

59

			mappings: self.mappings,

261

59

262

59

		.assimilate_storage(&mut t)

263

59

		.unwrap();

264

59

265

59

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

266

59

			chain_id: self.chain_id,

267

59

			..Default::default()

268

59

};

269

59

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

270

59

271

59

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

272

59

			accounts: self.evm_accounts,

273

59

			..Default::default()

274

59

};

275

59

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

276

59

277

59

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

278

59

			..Default::default()

279

59

};

280

59

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

281

59

282

59

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

283

59

			safe_xcm_version: self.safe_xcm_version,

284

59

			..Default::default()

285

59

};

286

59

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

287

59

288

59

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

289

59

			multiplier: Multiplier::from(10u128),

290

59

			..Default::default()

291

59

};

292

59

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

293

59

294

59

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

295

59

		let xcm_assets = self.xcm_assets.clone();

296

59

		ext.execute_with(|| {

297

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

298

67

			for xcm_asset_initialization in xcm_assets {

299

8

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

300

8

				AssetManager::register_foreign_asset(

301

8

					root_origin(),

302

8

					xcm_asset_initialization.asset_type,

303

8

					xcm_asset_initialization.metadata,

304

8

1,

305

8

					xcm_asset_initialization.is_sufficient,

306

8

307

8

				.unwrap();

308

16

				for (account, balance) in xcm_asset_initialization.balances {

309

8

					moonriver_runtime::Assets::mint(

310

8

						origin_of(AssetManager::account_id()),

311

8

						asset_id.into(),

312

8

						account,

313

8

						balance,

314

8

315

8

					.unwrap();

316

8

317

318

59

			System::set_block_number(1);

319

59

});

320

59

ext

321

59

322

323

324

pub const CHAIN_ID: u64 = 1281;

325

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

326

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

327

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

328

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

329

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

330

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

331

332

26

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

333

26

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

334

26

335

336

11

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

337

11

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

338

11

339

340

21

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

341

21

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

342

21

343

344

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

345

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

346

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

347

11

pub fn set_parachain_inherent_data() {

348

11

	use cumulus_primitives_core::PersistedValidationData;

349

11

	use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;

350

11

351

11

	let mut relay_sproof = RelayStateSproofBuilder::default();

352

11

	relay_sproof.para_id = 100u32.into();

353

11

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

354

11

355

11

	let additional_key_values = vec![(

356

11

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

357

11

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

358

11

)];

359

11

360

11

	relay_sproof.additional_key_values = additional_key_values;

361

11

362

11

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

363

11

364

11

	let vfp = PersistedValidationData {

365

11

		relay_parent_number: 1u32,

366

11

		relay_parent_storage_root,

367

11

		..Default::default()

368

11

};

369

11

	let parachain_inherent_data = ParachainInherentData {

370

11

		validation_data: vfp,

371

11

		relay_chain_state: relay_chain_state,

372

11

		downward_messages: Default::default(),

373

11

		horizontal_messages: Default::default(),

374

11

};

375

11

	assert_ok!(RuntimeCall::ParachainSystem(

376

11

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

377

11

			data: parachain_inherent_data

378

11

379

11

380

11

	.dispatch(inherent_origin()));

381

11

382

383

7

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

384

7

	let converter = TransactionConverter;

385

7

	converter.convert_transaction(ethereum_transaction(raw_hex_tx))

386

7

387

388

9

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

389

9

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

390

9

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

391

9

	assert!(transaction.is_ok());

392

9

	transaction.unwrap()

393

9

394

395

6602

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

396

6602

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

397

6602

	frame_support::storage::unhashed::put(

398

6602

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

399

6602

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

400

6602

);

401

6602