Grcov report - integration

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

//! Moonbase Runtime Integration Tests

18

19

mod common;

20

use common::*;

21

22

use precompile_utils::{

23

	precompile_set::{is_precompile_or_fail, IsActivePrecompile},

24

	prelude::*,

25

	testing::*,

26

};

27

28

use fp_evm::{Context, IsPrecompileResult};

29

use frame_support::{

30

	assert_noop, assert_ok,

31

	dispatch::DispatchClass,

32

	traits::{

33

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

34

		StorageInfo, StorageInfoTrait,

35

},

36

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

37

	StorageHasher, Twox128,

38

};

39

use moonbase_runtime::{

40

	//asset_config::ForeignAssetInstance,

41

	xcm_config::SelfReserve,

42

	AccountId,

43

	AssetId,

44

	Balances,

45

	CrowdloanRewards,

46

	EvmForeignAssets,

47

	Executive,

48

	OpenTechCommitteeCollective,

49

	ParachainStaking,

50

	PolkadotXcm,

51

	Precompiles,

52

	Runtime,

53

	RuntimeBlockWeights,

54

	RuntimeCall,

55

	RuntimeEvent,

56

	System,

57

	TransactionPayment,

58

	TransactionPaymentAsGasPrice,

59

	Treasury,

60

	TreasuryCouncilCollective,

61

	XcmTransactor,

62

	FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

63

	WEEKS,

64

};

65

use polkadot_parachain::primitives::Sibling;

66

use precompile_utils::testing::MockHandle;

67

use sp_runtime::{

68

	traits::{Convert as XcmConvert, Dispatchable},

69

	BuildStorage,

70

};

71

use std::str::from_utf8;

72

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

73

use xcm_executor::traits::ConvertLocation;

74

75

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

76

use moonbeam_xcm_benchmarks::weights::XcmWeight;

77

use moonkit_xcm_primitives::AccountIdAssetIdConversion;

78

use nimbus_primitives::NimbusId;

79

use pallet_evm::PrecompileSet;

80

//use pallet_evm_precompileset_assets_erc20::{SELECTOR_LOG_APPROVAL, SELECTOR_LOG_TRANSFER};

81

use moonbase_runtime::runtime_params::dynamic_params;

82

use pallet_moonbeam_foreign_assets::AssetStatus;

83

use pallet_transaction_payment::Multiplier;

84

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

85

use parity_scale_codec::Encode;

86

use sha3::{Digest, Keccak256};

87

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

88

use sp_runtime::{bounded_vec, DispatchError, ModuleError};

89

use std::cell::Cell;

90

use std::rc::Rc;

91

use xcm::{latest::prelude::*, VersionedAssets, VersionedLocation};

92

93

type AuthorMappingPCall =

94

	pallet_evm_precompile_author_mapping::AuthorMappingPrecompileCall<Runtime>;

95

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

96

type CrowdloanRewardsPCall =

97

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

98

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

99

	Runtime,

100

	moonbase_runtime::xcm_config::XcmExecutorConfig,

101

>;

102

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

103

/*type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

104

	Runtime,

105

	ForeignAssetInstance,

106

>;*/

107

type XcmTransactorV1PCall =

108

	pallet_evm_precompile_xcm_transactor::v1::XcmTransactorPrecompileV1Call<Runtime>;

109

type XcmTransactorV2PCall =

110

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

111

112

// TODO: can we construct a const U256...?

113

const BASE_FEE_GENISIS: u128 = 10 * GIGAWEI / 4;

114

115

#[test]

116

1

