Grcov report - integration

1

// Copyright 2019-2025 PureStake Inc.

2

// This file is part of Moonbeam.

3

4

// Moonbeam is free software: you can redistribute it and/or modify

5

// it under the terms of the GNU General Public License as published by

6

// the Free Software Foundation, either version 3 of the License, or

7

// (at your option) any later version.

8

9

// Moonbeam is distributed in the hope that it will be useful,

10

// but WITHOUT ANY WARRANTY; without even the implied warranty of

11

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

12

// GNU General Public License for more details.

13

14

// You should have received a copy of the GNU General Public License

15

// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

16

17

//! 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

		Contains, Currency as CurrencyT, EnsureOrigin, OnInitialize, PalletInfo, StorageInfo,

34

		StorageInfoTrait,

35

},

36

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

37

	StorageHasher, Twox128,

38

};

39

use moonbase_runtime::xcm_config::{AssetHubLocation, XcmExecutor};

40

use moonbase_runtime::{

41

	moonbase_xcm_weights, xcm_config::SelfReserve, AccountId, AssetId, Balances, EvmForeignAssets,

42

	Executive, NormalFilter, OpenTechCommitteeCollective, ParachainStaking, PolkadotXcm,

43

	Precompiles, ProxyType, Runtime, RuntimeBlockWeights, RuntimeCall, RuntimeEvent, System,

44

	TransactionPayment, TransactionPaymentAsGasPrice, Treasury, TreasuryCouncilCollective,

45

	XcmTransactor, FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, WEIGHT_PER_GAS,

46

};

47

use polkadot_parachain::primitives::Sibling;

48

use precompile_utils::testing::MockHandle;

49

use sp_runtime::{

50

	traits::{Convert as XcmConvert, Dispatchable},

51

	BuildStorage, Percent,

52

};

53

use std::str::from_utf8;

54

use xcm_builder::{ParentIsPreset, SiblingParachainConvertsVia};

55

use xcm_executor::traits::ConvertLocation;

56

57

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

58

use moonbase_runtime::runtime_params::dynamic_params;

59

use moonbase_runtime::xcm_config::LocationToAccountId;

60

use moonbase_xcm_weights::XcmWeight;

61

use moonkit_xcm_primitives::AccountIdAssetIdConversion;

62

use nimbus_primitives::NimbusId;

63

use pallet_evm::PrecompileSet;

64

use pallet_moonbeam_foreign_assets::AssetStatus;

65

use pallet_parachain_staking::InflationDistributionAccount;

66

use pallet_transaction_payment::Multiplier;

67

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

68

use parity_scale_codec::Encode;

69

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

70

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

71

use std::cell::Cell;

72

use std::rc::Rc;

73

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

74

75

type AuthorMappingPCall =

76

	pallet_evm_precompile_author_mapping::AuthorMappingPrecompileCall<Runtime>;

77

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

78

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

79

	Runtime,

80

	moonbase_runtime::xcm_config::XcmExecutorConfig,

81

>;

82

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

83

/*type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

84

	Runtime,

85

	ForeignAssetInstance,

86

>;*/

87

type XcmTransactorV1PCall =

88

	pallet_evm_precompile_xcm_transactor::v1::XcmTransactorPrecompileV1Call<Runtime>;

89

type XcmTransactorV2PCall =

90

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

91

92

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

93

const BASE_FEE_GENISIS: u128 = 10 * GIGAWEI / 4;

94

95

/// Helper function to set fee per second for an asset location (for compatibility with old tests).

96

/// Converts fee_per_second to relative_price and adds/edits the asset in the weight-trader.

97

2