fn xcmp_queue_controller_origin_is_root() {

117

1

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

118

1

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

119

1

	assert_ok!(

120

1

		<moonbase_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

121

1

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

122

1

);

123

1

124

125

#[test]

126

1

fn verify_pallet_prefixes() {

127

32

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

128

32

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

129

32

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

130

32

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

131

32

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

132

32

		// expand/storage.rs#L389-L401

133

32

		assert_eq!(

134

32

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

135

32

			Some(name)

136

32

);

137

32

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

	is_pallet_prefix::<moonbase_runtime::OpenTechCommitteeCollective>(

152

1

		"OpenTechCommitteeCollective",

153

1

);

154

1

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

155

1

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

156

1

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

157

1

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

158

1

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

159

1

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

160

1

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

161

1

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

162

1

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

163

1

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

164

1

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

165

1

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

166

1

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

167

1

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

168

1

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

169

1

	is_pallet_prefix::<moonbase_runtime::EthereumXcm>("EthereumXcm");

170

1

	is_pallet_prefix::<moonbase_runtime::Randomness>("Randomness");

171

1

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

172

1

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

173

1

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

174

1

175

13

	let prefix = |pallet_name, storage_name| {

176

13

		let mut res = [0u8; 32];

177

13

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

178

13

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

179

13

		res.to_vec()

180

13

};

181

1

	assert_eq!(

182

1

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

183

1

		vec![

184

1

			StorageInfo {

185

1

				pallet_name: b"Balances".to_vec(),

186

1

				storage_name: b"TotalIssuance".to_vec(),

187

1

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

188

1

				max_values: Some(1),

189

1

				max_size: Some(16),

190

1

},

191

1

			StorageInfo {

192

1

				pallet_name: b"Balances".to_vec(),

193

1

				storage_name: b"InactiveIssuance".to_vec(),

194

1

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

195

1

				max_values: Some(1),

196

1

				max_size: Some(16),

197

1

},

198

1

			StorageInfo {

199

1

				pallet_name: b"Balances".to_vec(),

200

1

				storage_name: b"Account".to_vec(),

201

1

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

202

1

				max_values: None,

203

1

				max_size: Some(100),

204

1

},

205

1

			StorageInfo {

206

1

				pallet_name: b"Balances".to_vec(),

207

1

				storage_name: b"Locks".to_vec(),

208

1

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

209

1

				max_values: None,

210

1

				max_size: Some(1287),

211

1

},

212

1

			StorageInfo {

213

1

				pallet_name: b"Balances".to_vec(),

214

1

				storage_name: b"Reserves".to_vec(),

215

1

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

216

1

				max_values: None,

217

1

				max_size: Some(1037),

218

1

},

219

1

			StorageInfo {

220

1

				pallet_name: b"Balances".to_vec(),

221

1

				storage_name: b"Holds".to_vec(),

222

1

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

223

1

				max_values: None,

224

1

				max_size: Some(55),

225

1

},

226

1

			StorageInfo {

227

1

				pallet_name: b"Balances".to_vec(),

228

1

				storage_name: b"Freezes".to_vec(),

229

1

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

230

1

				max_values: None,

231

1

				max_size: Some(37),

232

1

},

233

1

234

1

);

235

1

	assert_eq!(

236

1

		<moonbase_runtime::Sudo as StorageInfoTrait>::storage_info(),

237

1

		vec![StorageInfo {

238

1

			pallet_name: b"Sudo".to_vec(),

239

1

			storage_name: b"Key".to_vec(),

240

1

			prefix: prefix(b"Sudo", b"Key"),

241

1

			max_values: Some(1),

242

1

			max_size: Some(20),

243

1

}]

244

1

);

245

1

	assert_eq!(

246

1

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

247

1

		vec![

248

1

			StorageInfo {

249

1

				pallet_name: b"Proxy".to_vec(),

250

1

				storage_name: b"Proxies".to_vec(),

251

1

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

252

1

				max_values: None,

253

1

				max_size: Some(845),

254

1

},

255

1

			StorageInfo {

256

1

				pallet_name: b"Proxy".to_vec(),

257

1

				storage_name: b"Announcements".to_vec(),

258

1

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

259

1

				max_values: None,

260

1

				max_size: Some(1837),

261

1

262

1

263

1

);

264

1

	assert_eq!(

265

1

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

266

1

		vec![StorageInfo {

267

1

			pallet_name: b"MaintenanceMode".to_vec(),

268

1

			storage_name: b"MaintenanceMode".to_vec(),

269

1

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

270

1

			max_values: Some(1),

271

1

			max_size: None,

272

1

},]

273

1

);

274

275

1

	assert_eq!(

276

1

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

277

1

		vec![

278

1

			StorageInfo {

279

1

				pallet_name: b"RelayStorageRoots".to_vec(),

280

1

				storage_name: b"RelayStorageRoot".to_vec(),

281

1

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

282

1

				max_values: None,

283

1

				max_size: Some(44),

284

1

},

285

1

			StorageInfo {

286

1

				pallet_name: b"RelayStorageRoots".to_vec(),

287

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

288

1

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

289

1

				max_values: Some(1),

290

1

				max_size: Some(121),

291

1

},

292

1

293

1

);

294

1

295

296

#[test]

297

1

fn test_collectives_storage_item_prefixes() {

298

6

	for StorageInfo { pallet_name, .. } in

299

7

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

300

301

6

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

302

303

304

6

	for StorageInfo { pallet_name, .. } in

305

7

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

306

307

6

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

308

309

1

310

311

#[test]

312

1

fn collective_set_members_root_origin_works() {

313

1

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

314

1

		// TreasuryCouncilCollective

315

1

		assert_ok!(TreasuryCouncilCollective::set_members(

316

1

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

317

1

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

318

1

			Some(AccountId::from(ALICE)),

319

1

320

1

));

321

		// OpenTechCommitteeCollective

322

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

323

1

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

324

1

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

325

1

			Some(AccountId::from(ALICE)),

326

1

327

1

));

328

1

});

329

1

330

331

#[test]

332

1

fn collective_set_members_general_admin_origin_works() {

333

1

	use moonbase_runtime::{

334

1

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

335

1

};

336

1

337

1

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

338

1

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

339

1

		let alice = AccountId::from(ALICE);

340

1

341

1

		// TreasuryCouncilCollective

342

1

		let _ = Utility::dispatch_as(

343

1

			root_caller.clone(),

344

1

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

345

1

			Box::new(

346

1

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

347

1

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

348

1

					prime: Some(alice),

349

1

					old_count: 2,

350

1

351

1

				.into(),

352

1

),

353

1

);

354

1

		// OpenTechCommitteeCollective

355

1

		let _ = Utility::dispatch_as(

356

1

			root_caller,

357

1

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

358

1

			Box::new(

359

1

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

360

1

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

361

1

					prime: Some(alice),

362

1

					old_count: 2,

363

1

364

1

				.into(),

365

1

),

366

1

);

367

1

368

1

		assert_eq!(

369

1

			System::events()

370

1

				.into_iter()

371

2

				.filter_map(|r| {

372

2

					match r.event {

373

2

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

374

2

							if result.is_ok() =>

375

2

376

2

							Some(true)

377

378

						_ => None,

379

380

2

})

381

1

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

382

1

				.len(),

383

1

384

1

385

1

});

386

1

387

388

#[test]

389

1

fn collective_set_members_signed_origin_does_not_work() {

390

1

	let alice = AccountId::from(ALICE);

391

1

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

392

1

		// TreasuryCouncilCollective

393

1

		assert!(TreasuryCouncilCollective::set_members(

394

1

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

395

1

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

396

1

			Some(AccountId::from(ALICE)),

397

1

398

1

399

1

		.is_err());

400

		// OpenTechCommitteeCollective

401

1

		assert!(OpenTechCommitteeCollective::set_members(

402

1

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

403

1

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

404

1

			Some(AccountId::from(ALICE)),

405

1

406

1

407

1

		.is_err());

408

1

});

409

1

410

411

#[test]

412

1

fn verify_pallet_indices() {

413

34

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

414

34

		assert_eq!(

415

34

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

416

34

			Some(index)

417

34

);

418

34

419

1

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

420

1

	is_pallet_index::<moonbase_runtime::Utility>(1);

421

1

	is_pallet_index::<moonbase_runtime::Balances>(3);

422

1

	is_pallet_index::<moonbase_runtime::Sudo>(4);

423

1

	is_pallet_index::<moonbase_runtime::ParachainSystem>(6);

424

1

	is_pallet_index::<moonbase_runtime::TransactionPayment>(7);

425

1

	is_pallet_index::<moonbase_runtime::ParachainInfo>(8);

426

1

	is_pallet_index::<moonbase_runtime::EthereumChainId>(9);

427

1

	is_pallet_index::<moonbase_runtime::EVM>(10);

428

1

	is_pallet_index::<moonbase_runtime::Ethereum>(11);

429

1

	is_pallet_index::<moonbase_runtime::ParachainStaking>(12);

430

1

	is_pallet_index::<moonbase_runtime::Scheduler>(13);

431

1

	//is_pallet_index::<moonbase_runtime::Democracy>(14); Removed

432

1

	is_pallet_index::<moonbase_runtime::Treasury>(17);

433

1

	is_pallet_index::<moonbase_runtime::AuthorInherent>(18);

434

1

	is_pallet_index::<moonbase_runtime::AuthorFilter>(19);

435

1

	is_pallet_index::<moonbase_runtime::CrowdloanRewards>(20);

436

1

	is_pallet_index::<moonbase_runtime::AuthorMapping>(21);

437

1

	is_pallet_index::<moonbase_runtime::Proxy>(22);

438

1

	is_pallet_index::<moonbase_runtime::MaintenanceMode>(23);

439

1

	is_pallet_index::<moonbase_runtime::Identity>(24);

440

1

	is_pallet_index::<moonbase_runtime::XcmpQueue>(25);

441

1

	is_pallet_index::<moonbase_runtime::CumulusXcm>(26);

442

1

	is_pallet_index::<moonbase_runtime::PolkadotXcm>(28);

443

1

	is_pallet_index::<moonbase_runtime::Assets>(29);

444

1

	// is_pallet_index::<moonbase_runtime::XTokens>(30); Removed

445

1

	is_pallet_index::<moonbase_runtime::AssetManager>(31);

446

1

	is_pallet_index::<moonbase_runtime::Migrations>(32);

447

1

	is_pallet_index::<moonbase_runtime::XcmTransactor>(33);

448

1

	is_pallet_index::<moonbase_runtime::ProxyGenesisCompanion>(34);

449

1

	is_pallet_index::<moonbase_runtime::MoonbeamOrbiters>(37);

450

1

	is_pallet_index::<moonbase_runtime::EthereumXcm>(38);

451

1

	is_pallet_index::<moonbase_runtime::Randomness>(39);

452

1

	is_pallet_index::<moonbase_runtime::TreasuryCouncilCollective>(40);

453

1

	is_pallet_index::<moonbase_runtime::OpenTechCommitteeCollective>(46);

454

1

	is_pallet_index::<moonbase_runtime::MoonbeamLazyMigrations>(51);

455

1

456

457

#[test]

458

1

fn verify_reserved_indices() {

459

1

	use frame_metadata::*;

460

1

461

1

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

462

1

		.build_storage()

463

1

		.unwrap()

464

1

		.into();

465

1

466

1

	t.execute_with(|| {

467

1

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

468

1

		let metadata = match metadata.1 {

469

1

			RuntimeMetadata::V14(metadata) => metadata,

470

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

471

};

472

		// 35: BaseFee

473

		// 36: pallet_assets::<Instance1>

474

1

		let reserved = vec![35, 36];

475

1

		let existing = metadata

476

1

			.pallets

477

1

			.iter()

478

50

			.map(|p| p.index)

479

1

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

480

2

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

481

1

});

482

1

483

484

#[test]

485

1

fn verify_proxy_type_indices() {

486

1

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

487

1

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

488

1

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

489

1

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

490

1

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

491

1

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

492

1

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

493

1

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

494

1

495

496

#[test]

497

1

fn join_collator_candidates() {

498

1

	ExtBuilder::default()

499

1

		.with_balances(vec![

500

1

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

501

1

			(AccountId::from(BOB), 2_000 * UNIT),

502

1

			(AccountId::from(CHARLIE), 1_100 * UNIT),

503

1

			(AccountId::from(DAVE), 1_000 * UNIT),

504

1

])

505

1

		.with_collators(vec![

506

1

			(AccountId::from(ALICE), 1_000 * UNIT),

507

1

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

508

1

])

509

1

		.with_delegations(vec![

510

1

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

511

1

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

512

1

])

513

1

		.build()

514

1

		.execute_with(|| {

515

1

			assert_noop!(

516

1

				ParachainStaking::join_candidates(

517

1

					origin_of(AccountId::from(ALICE)),

518

1

					1_000 * UNIT,

519

1

					2u32

520

1

),

521

1

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

522

1

);

523

1

			assert_noop!(

524

1

				ParachainStaking::join_candidates(

525

1

					origin_of(AccountId::from(CHARLIE)),

526

1

					1_000 * UNIT,

527

1

					2u32

528

1

),

529

1

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

530

1

);

531

1

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

532

1

			assert_ok!(ParachainStaking::join_candidates(

533

1

				origin_of(AccountId::from(DAVE)),

534

1

				1_000 * UNIT,

535

1

				2u32

536

1

));

537

1

			assert_eq!(

538

1

				last_event(),

539

1

				RuntimeEvent::ParachainStaking(

540

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

541

1

						account: AccountId::from(DAVE),

542

1

						amount_locked: 1_000 * UNIT,

543

1

						new_total_amt_locked: 3_100 * UNIT

544

1

545

1

546

1

);

547

1

			let candidates = ParachainStaking::candidate_pool();

548

1

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

549

1

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

550

1

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

551

1

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

552

1

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

553

1

			assert_eq!(candidates.0[2].amount, 1_000 * UNIT);

554

1

});

555

1

556

557

#[test]

558

1

fn transfer_through_evm_to_stake() {

559

1

	ExtBuilder::default()

560

1

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

561

1

		.build()

562

1

		.execute_with(|| {

563

1

			// Charlie has no balance => fails to stake

564

1

			assert_noop!(

565

1

				ParachainStaking::join_candidates(

566

1

					origin_of(AccountId::from(CHARLIE)),

567

1

					1_000 * UNIT,

568

1

					0u32

569

1

),

570

1

				DispatchError::Module(ModuleError {

571

1

					index: 12,

572

1

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

573

1

					message: Some("InsufficientBalance")

574

1

})

575

1

);

576

577

			// Alice transfer from free balance 2000 UNIT to Bob

578

1

			assert_ok!(Balances::transfer_allow_death(

579

1

				origin_of(AccountId::from(ALICE)),

580

1

				AccountId::from(BOB),

581

1

				2_000 * UNIT,

582

1

));

583

1

			assert_eq!(Balances::free_balance(AccountId::from(BOB)), 2_000 * UNIT);

584

585

1

			let gas_limit = 100000u64;

586

1

			// Bob transfers 1000 UNIT to Charlie via EVM

587

1

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

588

1

				source: H160::from(BOB),

589

1

				target: H160::from(CHARLIE),

590

1

				input: Vec::new(),

591

1

				value: (1_000 * UNIT).into(),

592

1

				gas_limit,

593

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

594

1

				max_priority_fee_per_gas: None,

595

1

				nonce: None,

596

1

				access_list: Vec::new(),

597

1

})

598

1

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

599

1

			assert_eq!(

600

1

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

601

1

				1_000 * UNIT,

602

1

);

603

604

			// Charlie can stake now

605

1

			assert_ok!(ParachainStaking::join_candidates(

606

1

				origin_of(AccountId::from(CHARLIE)),

607

1

				1_000 * UNIT,

608

1

				0u32,

609

1

			),);

610

1

			let candidates = ParachainStaking::candidate_pool();

611

1

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

612

1

			assert_eq!(candidates.0[0].amount, 1_000 * UNIT);

613

1

});

614

1

615

616

#[test]

617

1

fn reward_block_authors() {

618

1

	ExtBuilder::default()

619

1

		.with_balances(vec![

620

1

			// Alice gets 100 extra tokens for her mapping deposit

621

1

			(AccountId::from(ALICE), 2_100 * UNIT),

622

1

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

623

1

])

624

1

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

625

1

		.with_delegations(vec![(

626

1

			AccountId::from(BOB),

627

1

			AccountId::from(ALICE),

628

1

			500 * UNIT,

629

1

)])

630

1

		.with_mappings(vec![(

631

1

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

632

1

			AccountId::from(ALICE),

633

1

)])

634

1

		.build()

635

1

		.execute_with(|| {

636

1

			increase_last_relay_slot_number(1);

637

1

			// Just before round 3

638

1

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

639

1

			// no rewards doled out yet

640

1

			assert_eq!(

641

1

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

642

1

				1_100 * UNIT,

643

1

);

644

1

			assert_eq!(Balances::usable_balance(AccountId::from(BOB)), 500 * UNIT,);

645

1

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

646

1

			// rewards minted and distributed

647

1

			assert_eq!(

648

1

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

649

1

				1213666666584000000000,

650

1

);

651

1

			assert_eq!(

652

1

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

653

1

				541333333292000000000,

654

1

);

655

1

});

656

1

657

658

#[test]

659

1

fn reward_block_authors_with_parachain_bond_reserved() {

660

1

	ExtBuilder::default()

661

1

		.with_balances(vec![

662

1

			// Alice gets 100 extra tokens for her mapping deposit

663

1

			(AccountId::from(ALICE), 2_100 * UNIT),

664

1

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

665

1

			(AccountId::from(CHARLIE), UNIT),

666

1

])

667

1

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

668

1

		.with_delegations(vec![(

669

1

			AccountId::from(BOB),

670

1

			AccountId::from(ALICE),

671

1

			500 * UNIT,

672

1

)])

673

1

		.with_mappings(vec![(

674

1

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

675

1

			AccountId::from(ALICE),

676

1

)])

677

1

		.build()

678

1

		.execute_with(|| {

679

1

			increase_last_relay_slot_number(1);

680

1

			assert_ok!(ParachainStaking::set_parachain_bond_account(

681

1

				root_origin(),

682

1

				AccountId::from(CHARLIE),

683

1

			),);

684

685

			// Stop just before round 2

686

1

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

687

1

688

1

			// no rewards doled out yet

689

1

			assert_eq!(

690

1

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

691

1

				1_100 * UNIT,

692

1

);

693

1

			assert_eq!(Balances::usable_balance(AccountId::from(BOB)), 500 * UNIT,);

694

1

			assert_eq!(Balances::usable_balance(AccountId::from(CHARLIE)), UNIT,);

695

696

			// Go to round 2

697

1

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

698

1

699

1

			// 30% reserved for parachain bond

700

1

			assert_eq!(

701

1

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

702

1

				47515000000000000000,

703

1

);

704

705

			// Go to round 3

706

1

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

707

1

			// rewards minted and distributed

708

1

			assert_eq!(

709

1

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

710

1

				1182693333281650000000,

711

1

);

712

1

			assert_eq!(

713

1

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

714

1

				525841666640825000000,

715

1

);

716

			// 30% again reserved for parachain bond

717

1

			assert_eq!(

718

1

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

719

1

				94727725000000000000,

720

1

);

721

1

});

722

1

723

724

#[test]

725

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

726

1

	ExtBuilder::default()

727

1

		.with_balances(vec![

728

1

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

729

1

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

730

1

])

731

1

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

732

1

		.with_mappings(vec![(

733

1

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

734

1

			AccountId::from(ALICE),

735

1

)])

736

1

		.with_crowdloan_fund(3_000_000 * UNIT)

737

1

		.build()

738

1

		.execute_with(|| {

739

1

			// set parachain inherent data

740

1

			set_parachain_inherent_data();

741

1

			let init_block = CrowdloanRewards::init_vesting_block();

742

1

			// This matches the previous vesting

743

1

			let end_block = init_block + 4 * WEEKS;

744

1

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

745

1

			assert_ok!(

746

1

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

747

1

					calls: vec![

748

1

						RuntimeCall::CrowdloanRewards(

749

1

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

750

1

								rewards: vec![(

751

1

									[4u8; 32].into(),

752

1

									Some(AccountId::from(CHARLIE)),

753

1

									1_500_000 * UNIT

754

1

)]

755

1

756

1

),

757

1

						RuntimeCall::CrowdloanRewards(

758

1

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

759

1

								rewards: vec![(

760

1

									[5u8; 32].into(),

761

1

									Some(AccountId::from(DAVE)),

762

1

									1_500_000 * UNIT

763

1

)]

764

1

765

1

),

766

1

						RuntimeCall::CrowdloanRewards(

767

1

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

768

1

								lease_ending_block: end_block

769

1

770

1

771

1

772

1

})

773

1

				.dispatch(root_origin())

774

1

);

775

			// 30 percent initial payout

776

1

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

777

			// 30 percent initial payout

778

1

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

779

1

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

780

1

			assert_eq!(last_event(), expected);

781

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

782

1

			assert_ok!(

783

1

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

784

1

					calls: vec![RuntimeCall::CrowdloanRewards(

785

1

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

786

1

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

787

1

788

1

)]

789

1

})

790

1

				.dispatch(root_origin())

791

1

);

792

1

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

793

1

				index: 0,

794

1

				error: DispatchError::Module(ModuleError {

795

1

					index: 20,

796

1

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

797

1

					message: None,

798

1

}),

799

1

});

800

1

			assert_eq!(last_event(), expected_fail);

801

			// Claim 1 block.

802

1

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

803

1

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

804

805

1

			let vesting_period = 4 * WEEKS as u128;

806

1

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

807

1

808

1

			assert_eq!(

809

1

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

810

1

					.unwrap()

811

1

					.claimed_reward,

812

1

				(450_000 * UNIT) + per_block

813

1

);

814

1

			assert_eq!(

815

1

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

816

1

					.unwrap()

817

1

					.claimed_reward,

818

1

				(450_000 * UNIT) + per_block

819

1

);

820

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

821

1

			assert_eq!(

822

1

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

823

1

				(450_000 * UNIT) + per_block

824

1

);

825

1

			assert_eq!(

826

1

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

827

1

				(450_000 * UNIT) + per_block

828

1

);

829

1

			assert_noop!(

830

1

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

831

1

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

832

1

);

833

1

});

834

1

835

836

#[test]

837

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

838

1

	ExtBuilder::default()

839

1

		.with_balances(vec![

840

1

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

841

1

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

842

1

])

843

1

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

844

1

		.with_mappings(vec![(

845

1

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

846

1

			AccountId::from(ALICE),

847

1

)])

848

1

		.with_crowdloan_fund(3_000_000 * UNIT)

849

1

		.build()

850

1

		.execute_with(|| {

851

1

			// set parachain inherent data

852

1

			let init_block = CrowdloanRewards::init_vesting_block();

853

1

			// This matches the previous vesting

854

1

			let end_block = init_block + 4 * WEEKS;

855

1

856

1

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

857

1

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

858

1

859

1

			let public1 = pair1.public();

860

1

			let public2 = pair2.public();

861

1

862

1

			// signature:

863

1

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

864

1

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

865

1

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

866

1

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

867

1

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

868

1

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

869

1

870

1

			let signature1 = pair1.sign(&message);

871

1

			let signature2 = pair2.sign(&message);

872

1

873

1

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

874

1

			assert_ok!(

875

1

				// two relay accounts pointing at the same reward account

876

1

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

877

1

					calls: vec![

878

1

						RuntimeCall::CrowdloanRewards(

879

1

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

880

1

								rewards: vec![(

881

1

									public1.into(),

882

1

									Some(AccountId::from(CHARLIE)),

883

1

									1_500_000 * UNIT

884

1

)]

885

1

886

1

),

887

1

						RuntimeCall::CrowdloanRewards(

888

1

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

889

1

								rewards: vec![(

890

1

									public2.into(),

891

1

									Some(AccountId::from(CHARLIE)),

892

1

									1_500_000 * UNIT

893

1

)]

894

1

895

1

),

896

1

						RuntimeCall::CrowdloanRewards(

897

1

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

898

1

								lease_ending_block: end_block

899

1

900

1

901

1

902

1

})

903

1

				.dispatch(root_origin())

904

1

);

905

			// 30 percent initial payout

906

1

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

907

908

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

909

1

			assert_noop!(

910

1

				CrowdloanRewards::change_association_with_relay_keys(

911

1

					origin_of(AccountId::from(CHARLIE)),

912

1

					AccountId::from(DAVE),

913

1

					AccountId::from(CHARLIE),

914

1

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

915

1

),

916

1

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

917

1

);

918

919

			// this should be valid

920

1

			assert_ok!(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![

925

1

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

926

1

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

927

1

928

1

));

929

930

1

			assert_eq!(

931

1

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

932

1

					.unwrap()

933

1

					.claimed_reward,

934

1

				(900_000 * UNIT)

935

1

);

936

1

});

937

1

938

939

#[test]

940

1

fn claim_via_precompile() {

941

1

	ExtBuilder::default()

942

1

		.with_balances(vec![

943

1

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

944

1

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

945

1

])

946

1

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

947

1

		.with_mappings(vec![(

948

1

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

949

1

			AccountId::from(ALICE),

950

1

)])

951

1

		.with_crowdloan_fund(3_000_000 * UNIT)

952

1

		.build()

953

1

		.execute_with(|| {

954

1

			// set parachain inherent data

955

1

			set_parachain_inherent_data();

956

1

			let init_block = CrowdloanRewards::init_vesting_block();

957

1

			// This matches the previous vesting

958

1

			let end_block = init_block + 4 * WEEKS;

959

1

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

960

1

			assert_ok!(

961

1

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

962

1

					calls: vec![

963

1

						RuntimeCall::CrowdloanRewards(

964

1

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

965

1

								rewards: vec![(

966

1

									[4u8; 32].into(),

967

1

									Some(AccountId::from(CHARLIE)),

968

1

									1_500_000 * UNIT

969

1

)]

970

1

971

1

),

972

1

						RuntimeCall::CrowdloanRewards(

973

1

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

974

1

								rewards: vec![(

975

1

									[5u8; 32].into(),

976

1

									Some(AccountId::from(DAVE)),

977

1

									1_500_000 * UNIT

978

1

)]

979

1

980

1

),

981

1

						RuntimeCall::CrowdloanRewards(

982

1

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

983

1

								lease_ending_block: end_block

984

1

985

1

986

1

987

1

})

988

1

				.dispatch(root_origin())

989

1

);

990

991

			// 30 percent initial payout

992

1

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

993

			// 30 percent initial payout

994

1

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

995

996

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

997

1

998

1

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

999

1

			let gas_limit = 100000u64;

1000

1

			let gas_price: U256 = BASE_FEE_GENISIS.into();

1001

1

1002

1

			// Construct the call data (selector, amount)

1003

1

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

1004

1

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

1005

1

1006

1

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

1007

1

				source: H160::from(CHARLIE),

1008

1

				target: crowdloan_precompile_address,

1009

1

				input: call_data,

1010

1

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

1011

1

				gas_limit,

1012

1

				max_fee_per_gas: gas_price,

1013

1

				max_priority_fee_per_gas: None,

1014

1

				nonce: None, // Use the next nonce

1015

1

				access_list: Vec::new(),

1016

1

})

1017

1

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

1018

1019

1

			let vesting_period = 4 * WEEKS as u128;

1020

1

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

1021

1

1022

1

			assert_eq!(

1023

1

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

1024

1

					.unwrap()

1025

1

					.claimed_reward,

1026

1

				(450_000 * UNIT) + per_block

1027

1

);

1028

1

})

1029

1

1030

1031

#[test]

1032

1

fn is_contributor_via_precompile() {

1033

1

	ExtBuilder::default()

1034

1

		.with_balances(vec![

1035

1

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

1036

1

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

1037

1

])

1038

1

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

1039

1

		.with_mappings(vec![(

1040

1

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

1041

1

			AccountId::from(ALICE),

1042

1

)])

1043

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1044

1

		.build()

1045

1

		.execute_with(|| {

1046

1

			// set parachain inherent data

1047

1

			let init_block = CrowdloanRewards::init_vesting_block();

1048

1

			// This matches the previous vesting

1049

1

			let end_block = init_block + 4 * WEEKS;

1050

1

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

1051

1

			assert_ok!(

1052

1

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

1053

1

					calls: vec![

1054

1

						RuntimeCall::CrowdloanRewards(

1055

1

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

1056

1

								rewards: vec![(

1057

1

									[4u8; 32].into(),

1058

1

									Some(AccountId::from(CHARLIE)),

1059

1

									1_500_000 * UNIT

1060

1

)]

1061

1

1062

1

),

1063

1

						RuntimeCall::CrowdloanRewards(

1064

1

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

1065

1

								rewards: vec![(

1066

1

									[5u8; 32].into(),

1067

1

									Some(AccountId::from(DAVE)),

1068

1

									1_500_000 * UNIT

1069

1

)]

1070

1

1071

1

),

1072

1

						RuntimeCall::CrowdloanRewards(

1073

1

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

1074

1

								lease_ending_block: end_block

1075

1

1076

1

1077

1

1078

1

})

1079

1

				.dispatch(root_origin())

1080

1

);

1081

1082

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1083

1

1084

1

			// Assert precompile reports Bob is not a contributor

1085

1

			Precompiles::new()

1086

1

				.prepare_test(

1087

1

					ALICE,

1088

1

					crowdloan_precompile_address,

1089

1

					CrowdloanRewardsPCall::is_contributor {

1090

1

						contributor: Address(BOB.into()),

1091

1

},

1092

1

1093

1

				.expect_cost(1669)

1094

1

				.expect_no_logs()

1095

1

				.execute_returns(false);

1096

1

1097

1

			// Assert precompile reports Charlie is a nominator

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(CHARLIE.into()),

1104

1

},

1105

1

1106

1

				.expect_cost(1669)

1107

1

				.expect_no_logs()

1108

1

				.execute_returns(true);

1109

1

})

1110

1

1111

1112

#[test]

1113

1

fn reward_info_via_precompile() {

1114

1

	ExtBuilder::default()

1115

1

		.with_balances(vec![

1116

1

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

1117

1

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

1118

1

])

1119

1

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

1120

1

		.with_mappings(vec![(

1121

1

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

1122

1

			AccountId::from(ALICE),

1123

1

)])

1124

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1125

1

		.build()

1126

1

		.execute_with(|| {

1127

1

			// set parachain inherent data

1128

1

			let init_block = CrowdloanRewards::init_vesting_block();

1129

1

			// This matches the previous vesting

1130

1

			let end_block = init_block + 4 * WEEKS;

1131

1

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

1132

1

			assert_ok!(

1133

1

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

1134

1

					calls: vec![

1135

1

						RuntimeCall::CrowdloanRewards(

1136

1

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

1137

1

								rewards: vec![(

1138

1

									[4u8; 32].into(),

1139

1

									Some(AccountId::from(CHARLIE)),

1140

1

									1_500_000 * UNIT

1141

1

)]

1142

1

1143

1

),

1144

1

						RuntimeCall::CrowdloanRewards(

1145

1

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

1146

1

								rewards: vec![(

1147

1

									[5u8; 32].into(),

1148

1

									Some(AccountId::from(DAVE)),

1149

1

									1_500_000 * UNIT

1150

1

)]

1151

1

1152

1

),

1153

1

						RuntimeCall::CrowdloanRewards(

1154

1

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

1155

1

								lease_ending_block: end_block

1156

1

1157

1

1158

1

1159

1

})

1160

1

				.dispatch(root_origin())

1161

1

);

1162

1163

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1164

1

1165

1

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

1166

1

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

1167

1

1168

1

			// Assert precompile reports correct Charlie reward info.

1169

1

			Precompiles::new()

1170

1

				.prepare_test(

1171

1

					ALICE,

1172

1

					crowdloan_precompile_address,

1173

1

					CrowdloanRewardsPCall::reward_info {

1174

1

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

1175

1

},

1176

1

1177

1

				.expect_cost(1669)

1178

1

				.expect_no_logs()

1179

1

				.execute_returns((expected_total, expected_claimed));

1180

1

})

1181

1

1182

1183

#[test]

1184

1

fn update_reward_address_via_precompile() {

1185

1

	ExtBuilder::default()

1186

1

		.with_balances(vec![

1187

1

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

1188

1

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

1189

1

])

1190

1

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

1191

1

		.with_mappings(vec![(

1192

1

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

1193

1

			AccountId::from(ALICE),

1194

1

)])

1195

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1196

1

		.build()

1197

1

		.execute_with(|| {

1198

1

			// set parachain inherent data

1199

1

			let init_block = CrowdloanRewards::init_vesting_block();

1200

1

			// This matches the previous vesting

1201

1

			let end_block = init_block + 4 * WEEKS;

1202

1

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

1203

1

			assert_ok!(

1204

1

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

1205

1

					calls: vec![

1206

1

						RuntimeCall::CrowdloanRewards(

1207

1

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

1208

1

								rewards: vec![(

1209

1

									[4u8; 32].into(),

1210

1

									Some(AccountId::from(CHARLIE)),

1211

1

									1_500_000 * UNIT

1212

1

)]

1213

1

1214

1

),

1215

1

						RuntimeCall::CrowdloanRewards(

1216

1

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

1217

1

								rewards: vec![(

1218

1

									[5u8; 32].into(),

1219

1

									Some(AccountId::from(DAVE)),

1220

1

									1_500_000 * UNIT

1221

1

)]

1222

1

1223

1

),

1224

1

						RuntimeCall::CrowdloanRewards(

1225

1

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

1226

1

								lease_ending_block: end_block

1227

1

1228

1

1229

1

1230

1

})

1231

1

				.dispatch(root_origin())

1232

1

);

1233

1234

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1235

1

1236

1

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

1237

1

			let gas_limit = 100000u64;

1238

1

			let gas_price: U256 = BASE_FEE_GENISIS.into();

1239

1

1240

1

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

1241

1

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

1242

1

			call_data[0..4]

1243

1

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

1244

1

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

1245

1

1246

1

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

1247

1

				source: H160::from(CHARLIE),

1248

1

				target: crowdloan_precompile_address,

1249

1

				input: call_data,

1250

1

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

1251

1

				gas_limit,

1252

1

				max_fee_per_gas: gas_price,

1253

1

				max_priority_fee_per_gas: None,

1254

1

				nonce: None, // Use the next nonce

1255

1

				access_list: Vec::new(),

1256

1

})

1257

1

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

1258

1259

1

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

1260

1

			assert_eq!(

1261

1

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

1262

1

					.unwrap()

1263

1

					.claimed_reward,

1264

1

				(450_000 * UNIT)

1265

1

);

1266

1

})

1267

1

1268

1269

#[test]

1270

1

fn create_and_manipulate_foreign_asset() {

1271

1

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

1272

1

		let source_location = xcm::v4::Location::parent();

1273

1

1274

1

		// Create foreign asset

1275

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1276

1

			moonbase_runtime::RuntimeOrigin::root(),

1277

1

1,

1278

1

			source_location.clone(),

1279

1

12,

1280

1

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

1281

1

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

1282

1

));

1283

1

		assert_eq!(

1284

1

			EvmForeignAssets::assets_by_id(1),

1285

1

			Some(source_location.clone())

1286

1

);

1287

1

		assert_eq!(

1288

1

			EvmForeignAssets::assets_by_location(&source_location),

1289

1

			Some((1, AssetStatus::Active))

1290

1

);

1291

1292

		// Freeze foreign asset

1293

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1294

1

			moonbase_runtime::RuntimeOrigin::root(),

1295

1

1,

1296

1

			true

1297

1

));

1298

1

		assert_eq!(

1299

1

			EvmForeignAssets::assets_by_location(&source_location),

1300

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1301

1

);

1302

1303

		// Unfreeze foreign asset

1304

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1305

1

			moonbase_runtime::RuntimeOrigin::root(),

1306

1

1,

1307

1

));

1308

1

		assert_eq!(

1309

1

			EvmForeignAssets::assets_by_location(&source_location),

1310

1

			Some((1, AssetStatus::Active))

1311

1

);

1312

1

});

1313

1

1314

1315

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

1316

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

1317

/*

1318

#[test]

1319

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1320

	ExtBuilder::default()

1321

		.with_xcm_assets(vec![XcmAssetInitialization {

1322

			asset_id: 1,

1323

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

1324

			name: "RelayToken",

1325

			symbol: "Relay",

1326

			decimals: 12,

1327

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

1328

}])

1329

		.with_balances(vec![

1330

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

1331

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

1332

])

1333

		.build()

1334

		.execute_with(|| {

1335

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

1336

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

1337

1338

			// Its address is

1339

			let asset_precompile_address = Runtime::asset_id_to_account(

1340

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1341

				relay_asset_id,

1342

);

1343

1344

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

1345

			assert_eq!(Assets::total_supply(relay_asset_id), 1_000 * UNIT);

1346

1347

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

1348

			Precompiles::new()

1349

				.prepare_test(

1350

					ALICE,

1351

					asset_precompile_address,

1352

					ForeignAssetsPCall::total_supply {},

1353

1354

				.expect_cost(3338)

1355

				.expect_no_logs()

1356

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

1357

1358

			// Access balanceOf through precompile

1359

			Precompiles::new()

1360

				.prepare_test(

1361

					ALICE,

1362

					asset_precompile_address,

1363

					ForeignAssetsPCall::balance_of {

1364

						who: Address(ALICE.into()),

1365

},

1366

1367

				.expect_cost(3338)

1368

				.expect_no_logs()

1369

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

1370

});

1371

1372

1373

#[test]

1374

fn xcm_asset_erc20_precompiles_transfer() {

1375

	ExtBuilder::default()

1376

		.with_xcm_assets(vec![XcmAssetInitialization {

1377

			asset_id: 1,

1378

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

1379

			name: "RelayToken",

1380

			symbol: "Relay",

1381

			decimals: 12,

1382

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

1383

}])

1384

		.with_balances(vec![

1385

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

1386

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

1387

])

1388

		.build()

1389

		.execute_with(|| {

1390

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

1391

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

1392

1393

			// Its address is

1394

			let asset_precompile_address = Runtime::asset_id_to_account(

1395

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1396

				relay_asset_id,

1397

);

1398

1399

			// Transfer tokens from Alice to Bob, 400 UNIT.

1400

			Precompiles::new()

1401

				.prepare_test(

1402

					ALICE,

1403

					asset_precompile_address,

1404

					ForeignAssetsPCall::transfer {

1405

						to: Address(BOB.into()),

1406

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

1407

},

1408

1409

				.expect_cost(24695)

1410

				.expect_log(log3(

1411

					asset_precompile_address,

1412

					SELECTOR_LOG_TRANSFER,

1413

					H160::from(ALICE),

1414

					H160::from(BOB),

1415

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

1416

))

1417

				.execute_returns(true);

1418

1419

			// Make sure BOB has 400 UNIT

1420

			Precompiles::new()

1421

				.prepare_test(

1422

					BOB,

1423

					asset_precompile_address,

1424

					ForeignAssetsPCall::balance_of {

1425

						who: Address(BOB.into()),

1426

},

1427

1428

				.expect_cost(3338)

1429

				.expect_no_logs()

1430

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

1431

});

1432

1433

1434

#[test]

1435

fn xcm_asset_erc20_precompiles_approve() {

1436

	ExtBuilder::default()

1437

		.with_xcm_assets(vec![XcmAssetInitialization {

1438

			asset_id: 1,

1439

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

1440

			name: "RelayToken",

1441

			symbol: "Relay",

1442

			decimals: 12,

1443

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

1444

}])

1445

		.with_balances(vec![

1446

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

1447

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

1448

])

1449

		.build()

1450

		.execute_with(|| {

1451

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

1452

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

1453

1454

			// Its address is

1455

			let asset_precompile_address = Runtime::asset_id_to_account(

1456

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1457

				relay_asset_id,

1458

);

1459

1460

			// Aprove Bob for spending 400 UNIT from Alice

1461

			Precompiles::new()

1462

				.prepare_test(

1463

					ALICE,

1464

					asset_precompile_address,

1465

					ForeignAssetsPCall::approve {

1466

						spender: Address(BOB.into()),

1467

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

1468

},

1469

1470

				.expect_cost(15604)

1471

				.expect_log(log3(

1472

					asset_precompile_address,

1473

					SELECTOR_LOG_APPROVAL,

1474

					H160::from(ALICE),

1475

					H160::from(BOB),

1476

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

1477

))

1478

				.execute_returns(true);

1479

1480

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

1481

			Precompiles::new()

1482

				.prepare_test(

1483

					BOB,

1484

					asset_precompile_address,

1485

					ForeignAssetsPCall::transfer_from {

1486

						from: Address(ALICE.into()),

1487

						to: Address(CHARLIE.into()),

1488

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

1489

},

1490

1491

				.expect_cost(29960)

1492

				.expect_log(log3(

1493

					asset_precompile_address,

1494

					SELECTOR_LOG_TRANSFER,

1495

					H160::from(ALICE),

1496

					H160::from(CHARLIE),

1497

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

1498

))

1499

				.execute_returns(true);

1500

1501

			// Make sure CHARLIE has 400 UNIT

1502

			Precompiles::new()

1503

				.prepare_test(

1504

					CHARLIE,

1505

					asset_precompile_address,

1506

					ForeignAssetsPCall::balance_of {

1507

						who: Address(CHARLIE.into()),

1508

},

1509

1510

				.expect_cost(3338)

1511

				.expect_no_logs()

1512

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

1513

});

1514

}*/

1515

1516

#[test]

1517

1

fn xtokens_precompiles_transfer() {

1518

1

	ExtBuilder::default()

1519

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1520

1

			asset_id: 1,

1521

1

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

1522

1

			name: "RelayToken",

1523

1

			symbol: "Relay",

1524

1

			decimals: 12,

1525

1

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

1526

1

}])

1527

1

		.with_balances(vec![

1528

1

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

1529

1

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

1530

1

])

1531

1

		.with_safe_xcm_version(3)

1532

1

		.build()

1533

1

		.execute_with(|| {

1534

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1535

1

1536

1

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

1537

1

			let relay_asset_id: AssetId = 1;

1538

1

1539

1

			// Its address is

1540

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1541

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1542

1

				relay_asset_id,

1543

1

);

1544

1

1545

1

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

1546

1

			let destination = Location::new(

1547

1

1,

1548

1

				[Junction::AccountId32 {

1549

1

					network: None,

1550

1

					id: [1u8; 32],

1551

1

}],

1552

1

);

1553

1

1554

1

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

1555

1

			let inside2 = inside.clone();

1556

1

1557

1

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

1558

1

			Precompiles::new()

1559

1

				.prepare_test(

1560

1

					ALICE,

1561

1

					xtokens_precompile_address,

1562

1

					XtokensPCall::transfer {

1563

1

						currency_address: Address(asset_precompile_address.into()),

1564

1

						amount: 500_000_000_000_000u128.into(),

1565

1

						destination,

1566

1

						weight: 4_000_000,

1567

1

},

1568

1

1569

1

				.expect_cost(176605)

1570

1

				.expect_no_logs()

1571

1

				// We expect an evm subcall ERC20.burnFrom

1572

1

				.with_subcall_handle(move |subcall| {

1573

1

					let Subcall {

1574

1

						address,

1575

1

						transfer,

1576

1

						input,

1577

1

						target_gas: _,

1578

1

						is_static,

1579

1

						context,

1580

1

					} = subcall;

1581

1

1582

1

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

1583

1

					assert_eq!(

1584

1

						address,

1585

1

						[255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1].into()

1586

1

);

1587

1

					assert_eq!(is_static, false);

1588

1589

1

					assert!(transfer.is_none());

1590

1591

1

					assert_eq!(

1592

1

						context.address,

1593

1

						[255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1].into()

1594

1

);

1595

1

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

1596

1597

1

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

1598

1

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

1599

1

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

1600

1601

1

					inside2.set(true);

1602

1

1603

1

					SubcallOutput {

1604

1

						output: Default::default(),

1605

1

						cost: 149_000,

1606

1

						logs: vec![],

1607

1

						..SubcallOutput::succeed()

1608

1

1609

1

})

1610

1

				.execute_returns(())

1611

1

})

1612

1

1613

1614

#[test]

1615

1

fn xtokens_precompiles_transfer_multiasset() {

1616

1

	ExtBuilder::default()

1617

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1618

1

			asset_id: 1,

1619

1

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

1620

1

			name: "RelayToken",

1621

1

			symbol: "Relay",

1622

1

			decimals: 12,

1623

1

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

1624

1

}])