fn set_fee_per_second_for_location(

98

2

	location: xcm::latest::prelude::Location,

99

2

	fee_per_second: u128,

100

2

) -> Result<(), ()> {

101

	use frame_support::weights::WeightToFee as _;

102

2

	let native_amount_per_second: u128 =

103

2

		<moonbase_runtime::Runtime as pallet_xcm_weight_trader::Config>::WeightToFee::weight_to_fee(

104

2

			&Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, 0),

105

106

2

		.try_into()

107

2

		.map_err(|_| ())?;

108

2

	let precision_factor = 10u128.pow(pallet_xcm_weight_trader::RELATIVE_PRICE_DECIMALS);

109

2

	let relative_price: u128 = if fee_per_second > 0u128 {

110

2

		native_amount_per_second

111

2

			.saturating_mul(precision_factor)

112

2

			.saturating_div(fee_per_second)

113

	} else {

114

		0u128

115

};

116

2

	if pallet_xcm_weight_trader::SupportedAssets::<moonbase_runtime::Runtime>::contains_key(

117

2

		&location,

118

) {

119

1

		let enabled =

120

1

			pallet_xcm_weight_trader::SupportedAssets::<moonbase_runtime::Runtime>::get(&location)

121

1

				.ok_or(())?

122

.0;

123

1

		pallet_xcm_weight_trader::SupportedAssets::<moonbase_runtime::Runtime>::insert(

124

1

			&location,

125

1

			(enabled, relative_price),

126

);

127

1

	} else {

128

1

		pallet_xcm_weight_trader::SupportedAssets::<moonbase_runtime::Runtime>::insert(

129

1

			&location,

130

1

			(true, relative_price),

131

1

);

132

1

133

2

	Ok(())

134

2

135

136

#[test]

137

1

fn xcmp_queue_controller_origin_is_root() {

138

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

139

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

140

1

	assert_ok!(

141

1

		<moonbase_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

142

1

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

143

);

144

1

145

146

#[test]

147

1

fn verify_pallet_prefixes() {

148

29

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

149

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

150

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

151

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

152

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

153

		// expand/storage.rs#L389-L401

154

29

		assert_eq!(

155

29

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

156

29

			Some(name)

157

);

158

29

159

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

160

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

161

1

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

162

1

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

163

1

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

164

1

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

165

1

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

166

1

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

167

1

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

168

1

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

169

1

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

170

1

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

171

1

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

172

1

	is_pallet_prefix::<moonbase_runtime::OpenTechCommitteeCollective>(

173

1

		"OpenTechCommitteeCollective",

174

);

175

1

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

176

1

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

177

1

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

178

1

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

179

1

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

180

1

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

181

1

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

182

1

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

183

1

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

184

1

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

185

1

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

186

1

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

187

1

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

188

1

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

189

1

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

190

1

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

191

1

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

192

193

13

	let prefix = |pallet_name, storage_name| {

194

13

		let mut res = [0u8; 32];

195

13

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

196

13

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

197

13

		res.to_vec()

198

13

};

199

1

	assert_eq!(

200

1

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

201

1

		vec![

202

1

			StorageInfo {

203

1

				pallet_name: b"Balances".to_vec(),

204

1

				storage_name: b"TotalIssuance".to_vec(),

205

1

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

206

1

				max_values: Some(1),

207

1

				max_size: Some(16),

208

1

},

209

1

			StorageInfo {

210

1

				pallet_name: b"Balances".to_vec(),

211

1

				storage_name: b"InactiveIssuance".to_vec(),

212

1

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

213

1

				max_values: Some(1),

214

1

				max_size: Some(16),

215

1

},

216

1

			StorageInfo {

217

1

				pallet_name: b"Balances".to_vec(),

218

1

				storage_name: b"Account".to_vec(),

219

1

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

220

1

				max_values: None,

221

1

				max_size: Some(100),

222

1

},

223

1

			StorageInfo {

224

1

				pallet_name: b"Balances".to_vec(),

225

1

				storage_name: b"Locks".to_vec(),

226

1

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

227

1

				max_values: None,

228

1

				max_size: Some(1287),

229

1

},

230

1

			StorageInfo {

231

1

				pallet_name: b"Balances".to_vec(),

232

1

				storage_name: b"Reserves".to_vec(),

233

1

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

234

1

				max_values: None,

235

1

				max_size: Some(1037),

236

1

},

237

1

			StorageInfo {

238

1

				pallet_name: b"Balances".to_vec(),

239

1

				storage_name: b"Holds".to_vec(),

240

1

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

241

1

				max_values: None,

242

1

				max_size: Some(55),

243

1

},

244

1

			StorageInfo {

245

1

				pallet_name: b"Balances".to_vec(),

246

1

				storage_name: b"Freezes".to_vec(),

247

1

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

248

1

				max_values: None,

249

1

				max_size: Some(73),

250

1

},

251

252

);

253

1

	assert_eq!(

254

1

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

255

1

		vec![StorageInfo {

256

1

			pallet_name: b"Sudo".to_vec(),

257

1

			storage_name: b"Key".to_vec(),

258

1

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

259

1

			max_values: Some(1),

260

1

			max_size: Some(20),

261

1

}]

262

);

263

1

	assert_eq!(

264

1

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

265

1

		vec![

266

1

			StorageInfo {

267

1

				pallet_name: b"Proxy".to_vec(),

268

1

				storage_name: b"Proxies".to_vec(),

269

1

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

270

1

				max_values: None,

271

1

				max_size: Some(845),

272

1

},

273

1

			StorageInfo {

274

1

				pallet_name: b"Proxy".to_vec(),

275

1

				storage_name: b"Announcements".to_vec(),

276

1

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

277

1

				max_values: None,

278

1

				max_size: Some(1837),

279

1

280

281

);

282

1

	assert_eq!(

283

1

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

284

1

		vec![StorageInfo {

285

1

			pallet_name: b"MaintenanceMode".to_vec(),

286

1

			storage_name: b"MaintenanceMode".to_vec(),

287

1

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

288

1

			max_values: Some(1),

289

1

			max_size: None,

290

1

},]

291

);

292

293

1

	assert_eq!(

294

1

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

295

1

		vec![

296

1

			StorageInfo {

297

1

				pallet_name: b"RelayStorageRoots".to_vec(),

298

1

				storage_name: b"RelayStorageRoot".to_vec(),

299

1

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

300

1

				max_values: None,

301

1

				max_size: Some(44),

302

1

},

303

1

			StorageInfo {

304

1

				pallet_name: b"RelayStorageRoots".to_vec(),

305

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

306

1

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

307

1

				max_values: Some(1),

308

1

				max_size: Some(121),

309

1

},

310

311

);

312

1

313

314

#[test]

315

1

fn test_collectives_storage_item_prefixes() {

316

7

	for StorageInfo { pallet_name, .. } in

317

1

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

318

319

7

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

320

321

322

7

	for StorageInfo { pallet_name, .. } in

323

1

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

324

325

7

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

326

327

1

328

329

#[test]

330

1

fn collective_set_members_root_origin_works() {

331

1

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

332

		// TreasuryCouncilCollective

333

1

		assert_ok!(TreasuryCouncilCollective::set_members(

334

1

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

335

1

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

336

1

			Some(AccountId::from(ALICE)),

337

338

));

339

		// OpenTechCommitteeCollective

340

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

341

1

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

342

1

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

343

1

			Some(AccountId::from(ALICE)),

344

345

));

346

1

});

347

1

348

349

#[test]

350

1

fn collective_set_members_general_admin_origin_works() {

351

	use moonbase_runtime::{

352

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

353

};

354

355

1

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

356

1

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

357

1

		let alice = AccountId::from(ALICE);

358

359

		// TreasuryCouncilCollective

360

1

		let _ = Utility::dispatch_as(

361

1

			root_caller.clone(),

362

1

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

363

1

			Box::new(

364

1

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

365

1

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

366

1

					prime: Some(alice),

367

1

					old_count: 2,

368

1

369

1

				.into(),

370

1

),

371

1

);

372

		// OpenTechCommitteeCollective

373

1

		let _ = Utility::dispatch_as(

374

1

			root_caller,

375

1

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

376

1

			Box::new(

377

1

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

378

1

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

379

1

					prime: Some(alice),

380

1

					old_count: 2,

381

1

382

1

				.into(),

383

1

),

384

1

);

385

386

1

		assert_eq!(

387

1

			System::events()

388

1

				.into_iter()

389

2

				.filter_map(|r| {

390

2

					match r.event {

391

2

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

392

2

							if result.is_ok() =>

393

394

2

							Some(true)

395

396

						_ => None,

397

398

2

})

399

1

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

400

1

				.len(),

401

402

403

1

});

404

1

405

406

#[test]

407

1

fn collective_set_members_signed_origin_does_not_work() {

408

1

	let alice = AccountId::from(ALICE);

409

1

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

410

		// TreasuryCouncilCollective

411

1

		assert!(TreasuryCouncilCollective::set_members(

412

1

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

413

1

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

414

1

			Some(AccountId::from(ALICE)),

415

1

416

1

417

1

		.is_err());

418

		// OpenTechCommitteeCollective

419

1

		assert!(OpenTechCommitteeCollective::set_members(

420

1

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

421

1

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

422

1

			Some(AccountId::from(ALICE)),

423

1

424

1

425

1

		.is_err());

426

1

});

427

1

428

429

#[test]

430

1

fn verify_pallet_indices() {

431

31

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

432

31

		assert_eq!(

433

31

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

434

31

			Some(index)

435

);

436

31

437

1

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

438

1

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

439

1

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

440

1

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

441

1

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

442

1

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

443

1

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

444

1

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

445

1

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

446

1

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

447

1

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

448

1

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

449

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

450

1

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

451

1

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

452

1

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

453

1

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

454

1

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

455

1

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

456

1

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

457

1

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

458

1

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

459

1

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

460

1

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

461

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

462

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

463

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

464

1

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

465

1

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

466

1

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

467

1

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

468

1

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

469

1

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

470

1

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

471

1

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

472

1

473

474

#[test]

475

1

fn verify_reserved_indices() {

476

	use frame_metadata::*;

477

478

1

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

479

1

		.build_storage()

480

1

		.unwrap()

481

1

		.into();

482

483

1

	t.execute_with(|| {

484

1

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

485

1

		let metadata = match metadata.1 {

486

1

			RuntimeMetadata::V14(metadata) => metadata,

487

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

488

};

489

		// 35: BaseFee

490

		// 36: pallet_assets::<Instance1>

491

1

		let reserved = vec![35, 36];

492

1

		let existing = metadata

493

1

			.pallets

494

1

			.iter()

495

1

			.map(|p| p.index)

496

1

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

497

2

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

498

1

});

499

1

500

501

#[test]

502

1

fn verify_proxy_type_indices() {

503

1

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

504

1

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

505

1

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

506

1

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

507

1

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

508

1

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

509

1

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

510

1

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

511

1

512

513

// This test ensure that we not filter out pure proxy calls

514

#[test]

515

1

fn verify_normal_filter_allow_pure_proxy() {

516

1

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

517

1

		assert!(NormalFilter::contains(&RuntimeCall::Proxy(

518

1

			pallet_proxy::Call::<Runtime>::create_pure {

519

1

				proxy_type: ProxyType::Any,

520

1

				delay: 0,

521

1

				index: 0,

522

1

523

1

		)));

524

1

		assert!(NormalFilter::contains(&RuntimeCall::Proxy(

525

1

			pallet_proxy::Call::<Runtime>::kill_pure {

526

1

				spawner: AccountId::from(ALICE),

527

1

				proxy_type: ProxyType::Any,

528

1

				index: 0,

529

1

				height: 0,

530

1

				ext_index: 0,

531

1

532

1

		)));

533

1

});

534

1

535

536

#[test]

537

1

fn join_collator_candidates() {

538

1

	ExtBuilder::default()

539

1

		.with_balances(vec![

540

1

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

541

1

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

542

1

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

543

1

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

544

1

])

545

1

		.with_collators(vec![

546

1

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

547

1

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

548

1

])

549

1

		.with_delegations(vec![

550

1

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

551

1

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

552

1

])

553

1

		.build()

554

1

		.execute_with(|| {

555

1

			assert_noop!(

556

1

				ParachainStaking::join_candidates(

557

1

					origin_of(AccountId::from(ALICE)),

558

1

					1_000 * UNIT,

559

					2u32

560

),

561

1

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

562

);

563

1

			assert_noop!(

564

1

				ParachainStaking::join_candidates(

565

1

					origin_of(AccountId::from(CHARLIE)),

566

1

					1_000 * UNIT,

567

					2u32

568

),

569

1

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

570

);

571

1

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

572

1

			assert_ok!(ParachainStaking::join_candidates(

573

1

				origin_of(AccountId::from(DAVE)),

574

1

				1_000 * UNIT,

575

				2u32

576

));

577

1

			assert_eq!(

578

1

				last_event(),

579

1

				RuntimeEvent::ParachainStaking(

580

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

581

1

						account: AccountId::from(DAVE),

582

1

						amount_locked: 1_000 * UNIT,

583

1

						new_total_amt_locked: 3_100 * UNIT

584

1

585

1

586

);

587

1

			let candidates = ParachainStaking::candidate_pool();

588

1

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

589

1

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

590

1

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

591

1

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

592

1

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

593

1

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

594

1

});

595

1

596

597

#[test]

598

1

fn transfer_through_evm_to_stake() {

599

1

	ExtBuilder::default()

600

1

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

601

1

		.build()

602

1

		.execute_with(|| {

603

			// Charlie has no balance => fails to stake

604

1

			assert_noop!(

605

1

				ParachainStaking::join_candidates(

606

1

					origin_of(AccountId::from(CHARLIE)),

607

1

					1_000 * UNIT,

608

					0u32

609

),

610

1

				DispatchError::Module(ModuleError {

611

1

					index: 12,

612

1

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

613

1

					message: Some("InsufficientBalance")

614

1

})

615

);

616

617

			// Alice transfer from free balance 2000 UNIT to Bob

618

1

			assert_ok!(Balances::transfer_allow_death(

619

1

				origin_of(AccountId::from(ALICE)),

620

1

				AccountId::from(BOB),

621

1

				2_000 * UNIT,

622

));

623

1

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

624

625

1

			let gas_limit = 100000u64;

626

			// Bob transfers 1000 UNIT to Charlie via EVM

627

1

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

628

1

				source: H160::from(BOB),

629

1

				target: H160::from(CHARLIE),

630

1

				input: Vec::new(),

631

1

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

632

1

				gas_limit,

633

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

634

1

				max_priority_fee_per_gas: None,

635

1

				nonce: None,

636

1

				access_list: Vec::new(),

637

1

				authorization_list: Vec::new(),

638

1

})

639

1

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

640

1

			assert_eq!(

641

1

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

642

				1_000 * UNIT,

643

);

644

645

			// Charlie can stake now

646

1

			assert_ok!(ParachainStaking::join_candidates(

647

1

				origin_of(AccountId::from(CHARLIE)),

648

1

				1_000 * UNIT,

649

				0u32,

650

			),);

651

1

			let candidates = ParachainStaking::candidate_pool();

652

1

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

653

1

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

654

1

});

655

1

656

657

#[test]

658

1

fn reward_block_authors() {

659

1

	ExtBuilder::default()

660

1

		.with_balances(vec![

661

1

			// Alice gets 100 extra tokens for her mapping deposit

662

1

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

663

1

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

664

1

])

665

1

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

666

1

		.with_delegations(vec![(

667

1

			AccountId::from(BOB),

668

1

			AccountId::from(ALICE),

669

1

			500 * UNIT,

670

1

)])

671

1

		.with_mappings(vec![(

672

1

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

673

1

			AccountId::from(ALICE),

674

1

)])

675

1

		.build()

676

1

		.execute_with(|| {

677

1

			increase_last_relay_slot_number(1);

678

			// Just before round 3

679

1

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

680

			// no rewards doled out yet

681

1

			assert_eq!(

682

1

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

683

				1_100 * UNIT,

684

);

685

1

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

686

1

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

687

			// rewards minted and distributed

688

1

			assert_eq!(

689

1

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

690

				1213666666584000000000,

691

);

692

1

			assert_eq!(

693

1

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

694

				541333333292000000000,

695

);

696

1

});

697

1

698

699

#[test]

700

1

fn reward_block_authors_with_parachain_bond_reserved() {

701

1

	ExtBuilder::default()

702

1

		.with_balances(vec![

703

1

			// Alice gets 100 extra tokens for her mapping deposit

704

1

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

705

1

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

706

1

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

707

1

])

708

1

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

709

1

		.with_delegations(vec![(

710

1

			AccountId::from(BOB),

711

1

			AccountId::from(ALICE),

712

1

			500 * UNIT,

713

1

)])

714

1

		.with_mappings(vec![(

715

1

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

716

1

			AccountId::from(ALICE),

717

1

)])

718

1

		.build()

719

1

		.execute_with(|| {

720

1

			increase_last_relay_slot_number(1);

721

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

722

1

				root_origin(),

723

1

724

1

					InflationDistributionAccount {

725

1

						account: AccountId::from(CHARLIE),

726

1

						percent: Percent::from_percent(30),

727

1

},

728

1

					InflationDistributionAccount::default(),

729

1

730

1

				.into()

731

));

732

733

			// Stop just before round 2

734

1

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

735

736

			// no rewards doled out yet

737

1

			assert_eq!(

738

1

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

739

				1_100 * UNIT,

740

);

741

1

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

742

1

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

743

744

			// Go to round 2

745

1

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

746

747

			// 30% reserved for parachain bond

748

1

			assert_eq!(

749

1

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

750

				47515000000000000000,

751

);

752

753

			// Go to round 3

754

1

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

755

			// rewards minted and distributed

756

1

			assert_eq!(

757

1

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

758

				1182693333281650000000,

759

);

760

1

			assert_eq!(

761

1

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

762

				525841666640825000000,

763

);

764

			// 30% again reserved for parachain bond

765

1

			assert_eq!(

766

1

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

767

				94727725000000000000,

768

);

769

1

});

770

1

771

772

#[test]

773

1

fn create_and_manipulate_foreign_asset_using_root() {

774

1

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

775

1

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

776

777

		// Create foreign asset

778

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

779

1

			moonbase_runtime::RuntimeOrigin::root(),

780

1,

781

1

			source_location.clone(),

782

12,

783

1

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

784

1

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

785

));

786

1

		assert_eq!(

787

1

			EvmForeignAssets::assets_by_id(1),

788

1

			Some(source_location.clone())

789

);

790

1

		assert_eq!(

791

1

			EvmForeignAssets::assets_by_location(&source_location),

792

			Some((1, AssetStatus::Active))

793

);

794

795

		// Freeze foreign asset

796

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

797

1

			moonbase_runtime::RuntimeOrigin::root(),

798

1,

799

			true

800

));

801

1

		assert_eq!(

802

1

			EvmForeignAssets::assets_by_location(&source_location),

803

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

804

);

805

806

		// Unfreeze foreign asset

807

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

808

1

			moonbase_runtime::RuntimeOrigin::root(),

809

1,

810

));

811

1

		assert_eq!(

812

1

			EvmForeignAssets::assets_by_location(&source_location),

813

			Some((1, AssetStatus::Active))

814

);

815

1

});

816

1

817

818

#[test]

819

1

fn create_and_manipulate_foreign_asset_using_sibling() {

820

1

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

821

1

		let asset_location: Location = (Parent, Parachain(1), PalletInstance(3)).into();

822

1

		let para_location = asset_location.chain_location();

823

1

		let para_account =

824

1

			LocationToAccountId::convert_location(&para_location).expect("Cannot convert location");

825

826

1

		let deposit = dynamic_params::xcm_config::ForeignAssetCreationDeposit::get();

827

1

		Balances::make_free_balance_be(&para_account, deposit * 2);

828

829

		// Create foreign asset

830

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

831

1

			pallet_xcm::Origin::Xcm(para_location.clone()).into(),

832

1,

833

1

			asset_location.clone(),

834

12,

835

1

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

836

1

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

837

));

838

839

		// deposit is taken from the account

840

1

		assert_eq!(Balances::free_balance(&para_account), deposit);

841

842

1

		assert_eq!(

843

1

			EvmForeignAssets::assets_by_id(1),

844

1

			Some(asset_location.clone())

845

);

846

1

		assert_eq!(

847

1

			EvmForeignAssets::assets_by_location(&asset_location),

848

			Some((1, AssetStatus::Active))

849

);

850

851

		// Freeze foreign asset

852

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

853

1

			pallet_xcm::Origin::Xcm(para_location.clone()).into(),

854

1,

855

			true

856

));

857

1

		assert_eq!(

858

1

			EvmForeignAssets::assets_by_location(&asset_location),

859

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

860

);

861

862

		// Unfreeze foreign asset

863

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

864

1

			pallet_xcm::Origin::Xcm(para_location.clone()).into(),

865

1,

866

));

867

1

		assert_eq!(

868

1

			EvmForeignAssets::assets_by_location(&asset_location),

869

			Some((1, AssetStatus::Active))

870

);

871

1

});