1625

1

		.with_balances(vec![

1626

1

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

1627

1

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

1628

1

])

1629

1

		.with_safe_xcm_version(3)

1630

1

		.build()

1631

1

		.execute_with(|| {

1632

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1633

1

1634

1

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

1635

1

			let destination = Location::new(

1636

1

1,

1637

1

				[Junction::AccountId32 {

1638

1

					network: None,

1639

1

					id: [1u8; 32],

1640

1

}],

1641

1

);

1642

1

1643

1

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

1644

1

			let inside2 = inside.clone();

1645

1

1646

1

			// This time we transfer it through TransferMultiAsset

1647

1

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

1648

1

			Precompiles::new()

1649

1

				.prepare_test(

1650

1

					ALICE,

1651

1

					xtokens_precompile_address,

1652

1

					XtokensPCall::transfer_multiasset {

1653

1

						// We want to transfer the relay token

1654

1

						asset: Location::parent(),

1655

1

						amount: 500_000_000_000_000u128.into(),

1656

1

						destination,

1657

1

						weight: 4_000_000,

1658

1

},

1659

1

1660

1

				.expect_cost(176605)

1661

1

				.expect_no_logs()

1662

1

				// We expect an evm subcall ERC20.burnFrom

1663

1

				.with_subcall_handle(move |subcall| {

1664

1

					let Subcall {

1665

1

						address,

1666

1

						transfer,

1667

1

						input,

1668

1

						target_gas: _,

1669

1

						is_static,

1670

1

						context,

1671

1

					} = subcall;

1672

1

1673

1

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

1674

1

					assert_eq!(

1675

1

						address,

1676

1

						[255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1].into()

1677

1

);

1678

1

					assert_eq!(is_static, false);

1679

1680

1

					assert!(transfer.is_none());

1681

1682

1

					assert_eq!(

1683

1

						context.address,

1684

1

						[255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1].into()

1685

1

);

1686

1

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

1687

1688

1

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

1689

1

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

1690

1

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

1691

1692

1

					inside2.set(true);

1693

1

1694

1

					SubcallOutput {

1695

1

						output: Default::default(),

1696

1

						cost: 149_000,

1697

1

						logs: vec![],

1698

1

						..SubcallOutput::succeed()

1699

1

1700

1

})

1701

1

				.execute_returns(());

1702

1

1703

1

			// Ensure that the subcall was actually called.

1704

1

			assert!(inside.get(), "subcall not called");

1705

1

})

1706

1

1707

1708

#[test]

1709

1

fn xtokens_precompiles_transfer_native() {

1710

1

	ExtBuilder::default()

1711

1

		.with_balances(vec![

1712

1

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

1713

1

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

1714

1

])

1715

1

		.with_safe_xcm_version(3)

1716

1

		.build()

1717

1

		.execute_with(|| {

1718

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1719

1

1720

1

			// Its address is

1721

1

			let asset_precompile_address = H160::from_low_u64_be(2050);

1722

1

1723

1

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

1724

1

			let destination = Location::new(

1725

1

1,

1726

1

				[Junction::AccountId32 {

1727

1

					network: None,

1728

1

					id: [1u8; 32],

1729

1

}],

1730

1

);

1731

1

1732

1

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

1733

1

			Precompiles::new()

1734

1

				.prepare_test(

1735

1

					ALICE,

1736

1

					xtokens_precompile_address,

1737

1

					XtokensPCall::transfer {

1738

1

						currency_address: Address(asset_precompile_address),

1739

1

						amount: { 500 * UNIT }.into(),

1740

1

						destination,

1741

1

						weight: 4_000_000,

1742

1

},

1743

1

1744

1

				.expect_cost(25005)

1745

1

				.expect_no_logs()

1746

1

				.execute_returns(());

1747

1

})

1748

1

1749

1750

1

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

1751

1

where

1752

1

	F: FnMut() -> (),

1753

1

1754

1

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

1755

1

		.build_storage()

1756

1

		.unwrap()

1757

1

		.into();

1758

1

	t.execute_with(|| {

1759

1

		System::set_block_consumed_resources(w, 0);

1760

1

		assertions()

1761

1

});

1762

1

1763

1764

#[test]

1765

#[rustfmt::skip]

1766

1

fn length_fee_is_sensible() {

1767

1

	use sp_runtime::testing::TestXt;

1768

1

1769

1

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

1770

1

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

1771

1

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

1772

1

		let uxt: TestXt<_, ()> = TestXt::new(call, Some((1u64, ())));

1773

1

1774

9

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

1775

9

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

1776

9

				.inclusion_fee

1777

9

				.expect("fee should be calculated")

1778

9

				.len_fee

1779

9

};

1780

1781

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

1782

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

1783

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

1784

		//                             |           |

1785

1

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

1786

1

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

1787

1

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

1788

1

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

1789

1

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

1790

1

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

1791

1

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

1792

1

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

1793

1

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

1794

1

});

1795

1

1796

1797

#[test]

1798

1

fn multiplier_can_grow_from_zero() {

1799

1

	use frame_support::traits::Get;

1800

1

1801

1

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

1802

1

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

1803

1

		* RuntimeBlockWeights::get()

1804

1

			.get(DispatchClass::Normal)

1805

1

			.max_total

1806

1

			.unwrap();

1807

1

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

1808

1

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

1809

1

	run_with_system_weight(target * 101 / 100, || {

1810

1

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

1811

1

		assert!(

1812

1

			next > minimum_multiplier,

1813

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

1814

			next,

1815

			minimum_multiplier

1816

);

1817

1

})

1818

1

1819

1820

#[test]

1821

1

fn ethereum_invalid_transaction() {

1822

1

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

1823

1

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

1824

1

		// on chain is rejected.

1825

1

		assert_eq!(

1826

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1827

1

			Err(

1828

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1829

1

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

1830

1

1831

1

1832

1

);

1833

1

});

1834

1

1835

1836

#[test]

1837

1

fn transfer_ed_0_substrate() {

1838

1

	ExtBuilder::default()

1839

1

		.with_balances(vec![

1840

1

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

1841

1

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

1842

1

])

1843

1

		.build()

1844

1

		.execute_with(|| {

1845

1

			// Substrate transfer

1846

1

			assert_ok!(Balances::transfer_allow_death(

1847

1

				origin_of(AccountId::from(ALICE)),

1848

1

				AccountId::from(BOB),

1849

1

				1 * UNIT,

1850

1

));

1851

			// 1 WEI is left in the account

1852

1

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

1853

1

});

1854

1

1855

1856

#[test]

1857

1

fn initial_gas_fee_is_correct() {

1858

1

	use fp_evm::FeeCalculator;

1859

1

1860

1

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

1861

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1862

1

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

1863

1864

1

		assert_eq!(

1865

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1866

1

1867

1

				2_500_000_000u128.into(),

1868

1

				Weight::from_parts(41_742_000u64, 0)

1869

1

1870

1

);

1871

1

});

1872

1

1873

1874

#[test]

1875

1

fn transfer_ed_0_evm() {

1876

1

	ExtBuilder::default()

1877

1

		.with_balances(vec![

1878

1

1879

1

				AccountId::from(ALICE),

1880

1

				((1 * UNIT) + (21_000 * BASE_FEE_GENISIS)) + (1 * WEI),

1881

1

),

1882

1

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

1883

1

])

1884

1

		.build()

1885

1

		.execute_with(|| {

1886

1

			set_parachain_inherent_data();

1887

1

			// EVM transfer

1888

1

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

1889

1

				source: H160::from(ALICE),

1890

1

				target: H160::from(BOB),

1891

1

				input: Vec::new(),

1892

1

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

1893

1

				gas_limit: 21_000u64,

1894

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1895

1

				max_priority_fee_per_gas: None,

1896

1

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

1897

1

				access_list: Vec::new(),

1898

1

})

1899

1

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

1900

			// 1 WEI is left in the account

1901

1

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

1902

1

});

1903

1

1904

1905

#[test]

1906

1

fn refund_ed_0_evm() {

1907

1

	ExtBuilder::default()

1908

1

		.with_balances(vec![

1909

1

1910

1

				AccountId::from(ALICE),

1911

1

				((1 * UNIT) + (21_777 * BASE_FEE_GENISIS) + existential_deposit()),

1912

1

),

1913

1

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

1914

1

])

1915

1

		.build()

1916

1

		.execute_with(|| {

1917

1

			// EVM transfer that zeroes ALICE

1918

1

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

1919

1

				source: H160::from(ALICE),

1920

1

				target: H160::from(BOB),

1921

1

				input: Vec::new(),

1922

1

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

1923

1

				gas_limit: 21_777u64,

1924

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1925

1

				max_priority_fee_per_gas: None,

1926

1

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

1927

1

				access_list: Vec::new(),

1928

1

})

1929

1

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

1930

			// ALICE is refunded

1931

1

			assert_eq!(

1932

1

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

1933

1

				777 * BASE_FEE_GENISIS + existential_deposit(),

1934

1

);

1935

1

});