872

1

873

874

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

875

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

876

/*

877

#[test]

878

fn xcm_asset_erc20_precompiles_supply_and_balance() {

879

	ExtBuilder::default()

880

		.with_xcm_assets(vec![XcmAssetInitialization {

881

			asset_id: 1,

882

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

883

			name: "RelayToken",

884

			symbol: "Relay",

885

			decimals: 12,

886

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

887

}])

888

		.with_balances(vec![

889

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

890

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

891

])

892

		.build()

893

		.execute_with(|| {

894

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

895

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

896

897

			// Its address is

898

			let asset_precompile_address = Runtime::asset_id_to_account(

899

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

900

				relay_asset_id,

901

);

902

903

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

904

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

905

906

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

907

			Precompiles::new()

908

				.prepare_test(

909

					ALICE,

910

					asset_precompile_address,

911

					ForeignAssetsPCall::total_supply {},

912

913

				.expect_cost(3338)

914

				.expect_no_logs()

915

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

916

917

			// Access balanceOf through precompile

918

			Precompiles::new()

919

				.prepare_test(

920

					ALICE,

921

					asset_precompile_address,

922

					ForeignAssetsPCall::balance_of {

923

						who: Address(ALICE.into()),

924

},

925

926

				.expect_cost(3338)

927

				.expect_no_logs()

928

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

929

});

930

931

932

#[test]

933

fn xcm_asset_erc20_precompiles_transfer() {

934

	ExtBuilder::default()

935

		.with_xcm_assets(vec![XcmAssetInitialization {

936

			asset_id: 1,

937

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

938

			name: "RelayToken",

939

			symbol: "Relay",

940

			decimals: 12,

941

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

942

}])

943

		.with_balances(vec![

944

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

945

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

946

])

947

		.build()

948

		.execute_with(|| {

949

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

950

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

951

952

			// Its address is

953

			let asset_precompile_address = Runtime::asset_id_to_account(

954

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

955

				relay_asset_id,

956

);

957

958

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

959

			Precompiles::new()

960

				.prepare_test(

961

					ALICE,

962

					asset_precompile_address,

963

					ForeignAssetsPCall::transfer {

964

						to: Address(BOB.into()),

965

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

966

},

967

968

				.expect_cost(24695)

969

				.expect_log(log3(

970

					asset_precompile_address,

971

					SELECTOR_LOG_TRANSFER,

972

					H160::from(ALICE),

973

					H160::from(BOB),

974

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

975

))

976

				.execute_returns(true);

977

978

			// Make sure BOB has 400 UNIT

979

			Precompiles::new()

980

				.prepare_test(

981

					BOB,

982

					asset_precompile_address,

983

					ForeignAssetsPCall::balance_of {

984

						who: Address(BOB.into()),

985

},

986

987

				.expect_cost(3338)

988

				.expect_no_logs()

989

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

990

});

991

992

993

#[test]

994

fn xcm_asset_erc20_precompiles_approve() {

995

	ExtBuilder::default()

996

		.with_xcm_assets(vec![XcmAssetInitialization {

997

			asset_id: 1,

998

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

999

			name: "RelayToken",

1000

			symbol: "Relay",

1001

			decimals: 12,

1002

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

1003

}])

1004

		.with_balances(vec![

1005

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

1006

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

1007

])

1008

		.build()

1009

		.execute_with(|| {

1010

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

1011

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

1012

1013

			// Its address is

1014

			let asset_precompile_address = Runtime::asset_id_to_account(

1015

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1016

				relay_asset_id,

1017

);

1018

1019

			// Aprove Bob for spending 400 UNIT from Alice

1020

			Precompiles::new()

1021

				.prepare_test(

1022

					ALICE,

1023

					asset_precompile_address,

1024

					ForeignAssetsPCall::approve {

1025

						spender: Address(BOB.into()),

1026

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

1027

},

1028

1029

				.expect_cost(15604)

1030

				.expect_log(log3(

1031

					asset_precompile_address,

1032

					SELECTOR_LOG_APPROVAL,

1033

					H160::from(ALICE),

1034

					H160::from(BOB),

1035

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

1036

))

1037

				.execute_returns(true);

1038

1039

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

1040

			Precompiles::new()

1041

				.prepare_test(

1042

					BOB,

1043

					asset_precompile_address,

1044

					ForeignAssetsPCall::transfer_from {

1045

						from: Address(ALICE.into()),

1046

						to: Address(CHARLIE.into()),

1047

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

1048

},

1049

1050

				.expect_cost(29960)

1051

				.expect_log(log3(

1052

					asset_precompile_address,

1053

					SELECTOR_LOG_TRANSFER,

1054

					H160::from(ALICE),

1055

					H160::from(CHARLIE),

1056

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

1057

))

1058

				.execute_returns(true);

1059

1060

			// Make sure CHARLIE has 400 UNIT

1061

			Precompiles::new()

1062

				.prepare_test(

1063

					CHARLIE,

1064

					asset_precompile_address,

1065

					ForeignAssetsPCall::balance_of {

1066

						who: Address(CHARLIE.into()),

1067

},

1068

1069

				.expect_cost(3338)

1070

				.expect_no_logs()

1071

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

1072

});

1073

}*/

1074

1075

#[test]

1076

1

fn xtokens_precompiles_transfer() {

1077

1

	ExtBuilder::default()

1078

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1079

1

			asset_id: 1,

1080

1

			xcm_location: AssetHubLocation::get(),

1081

1

			name: "RelayToken",

1082

1

			symbol: "Relay",

1083

1

			decimals: 12,

1084

1

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

1085

1

}])

1086

1

		.with_balances(vec![

1087

1

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

1088

1

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

1089

1

])

1090

1

		.with_safe_xcm_version(3)

1091

1

		.build()

1092

1

		.execute_with(|| {

1093

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1094

1095

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

1096

1

			let asset_id: AssetId = 1;

1097

1098

			// Its address is

1099

1

			let asset_precompile_address =

1100

1

				Runtime::asset_id_to_account(FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, asset_id);

1101

1102

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

1103

1

			let destination = Location::new(

1104

1,

1105

1

				[Junction::AccountId32 {

1106

1

					network: None,

1107

1

					id: [1u8; 32],

1108

1

}],

1109

);

1110

1111

1

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

1112

1

			let inside2 = inside.clone();

1113

1114

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

1115

1

			Precompiles::new()

1116

1

				.prepare_test(

1117

					ALICE,

1118

1

					xtokens_precompile_address,

1119

1

					XtokensPCall::transfer {

1120

1

						currency_address: Address(asset_precompile_address.into()),

1121

1

						amount: 500_000_000_000_000u128.into(),

1122

1

						destination,

1123

1

						weight: 4_000_000,

1124

1

},

1125

1126

1

				.expect_cost(253269)

1127

1

				.expect_no_logs()

1128

				// We expect an evm subcall ERC20.burnFrom

1129

1

				.with_subcall_handle(move |subcall| {

1130

					let Subcall {

1131

1

						address,

1132

1

						transfer,

1133

1

						input,

1134

						target_gas: _,

1135

1

						is_static,

1136

1

						context,

1137

1

					} = subcall;

1138

1139

1

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

1140

1

					assert_eq!(

1141

						address,

1142

1

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

1143

);

1144

1

					assert_eq!(is_static, false);

1145

1146

1

					assert!(transfer.is_none());

1147

1148

1

					assert_eq!(

1149

						context.address,

1150

1

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

1151

);

1152

1

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

1153

1154

1

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

1155

1

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

1156

1

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

1157

1158

1

					inside2.set(true);

1159

1160

1

					SubcallOutput {

1161

1

						output: Default::default(),

1162

1

						cost: 149_000,

1163

1

						logs: vec![],

1164

1

						..SubcallOutput::succeed()

1165

1

1166

1

})

1167

1

				.execute_returns(())

1168

1

})

1169

1

1170

1171

#[test]

1172

1

fn xtokens_precompiles_transfer_multiasset() {

1173

1

	ExtBuilder::default()

1174

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1175

1

			asset_id: 1,

1176

1

			xcm_location: AssetHubLocation::get(),

1177

1

			name: "DOT",

1178

1

			symbol: "DOT",

1179

1

			decimals: 12,

1180

1

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

1181

1

}])

1182

1

		.with_balances(vec![

1183

1

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

1184

1

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

1185

1

])

1186

1

		.with_safe_xcm_version(3)

1187

1

		.build()

1188

1

		.execute_with(|| {

1189

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1190

1191

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

1192

1

			let destination = Location::new(

1193

1,

1194

1

				[Junction::AccountId32 {

1195

1

					network: None,

1196

1

					id: [1u8; 32],

1197

1

}],

1198

);

1199

1200

1

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

1201

1

			let inside2 = inside.clone();

1202

1203

			// This time we transfer it through TransferMultiAsset

1204

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

1205

1

			Precompiles::new()

1206

1

				.prepare_test(

1207

					ALICE,

1208

1

					xtokens_precompile_address,

1209

1

					XtokensPCall::transfer_multiasset {

1210

1

						// We want to transfer DOT

1211

1

						asset: AssetHubLocation::get(),

1212

1

						amount: 500_000_000_000_000u128.into(),

1213

1

						destination,

1214

1

						weight: 4_000_000,

1215

1

},

1216

1217

1

				.expect_cost(253269)

1218

1

				.expect_no_logs()

1219

				// We expect an evm subcall ERC20.burnFrom

1220

1

				.with_subcall_handle(move |subcall| {

1221

					let Subcall {

1222

1

						address,

1223

1

						transfer,

1224

1

						input,

1225

						target_gas: _,

1226

1

						is_static,

1227

1

						context,

1228

1

					} = subcall;

1229

1230

1

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

1231

1

					assert_eq!(

1232

						address,

1233

1

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

1234

);

1235

1

					assert_eq!(is_static, false);

1236

1237

1

					assert!(transfer.is_none());

1238

1239

1

					assert_eq!(

1240

						context.address,

1241

1

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

1242

);

1243

1

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

1244

1245

1

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

1246

1

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

1247

1

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

1248

1249

1

					inside2.set(true);

1250

1251

1

					SubcallOutput {

1252

1

						output: Default::default(),

1253

1

						cost: 149_000,

1254

1

						logs: vec![],

1255

1

						..SubcallOutput::succeed()

1256

1

1257

1

})

1258

1

				.execute_returns(());

1259

1260

			// Ensure that the subcall was actually called.

1261

1

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

1262

1

})

1263

1

1264

1265

#[test]

1266

1

fn xtokens_precompiles_transfer_native() {

1267

1

	ExtBuilder::default()

1268

1

		.with_balances(vec![

1269

1

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

1270

1

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

1271

1

])

1272

1

		.with_safe_xcm_version(3)

1273

1

		.build()

1274

1

		.execute_with(|| {

1275

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1276

1277

			// Its address is

1278

1

			let asset_precompile_address = H160::from_low_u64_be(2050);

1279

1280

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

1281

1

			let destination = Location::new(

1282

1,

1283

1

				[Junction::AccountId32 {

1284

1

					network: None,

1285

1

					id: [1u8; 32],

1286

1

}],

1287

);

1288

1289

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

1290

1

			Precompiles::new()

1291

1

				.prepare_test(

1292

					ALICE,

1293

1

					xtokens_precompile_address,

1294

1

					XtokensPCall::transfer {

1295

1

						currency_address: Address(asset_precompile_address),

1296

1

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

1297

1

						destination,

1298

1

						weight: 4_000_000,

1299

1

},

1300

1301

1

				.expect_cost(101669)

1302

1

				.expect_no_logs()

1303

1

				.execute_returns(());

1304

1

})

1305

1

1306

1307

1

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

1308

1

where

1309

1

	F: FnMut() -> (),

1310

1311

1

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

1312

1

		.build_storage()

1313

1

		.unwrap()

1314

1

		.into();

1315

1

	t.execute_with(|| {

1316

1

		System::set_block_consumed_resources(w, 0);

1317

1

		assertions()

1318

1

});

1319

1

1320

1321

#[test]

1322

#[rustfmt::skip]

1323

1

fn length_fee_is_sensible() {

1324

	use sp_runtime::testing::TestXt;

1325

1326

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

1327

1

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

1328

1

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

1329

1

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

1330

1331

9

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

1332

9

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

1333

9

				.inclusion_fee

1334

9

				.expect("fee should be calculated")

1335

9

				.len_fee

1336

9

};

1337

1338

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

1339

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

1340

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

1341

		//                             |           |

1342

1

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

1343

1

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

1344

1

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

1345

1

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

1346

1

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

1347

1

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

1348

1

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

1349

1

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

1350

1

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

1351

1

});

1352

1

1353

1354

#[test]

1355

1

fn multiplier_can_grow_from_zero() {

1356

	use frame_support::traits::Get;

1357

1358

1

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

1359

1

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

1360

1

		* RuntimeBlockWeights::get()

1361

1

			.get(DispatchClass::Normal)

1362

1

			.max_total

1363

1

			.unwrap();

1364

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

1365

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

1366

1

	run_with_system_weight(target * 101 / 100, || {

1367

1

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

1368

1

		assert!(

1369

1

			next > minimum_multiplier,

1370

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

1371

			next,

1372

			minimum_multiplier

1373

);

1374

1

})

1375

1

1376

1377

#[test]

1378

1

fn ethereum_invalid_transaction() {

1379

1

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

1380

1

		set_parachain_inherent_data();

1381

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

1382

		// on chain is rejected.

1383

1

		assert_eq!(

1384

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1385

			Err(

1386

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1387

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

1388

1389

1390

);

1391

1

});

1392

1

1393

1394

#[test]

1395

1

fn transfer_ed_0_substrate() {

1396

1

	ExtBuilder::default()

1397

1

		.with_balances(vec![

1398

1

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

1399

1

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

1400

1

])

1401

1

		.build()

1402

1

		.execute_with(|| {

1403

			// Substrate transfer

1404

1

			assert_ok!(Balances::transfer_allow_death(

1405

1

				origin_of(AccountId::from(ALICE)),

1406

1

				AccountId::from(BOB),

1407

1

				1 * UNIT,

1408

));

1409

			// 1 WEI is left in the account

1410

1

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

1411

1

});

1412

1

1413

1414

#[test]

1415

1

fn initial_gas_fee_is_correct() {

1416

	use fp_evm::FeeCalculator;

1417

1418

1

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

1419

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1420

1

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

1421

1422

1

		assert_eq!(

1423

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1424

1

1425

1

				2_500_000_000u128.into(),

1426

1

				Weight::from_parts(<Runtime as frame_system::Config>::DbWeight::get().read, 0)

1427

1

1428

);

1429

1

});

1430

1

1431

1432

#[test]

1433

1

fn transfer_ed_0_evm() {

1434

1

	ExtBuilder::default()

1435

1

		.with_balances(vec![

1436

1

1437

1

				AccountId::from(ALICE),

1438

1

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

1439

1

),

1440

1

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

1441

1

])

1442

1

		.build()

1443

1

		.execute_with(|| {

1444

1

			set_parachain_inherent_data();

1445

			// EVM transfer

1446

1

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

1447

1

				source: H160::from(ALICE),

1448

1

				target: H160::from(BOB),

1449

1

				input: Vec::new(),

1450

1

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

1451

1

				gas_limit: 21_000u64,

1452

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1453

1

				max_priority_fee_per_gas: None,

1454

1

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

1455

1

				access_list: Vec::new(),

1456

1

				authorization_list: Vec::new(),

1457

1

})

1458

1

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

1459

			// 1 WEI is left in the account

1460

1

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

1461

1

});

1462

1

1463

1464

#[test]

1465

1

fn refund_ed_0_evm() {

1466

1

	ExtBuilder::default()

1467

1

		.with_balances(vec![

1468

1

1469

1

				AccountId::from(ALICE),

1470

1

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

1471

1

),

1472

1

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

1473

1

])

1474

1

		.build()

1475

1

		.execute_with(|| {

1476

			// EVM transfer that zeroes ALICE

1477

1

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

1478

1

				source: H160::from(ALICE),

1479

1

				target: H160::from(BOB),

1480

1

				input: Vec::new(),

1481

1

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

1482

1

				gas_limit: 21_777u64,

1483

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1484

1

				max_priority_fee_per_gas: None,

1485

1

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

1486

1

				access_list: Vec::new(),

1487

1

				authorization_list: Vec::new(),

1488

1

})

1489

1

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

1490

			// ALICE is refunded

1491

1

			assert_eq!(

1492

1

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

1493

1

				777 * BASE_FEE_GENISIS + existential_deposit(),

1494

);

1495

1

});

1496

1

1497

1498

#[test]

1499

1

fn author_does_receive_priority_fee() {

1500

1

	ExtBuilder::default()

1501

1

		.with_balances(vec![(

1502

1

			AccountId::from(BOB),

1503

1

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

1504

1

)])

1505

1

		.build()

1506

1

		.execute_with(|| {

1507

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

1508

1

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

1509

1

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

1510

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

1511

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

1512

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

1513

1

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

1514

1515

			// EVM transfer.

1516

1

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

1517

1

				source: H160::from(BOB),

1518

1

				target: H160::from(ALICE),

1519

1

				input: Vec::new(),

1520

1

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

1521

1

				gas_limit: 21_000u64,

1522

1

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

1523

1

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

1524

1

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

1525

1

				access_list: Vec::new(),

1526

1

				authorization_list: Vec::new(),

1527

1

})

1528

1

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

1529

1530

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1531

			// Author free balance increased by priority fee.

1532

1

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

1533

1

});

1534

1

1535

1536

#[test]

1537

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1538

1

	ExtBuilder::default()

1539

1

		.with_balances(vec![

1540

1

1541

1

				AccountId::from(BOB),

1542

1

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

1543

1

),

1544

1

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

1545

1

1546

1

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

1547

1

				existential_deposit(),

1548

1

),

1549

1

])

1550

1

		.build()

1551

1

		.execute_with(|| {

1552

1

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

1553

1

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

1554

1

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

1555

			// EVM transfer.

1556

1

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

1557

1

				source: H160::from(BOB),

1558

1

				target: H160::from(ALICE),

1559

1

				input: Vec::new(),

1560

1

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

1561

1

				gas_limit: 21_000u64,

1562

1

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

1563

1

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

1564

1

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

1565

1

				access_list: Vec::new(),

1566

1

				authorization_list: Vec::new(),

1567

1

})

1568

1

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

1569

1570

1

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

1571

1572

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

1573

1574

1

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

1575

1576

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

1577

1

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

1578

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1579

1580

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1581

1582

1

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

1583

1

});

1584

1

1585

1586

#[test]

1587

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1588

	use fp_evm::FeeCalculator;

1589

1

	ExtBuilder::default()

1590

1

		.with_balances(vec![

1591

1

1592

1

				AccountId::from(BOB),

1593

1

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

1594

1

),

1595

1

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

1596

1

1597

1

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

1598

1

				existential_deposit(),

1599

1

),

1600

1

])

1601

1

		.build()

1602

1

		.execute_with(|| {

1603

1

			set_parachain_inherent_data();

1604

1

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

1605

			// EVM transfer.

1606

1

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

1607

1

				source: H160::from(BOB),

1608

1

				target: H160::from(ALICE),

1609

1

				input: Vec::new(),

1610

1

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

1611

1

				gas_limit: 21_000u64,

1612

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1613

1

				max_priority_fee_per_gas: None,

1614

1

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

1615

1

				access_list: Vec::new(),

1616

1

				authorization_list: Vec::new(),

1617

1

})

1618

1

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

1619

1620

1

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

1621

			// Fee is 1 GWEI base fee.

1622

1

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

1623

1

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

1624

1625

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

1626

1627

1

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

1628

1629

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

1630

1

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

1631

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1632

1633

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1634

1635

1

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

1636

1

});

1637

1

1638

1639

#[test]

1640

1

fn root_can_change_default_xcm_vers() {

1641

1

	ExtBuilder::default()

1642

1

		.with_balances(vec![

1643

1

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

1644

1

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

1645

1

])

1646

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1647

1

			asset_id: 1,

1648

1

			xcm_location: AssetHubLocation::get(),

1649

1

			name: "Dot",

1650

1

			symbol: "Dot",

1651

1

			decimals: 12,

1652

1

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

1653

1

}])

1654

1

		.build()

1655

1

		.execute_with(|| {

1656

1

			let source_id: moonbase_runtime::AssetId = 1;

1657

1

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

1658

1

			let asset = Asset {

1659

1

				id: AssetId(

1660

1

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

1661

1

						currency_id,

1662

1

1663

1

					.unwrap(),

1664

1

),

1665

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1666

1

};

1667

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

1668

			// know with which version to send

1669

1

			assert_noop!(

1670

1

				PolkadotXcm::transfer_assets(

1671

1

					origin_of(AccountId::from(ALICE)),

1672

1

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

1673

1

					Box::new(VersionedLocation::from(Location {

1674

1

						parents: 0,

1675

1

						interior: [AccountId32 {

1676

1

							network: None,

1677

1

							id: [1u8; 32],

1678

1

}]

1679

1

						.into(),

1680

1

					})),

1681

1

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

1682

0,

1683

1

					WeightLimit::Unlimited,

1684

),

1685

1

				pallet_xcm::Error::<Runtime>::LocalExecutionIncompleteWithError {

1686

1

					index: 2,

1687

1

					error: pallet_xcm::ExecutionError::DestinationUnsupported

1688

1

1689

);

1690

1691

			// Root sets the defaultXcm

1692

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1693

1

				root_origin(),

1694

1

				Some(5)

1695

));

1696

1697

			// Now transferring does not fail

1698

1

			assert_ok!(PolkadotXcm::transfer_assets(

1699

1

				origin_of(AccountId::from(ALICE)),

1700

1

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

1701

1

				Box::new(VersionedLocation::from(Location {

1702

1

					parents: 0,

1703

1

					interior: [AccountId32 {

1704

1

						network: None,

1705

1

						id: [1u8; 32],

1706

1

}]

1707

1

					.into(),

1708

1

				})),

1709

1

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

1710

0,

1711

1

				WeightLimit::Unlimited

1712

));

1713

1

})