1936

1

1937

1938

#[test]

1939

1

fn author_does_receive_priority_fee() {

1940

1

	ExtBuilder::default()

1941

1

		.with_balances(vec![(

1942

1

			AccountId::from(BOB),

1943

1

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

1944

1

)])

1945

1

		.build()

1946

1

		.execute_with(|| {

1947

1

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

1948

1

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

1949

1

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

1950

1

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

1951

1

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

1952

1

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

1953

1

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

1954

1

1955

1

			// EVM transfer.

1956

1

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

1957

1

				source: H160::from(BOB),

1958

1

				target: H160::from(ALICE),

1959

1

				input: Vec::new(),

1960

1

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

1961

1

				gas_limit: 21_000u64,

1962

1

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

1963

1

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

1964

1

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

1965

1

				access_list: Vec::new(),

1966

1

})

1967

1

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

1968

1969

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1970

1

			// Author free balance increased by priority fee.

1971

1

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

1972

1

});

1973

1

1974

1975

#[test]

1976

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1977

1

	ExtBuilder::default()

1978

1

		.with_balances(vec![

1979

1

1980

1

				AccountId::from(BOB),

1981

1

				(1 * UNIT) + (21_000 * (2 * BASE_FEE_GENISIS) + existential_deposit()),

1982

1

),

1983

1

			(AccountId::from(ALICE), existential_deposit()),

1984

1

1985

1

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

1986

1

				existential_deposit(),

1987

1

),

1988

1

])

1989

1

		.build()

1990

1

		.execute_with(|| {

1991

1

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

1992

1

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

1993

1

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

1994

1

			// EVM transfer.

1995

1

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

1996

1

				source: H160::from(BOB),

1997

1

				target: H160::from(ALICE),

1998

1

				input: Vec::new(),

1999

1

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

2000

1

				gas_limit: 21_000u64,

2001

1

				max_fee_per_gas: U256::from(2 * BASE_FEE_GENISIS),

2002

1

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

2003

1

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

2004

1

				access_list: Vec::new(),

2005

1

})

2006

1

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

2007

2008

1

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

2009

1

2010

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

2011

1

2012

1

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

2013

1

2014

1

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

2015

1

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

2016

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

2017

1

2018

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

2019

2020

1

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

2021

1

});

2022

1

2023

2024

#[test]

2025

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

2026

1

	use fp_evm::FeeCalculator;

2027

1

	ExtBuilder::default()

2028

1

		.with_balances(vec![

2029

1

2030

1

				AccountId::from(BOB),

2031

1

				(1 * UNIT) + (21_000 * (2 * BASE_FEE_GENISIS)),

2032

1

),

2033

1

			(AccountId::from(ALICE), existential_deposit()),

2034

1

2035

1

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

2036

1

				existential_deposit(),

2037

1

),

2038

1

])

2039

1

		.build()

2040

1

		.execute_with(|| {

2041

1

			set_parachain_inherent_data();

2042

1

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

2043

1

			// EVM transfer.

2044

1

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

2045

1

				source: H160::from(BOB),

2046

1

				target: H160::from(ALICE),

2047

1

				input: Vec::new(),

2048

1

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

2049

1

				gas_limit: 21_000u64,

2050

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2051

1

				max_priority_fee_per_gas: None,

2052

1

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

2053

1

				access_list: Vec::new(),

2054

1

})

2055

1

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

2056

2057

1

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

2058

1

			// Fee is 1 GWEI base fee.

2059

1

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

2060

1

			assert_eq!(base_fee.as_u128(), BASE_FEE_GENISIS); // hint in case following asserts fail

2061

2062

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

2063

1

2064

1

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

2065

1

2066

1

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

2067

1

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

2068

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

2069

1

2070

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

2071

2072

1

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

2073

1

});

2074

1

2075

2076

#[test]

2077

1

fn root_can_change_default_xcm_vers() {

2078

1

	ExtBuilder::default()

2079

1

		.with_balances(vec![

2080

1

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

2081

1

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

2082

1

])

2083

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2084

1

			asset_id: 1,

2085

1

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

2086

1

			name: "RelayToken",

2087

1

			symbol: "Relay",

2088

1

			decimals: 12,

2089

1

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

2090

1

}])

2091

1

		.build()

2092

1

		.execute_with(|| {

2093

1

			let source_id: moonbase_runtime::AssetId = 1;

2094

1

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

2095

1

			let asset = Asset {

2096

1

				id: AssetId(

2097

1

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

2098

1

						currency_id,

2099

1

2100

1

					.unwrap(),

2101

1

),

2102

1

				fun: Fungibility::Fungible(100_000_000_000_000),

2103

1

};

2104

1

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

2105

1

			// know with which version to send

2106

1

			assert_noop!(

2107

1

				PolkadotXcm::transfer_assets(

2108

1

					origin_of(AccountId::from(ALICE)),

2109

1

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

2110

1

					Box::new(VersionedLocation::V4(Location {

2111

1

						parents: 0,

2112

1

						interior: [AccountId32 {

2113

1

							network: None,

2114

1

							id: [1u8; 32],

2115

1

}]

2116

1

						.into(),

2117

1

					})),

2118

1

					Box::new(VersionedAssets::V4(asset.clone().into())),

2119

1

0,

2120

1

					WeightLimit::Unlimited

2121

1

),

2122

1

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

2123

1

);

2124

2125

			// Root sets the defaultXcm

2126

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

2127

1

				root_origin(),

2128

1

				Some(4)

2129

1

));

2130

2131

			// Now transferring does not fail

2132

1

			assert_ok!(PolkadotXcm::transfer_assets(

2133

1

				origin_of(AccountId::from(ALICE)),

2134

1

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

2135

1

				Box::new(VersionedLocation::V4(Location {

2136

1

					parents: 0,

2137

1

					interior: [AccountId32 {

2138

1

						network: None,

2139

1

						id: [1u8; 32],

2140

1

}]

2141

1

					.into(),

2142

1

				})),

2143

1

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

2144

1

0,

2145

1

				WeightLimit::Unlimited

2146

1

));

2147

1

})

2148

1

2149

2150

#[test]

2151

1

fn transactor_cannot_use_more_than_max_weight() {

2152

1

	ExtBuilder::default()

2153

1

		.with_balances(vec![

2154

1

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

2155

1

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

2156

1

])

2157

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2158

1

			asset_id: 1,

2159

1

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

2160

1

			name: "RelayToken",

2161

1

			symbol: "Relay",

2162

1

			decimals: 12,

2163

1

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

2164

1

}])

2165

1

		.build()

2166