1714

1

1715

1716

#[test]

1717

1

fn transactor_cannot_use_more_than_max_weight() {

1718

1

	ExtBuilder::default()

1719

1

		.with_balances(vec![

1720

1

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

1721

1

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

1722

1

])

1723

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1724

1

			asset_id: 1,

1725

1

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

1726

1

			name: "RelayToken",

1727

1

			symbol: "Relay",

1728

1

			decimals: 12,

1729

1

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

1730

1

}])

1731

1

		.build()

1732

1

		.execute_with(|| {

1733

1

			let source_id: moonbase_runtime::AssetId = 1;

1734

1

			assert_ok!(XcmTransactor::register(

1735

1

				root_origin(),

1736

1

				AccountId::from(ALICE),

1737

0,

1738

));

1739

1740

			// Root can set transact info

1741

1

			assert_ok!(XcmTransactor::set_transact_info(

1742

1

				root_origin(),

1743

1

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

1744

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

1745

1

				3000.into(),

1746

1

				20000.into(),

1747

1

				None

1748

));

1749

			// Set fee per second using weight-trader (replaces old set_fee_per_second)

1750

1

			set_fee_per_second_for_location(xcm::latest::prelude::Location::parent(), 1)

1751

1

				.expect("must succeed");

1752

1753

1

			assert_noop!(

1754

1

				XcmTransactor::transact_through_derivative(

1755

1

					origin_of(AccountId::from(ALICE)),

1756

1

					moonbase_runtime::xcm_config::Transactors::Relay,

1757

0,

1758

1

					CurrencyPayment {

1759

1

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

1760

1

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

1761

1

)),

1762

1

						fee_amount: None

1763

1

},

1764

1

					vec![],

1765

					// 20000 is the max

1766

1

					TransactWeights {

1767

1

						transact_required_weight_at_most: 17001.into(),

1768

1

						overall_weight: None

1769

1

},

1770

					false

1771

),

1772

1

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

1773

);

1774

1

			assert_noop!(

1775

1

				XcmTransactor::transact_through_derivative(

1776

1

					origin_of(AccountId::from(ALICE)),

1777

1

					moonbase_runtime::xcm_config::Transactors::Relay,

1778

0,

1779

1

					CurrencyPayment {

1780

1

						currency: Currency::AsCurrencyId(

1781

1

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

1782

1

),

1783

1

						fee_amount: None

1784

1

},

1785

1

					vec![],

1786

					// 20000 is the max

1787

1

					TransactWeights {

1788

1

						transact_required_weight_at_most: 17001.into(),

1789

1

						overall_weight: None

1790

1

},

1791

					false

1792

),

1793

1

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

1794

);

1795

1

})

1796

1

1797

1798

#[test]

1799

1

fn root_can_use_hrmp_manage() {

1800

1

	ExtBuilder::default()

1801

1

		.with_balances(vec![

1802

1

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

1803

1

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

1804

1

])

1805

1

		.build()

1806

1

		.execute_with(|| {

1807

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

1808

			// But all rest checks pass

1809

1

			assert_noop!(

1810

1

				XcmTransactor::hrmp_manage(

1811

1

					root_origin(),

1812

1

					HrmpOperation::Accept {

1813

1

						para_id: 2000u32.into()

1814

1

},

1815

1

					CurrencyPayment {

1816

1

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

1817

1

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

1818

1

)),

1819

1

						fee_amount: Some(10000)

1820

1

},

1821

					// 20000 is the max

1822

1

					TransactWeights {

1823

1

						transact_required_weight_at_most: 17001.into(),

1824

1

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

1825

1

1826

),

1827

1

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

1828

);

1829

1

})

1830

1

1831

1832

#[test]

1833

1

fn transact_through_signed_precompile_works_v1() {

1834

1

	ExtBuilder::default()

1835

1

		.with_balances(vec![

1836

1

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

1837

1

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

1838

1

])

1839

1

		.with_safe_xcm_version(3)

1840

1

		.build()

1841

1

		.execute_with(|| {

1842

			// Destination

1843

1

			let dest = Location::parent();

1844

1845

1

			let fee_payer_asset = Location::parent();

1846

1847

1

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

1848

1849

1

			let xcm_transactor_v1_precompile_address = H160::from_low_u64_be(2054);

1850

1851

			// Root can set transact info

1852

1

			assert_ok!(XcmTransactor::set_transact_info(

1853

1

				root_origin(),

1854

1

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

1855

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

1856

1

				3000.into(),

1857

1

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

1858

1

				Some(4000.into())

1859

));

1860

1861

			// Set fee per second using weight-trader (replaces old set_fee_per_second).

1862

			// With the new FeeTrader semantics, very small `fee_per_second` values combined

1863

			// with small weights can legitimately produce a zero fee, which the relay-chain

1864

			// XCM barrier rejects. To keep the v1 precompile test meaningful while adapting

1865

			// to the new semantics, we choose a `fee_per_second` large enough that the

1866

			// computed fee for this test's weight (15_000) is at least 1 unit.

1867

1

			set_fee_per_second_for_location(

1868

1

				xcm::latest::prelude::Location::parent(),

1869

				100_000_000, // any value >= WEIGHT_REF_TIME_PER_SECOND / 15_000 works

1870

1871

1

			.expect("must succeed");

1872

1873

1

			Precompiles::new()

1874

1

				.prepare_test(

1875

					ALICE,

1876

1

					xcm_transactor_v1_precompile_address,

1877

1

					XcmTransactorV1PCall::transact_through_signed_multilocation {

1878

1

						dest,

1879

1

						fee_asset: fee_payer_asset,

1880

1

						weight: 15000,

1881

1

						call: bytes.into(),

1882

1

},

1883

1884

1

				.expect_cost(31105)

1885

1

				.expect_no_logs()

1886

1

				.execute_returns(());

1887

1

});

1888

1

1889

1890

#[test]

1891

1

fn transact_through_signed_precompile_works_v2() {

1892

1

	ExtBuilder::default()

1893

1

		.with_balances(vec![

1894

1

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

1895

1

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

1896

1

])

1897

1

		.with_safe_xcm_version(3)

1898

1

		.build()

1899

1

		.execute_with(|| {

1900

			// Destination

1901

1

			let dest = Location::parent();

1902

1903

1

			let fee_payer_asset = Location::parent();

1904

1905

1

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

1906

1907

1

			let total_weight = 1_000_000_000u64;

1908

1909

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1910

1911

1

			Precompiles::new()

1912

1

				.prepare_test(

1913

					ALICE,

1914

1

					xcm_transactor_v2_precompile_address,

1915

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1916

1

						dest,

1917

1

						fee_asset: fee_payer_asset,

1918

1

						weight: 4_000_000,

1919

1

						call: bytes.into(),

1920

1

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

1921

1

						overall_weight: total_weight,

1922

1

},

1923

1924

1

				.expect_cost(31105)

1925

1

				.expect_no_logs()

1926

1

				.execute_returns(());

1927

1

});

1928

1

1929

1930

#[test]

1931

1

fn transact_through_signed_cannot_send_to_local_chain() {

1932

1

	ExtBuilder::default()

1933

1

		.with_balances(vec![

1934

1

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

1935

1

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

1936

1

])

1937

1

		.with_safe_xcm_version(3)

1938

1

		.build()

1939

1

		.execute_with(|| {

1940

			// Destination

1941

1

			let dest = Location::here();

1942

1943

1

			let fee_payer_asset = Location::parent();

1944

1945

1

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

1946

1947

1

			let total_weight = 1_000_000_000u64;

1948

1949

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1950

1951

1

			Precompiles::new()

1952

1

				.prepare_test(

1953

					ALICE,

1954

1

					xcm_transactor_v2_precompile_address,

1955

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1956

1

						dest,

1957

1

						fee_asset: fee_payer_asset,

1958

1

						weight: 4_000_000,

1959

1

						call: bytes.into(),

1960

1

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

1961

1

						overall_weight: total_weight,

1962

1

},

1963

1964

1

				.execute_reverts(|output| {

1965

1

					from_utf8(&output)

1966

1

						.unwrap()

1967

1

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

1968

1

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

1969

1

});

1970

1

});

1971

1

1972

1973

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

1974

#[test]

1975

1

fn account_id_32_encodes_like_32_byte_u8_slice() {

1976

1

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

1977

1

	let account_as_slice = [1u8; 32];

1978

1

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

1979

1

1980

1981

#[test]

1982

1

fn author_mapping_precompile_associate_update_and_clear() {

1983

1

	ExtBuilder::default()

1984

1

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

1985

1

		.build()

1986

1

		.execute_with(|| {

1987

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

1988

1

			let first_nimbus_id: NimbusId =

1989

1

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

1990

1

			let first_vrf_id: session_keys_primitives::VrfId =

1991

1

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

1992

1

			let second_nimbus_id: NimbusId =

1993

1

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

1994

1

			let second_vrf_id: session_keys_primitives::VrfId =

1995

1

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

1996

1997

			// Associate it

1998

1

			Precompiles::new()

1999

1

				.prepare_test(

2000

					ALICE,

2001

1

					author_mapping_precompile_address,

2002

1

					AuthorMappingPCall::add_association {

2003

1

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

2004

1

},

2005

2006

1

				.expect_cost(19931)

2007

1

				.expect_no_logs()

2008

1

				.execute_returns(());

2009

2010

1

			let expected_associate_event =

2011

1

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

2012

1

					nimbus_id: first_nimbus_id.clone(),

2013

1

					account_id: AccountId::from(ALICE),

2014

1

					keys: first_vrf_id.clone(),

2015

1

});

2016

1

			assert_eq!(last_event(), expected_associate_event);

2017

2018

			// Update it

2019

1

			Precompiles::new()

2020

1

				.prepare_test(

2021

					ALICE,

2022

1

					author_mapping_precompile_address,

2023

1

					AuthorMappingPCall::update_association {

2024

1

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

2025

1

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

2026

1

},

2027

2028

1

				.expect_cost(19448)

2029

1

				.expect_no_logs()

2030

1

				.execute_returns(());

2031

2032

1

			let expected_update_event =

2033

1

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

2034

1

					new_nimbus_id: second_nimbus_id.clone(),

2035

1

					account_id: AccountId::from(ALICE),

2036

1

					new_keys: second_vrf_id.clone(),

2037

1

});

2038

1

			assert_eq!(last_event(), expected_update_event);

2039

2040

			// Clear it

2041

1

			Precompiles::new()

2042

1

				.prepare_test(

2043

					ALICE,

2044

1

					author_mapping_precompile_address,

2045

1

					AuthorMappingPCall::clear_association {

2046

1

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

2047

1

},

2048

2049

1

				.expect_cost(19942)

2050

1

				.expect_no_logs()

2051

1

				.execute_returns(());

2052

2053

1

			let expected_clear_event =

2054

1

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

2055

1

					nimbus_id: second_nimbus_id,

2056

1

					account_id: AccountId::from(ALICE),

2057

1

					keys: second_vrf_id,

2058

1

});

2059

1

			assert_eq!(last_event(), expected_clear_event);

2060

1

});

2061

1

2062

2063

#[test]

2064

1

fn author_mapping_register_and_set_keys() {

2065

1

	ExtBuilder::default()

2066

1

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

2067

1

		.build()

2068

1

		.execute_with(|| {

2069

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2070

1

			let first_nimbus_id: NimbusId =

2071

1

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

2072

1

			let first_vrf_key: session_keys_primitives::VrfId =

2073

1

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

2074

1

			let second_nimbus_id: NimbusId =

2075

1

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

2076

1

			let second_vrf_key: session_keys_primitives::VrfId =

2077

1

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

2078

2079

			// Associate it

2080

1

			Precompiles::new()

2081

1

				.prepare_test(

2082

					ALICE,

2083

1

					author_mapping_precompile_address,

2084

1

					AuthorMappingPCall::set_keys {

2085

1

						keys: solidity::encode_arguments((

2086

1

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

2087

1

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

2088

1

))

2089

1

						.into(),

2090

1

},

2091

2092

1

				.expect_cost(22448)

2093

1

				.expect_no_logs()

2094

1

				.execute_returns(());

2095

2096

1

			let expected_associate_event =

2097

1

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

2098

1

					nimbus_id: first_nimbus_id.clone(),

2099

1

					account_id: AccountId::from(ALICE),

2100

1

					keys: first_vrf_key.clone(),

2101

1

});

2102

1

			assert_eq!(last_event(), expected_associate_event);

2103

2104

			// Update it

2105

1

			Precompiles::new()

2106

1

				.prepare_test(

2107

					ALICE,

2108

1

					author_mapping_precompile_address,

2109

1

					AuthorMappingPCall::set_keys {

2110

1

						keys: solidity::encode_arguments((

2111

1

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

2112

1

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

2113

1

))

2114

1

						.into(),

2115

1

},

2116

2117

1

				.expect_cost(22448)

2118

1

				.expect_no_logs()

2119

1

				.execute_returns(());

2120

2121

1

			let expected_update_event =

2122

1

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

2123

1

					new_nimbus_id: second_nimbus_id.clone(),

2124

1

					account_id: AccountId::from(ALICE),

2125

1

					new_keys: second_vrf_key.clone(),

2126

1

});

2127

1

			assert_eq!(last_event(), expected_update_event);

2128

1

});

2129

1

2130

2131

#[test]

2132

1

fn test_xcm_utils_ml_tp_account() {

2133

1

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

2134

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2135

1

		let expected_address_parent: H160 =

2136

1

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

2137

1

				.unwrap()

2138

1

				.into();

2139

2140

1

		Precompiles::new()

2141

1

			.prepare_test(

2142

				ALICE,

2143

1

				xcm_utils_precompile_address,

2144

1

				XcmUtilsPCall::multilocation_to_address {

2145

1

					location: Location::parent(),

2146

1

},

2147

2148

1

			.expect_cost(

2149

1

				<Runtime as frame_system::Config>::DbWeight::get()

2150

1

					.read

2151

1

					.saturating_div(WEIGHT_PER_GAS)

2152

1

					.saturating_mul(2),

2153

2154

1

			.expect_no_logs()

2155

1

			.execute_returns(Address(expected_address_parent));

2156

2157

1

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

2158

1

		let expected_address_parachain: H160 =

2159

1

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

2160

1

				&parachain_2000_multilocation,

2161

2162

1

			.unwrap()

2163

1

			.into();

2164

2165

1

		Precompiles::new()

2166

1

			.prepare_test(

2167

				ALICE,

2168

1

				xcm_utils_precompile_address,

2169

1

				XcmUtilsPCall::multilocation_to_address {

2170

1

					location: parachain_2000_multilocation,

2171

1

},

2172

2173

1

			.expect_cost(

2174

1

				<Runtime as frame_system::Config>::DbWeight::get()

2175

1

					.read

2176

1

					.saturating_div(WEIGHT_PER_GAS)

2177

1

					.saturating_mul(2),

2178

2179

1

			.expect_no_logs()

2180

1

			.execute_returns(Address(expected_address_parachain));

2181

2182

1

		let alice_in_parachain_2000_multilocation = Location::new(

2183

1,

2184

1

2185

1

				Parachain(2000),

2186

1

				AccountKey20 {

2187

1

					network: None,

2188

1

					key: ALICE,

2189

1

},

2190

1

],

2191

);

2192

1

		let expected_address_alice_in_parachain_2000 =

2193

1

			xcm_builder::HashedDescription::<

2194

1

				AccountId,

2195

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2196

1

			>::convert_location(&alice_in_parachain_2000_multilocation)

2197

1

			.unwrap()

2198

1

			.into();

2199

2200

1

		Precompiles::new()

2201

1

			.prepare_test(

2202

				ALICE,

2203

1

				xcm_utils_precompile_address,

2204

1

				XcmUtilsPCall::multilocation_to_address {

2205

1

					location: alice_in_parachain_2000_multilocation,

2206

1

},

2207

2208

1

			.expect_cost(

2209

1

				<Runtime as frame_system::Config>::DbWeight::get()

2210

1

					.read

2211

1

					.saturating_div(WEIGHT_PER_GAS)

2212

1

					.saturating_mul(2),

2213

2214

1

			.expect_no_logs()

2215

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2216

1

});

2217

1

2218

2219

#[test]

2220

1

fn test_nested_batch_calls_from_xcm_transact() {

2221

1

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

2222

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2223

		// in a future polkadot-sdk version

2224

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2225

2226

1

		let mut valid_nested_calls =

2227

1

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

2228

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2229

8

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

2230

8

				calls: vec![valid_nested_calls],

2231

8

});

2232

8

2233

2234

1

		let valid_message = Xcm(vec![Transact {

2235

1

			origin_kind: OriginKind::SovereignAccount,

2236

1

			fallback_max_weight: None,

2237

1

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

2238

1

		}]);

2239

2240

1

		assert!(XcmExecutor::prepare(valid_message, Weight::MAX).is_ok());

2241

2242

1

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

2243

1

			calls: vec![valid_nested_calls],

2244

1

});

2245

2246

1

		let invalid_message = Xcm(vec![Transact {

2247

1

			origin_kind: OriginKind::SovereignAccount,

2248

1

			fallback_max_weight: None,

2249

1

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

2250

1

		}]);

2251

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

2252

1

		assert!(XcmExecutor::prepare(invalid_message, Weight::MAX).is_err());

2253

1

});

2254

1

2255

2256

#[test]

2257

1

fn test_xcm_utils_weight_message() {

2258

1

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

2259

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2260

1

		let expected_weight =

2261

1

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

2262

2263

1

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

2264

2265

1

		let input = XcmUtilsPCall::weight_message {

2266

1

			message: message.into(),

2267

1

};

2268

2269

1

		Precompiles::new()

2270

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2271

1

			.expect_cost(

2272

1

				<Runtime as frame_system::Config>::DbWeight::get()

2273

1

					.read

2274

1

					.saturating_div(WEIGHT_PER_GAS),

2275

2276

1

			.expect_no_logs()

2277

1

			.execute_returns(expected_weight);

2278

1

});

2279

1

2280

2281

#[test]

2282

1

fn test_xcm_utils_get_units_per_second() {

2283

1

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

2284

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2285

1

		let location = SelfReserve::get();

2286

2287

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2288

2289

1

		let expected_units =

2290

1

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

2291

2292

1

		Precompiles::new()

2293

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2294

1

			.expect_cost(

2295

1

				<Runtime as frame_system::Config>::DbWeight::get()

2296

1

					.read

2297

1

					.saturating_div(WEIGHT_PER_GAS)

2298

1

					.saturating_mul(2),

2299

2300

1

			.expect_no_logs()

2301

1

			.execute_returns(expected_units);

2302

1

});

2303

1

2304

2305

#[test]

2306

1

fn precompile_existence() {

2307

1

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

2308

1

		let precompiles = Precompiles::new();

2309

1

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

2310

			1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 256, 1024, 1025, 1026, 1027,

2311

			2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061,

2312

			2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074,

2313

2314

1

		.into_iter()

2315

1

		.map(H160::from_low_u64_be)

2316

1

		.collect();

2317

2318

3001

		for i in 0..3000 {

2319

3000

			let address = H160::from_low_u64_be(i);

2320

2321

3000

			if precompile_addresses.contains(&address) {

2322

48

				assert!(

2323

48

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

2324

					"is_precompile({}) should return true",

2325

2326

);

2327

2328

48

				assert!(

2329

48

					precompiles

2330

48

						.execute(&mut MockHandle::new(

2331

48

							address,

2332

48

							Context {

2333

48

								address,

2334

48

								caller: H160::zero(),

2335

48

								apparent_value: U256::zero()

2336

48

2337

48

),)

2338

48

						.is_some(),

2339

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

2340

2341

);

2342

			} else {

2343

2952

				assert!(

2344

2952

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

2345

					"is_precompile({}) should return false",

2346

2347

);

2348

2349

2952

				assert!(

2350

2952

					precompiles

2351

2952

						.execute(&mut MockHandle::new(

2352

2952

							address,

2353

2952

							Context {

2354

2952

								address,

2355

2952

								caller: H160::zero(),

2356

2952

								apparent_value: U256::zero()

2357

2952

2358

2952

),)

2359

2952

						.is_none(),

2360

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

2361

2362

);

2363

2364

2365

1

});

2366

1

2367

2368

#[test]

2369

1

fn removed_precompiles() {

2370

1

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

2371

1

		let precompiles = Precompiles::new();

2372

1

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

2373

2374

3000

		for i in 1..3000 {

2375

2999

			let address = H160::from_low_u64_be(i);

2376

2377

2999

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

2378

2951

				continue;

2379

48

2380

2381

48

			if !removed_precompiles.contains(&i) {

2382

43

				assert!(

2383

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2384

43

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

2385

						_ => false,

2386

},

2387

					"{i} should be an active precompile"

2388

);

2389

43

				continue;

2390

5

2391

2392

5

			assert!(

2393

5

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

2394

5

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

2395

					_ => false,

2396

},

2397

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

2398

);

2399

2400

5

			precompiles

2401

5

				.prepare_test(Alice, address, [])

2402

5

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

2403

2404

1

})

2405

1

2406

2407

#[test]

2408

1

fn substrate_based_fees_zero_txn_costs_only_base_extrinsic() {

2409

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

2410

	use moonbase_runtime::{currency, EXTRINSIC_BASE_WEIGHT};

2411

2412

1

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

2413

1

		let size_bytes = 0;

2414

1

		let tip = 0;

2415

1

		let dispatch_info = DispatchInfo {

2416

1

			class: DispatchClass::Normal,

2417

1

			pays_fee: Pays::Yes,

2418

1

			call_weight: Weight::zero(),

2419

1

			extension_weight: Weight::zero(),

2420

1

};

2421

2422

1

		assert_eq!(

2423

1

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

2424

1

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

2425

);

2426

1

});

2427

1

2428

2429

#[test]

2430

1

fn deal_with_fees_handles_tip() {

2431

	use frame_support::traits::OnUnbalanced;

2432

	use moonbase_runtime::Treasury;

2433

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2434

2435

1

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

2436

1

		set_parachain_inherent_data();

2437

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

2438

		// in the Moonbeam runtime. It verifies that:

2439

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

2440

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

2441

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

2442

2443

		// The test details:

2444

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

2445

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

2446

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

2447

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

2448

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

2449

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

2450

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

2451

2452

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

2453

1

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

2454

1

			AccountId,

2455

1

		>>::issue(100);

2456

1

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

2457

1

			AccountId,

2458

1

		>>::issue(1000);

2459

2460

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

2461

1

		let total_supply_before = Balances::total_issuance();

2462

1

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

2463

1

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

2464

1

		assert_eq!(total_supply_before, 1_100);

2465

1

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

2466

2467

		// Step 3: Execute the fees handling logic.

2468

1

		DealWithSubstrateFeesAndTip::<

2469

1

			Runtime,

2470

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2471

1

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

2472

2473

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

2474

1

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

2475

2476

1

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

2477

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2478

2479

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

2480

1

		assert_eq!(

2481

1

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

2482

			treasury_fee_part,

2483

);

2484

2485

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

2486

1

		let total_supply_after = Balances::total_issuance();

2487

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2488

2489

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

2490

1

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

2491

1

		assert_eq!(

2492

1

			block_author_balance_after - block_author_balance_before,

2493

			1000,

2494

);

2495

1

});

2496

1

2497

2498

#[test]

2499

1

fn evm_revert_substrate_events() {

2500

1

	ExtBuilder::default()

2501

1

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

2502

1

		.build()

2503

1

		.execute_with(|| {

2504

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2505

2506

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

2507

			// Thus BatchAll will revert the transfer.

2508

1

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

2509

1

				source: ALICE.into(),

2510

1

				target: batch_precompile_address,

2511

1

				input: BatchPCall::batch_all {

2512

1

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

2513

1

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

2514

1

					call_data: vec![].into(),

2515

1

					gas_limit: vec![].into()

2516

1

2517

1

				.into(),

2518

1

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

2519

1

				gas_limit: 500_000,

2520

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2521

1

				max_priority_fee_per_gas: None,

2522

1

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

2523

1

				access_list: Vec::new(),

2524

1

				authorization_list: Vec::new(),

2525

1

})

2526

1

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

2527

2528

1

			let transfer_count = System::events()

2529

1

				.iter()

2530

4

				.filter(|r| match r.event {

2531

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

2532

6

					_ => false,

2533

6

})

2534

1

				.count();

2535

2536

1

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

2537

1

});

2538

1

2539

2540

#[test]

2541

1

fn evm_success_keeps_substrate_events() {

2542

1

	ExtBuilder::default()

2543

1

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

2544

1

		.build()

2545

1

		.execute_with(|| {

2546

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2547

2548

1

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

2549

1

				source: ALICE.into(),

2550

1

				target: batch_precompile_address,

2551

1

				input: BatchPCall::batch_all {

2552

1

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

2553

1

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

2554

1

					call_data: vec![].into(),

2555

1

					gas_limit: vec![].into()

2556

1

2557

1

				.into(),

2558

1

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

2559

1

				gas_limit: 500_000,

2560

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2561

1

				max_priority_fee_per_gas: None,

2562

1

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

2563

1

				access_list: Vec::new(),

2564

1

				authorization_list: Vec::new(),

2565

1

})

2566

1

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

2567

2568

1

			let transfer_count = System::events()

2569

1

				.iter()

2570

6

				.filter(|r| match r.event {

2571

1

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

2572

9

					_ => false,

2573

10

})

2574

1

				.count();

2575

2576

1

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

2577

1

});

2578

1

2579

2580

#[test]

2581

1

fn validate_transaction_fails_on_filtered_call() {

2582

	use sp_runtime::transaction_validity::{

2583

		InvalidTransaction, TransactionSource, TransactionValidityError,

2584

};

2585

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

2586

2587

1

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

2588

1

		let xt = UncheckedExtrinsic::new_bare(

2589

1

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

2590

1

				source: Default::default(),

2591

1

				target: H160::default(),

2592

1

				input: Vec::new(),

2593

1

				value: Default::default(),

2594

1

				gas_limit: Default::default(),

2595

1

				max_fee_per_gas: Default::default(),

2596

1

				max_priority_fee_per_gas: Default::default(),

2597

1

				nonce: Default::default(),

2598

1

				access_list: Default::default(),

2599

1

				authorization_list: Default::default(),

2600

1

2601

1

			.into(),

2602

);

2603

2604

1

		assert_eq!(

2605

1

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

2606

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

2607

);

2608

1

});

2609

1

2610

2611

#[cfg(test)]

2612

mod treasury_tests {

2613

	use super::*;

2614

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

2615

	use moonbase_runtime::XcmWeightTrader;

2616

	use sp_runtime::traits::Hash;

2617

2618

8

	fn expect_events(events: Vec<RuntimeEvent>) {

2619

8

		let block_events: Vec<RuntimeEvent> =

2620

8

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

2621

2622

8

		dbg!(events.clone());

2623

8

		dbg!(block_events.clone());

2624

2625

12

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

2626

8

2627

2628

13

	fn next_block() {

2629

13

		System::reset_events();

2630

13

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

2631

13

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

2632

13

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

2633

13

2634

2635

6

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

2636

6

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

2637

6

			.expect("failed to get account balance")

2638

6

2639

2640

	#[test]

2641

1

	fn test_treasury_spend_local_with_root_origin() {

2642

1

		let initial_treasury_balance = 1_000 * UNIT;

2643

1

		ExtBuilder::default()

2644

1

			.with_balances(vec![

2645

1

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

2646

1

				(Treasury::account_id(), initial_treasury_balance),

2647

1

])

2648

1

			.build()

2649

1

			.execute_with(|| {

2650

1

				let spend_amount = 100u128 * UNIT;

2651

1

				let spend_beneficiary = AccountId::from(BOB);

2652

2653

1

				next_block();

2654

2655

				// Perform treasury spending

2656

1

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

2657

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

2658

1

					root_origin(),

2659

1

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

2660

1

						amount: spend_amount,

2661

1

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

2662

1

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

2663

1

						valid_from: Some(valid_from),

2664

1

}))

2665

));

2666

2667

1

				let payout_period =

2668

1

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

2669

1

				let expected_events = [RuntimeEvent::Treasury(

2670

1

					pallet_treasury::Event::AssetSpendApproved {

2671

1

						index: 0,

2672

1

						asset_kind: NativeOrWithId::Native,

2673

1

						amount: spend_amount,

2674

1

						beneficiary: spend_beneficiary,

2675

1

						valid_from,

2676

1

						expire_at: payout_period + valid_from,

2677

1

},

2678

1

)]

2679

1

				.to_vec();

2680

1

				expect_events(expected_events);

2681

2682

6

				while System::block_number() < valid_from {

2683

5

					next_block();

2684

5

2685

2686

1

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

2687

2688

1

				let expected_events = [

2689

1

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

2690

1

						index: 0,

2691

1

						payment_id: (),

2692

1

}),

2693

1

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

2694

1

						from: Treasury::account_id(),

2695

1

						to: spend_beneficiary,

2696

1

						amount: spend_amount,

2697

1

}),