1

		.execute_with(|| {

2167

1

			let source_id: moonbase_runtime::AssetId = 1;

2168

1

			assert_ok!(XcmTransactor::register(

2169

1

				root_origin(),

2170

1

				AccountId::from(ALICE),

2171

1

0,

2172

1

));

2173

2174

			// Root can set transact info

2175

1

			assert_ok!(XcmTransactor::set_transact_info(

2176

1

				root_origin(),

2177

1

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

2178

1

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

2179

1

				3000.into(),

2180

1

				20000.into(),

2181

1

				None

2182

1

));

2183

			// Root can set transact info

2184

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2185

1

				root_origin(),

2186

1

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

2187

1

1,

2188

1

));

2189

2190

1

			assert_noop!(

2191

1

				XcmTransactor::transact_through_derivative(

2192

1

					origin_of(AccountId::from(ALICE)),

2193

1

					moonbase_runtime::xcm_config::Transactors::Relay,

2194

1

0,

2195

1

					CurrencyPayment {

2196

1

						currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

2197

1

							Location::parent()

2198

1

						))),

2199

1

						fee_amount: None

2200

1

},

2201

1

					vec![],

2202

1

					// 20000 is the max

2203

1

					TransactWeights {

2204

1

						transact_required_weight_at_most: 17001.into(),

2205

1

						overall_weight: None

2206

1

},

2207

1

					false

2208

1

),

2209

1

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

2210

1

);

2211

1

			assert_noop!(

2212

1

				XcmTransactor::transact_through_derivative(

2213

1

					origin_of(AccountId::from(ALICE)),

2214

1

					moonbase_runtime::xcm_config::Transactors::Relay,

2215

1

0,

2216

1

					CurrencyPayment {

2217

1

						currency: Currency::AsCurrencyId(

2218

1

							moonbase_runtime::xcm_config::CurrencyId::ForeignAsset(source_id)

2219

1

),

2220

1

						fee_amount: None

2221

1

},

2222

1

					vec![],

2223

1

					// 20000 is the max

2224

1

					TransactWeights {

2225

1

						transact_required_weight_at_most: 17001.into(),

2226

1

						overall_weight: None

2227

1

},

2228

1

					false

2229

1

),

2230

1

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

2231

1

);

2232

1

})

2233

1

2234

2235

#[test]

2236

1