2698

1

2699

1

				.to_vec();

2700

1

				expect_events(expected_events);

2701

1

});

2702

1

2703

2704

	#[test]

2705

1

	fn test_treasury_spend_local_with_council_origin() {

2706

1

		let initial_treasury_balance = 1_000 * UNIT;

2707

1

		ExtBuilder::default()

2708

1

			.with_balances(vec![

2709

1

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

2710

1

				(Treasury::account_id(), initial_treasury_balance),

2711

1

])

2712

1

			.build()

2713

1

			.execute_with(|| {

2714

1

				let spend_amount = 100u128 * UNIT;

2715

1

				let spend_beneficiary = AccountId::from(BOB);

2716

2717

1

				next_block();

2718

2719

				// TreasuryCouncilCollective

2720

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2721

1

					root_origin(),

2722

1

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

2723

1

					Some(AccountId::from(ALICE)),

2724

2725

));

2726

2727

1

				next_block();

2728

2729

				// Perform treasury spending

2730

1

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

2731

1

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

2732

1

					amount: spend_amount,

2733

1

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

2734

1

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

2735

1

					valid_from: Some(valid_from),

2736

1

});

2737

1

				assert_ok!(TreasuryCouncilCollective::propose(

2738

1

					origin_of(AccountId::from(ALICE)),

2739

1,

2740

1

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

2741

					1_000

2742

));

2743

2744

1

				let payout_period =

2745

1

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

2746

1

				let expected_events = [

2747

1

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

2748

1

						index: 0,

2749

1

						asset_kind: NativeOrWithId::Native,

2750

1

						amount: spend_amount,

2751

1

						beneficiary: spend_beneficiary,

2752

1

						valid_from,

2753

1

						expire_at: payout_period + valid_from,

2754

1

}),

2755

1

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

2756

1

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

2757

1

						result: Ok(()),

2758

1

}),

2759

1

2760

1

				.to_vec();

2761

1

				expect_events(expected_events);

2762

2763

6

				while System::block_number() < valid_from {

2764

5

					next_block();

2765

5

2766

2767

1

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

2768

2769

1

				let expected_events = [

2770

1

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

2771

1

						index: 0,

2772

1

						payment_id: (),

2773

1

}),

2774

1

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

2775

1

						from: Treasury::account_id(),

2776

1

						to: spend_beneficiary,

2777

1

						amount: spend_amount,

2778

1

}),

2779

1

2780

1

				.to_vec();

2781

1

				expect_events(expected_events);

2782

1

});

2783

1

2784

2785

	#[test]

2786

1

	fn test_treasury_spend_foreign_asset_with_root_origin() {

2787

1

		let initial_treasury_balance = 1_000 * UNIT;

2788

1

		let asset_id = 1000100010001000u128;

2789

1

		ExtBuilder::default()

2790

1

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

2791

1

			.build()

2792

1

			.execute_with(|| {

2793

1

				let spend_amount = 100u128 * UNIT;

2794

1

				let spend_beneficiary = AccountId::from(BOB);

2795

2796

1

				let asset_location: Location = Location {

2797

1

					parents: 1,

2798

1

					interior: Junctions::Here,

2799

1

};

2800

2801

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2802

1

					root_origin(),

2803

1

					asset_id,

2804

1

					asset_location.clone(),

2805

12,

2806

1

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

2807

1

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

2808

));

2809

2810

1

				assert_ok!(XcmWeightTrader::add_asset(

2811

1

					root_origin(),

2812

1

					asset_location,

2813

					1u128

2814

));

2815

2816

1

				assert_ok!(EvmForeignAssets::mint_into(

2817

1

					asset_id,

2818

1

					Treasury::account_id(),

2819

1

					initial_treasury_balance.into()

2820

));

2821

2822

1

				assert_eq!(

2823

1

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

2824

1

					initial_treasury_balance.into(),

2825

					"Treasury balance not updated"

2826

);

2827

2828

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

2829

1

					root_origin(),

2830

1

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

2831

1

						amount: spend_amount,

2832

1

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

2833

1

						beneficiary: Box::new(spend_beneficiary),

2834

1

						valid_from: None,

2835

1

}))

2836

));

2837

2838

1

				let payout_period =

2839

1

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

2840

2841

1

				let current_block = System::block_number();

2842

1

				expect_events(vec![RuntimeEvent::Treasury(

2843

1

					pallet_treasury::Event::AssetSpendApproved {

2844

1

						index: 0,

2845

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2846

1

						amount: spend_amount,

2847

1

						beneficiary: spend_beneficiary,

2848

1

						valid_from: current_block,

2849

1

						expire_at: current_block + payout_period,

2850

1

},

2851

1

				)]);

2852

2853

1

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

2854

2855

1

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

2856

1

					index: 0,

2857

1

					payment_id: (),

2858

1

				})]);

2859

2860

1

				assert_eq!(

2861

1

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

2862

1

					(initial_treasury_balance - spend_amount).into(),

2863

					"Treasury balance not updated"

2864

);

2865

2866

1

				assert_eq!(

2867

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2868

1

					spend_amount.into(),

2869

					"Treasury payout failed"

2870

);

2871

1

});

2872

1

2873

2874

	#[test]

2875

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2876

1

		let initial_treasury_balance = 1_000 * UNIT;

2877

1

		let asset_id = 1000100010001000u128;

2878

1

		ExtBuilder::default()

2879

1

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

2880

1

			.build()

2881

1

			.execute_with(|| {

2882

1

				let spend_amount = 100u128 * UNIT;

2883

1

				let spend_beneficiary = AccountId::from(BOB);

2884

2885

1

				let asset_location: Location = Location {

2886

1

					parents: 1,

2887

1

					interior: Junctions::Here,

2888

1

};

2889

2890

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2891

1

					root_origin(),

2892

1

					asset_id,

2893

1

					asset_location.clone(),

2894

12,

2895

1

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

2896

1

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

2897

));

2898

2899

1

				assert_ok!(XcmWeightTrader::add_asset(

2900

1

					root_origin(),

2901

1

					asset_location,

2902

					1u128

2903

));

2904

2905

1

				assert_ok!(EvmForeignAssets::mint_into(

2906

1

					asset_id,

2907

1

					Treasury::account_id(),

2908

1

					initial_treasury_balance.into()

2909

));

2910

2911

1

				assert_eq!(

2912

1

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

2913

1

					initial_treasury_balance.into(),

2914

					"Treasury balance not updated"

2915

);

2916

2917

				// TreasuryCouncilCollective

2918

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2919

1

					root_origin(),

2920

1

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

2921

1

					Some(AccountId::from(ALICE)),

2922

2923

));

2924

2925

				// Perform treasury spending

2926

1

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

2927

1

					amount: spend_amount,

2928

1

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

2929

1

					beneficiary: Box::new(spend_beneficiary),

2930

1

					valid_from: None,

2931

1

});

2932

1

				assert_ok!(TreasuryCouncilCollective::propose(

2933

1

					origin_of(AccountId::from(ALICE)),

2934

1,

2935

1

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

2936

					1_000

2937

));

2938

2939

1

				let payout_period =

2940

1

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

2941

2942

1

				let current_block = System::block_number();

2943

1

				let expected_events = [

2944

1

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

2945

1

						index: 0,

2946

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2947

1

						amount: spend_amount,

2948

1

						beneficiary: spend_beneficiary,

2949

1

						valid_from: current_block,

2950

1

						expire_at: current_block + payout_period,

2951

1

}),

2952

1

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

2953

1

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

2954

1

						result: Ok(()),

2955

1

}),

2956

1

2957

1

				.to_vec();

2958

1

				expect_events(expected_events);

2959

2960

1

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

2961

2962

1

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

2963

1

					index: 0,

2964

1

					payment_id: (),

2965

1

				})]);

2966

2967

1

				assert_eq!(

2968

1

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

2969

1

					(initial_treasury_balance - spend_amount).into(),

2970

					"Treasury balance not updated"

2971

);

2972

2973

1

				assert_eq!(

2974

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2975

1

					spend_amount.into(),

2976

					"Treasury payout failed"

2977

);

2978

1

});

2979

1

2980

2981

2982

#[cfg(test)]

2983

mod fee_tests {

2984

	use super::*;

2985

	use fp_evm::FeeCalculator;

2986

	use frame_support::{

2987

		traits::{ConstU128, OnFinalize},

2988

		weights::{ConstantMultiplier, WeightToFee},

2989

};

2990

	use moonbase_runtime::{

2991

		currency, BlockWeights, FastAdjustingFeeUpdate, LengthToFee, MinimumMultiplier,

2992

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2993

};

2994

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

2995

2996

1

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

2997

1

	where

2998

1

		F: FnMut() -> (),

2999

3000

1

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

3001

1

			.build_storage()

3002

1

			.unwrap()

3003

1

			.into();

3004

1

		t.execute_with(|| {

3005

1

			System::set_block_consumed_resources(w, 0);

3006

1

			assertions()

3007

1

});

3008

1

3009

3010

	#[test]

3011

1

	fn test_multiplier_can_grow_from_zero() {

3012

1

		let minimum_multiplier = MinimumMultiplier::get();

3013

1

		let target = TargetBlockFullness::get()

3014

1

			* BlockWeights::get()

3015

1

				.get(DispatchClass::Normal)

3016

1

				.max_total

3017

1

				.unwrap();

3018

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

3019

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

3020

1

		run_with_system_weight(target * 101 / 100, || {

3021

1

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

3022

1

			assert!(

3023

1

				next > minimum_multiplier,

3024

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

3025

				next,

3026

				minimum_multiplier

3027

);

3028

1

})

3029

1

3030

3031

	#[test]

3032

1

	fn test_fee_calculation() {

3033

1

		let base_extrinsic = BlockWeights::get()

3034

1

			.get(DispatchClass::Normal)

3035

1

			.base_extrinsic;

3036

1

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

3037

1

		let extrinsic_len = 100u32;

3038

1

		let extrinsic_weight = 5_000u64;

3039

1

		let tip = 42u128;

3040

		type WeightToFeeImpl =

3041

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

3042

		type LengthToFeeImpl = LengthToFee;

3043

3044

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

3045

1

		let expected_fee =

3046

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3047

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

3048

1

					&Weight::from_parts(extrinsic_weight, 1),

3049

1

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

3050

1

				+ tip;

3051

3052

1

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

3053

1

			.build_storage()

3054

1

			.unwrap()

3055

1

			.into();

3056

1

		t.execute_with(|| {

3057

1

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

3058

1

			let actual_fee = TransactionPayment::compute_fee(

3059

1

				extrinsic_len,

3060

1

				&frame_support::dispatch::DispatchInfo {

3061

1

					class: DispatchClass::Normal,

3062

1

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

3063

1

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

3064

1

					extension_weight: Weight::zero(),

3065

1

},

3066

1

				tip,

3067

);

3068

3069

1

			assert_eq!(

3070

				expected_fee,

3071

				actual_fee,

3072

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

3073

				actual_fee - expected_fee

3074

);

3075

1

});

3076

1

3077

3078

	#[test]

3079

1

	fn test_min_gas_price_is_deterministic() {

3080

1

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

3081

1

			.build_storage()

3082

1

			.unwrap()

3083

1

			.into();

3084

1

		t.execute_with(|| {

3085

1

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

3086

1

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

3087

1

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

3088

1

			let expected: U256 = multiplier

3089

1

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

3090

1

				.into();

3091

3092

1

			assert_eq!(expected, actual);

3093

1

});

3094

1

3095

3096

	#[test]

3097

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3098

1

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

3099

1

			.build_storage()

3100

1

			.unwrap()

3101

1

			.into();

3102

1

		t.execute_with(|| {

3103

1

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

3104

1

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

3105

3106

1

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

3107

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3108

1

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

3109

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3110

3111

1

			assert_ne!(

3112

				a, b,

3113

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

3114

);

3115

1

});

3116

1

3117

3118

	#[test]

3119

1

	fn test_fee_scenarios() {

3120

		use sp_runtime::FixedU128;

3121

1

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

3122

1

			.build_storage()

3123

1

			.unwrap()

3124

1

			.into();

3125

1

		t.execute_with(|| {

3126

1

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

3127

12

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

3128

12

				let start_multiplier =

3129

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3130

12

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

3131

3132

12

				let block_weight = NORMAL_WEIGHT * fullness;

3133

3134

60004

				for i in 0..num_blocks {

3135

60004

					System::set_block_number(i as u32);

3136

60004

					System::set_block_consumed_resources(block_weight, 0);

3137

60004

					TransactionPayment::on_finalize(i as u32);

3138

60004

3139

3140

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3141

12

};

3142

3143

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

3144

			// they are expected to change when parameters that influence

3145

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

3146

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

3147

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

3148

3149

1

			assert_eq!(

3150

1

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

3151

1

				U256::from(998_600_980),

3152

);

3153

1

			assert_eq!(

3154

1

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

3155

1

				U256::from(999_600_080),

3156

);

3157

1

			assert_eq!(

3158

1

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

3159

1

				U256::from(1_000_600_180),

3160

);

3161

1

			assert_eq!(

3162

1

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

3163

1

				U256::from(1_002_603_380),

3164

);

3165

3166

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

3167

1

			assert_eq!(

3168

1

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

3169

1

				U256::from(431_710_642),

3170

);

3171

1

			assert_eq!(

3172

1

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

3173

1

				U256::from(786_627_866),

3174

);

3175

1

			assert_eq!(

3176

1

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

3177

1

				U256::from(1_433_329_383u128),

3178

);

3179

1

			assert_eq!(

3180

1

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

3181

1

				U256::from(4_758_812_897u128),

3182

);

3183

3184

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

3185

1

			assert_eq!(

3186

1

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

3187

1

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

3188

);

3189

1

			assert_eq!(

3190

1

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

3191

1

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

3192

);

3193

1

			assert_eq!(

3194

1

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

3195

1

				U256::from(5_653_326_895_069u128),

3196

);

3197

1

			assert_eq!(

3198

1

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

3199

1

				U256::from(31_250_000_000_000u128),

3200

				// upper bound enforced (min_gas_price * MaximumMultiplier)

3201

);

3202

1

});

3203

1

3204

3205

3206

#[cfg(test)]

3207

mod balance_tests {

3208

	use crate::common::{ExtBuilder, ALICE};

3209

	use frame_support::assert_ok;

3210

	use frame_support::traits::LockableCurrency;

3211

	use frame_support::traits::{LockIdentifier, ReservableCurrency, WithdrawReasons};

3212

	use moonbase_runtime::{Balances, Runtime, System};

3213

	use moonbeam_core_primitives::AccountId;

3214

3215

	#[test]

3216

1

	fn reserve_should_work_for_frozen_balance() {

3217

1

		let alice = AccountId::from(ALICE);

3218

		const ID_1: LockIdentifier = *b"1       ";

3219

3220

1

		ExtBuilder::default()

3221

1

			.with_balances(vec![(alice, 10)])

3222

1

			.build()

3223

1

			.execute_with(|| {

3224

				// Check balances

3225

1

				let account = System::account(&alice).data;

3226

1

				assert_eq!(account.free, 10);

3227

1

				assert_eq!(account.frozen, 0);

3228

1

				assert_eq!(account.reserved, 0);

3229

3230

1

				Balances::set_lock(ID_1, &alice, 9, WithdrawReasons::RESERVE);

3231

3232

1

				let account = System::account(&alice).data;

3233

1

				assert_eq!(account.free, 10);

3234

1

				assert_eq!(account.frozen, 9);

3235

1

				assert_eq!(account.reserved, 0);

3236

3237

1

				assert_ok!(Balances::reserve(&alice, 5));

3238

3239

1

				let account = System::account(&alice).data;

3240

1

				assert_eq!(account.free, 5);

3241

1

				assert_eq!(account.frozen, 9);

3242

1

				assert_eq!(account.reserved, 5);

3243

3244

1

				let previous_reserved_amount = account.reserved;

3245

1

				let ed: u128 = <Runtime as pallet_balances::Config>::ExistentialDeposit::get();

3246

1

				let next_reserve = account.free.saturating_sub(ed);

3247

1

				assert_ok!(Balances::reserve(&alice, next_reserve));

3248

3249

1

				let account = System::account(&alice).data;

3250

1

				assert_eq!(account.free, ed);

3251

1

				assert_eq!(account.frozen, 9);

3252

1

				assert_eq!(

3253

					account.reserved,

3254

1

					previous_reserved_amount.saturating_add(next_reserve)

3255

);

3256

1

});

3257

1

3258

3259

3260

moonbeam_runtime_common::generate_common_xcm_tests!(moonbase_runtime);