fn root_can_use_hrmp_manage() {

2237

1

	ExtBuilder::default()

2238

1

		.with_balances(vec![

2239

1

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

2240

1

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

2241

1

])

2242

1

		.build()

2243

1

		.execute_with(|| {

2244

1

			// It fails sending, because the router does not work in test mode

2245

1

			// But all rest checks pass

2246

1

			assert_noop!(

2247

1

				XcmTransactor::hrmp_manage(

2248

1

					root_origin(),

2249

1

					HrmpOperation::Accept {

2250

1

						para_id: 2000u32.into()

2251

1

},

2252

1

					CurrencyPayment {

2253

1

						currency: Currency::AsMultiLocation(Box::new(xcm::VersionedLocation::V4(

2254

1

							Location::parent()

2255

1

						))),

2256

1

						fee_amount: Some(10000)

2257

1

},

2258

1

					// 20000 is the max

2259

1

					TransactWeights {

2260

1

						transact_required_weight_at_most: 17001.into(),

2261

1

						overall_weight: Some(Limited(20000.into()))

2262

1

2263

1

),

2264

1

				pallet_xcm_transactor::Error::<Runtime>::ErrorValidating

2265

1

);

2266

1

})

2267

1

2268

2269

#[test]

2270

1

fn transact_through_signed_precompile_works_v1() {

2271

1

	ExtBuilder::default()

2272

1

		.with_balances(vec![

2273

1

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

2274

1

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

2275

1

])

2276

1

		.with_safe_xcm_version(3)

2277

1

		.build()

2278

1

		.execute_with(|| {

2279

1

			// Destination

2280

1

			let dest = Location::parent();

2281

1

2282

1

			let fee_payer_asset = Location::parent();

2283

1

2284

1

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

2285

1

2286

1

			let xcm_transactor_v1_precompile_address = H160::from_low_u64_be(2054);

2287

1

2288

1

			// Root can set transact info

2289

1

			assert_ok!(XcmTransactor::set_transact_info(

2290

1

				root_origin(),

2291

1

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

2292

1

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

2293

1

				3000.into(),

2294

1

				Weight::from_parts(200_000, (xcm_primitives::DEFAULT_PROOF_SIZE) + 4000),

2295

1

				Some(4000.into())

2296

1

));

2297

			// Root can set transact info

2298

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2299

1

				root_origin(),

2300

1

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

2301

1

1,

2302

1

));

2303

2304

1

			Precompiles::new()

2305

1

				.prepare_test(

2306

1

					ALICE,

2307

1

					xcm_transactor_v1_precompile_address,

2308

1

					XcmTransactorV1PCall::transact_through_signed_multilocation {

2309

1

						dest,

2310

1

						fee_asset: fee_payer_asset,

2311

1

						weight: 15000,

2312

1

						call: bytes.into(),

2313

1

},

2314

1

2315

1

				.expect_cost(23664)

2316

1

				.expect_no_logs()

2317

1

				.execute_returns(());

2318

1

});

2319

1

2320

2321

#[test]

2322

1

fn transact_through_signed_precompile_works_v2() {

2323

1

	ExtBuilder::default()

2324

1

		.with_balances(vec![

2325

1

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

2326

1

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

2327

1

])

2328

1

		.with_safe_xcm_version(3)

2329

1

		.build()

2330

1

		.execute_with(|| {

2331

1

			// Destination

2332

1

			let dest = Location::parent();

2333

1

2334

1

			let fee_payer_asset = Location::parent();

2335

1

2336

1

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

2337

1

2338

1

			let total_weight = 1_000_000_000u64;

2339

1

2340

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2341

1

2342

1

			Precompiles::new()

2343

1

				.prepare_test(

2344

1

					ALICE,

2345

1

					xcm_transactor_v2_precompile_address,

2346

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2347

1

						dest,

2348

1

						fee_asset: fee_payer_asset,

2349

1

						weight: 4_000_000,

2350

1

						call: bytes.into(),

2351

1

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

2352

1

						overall_weight: total_weight,

2353

1

},

2354

1

2355

1

				.expect_cost(23664)

2356

1

				.expect_no_logs()

2357

1

				.execute_returns(());

2358

1

});

2359

1

2360

2361

#[test]

2362

1

fn transact_through_signed_cannot_send_to_local_chain() {

2363

1

	ExtBuilder::default()

2364

1

		.with_balances(vec![

2365

1

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

2366

1

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

2367

1

])

2368

1

		.with_safe_xcm_version(3)

2369

1

		.build()

2370

1

		.execute_with(|| {

2371

1

			// Destination

2372

1

			let dest = Location::here();

2373

1

2374

1

			let fee_payer_asset = Location::parent();

2375

1

2376

1

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

2377

1

2378

1

			let total_weight = 1_000_000_000u64;

2379

1

2380

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2381

1

2382

1

			Precompiles::new()

2383

1

				.prepare_test(

2384

1

					ALICE,

2385

1

					xcm_transactor_v2_precompile_address,

2386

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2387

1

						dest,

2388

1

						fee_asset: fee_payer_asset,

2389

1

						weight: 4_000_000,

2390

1

						call: bytes.into(),

2391

1

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

2392

1

						overall_weight: total_weight,

2393

1

},

2394

1

2395

1

				.execute_reverts(|output| {

2396

1

					from_utf8(&output)

2397

1

						.unwrap()

2398

1

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

2399

1

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

2400

1

});

2401

1

});

2402

1

2403

2404

// Test to ensure we can use either in crowdloan rewards without worrying for migrations

2405

#[test]

2406

1

fn account_id_32_encodes_like_32_byte_u8_slice() {

2407

1

	let account_as_account_id_32: sp_runtime::AccountId32 = [1u8; 32].into();

2408

1

	let account_as_slice = [1u8; 32];

2409

1

	assert_eq!(account_as_account_id_32.encode(), account_as_slice.encode());

2410

1

2411

2412

#[test]

2413

1

fn author_mapping_precompile_associate_update_and_clear() {

2414

1

	ExtBuilder::default()

2415

1

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

2416

1

		.build()

2417

1

		.execute_with(|| {

2418

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2419

1

			let first_nimbus_id: NimbusId =

2420

1

				sp_core::sr25519::Public::unchecked_from([1u8; 32]).into();

2421

1

			let first_vrf_id: session_keys_primitives::VrfId =

2422

1

				sp_core::sr25519::Public::unchecked_from([1u8; 32]).into();

2423

1

			let second_nimbus_id: NimbusId =

2424

1

				sp_core::sr25519::Public::unchecked_from([2u8; 32]).into();

2425

1

			let second_vrf_id: session_keys_primitives::VrfId =

2426

1

				sp_core::sr25519::Public::unchecked_from([2u8; 32]).into();

2427

1

2428

1

			// Associate it

2429

1

			Precompiles::new()

2430

1

				.prepare_test(

2431

1

					ALICE,

2432

1

					author_mapping_precompile_address,

2433

1

					AuthorMappingPCall::add_association {

2434

1

						nimbus_id: [1u8; 32].into(),

2435

1

},

2436

1

2437

1

				.expect_cost(14404)

2438

1

				.expect_no_logs()

2439

1

				.execute_returns(());

2440

1

2441

1

			let expected_associate_event =

2442

1

				RuntimeEvent::AuthorMapping(pallet_author_mapping::Event::KeysRegistered {

2443

1

					nimbus_id: first_nimbus_id.clone(),

2444

1

					account_id: AccountId::from(ALICE),

2445

1

					keys: first_vrf_id.clone(),

2446

1

});

2447

1

			assert_eq!(last_event(), expected_associate_event);

2448

2449

			// Update it

2450

1

			Precompiles::new()

2451

1

				.prepare_test(

2452

1

					ALICE,

2453

1

					author_mapping_precompile_address,

2454

1

					AuthorMappingPCall::update_association {

2455

1

						old_nimbus_id: [1u8; 32].into(),

2456

1

						new_nimbus_id: [2u8; 32].into(),

2457

1

},

2458

1

2459

1

				.expect_cost(13909)

2460

1

				.expect_no_logs()

2461

1

				.execute_returns(());

2462

1

2463

1

			let expected_update_event =

2464

1

				RuntimeEvent::AuthorMapping(pallet_author_mapping::Event::KeysRotated {

2465

1

					new_nimbus_id: second_nimbus_id.clone(),

2466

1

					account_id: AccountId::from(ALICE),

2467

1

					new_keys: second_vrf_id.clone(),

2468

1

});

2469

1

			assert_eq!(last_event(), expected_update_event);

2470

2471

			// Clear it

2472

1

			Precompiles::new()

2473

1

				.prepare_test(

2474

1

					ALICE,

2475

1

					author_mapping_precompile_address,

2476

1

					AuthorMappingPCall::clear_association {

2477

1

						nimbus_id: [2u8; 32].into(),

2478

1

},

2479

1

2480

1

				.expect_cost(14404)

2481

1

				.expect_no_logs()

2482

1

				.execute_returns(());

2483

1

2484

1

			let expected_clear_event =

2485

1

				RuntimeEvent::AuthorMapping(pallet_author_mapping::Event::KeysRemoved {

2486

1

					nimbus_id: second_nimbus_id,

2487

1

					account_id: AccountId::from(ALICE),

2488

1

					keys: second_vrf_id,

2489

1

});

2490

1

			assert_eq!(last_event(), expected_clear_event);

2491

1

});

2492

1

2493

2494

#[test]

2495

1

fn author_mapping_register_and_set_keys() {

2496

1

	ExtBuilder::default()

2497

1

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

2498

1

		.build()

2499

1

		.execute_with(|| {

2500

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2501

1

			let first_nimbus_id: NimbusId =

2502

1

				sp_core::sr25519::Public::unchecked_from([1u8; 32]).into();

2503

1

			let first_vrf_key: session_keys_primitives::VrfId =

2504

1

				sp_core::sr25519::Public::unchecked_from([3u8; 32]).into();

2505

1

			let second_nimbus_id: NimbusId =

2506

1

				sp_core::sr25519::Public::unchecked_from([2u8; 32]).into();

2507

1

			let second_vrf_key: session_keys_primitives::VrfId =

2508

1

				sp_core::sr25519::Public::unchecked_from([4u8; 32]).into();

2509

1

2510

1

			// Associate it

2511

1

			Precompiles::new()

2512

1

				.prepare_test(

2513

1

					ALICE,

2514

1

					author_mapping_precompile_address,

2515

1

					AuthorMappingPCall::set_keys {

2516

1

						keys: solidity::encode_arguments((

2517

1

							H256::from([1u8; 32]),

2518

1

							H256::from([3u8; 32]),

2519

1

))

2520

1

						.into(),

2521

1

},

2522

1

2523

1

				.expect_cost(16184)

2524

1

				.expect_no_logs()

2525

1

				.execute_returns(());

2526

1

2527

1

			let expected_associate_event =

2528

1

				RuntimeEvent::AuthorMapping(pallet_author_mapping::Event::KeysRegistered {

2529

1

					nimbus_id: first_nimbus_id.clone(),

2530

1

					account_id: AccountId::from(ALICE),

2531

1

					keys: first_vrf_key.clone(),

2532

1

});

2533

1

			assert_eq!(last_event(), expected_associate_event);

2534

2535

			// Update it

2536

1

			Precompiles::new()

2537

1

				.prepare_test(

2538

1

					ALICE,

2539

1

					author_mapping_precompile_address,

2540

1

					AuthorMappingPCall::set_keys {

2541

1

						keys: solidity::encode_arguments((

2542

1

							H256::from([2u8; 32]),

2543

1

							H256::from([4u8; 32]),

2544

1

))

2545

1

						.into(),

2546

1

},

2547

1

2548

1

				.expect_cost(16184)

2549

1

				.expect_no_logs()

2550

1

				.execute_returns(());

2551

1

2552

1

			let expected_update_event =

2553

1

				RuntimeEvent::AuthorMapping(pallet_author_mapping::Event::KeysRotated {

2554

1

					new_nimbus_id: second_nimbus_id.clone(),

2555

1

					account_id: AccountId::from(ALICE),

2556

1

					new_keys: second_vrf_key.clone(),

2557

1

});

2558

1

			assert_eq!(last_event(), expected_update_event);

2559

1

});

2560

1

2561

2562

#[test]

2563

1

fn test_xcm_utils_ml_tp_account() {

2564

1

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

2565

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2566

1

		let expected_address_parent: H160 =

2567

1

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

2568

1

				.unwrap()

2569

1

				.into();

2570

1

2571

1

		Precompiles::new()

2572

1

			.prepare_test(

2573

1

				ALICE,

2574

1

				xcm_utils_precompile_address,

2575

1

				XcmUtilsPCall::multilocation_to_address {

2576

1

					location: Location::parent(),

2577

1

},

2578

1

2579

1

			.expect_cost(1669)

2580

1

			.expect_no_logs()

2581

1

			.execute_returns(Address(expected_address_parent));

2582

1

2583

1

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

2584

1

		let expected_address_parachain: H160 =

2585

1

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

2586

1

				&parachain_2000_multilocation,

2587

1

2588

1

			.unwrap()

2589

1

			.into();

2590

1

2591

1

		Precompiles::new()

2592

1

			.prepare_test(

2593

1

				ALICE,

2594

1

				xcm_utils_precompile_address,

2595

1

				XcmUtilsPCall::multilocation_to_address {

2596

1

					location: parachain_2000_multilocation,

2597

1

},

2598

1

2599

1

			.expect_cost(1669)

2600

1

			.expect_no_logs()

2601

1

			.execute_returns(Address(expected_address_parachain));

2602

1

2603

1

		let alice_in_parachain_2000_multilocation = Location::new(

2604

1

1,

2605

1

2606

1

				Parachain(2000),

2607

1

				AccountKey20 {

2608

1

					network: None,

2609

1

					key: ALICE,

2610

1

},

2611

1

],

2612

1

);

2613

1

		let expected_address_alice_in_parachain_2000 =

2614

1

			xcm_builder::HashedDescription::<

2615

1

				AccountId,

2616

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2617

1

			>::convert_location(&alice_in_parachain_2000_multilocation)

2618

1

			.unwrap()

2619

1

			.into();

2620

1

2621

1

		Precompiles::new()

2622

1

			.prepare_test(

2623

1

				ALICE,

2624

1

				xcm_utils_precompile_address,

2625

1

				XcmUtilsPCall::multilocation_to_address {

2626

1

					location: alice_in_parachain_2000_multilocation,

2627

1

},

2628

1

2629

1

			.expect_cost(1669)

2630

1

			.expect_no_logs()

2631

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2632

1

});

2633

1

2634

2635

#[test]

2636

1

fn test_xcm_utils_weight_message() {

2637

1

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

2638

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2639

1

		let expected_weight =

2640

1

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

2641

1

2642

1

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

2643

1

2644

1

		let input = XcmUtilsPCall::weight_message {

2645

1

			message: message.into(),

2646

1

};

2647

1

2648

1

		Precompiles::new()

2649

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2650

1

			.expect_cost(0)

2651

1

			.expect_no_logs()

2652

1

			.execute_returns(expected_weight);

2653

1

});

2654

1

2655

2656

#[test]

2657

1

fn test_xcm_utils_get_units_per_second() {

2658

1

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

2659

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2660

1

		let location = SelfReserve::get();

2661

1

2662

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2663

1

2664

1

		let expected_units =

2665

1

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

2666

1

2667

1

		Precompiles::new()

2668

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2669

1

			.expect_cost(1669)

2670

1

			.expect_no_logs()

2671

1

			.execute_returns(expected_units);

2672

1

});

2673

1

2674

2675

#[test]

2676

1

fn precompile_existence() {

2677

1

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

2678

1

		let precompiles = Precompiles::new();

2679

1

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

2680

1

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

2681

1

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

2682

1

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

2683

1

2684

1

		.into_iter()

2685

1

		.map(H160::from_low_u64_be)

2686

1

		.collect();

2687

2688

3001

		for i in 0..3000 {

2689

3000

			let address = H160::from_low_u64_be(i);

2690

3000

2691

3000

			if precompile_addresses.contains(&address) {

2692

42

				assert!(

2693

42

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

2694

					"is_precompile({}) should return true",

2695

2696

);

2697

2698

42

				assert!(

2699

42

					precompiles

2700

42

						.execute(&mut MockHandle::new(

2701

42

							address,

2702

42

							Context {

2703

42

								address,

2704

42

								caller: H160::zero(),

2705

42

								apparent_value: U256::zero()

2706

42

2707

42

),)

2708

42

						.is_some(),

2709

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

2710

2711

);

2712

			} else {

2713

2958

				assert!(

2714

2958

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

2715

					"is_precompile({}) should return false",

2716

2717

);

2718

2719

2958

				assert!(

2720

2958

					precompiles

2721

2958

						.execute(&mut MockHandle::new(

2722

2958

							address,

2723

2958

							Context {

2724

2958

								address,

2725

2958

								caller: H160::zero(),

2726

2958

								apparent_value: U256::zero()

2727

2958

2728

2958

),)

2729

2958

						.is_none(),

2730

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

2731

2732

);

2733

2734

2735

1

});

2736

1

2737

2738

#[test]

2739

1

fn removed_precompiles() {

2740

1

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

2741

1

		let precompiles = Precompiles::new();

2742

1

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

2743

2744

3000

		for i in 1..3000 {

2745

2999

			let address = H160::from_low_u64_be(i);

2746

2999

2747

2999

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

2748

2957

				continue;

2749

42

2750

42

2751

42

			if !removed_precompiles.contains(&i) {

2752

38

				assert!(

2753

38

					match precompiles.is_active_precompile(address, 100_000u64) {

2754

38

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

2755

						_ => false,

2756

},

2757

					"{i} should be an active precompile"

2758

);

2759

38

				continue;

2760

4

2761

4

2762

4

			assert!(

2763

4

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

2764

4

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

2765

					_ => false,

2766

},

2767

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

2768

);

2769

2770

4

			precompiles

2771

4

				.prepare_test(Alice, address, [])

2772

4

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

2773

2774

1

})

2775

1

2776

2777

#[test]

2778

1

fn substrate_based_fees_zero_txn_costs_only_base_extrinsic() {

2779

1

	use frame_support::dispatch::{DispatchInfo, Pays};

2780

1

	use moonbase_runtime::{currency, EXTRINSIC_BASE_WEIGHT};

2781

1

2782

1

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

2783

1

		let size_bytes = 0;

2784

1

		let tip = 0;

2785

1

		let dispatch_info = DispatchInfo {

2786

1

			weight: Weight::zero(),

2787

1

			class: DispatchClass::Normal,

2788

1

			pays_fee: Pays::Yes,

2789

1

};

2790

1

2791

1

		assert_eq!(

2792

1

			TransactionPayment::compute_fee(size_bytes, &dispatch_info, tip),

2793

1

			EXTRINSIC_BASE_WEIGHT.ref_time() as u128 * currency::WEIGHT_FEE,

2794

1

);

2795

1

});

2796

1

2797

2798

#[test]

2799

1

fn deal_with_fees_handles_tip() {

2800

1

	use frame_support::traits::OnUnbalanced;

2801

1

	use moonbase_runtime::Treasury;

2802

1

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2803

1

2804

1

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

2805

1

		set_parachain_inherent_data();

2806

1

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

2807

1

		// in the Moonbeam runtime. It verifies that:

2808

1

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

2809

1

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

2810

1

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

2811

1

2812

1

		// The test details:

2813

1

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

2814

1

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

2815

1

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

2816

1

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

2817

1

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

2818

1

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

2819

1

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

2820

1

2821

1

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

2822

1

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

2823

1

			AccountId,

2824

1

		>>::issue(100);

2825

1

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

2826

1

			AccountId,

2827

1

		>>::issue(1000);

2828

1

2829

1

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

2830

1

		let total_supply_before = Balances::total_issuance();

2831

1

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

2832

1

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

2833

1

		assert_eq!(total_supply_before, 1_100);

2834

1

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

2835

2836

		// Step 3: Execute the fees handling logic.

2837

1

		DealWithSubstrateFeesAndTip::<

2838

1

			Runtime,

2839

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2840

1

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

2841

1

2842

1

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

2843

1

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

2844

1

2845

1

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

2846

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2847

1

2848

1

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

2849

1

		assert_eq!(

2850

1

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

2851

1

			treasury_fee_part,

2852

1

);

2853

2854

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

2855

1

		let total_supply_after = Balances::total_issuance();

2856

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2857

2858

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

2859

1

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

2860

1

		assert_eq!(

2861

1

			block_author_balance_after - block_author_balance_before,

2862

1

			1000,

2863

1

);

2864

1

});

2865

1

2866

2867

#[test]

2868

1

fn evm_revert_substrate_events() {

2869

1

	ExtBuilder::default()

2870

1

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

2871

1

		.build()

2872

1

		.execute_with(|| {

2873

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2874

1

2875

1

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

2876

1

			// Thus BatchAll will revert the transfer.

2877

1

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

2878

1

				source: ALICE.into(),

2879

1

				target: batch_precompile_address,

2880

1

				input: BatchPCall::batch_all {

2881

1

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

2882

1

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

2883

1

					call_data: vec![].into(),

2884

1

					gas_limit: vec![].into()

2885

1

2886

1

				.into(),

2887

1

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

2888

1

				gas_limit: 500_000,

2889

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2890

1

				max_priority_fee_per_gas: None,

2891

1

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

2892

1

				access_list: Vec::new(),

2893

1

})

2894

1

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

2895

2896

1

			let transfer_count = System::events()

2897

1

				.iter()

2898

6

				.filter(|r| match r.event {

2899

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

2900

6

					_ => false,

2901

6

})

2902

1

				.count();

2903

1

2904

1

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

2905

1

});

2906

1

2907

2908

#[test]

2909

1

fn evm_success_keeps_substrate_events() {

2910

1

	ExtBuilder::default()

2911

1

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

2912

1

		.build()

2913

1

		.execute_with(|| {

2914

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2915

1

2916

1

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

2917

1

				source: ALICE.into(),

2918

1

				target: batch_precompile_address,

2919

1

				input: BatchPCall::batch_all {

2920

1

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

2921

1

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

2922

1

					call_data: vec![].into(),

2923

1

					gas_limit: vec![].into()

2924

1

2925

1

				.into(),

2926

1

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

2927

1

				gas_limit: 500_000,

2928

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2929

1

				max_priority_fee_per_gas: None,

2930

1

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

2931

1

				access_list: Vec::new(),

2932

1

})

2933

1

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

2934

2935

1

			let transfer_count = System::events()

2936

1

				.iter()

2937

10

				.filter(|r| match r.event {

2938

1

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

2939

9

					_ => false,

2940

10

})

2941

1

				.count();

2942

1

2943

1

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

2944

1

});

2945

1

2946

2947

#[test]

2948

1

fn validate_transaction_fails_on_filtered_call() {

2949

1

	use sp_runtime::transaction_validity::{

2950

1

		InvalidTransaction, TransactionSource, TransactionValidityError,

2951

1

};

2952

1

	use sp_transaction_pool::runtime_api::runtime_decl_for_tagged_transaction_queue::TaggedTransactionQueueV3; // editorconfig-checker-disable-line

2953

1

2954

1

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

2955

1

		let xt = UncheckedExtrinsic::new_unsigned(

2956

1

			pallet_evm::Call::<Runtime>::call {

2957

1

				source: Default::default(),

2958

1

				target: H160::default(),

2959

1

				input: Vec::new(),

2960

1

				value: Default::default(),

2961

1

				gas_limit: Default::default(),

2962

1

				max_fee_per_gas: Default::default(),

2963

1

				max_priority_fee_per_gas: Default::default(),

2964

1

				nonce: Default::default(),

2965

1

				access_list: Default::default(),

2966

1

2967

1

			.into(),

2968

1

);

2969

1

2970

1

		assert_eq!(

2971

1

			Runtime::validate_transaction(TransactionSource::External, xt, Default::default(),),

2972

1

			Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),

2973

1

);

2974

1

});

2975

1

2976

2977

#[cfg(test)]

2978

mod treasury_tests {

2979

	use super::*;

2980

	use sp_runtime::traits::Hash;

2981

2982

4

	fn expect_events(events: Vec<RuntimeEvent>) {

2983

4

		let block_events: Vec<RuntimeEvent> =

2984

13

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

2985

4

2986

4

		dbg!(events.clone());

2987

4

		dbg!(block_events.clone());

2988

4

2989

7

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

2990

4

2991

2992

8

	fn next_block() {

2993

8

		System::reset_events();

2994

8

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

2995

8

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

2996

8

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

2997

8

2998

2999

	#[test]

3000

1

	fn test_treasury_spend_local_with_root_origin() {

3001

1

		let initial_treasury_balance = 1_000 * UNIT;

3002

1

		ExtBuilder::default()

3003

1

			.with_balances(vec![

3004

1

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

3005

1

				(Treasury::account_id(), initial_treasury_balance),

3006

1

])

3007

1

			.build()

3008

1

			.execute_with(|| {

3009

1

				let spend_amount = 100u128 * UNIT;

3010

1

				let spend_beneficiary = AccountId::from(BOB);

3011

1

3012

1

				next_block();

3013

1

3014

1

				// Perform treasury spending

3015

1

3016

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

3017

1

					root_origin(),

3018

1

					Box::new(RuntimeCall::Treasury(pallet_treasury::Call::spend {

3019

1

						amount: spend_amount,

3020

1

						asset_kind: Box::new(()),

3021

1

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

3022

1

						valid_from: Some(5u32),

3023

1

}))

3024

1

));

3025

3026

1

				let payout_period =

3027

1

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

3028

1

				let expected_events = [RuntimeEvent::Treasury(

3029

1

					pallet_treasury::Event::AssetSpendApproved {

3030

1

						index: 0,

3031

1

						asset_kind: (),

3032

1

						amount: spend_amount,

3033

1

						beneficiary: spend_beneficiary,

3034

1

						valid_from: 5u32,

3035

1

						expire_at: payout_period + 5u32,

3036

1

},

3037

1

)]

3038

1

				.to_vec();

3039

1

				expect_events(expected_events);

3040

3041

4

				while System::block_number() < 5u32 {

3042

3

					next_block();

3043

3

3044

3045

1

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

3046

3047

1

				let expected_events = [

3048

1

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

3049

1

						index: 0,

3050

1

						payment_id: (),

3051

1

}),

3052

1

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

3053

1

						from: Treasury::account_id(),

3054

1

						to: spend_beneficiary,

3055

1

						amount: spend_amount,

3056

1

}),

3057

1

3058

1

				.to_vec();

3059

1

				expect_events(expected_events);

3060

1

});

3061

1

3062

3063

	#[test]

3064

1

	fn test_treasury_spend_local_with_council_origin() {

3065

1

		let initial_treasury_balance = 1_000 * UNIT;

3066

1

		ExtBuilder::default()

3067

1

			.with_balances(vec![

3068

1

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

3069

1

				(Treasury::account_id(), initial_treasury_balance),

3070

1

])

3071

1

			.build()

3072

1

			.execute_with(|| {

3073

1

				let spend_amount = 100u128 * UNIT;

3074

1

				let spend_beneficiary = AccountId::from(BOB);

3075

1

3076

1

				next_block();

3077

1

3078

1

				// TreasuryCouncilCollective

3079

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3080

1

					root_origin(),

3081

1

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

3082

1

					Some(AccountId::from(ALICE)),

3083

1

3084

1

));

3085

3086

1

				next_block();

3087

1

3088

1

				// Perform treasury spending

3089

1

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

3090

1

					amount: spend_amount,

3091

1

					asset_kind: Box::new(()),

3092

1

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

3093

1

					valid_from: Some(5u32),

3094

1

});

3095

1

				assert_ok!(TreasuryCouncilCollective::propose(

3096

1

					origin_of(AccountId::from(ALICE)),

3097

1

1,

3098

1

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

3099

1

					1_000

3100

1

));

3101

3102

1

				let payout_period =

3103

1

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

3104

1

				let expected_events = [

3105

1

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

3106

1

						index: 0,

3107

1

						asset_kind: (),

3108

1

						amount: spend_amount,

3109

1

						beneficiary: spend_beneficiary,

3110

1

						valid_from: 5u32,

3111

1

						expire_at: payout_period + 5u32,

3112

1

}),

3113

1

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

3114

1

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

3115

1

						result: Ok(()),

3116

1

}),

3117

1

3118

1

				.to_vec();

3119

1

				expect_events(expected_events);

3120

3121

3

				while System::block_number() < 5u32 {

3122

2

					next_block();

3123

2

3124

3125

1

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

3126

3127

1

				let expected_events = [

3128

1

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

3129

1

						index: 0,

3130

1

						payment_id: (),

3131

1

}),

3132

1

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

3133

1

						from: Treasury::account_id(),

3134

1

						to: spend_beneficiary,

3135

1

						amount: spend_amount,

3136

1

}),

3137

1

3138

1

				.to_vec();

3139

1

				expect_events(expected_events);

3140

1

});

3141

1

3142

3143

3144

#[cfg(test)]

3145

mod fee_tests {

3146

	use super::*;

3147

	use fp_evm::FeeCalculator;

3148

	use frame_support::{

3149

		traits::{ConstU128, OnFinalize},

3150

		weights::{ConstantMultiplier, WeightToFee},

3151

};

3152

	use moonbase_runtime::{

3153

		currency, BlockWeights, FastAdjustingFeeUpdate, LengthToFee, MinimumMultiplier,

3154

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

3155

};

3156

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

3157

3158

1

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

3159

1

	where

3160

1

		F: FnMut() -> (),

3161

1

3162

1

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

3163

1

			.build_storage()

3164

1

			.unwrap()

3165

1

			.into();

3166

1

		t.execute_with(|| {

3167

1

			System::set_block_consumed_resources(w, 0);

3168

1

			assertions()

3169

1

});

3170

1

3171

3172

	#[test]

3173

1

	fn test_multiplier_can_grow_from_zero() {

3174

1

		let minimum_multiplier = MinimumMultiplier::get();

3175

1

		let target = TargetBlockFullness::get()

3176

1

			* BlockWeights::get()

3177

1

				.get(DispatchClass::Normal)

3178

1

				.max_total

3179

1

				.unwrap();

3180

1

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

3181

1

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

3182

1

		run_with_system_weight(target * 101 / 100, || {

3183

1

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

3184

1

			assert!(

3185

1

				next > minimum_multiplier,

3186

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

3187

				next,

3188

				minimum_multiplier

3189

);

3190

1

})

3191

1

3192

3193

	#[test]

3194

1

	fn test_fee_calculation() {

3195

1

		let base_extrinsic = BlockWeights::get()

3196

1

			.get(DispatchClass::Normal)

3197

1

			.base_extrinsic;

3198

1

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

3199

1

		let extrinsic_len = 100u32;

3200

1

		let extrinsic_weight = 5_000u64;

3201

1

		let tip = 42u128;

3202

1

		type WeightToFeeImpl =

3203

1

			ConstantMultiplier<u128, ConstU128<{ moonbase_runtime::currency::WEIGHT_FEE }>>;

3204

1

		type LengthToFeeImpl = LengthToFee;

3205

1

3206

1

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

3207

1

		let expected_fee =

3208

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3209

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

3210

1

					&Weight::from_parts(extrinsic_weight, 1),

3211

1

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

3212

1

				+ tip;

3213

1

3214

1

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

3215

1

			.build_storage()

3216

1

			.unwrap()

3217

1

			.into();

3218

1

		t.execute_with(|| {

3219

1

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

3220

1

			let actual_fee = TransactionPayment::compute_fee(

3221

1

				extrinsic_len,

3222

1

				&frame_support::dispatch::DispatchInfo {

3223

1

					class: DispatchClass::Normal,

3224

1

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

3225

1

					weight: Weight::from_parts(extrinsic_weight, 1),

3226

1

},

3227

1

				tip,

3228

1

);

3229

1

3230

1

			assert_eq!(

3231

				expected_fee,

3232

				actual_fee,

3233

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

3234

				actual_fee - expected_fee

3235

);

3236

1

});

3237

1

3238

3239

	#[test]

3240

1

	fn test_min_gas_price_is_deterministic() {

3241

1

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

3242

1

			.build_storage()

3243

1

			.unwrap()

3244

1

			.into();

3245

1

		t.execute_with(|| {

3246

1

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

3247

1

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

3248

1

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

3249

1

			let expected: U256 = multiplier

3250

1

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

3251

1

				.into();

3252

1

3253

1

			assert_eq!(expected, actual);

3254

1

});

3255

1

3256

3257

	#[test]

3258

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3259

1

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

3260

1

			.build_storage()

3261

1

			.unwrap()

3262

1

			.into();

3263

1

		t.execute_with(|| {

3264

1

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

3265

1

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

3266

1

3267

1

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

3268

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3269

1

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

3270

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3271

1

3272

1

			assert_ne!(

3273

				a, b,

3274

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

3275

);

3276

1

});

3277

1

3278

3279

	#[test]

3280

1

	fn test_fee_scenarios() {

3281

1

		use sp_runtime::FixedU128;

3282

1

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

3283

1

			.build_storage()

3284

1

			.unwrap()

3285

1

			.into();

3286

1

		t.execute_with(|| {

3287

1

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

3288

12

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

3289

12

				let start_multiplier =

3290

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3291

12

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

3292

12

3293

12

				let block_weight = NORMAL_WEIGHT * fullness;

3294

3295

60004

				for i in 0..num_blocks {

3296

60004

					System::set_block_number(i as u32);

3297

60004

					System::set_block_consumed_resources(block_weight, 0);

3298

60004

					TransactionPayment::on_finalize(i as u32);

3299

60004

3300

3301

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3302

12

};

3303

3304

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

3305

			// they are expected to change when parameters that influence

3306

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

3307

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

3308

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

3309

3310

1

			assert_eq!(

3311

1

				sim(1_000_000_000, Perbill::from_percent(0), 1),

3312

1

				U256::from(998_600_980),

3313

1

);

3314

1

			assert_eq!(

3315

1

				sim(1_000_000_000, Perbill::from_percent(25), 1),

3316

1

				U256::from(999_600_080),

3317

1

);

3318

1

			assert_eq!(

3319

1

				sim(1_000_000_000, Perbill::from_percent(50), 1),

3320

1

				U256::from(1_000_600_180),

3321

1

);

3322

1

			assert_eq!(

3323

1

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

3324

1

				U256::from(1_002_603_380),

3325

1

);

3326

3327

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

3328

1

			assert_eq!(

3329

1

				sim(1_000_000_000, Perbill::from_percent(0), 600),

3330

1

				U256::from(431_710_642),

3331

1

);

3332

1

			assert_eq!(

3333

1

				sim(1_000_000_000, Perbill::from_percent(25), 600),

3334

1

				U256::from(786_627_866),

3335

1

);

3336

1

			assert_eq!(

3337

1

				sim(1_000_000_000, Perbill::from_percent(50), 600),

3338

1

				U256::from(1_433_329_383u128),

3339

1

);

3340

1

			assert_eq!(

3341

1

				sim(1_000_000_000, Perbill::from_percent(100), 600),

3342

1

				U256::from(4_758_812_897u128),

3343

1

);

3344

3345

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

3346

1

			assert_eq!(

3347

1

				sim(1_000_000_000, Perbill::from_percent(0), 14400),

3348

1

				U256::from(31_250_000), // lower bound enforced

3349

1

);

3350

1

			assert_eq!(

3351

1

				sim(1_000_000_000, Perbill::from_percent(25), 14400),

3352

1

				U256::from(31_250_000), // lower bound enforced if threshold not reached

3353

1

);

3354

1

			assert_eq!(

3355

1

				sim(1_000_000_000, Perbill::from_percent(50), 14400),

3356

1

				U256::from(5_653_326_895_069u128),

3357

1

);

3358

1

			assert_eq!(

3359

1

				sim(1_000_000_000, Perbill::from_percent(100), 14400),

3360

1

				U256::from(31_250_000_000_000u128),

3361

1

				// upper bound enforced (min_gas_price * MaximumMultiplier)

3362

1

);

3363

1

});

3364

1

3365