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

#[test]

96

1

fn xcmp_queue_controller_origin_is_root() {

97

1

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

98

1

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

99

1

	assert_ok!(

100

1

		<moonbase_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

101

1

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

102

1

);

103

1

104

105

#[test]

106

1

fn verify_pallet_prefixes() {

107

29

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

108

29

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

109

29

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

110

29

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

111

29

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

112

29

		// expand/storage.rs#L389-L401

113

29

		assert_eq!(

114

29

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

115

29

			Some(name)

116

29

);

117

29

118

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

119

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

120

1

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

121

1

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

122

1

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

123

1

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

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

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

130

1

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

131

1

	is_pallet_prefix::<moonbase_runtime::OpenTechCommitteeCollective>(

132

1

		"OpenTechCommitteeCollective",

133

1

);

134

1

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

135

1

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

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

152

13

	let prefix = |pallet_name, storage_name| {

153

13

		let mut res = [0u8; 32];

154

13

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

155

13

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

156

13

		res.to_vec()

157

13

};

158

1

	assert_eq!(

159

1

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

160

1

		vec![

161

1

			StorageInfo {

162

1

				pallet_name: b"Balances".to_vec(),

163

1

				storage_name: b"TotalIssuance".to_vec(),

164

1

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

165

1

				max_values: Some(1),

166

1

				max_size: Some(16),

167

1

},

168

1

			StorageInfo {

169

1

				pallet_name: b"Balances".to_vec(),

170

1

				storage_name: b"InactiveIssuance".to_vec(),

171

1

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

172

1

				max_values: Some(1),

173

1

				max_size: Some(16),

174

1

},

175

1

			StorageInfo {

176

1

				pallet_name: b"Balances".to_vec(),

177

1

				storage_name: b"Account".to_vec(),

178

1

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

179

1

				max_values: None,

180

1

				max_size: Some(100),

181

1

},

182

1

			StorageInfo {

183

1

				pallet_name: b"Balances".to_vec(),

184

1

				storage_name: b"Locks".to_vec(),

185

1

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

186

1

				max_values: None,

187

1

				max_size: Some(1287),

188

1

},

189

1

			StorageInfo {

190

1

				pallet_name: b"Balances".to_vec(),

191

1

				storage_name: b"Reserves".to_vec(),

192

1

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

193

1

				max_values: None,

194

1

				max_size: Some(1037),

195

1

},

196

1

			StorageInfo {

197

1

				pallet_name: b"Balances".to_vec(),

198

1

				storage_name: b"Holds".to_vec(),

199

1

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

200

1

				max_values: None,

201

1

				max_size: Some(55),

202

1

},

203

1

			StorageInfo {

204

1

				pallet_name: b"Balances".to_vec(),

205

1

				storage_name: b"Freezes".to_vec(),

206

1

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

207

1

				max_values: None,

208

1

				max_size: Some(73),

209

1

},

210

1

211

1

);

212

1

	assert_eq!(

213

1

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

214

1

		vec![StorageInfo {

215

1

			pallet_name: b"Sudo".to_vec(),

216

1

			storage_name: b"Key".to_vec(),

217

1

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

218

1

			max_values: Some(1),

219

1

			max_size: Some(20),

220

1

}]

221

1

);

222

1

	assert_eq!(

223

1

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

224

1

		vec![

225

1

			StorageInfo {

226

1

				pallet_name: b"Proxy".to_vec(),

227

1

				storage_name: b"Proxies".to_vec(),

228

1

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

229

1

				max_values: None,

230

1

				max_size: Some(845),

231

1

},

232

1

			StorageInfo {

233

1

				pallet_name: b"Proxy".to_vec(),

234

1

				storage_name: b"Announcements".to_vec(),

235

1

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

236

1

				max_values: None,

237

1

				max_size: Some(1837),

238

1

239

1

240

1

);

241

1

	assert_eq!(

242

1

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

243

1

		vec![StorageInfo {

244

1

			pallet_name: b"MaintenanceMode".to_vec(),

245

1

			storage_name: b"MaintenanceMode".to_vec(),

246

1

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

247

1

			max_values: Some(1),

248

1

			max_size: None,

249

1

},]

250

1

);

251

252

1

	assert_eq!(

253

1

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

254

1

		vec![

255

1

			StorageInfo {

256

1

				pallet_name: b"RelayStorageRoots".to_vec(),

257

1

				storage_name: b"RelayStorageRoot".to_vec(),

258

1

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

259

1

				max_values: None,

260

1

				max_size: Some(44),

261

1

},

262

1

			StorageInfo {

263

1

				pallet_name: b"RelayStorageRoots".to_vec(),

264

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

265

1

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

266

1

				max_values: Some(1),

267

1

				max_size: Some(121),

268

1

},

269

1

270

1

);

271

1

272

273

#[test]

274

1

fn test_collectives_storage_item_prefixes() {

275

7

	for StorageInfo { pallet_name, .. } in

276

8

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

277

278

7

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

279

280

281

7

	for StorageInfo { pallet_name, .. } in

282

8

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

283

284

7

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

285

286

1

287

288

#[test]

289

1

fn collective_set_members_root_origin_works() {

290

1

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

291

1

		// TreasuryCouncilCollective

292

1

		assert_ok!(TreasuryCouncilCollective::set_members(

293

1

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

294

1

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

295

1

			Some(AccountId::from(ALICE)),

296

1

297

1

));

298

		// OpenTechCommitteeCollective

299

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

300

1

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

301

1

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

302

1

			Some(AccountId::from(ALICE)),

303

1

304

1

));

305

1

});

306

1

307

308

#[test]

309

1

fn collective_set_members_general_admin_origin_works() {

310

	use moonbase_runtime::{

311

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

312

};

313

314

1

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

315

1

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

316

1

		let alice = AccountId::from(ALICE);

317

1

318

1

		// TreasuryCouncilCollective

319

1

		let _ = Utility::dispatch_as(

320

1

			root_caller.clone(),

321

1

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

322

1

			Box::new(

323

1

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

324

1

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

325

1

					prime: Some(alice),

326

1

					old_count: 2,

327

1

328

1

				.into(),

329

1

),

330

1

);

331

1

		// OpenTechCommitteeCollective

332

1

		let _ = Utility::dispatch_as(

333

1

			root_caller,

334

1

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

335

1

			Box::new(

336

1

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

337

1

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

338

1

					prime: Some(alice),

339

1

					old_count: 2,

340

1

341

1

				.into(),

342

1

),

343

1

);

344

1

345

1

		assert_eq!(

346

1

			System::events()

347

1

				.into_iter()

348

2

				.filter_map(|r| {

349

2

					match r.event {

350

2

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

351

2

							if result.is_ok() =>

352

2

353

2

							Some(true)

354

355

						_ => None,

356

357

2

})

358

1

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

359

1

				.len(),

360

1

361

1

362

1

});

363

1

364

365

#[test]

366

1

fn collective_set_members_signed_origin_does_not_work() {

367

1

	let alice = AccountId::from(ALICE);

368

1

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

369

1

		// TreasuryCouncilCollective

370

1

		assert!(TreasuryCouncilCollective::set_members(

371

1

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

372

1

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

373

1

			Some(AccountId::from(ALICE)),

374

1

375

1

376

1

		.is_err());

377

		// OpenTechCommitteeCollective

378

1

		assert!(OpenTechCommitteeCollective::set_members(

379

1

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

380

1

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

381

1

			Some(AccountId::from(ALICE)),

382

1

383

1

384

1

		.is_err());

385

1

});

386

1

387

388

#[test]

389

1

fn verify_pallet_indices() {

390

31

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

391

31

		assert_eq!(

392

31

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

393

31

			Some(index)

394

31

);

395

31

396

1

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

397

1

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

398

1

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

399

1

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

400

1

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

401

1

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

402

1

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

403

1

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

404

1

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

405

1

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

406

1

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

407

1

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

408

1

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

409

1

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

410

1

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

411

1

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

412

1

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

413

1

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

414

1

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

415

1

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

416

1

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

417

1

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

418

1

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

419

1

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

420

1

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

421

1

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

422

1

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

423

1

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

424

1

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

425

1

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

426

1

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

427

1

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

428

1

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

429

1

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

430

1

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

431

1

432

433

#[test]

434

1

fn verify_reserved_indices() {

435

	use frame_metadata::*;

436

437

1

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

438

1

		.build_storage()

439

1

		.unwrap()

440

1

		.into();

441

1

442

1

	t.execute_with(|| {

443

1

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

444

1

		let metadata = match metadata.1 {

445

1

			RuntimeMetadata::V14(metadata) => metadata,

446

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

447

};

448

		// 35: BaseFee

449

		// 36: pallet_assets::<Instance1>

450

1

		let reserved = vec![35, 36];

451

1

		let existing = metadata

452

1

			.pallets

453

1

			.iter()

454

48

			.map(|p| p.index)

455

1

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

456

2

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

457

1

});

458

1

459

460

#[test]

461

1

fn verify_proxy_type_indices() {

462

1

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

463

1

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

464

1

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

465

1

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

466

1

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

467

1

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

468

1

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

469

1

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

470

1

471

472

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

473

#[test]

474

1

fn verify_normal_filter_allow_pure_proxy() {

475

1

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

476

1

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

477

1

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

478

1

				proxy_type: ProxyType::Any,

479

1

				delay: 0,

480

1

				index: 0,

481

1

482

1

		)));

483

1

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

484

1

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

485

1

				spawner: AccountId::from(ALICE),

486

1

				proxy_type: ProxyType::Any,

487

1

				index: 0,

488

1

				height: 0,

489

1

				ext_index: 0,

490

1

491

1

		)));

492

1

});

493

1

494

495

#[test]

496

1

fn join_collator_candidates() {

497

1

	ExtBuilder::default()

498

1

		.with_balances(vec![

499

1

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

500

1

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

501

1

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

502

1

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

503

1

])

504

1

		.with_collators(vec![

505

1

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

506

1

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

507

1

])

508

1

		.with_delegations(vec![

509

1

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

510

1

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

511

1

])

512

1

		.build()

513

1

		.execute_with(|| {

514

1

			assert_noop!(

515

1

				ParachainStaking::join_candidates(

516

1

					origin_of(AccountId::from(ALICE)),

517

1

					1_000 * UNIT,

518

1

					2u32

519

1

),

520

1

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

521

1

);

522

1

			assert_noop!(

523

1

				ParachainStaking::join_candidates(

524

1

					origin_of(AccountId::from(CHARLIE)),

525

1

					1_000 * UNIT,

526

1

					2u32

527

1

),

528

1

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

529

1

);

530

1

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

531

1

			assert_ok!(ParachainStaking::join_candidates(

532

1

				origin_of(AccountId::from(DAVE)),

533

1

				1_000 * UNIT,

534

1

				2u32

535

1

));

536

1

			assert_eq!(

537

1

				last_event(),

538

1

				RuntimeEvent::ParachainStaking(

539

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

540

1

						account: AccountId::from(DAVE),

541

1

						amount_locked: 1_000 * UNIT,

542

1

						new_total_amt_locked: 3_100 * UNIT

543

1

544

1

545

1

);

546

1

			let candidates = ParachainStaking::candidate_pool();

547

1

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

548

1

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

549

1

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

550

1

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

551

1

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

552

1

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

553

1

});

554

1

555

556

#[test]

557

1

fn transfer_through_evm_to_stake() {

558

1

	ExtBuilder::default()

559

1

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

560

1

		.build()

561

1

		.execute_with(|| {

562

1

			// Charlie has no balance => fails to stake

563

1

			assert_noop!(

564

1

				ParachainStaking::join_candidates(

565

1

					origin_of(AccountId::from(CHARLIE)),

566

1

					1_000 * UNIT,

567

1

					0u32

568

1

),

569

1

				DispatchError::Module(ModuleError {

570

1

					index: 12,

571

1

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

572

1

					message: Some("InsufficientBalance")

573

1

})

574

1

);

575

576

			// Alice transfer from free balance 2000 UNIT to Bob

577

1

			assert_ok!(Balances::transfer_allow_death(

578

1

				origin_of(AccountId::from(ALICE)),

579

1

				AccountId::from(BOB),

580

1

				2_000 * UNIT,

581

1

));

582

1

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

583

584

1

			let gas_limit = 100000u64;

585

1

			// Bob transfers 1000 UNIT to Charlie via EVM

586

1

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

587

1

				source: H160::from(BOB),

588

1

				target: H160::from(CHARLIE),

589

1

				input: Vec::new(),

590

1

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

591

1

				gas_limit,

592

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

593

1

				max_priority_fee_per_gas: None,

594

1

				nonce: None,

595

1

				access_list: Vec::new(),

596

1

				authorization_list: Vec::new(),

597

1

})

598

1

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

599

1

			assert_eq!(

600

1

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

601

1

				1_000 * UNIT,

602

1

);

603

604

			// Charlie can stake now

605

1

			assert_ok!(ParachainStaking::join_candidates(

606

1

				origin_of(AccountId::from(CHARLIE)),

607

1

				1_000 * UNIT,

608

1

				0u32,

609

1

			),);

610

1

			let candidates = ParachainStaking::candidate_pool();

611

1

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

612

1

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

613

1

});

614

1

615

616

#[test]

617

1

fn reward_block_authors() {

618

1

	ExtBuilder::default()

619

1

		.with_balances(vec![

620

1

			// Alice gets 100 extra tokens for her mapping deposit

621

1

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

622

1

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

623

1

])

624

1

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

625

1

		.with_delegations(vec![(

626

1

			AccountId::from(BOB),

627

1

			AccountId::from(ALICE),

628

1

			500 * UNIT,

629

1

)])

630

1

		.with_mappings(vec![(

631

1

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

632

1

			AccountId::from(ALICE),

633

1

)])

634

1

		.build()

635

1

		.execute_with(|| {

636

1

			increase_last_relay_slot_number(1);

637

1

			// Just before round 3

638

1

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

639

1

			// no rewards doled out yet

640

1

			assert_eq!(

641

1

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

642

1

				1_100 * UNIT,

643

1

);

644

1

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

645

1

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

646

1

			// rewards minted and distributed

647

1

			assert_eq!(

648

1

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

649

1

				1213666666584000000000,

650

1

);

651

1

			assert_eq!(

652

1

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

653

1

				541333333292000000000,

654

1

);

655

1

});

656

1

657

658

#[test]

659

1

fn reward_block_authors_with_parachain_bond_reserved() {

660

1

	ExtBuilder::default()

661

1

		.with_balances(vec![

662

1

			// Alice gets 100 extra tokens for her mapping deposit

663

1

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

664

1

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

665

1

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

666

1

])

667

1

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

668

1

		.with_delegations(vec![(

669

1

			AccountId::from(BOB),

670

1

			AccountId::from(ALICE),

671

1

			500 * UNIT,

672

1

)])

673

1

		.with_mappings(vec![(

674

1

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

675

1

			AccountId::from(ALICE),

676

1

)])

677

1

		.build()

678

1

		.execute_with(|| {

679

1

			increase_last_relay_slot_number(1);

680

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

681

1

				root_origin(),

682

1

683

1

					InflationDistributionAccount {

684

1

						account: AccountId::from(CHARLIE),

685

1

						percent: Percent::from_percent(30),

686

1

},

687

1

					InflationDistributionAccount::default(),

688

1

689

1

				.into()

690

1

));

691

692

			// Stop just before round 2

693

1

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

694

1

695

1

			// no rewards doled out yet

696

1

			assert_eq!(

697

1

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

698

1

				1_100 * UNIT,

699

1

);

700

1

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

701

1

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

702

703

			// Go to round 2

704

1

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

705

1

706

1

			// 30% reserved for parachain bond

707

1

			assert_eq!(

708

1

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

709

1

				47515000000000000000,

710

1

);

711

712

			// Go to round 3

713

1

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

714

1

			// rewards minted and distributed

715

1

			assert_eq!(

716

1

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

717

1

				1182693333281650000000,

718

1

);

719

1

			assert_eq!(

720

1

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

721

1

				525841666640825000000,

722

1

);

723

			// 30% again reserved for parachain bond

724

1

			assert_eq!(

725

1

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

726

1

				94727725000000000000,

727

1

);

728

1

});

729

1

730

731

#[test]

732

1

fn create_and_manipulate_foreign_asset_using_root() {

733

1

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

734

1

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

735

1

736

1

		// Create foreign asset

737

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

738

1

			moonbase_runtime::RuntimeOrigin::root(),

739

1

1,

740

1

			source_location.clone(),

741

1

12,

742

1

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

743

1

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

744

1

));

745

1

		assert_eq!(

746

1

			EvmForeignAssets::assets_by_id(1),

747

1

			Some(source_location.clone())

748

1

);

749

1

		assert_eq!(

750

1

			EvmForeignAssets::assets_by_location(&source_location),

751

1

			Some((1, AssetStatus::Active))

752

1

);

753

754

		// Freeze foreign asset

755

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

756

1

			moonbase_runtime::RuntimeOrigin::root(),

757

1

1,

758

1

			true

759

1

));

760

1

		assert_eq!(

761

1

			EvmForeignAssets::assets_by_location(&source_location),

762

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

763

1

);

764

765

		// Unfreeze foreign asset

766

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

767

1

			moonbase_runtime::RuntimeOrigin::root(),

768

1

1,

769

1

));

770

1

		assert_eq!(

771

1

			EvmForeignAssets::assets_by_location(&source_location),

772

1

			Some((1, AssetStatus::Active))

773

1

);

774

1

});

775

1

776

777

#[test]

778

1

fn create_and_manipulate_foreign_asset_using_sibling() {

779

1

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

780

1

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

781

1

		let para_location = asset_location.chain_location();

782

1

		let para_account =

783

1

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

784

1

785

1

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

786

1

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

787

1

788

1

		// Create foreign asset

789

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

790

1

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

791

1

1,

792

1

			asset_location.clone(),

793

1

12,

794

1

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

795

1

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

796

1

));

797

798

		// deposit is taken from the account

799

1

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

800

801

1

		assert_eq!(

802

1

			EvmForeignAssets::assets_by_id(1),

803

1

			Some(asset_location.clone())

804

1

);

805

1

		assert_eq!(

806

1

			EvmForeignAssets::assets_by_location(&asset_location),

807

1

			Some((1, AssetStatus::Active))

808

1

);

809

810

		// Freeze foreign asset

811

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

812

1

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

813

1

1,

814

1

			true

815

1

));

816

1

		assert_eq!(

817

1

			EvmForeignAssets::assets_by_location(&asset_location),

818

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

819

1

);

820

821

		// Unfreeze foreign asset

822

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

823

1

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

824

1

1,

825

1

));

826

1

		assert_eq!(

827

1

			EvmForeignAssets::assets_by_location(&asset_location),

828

1

			Some((1, AssetStatus::Active))

829

1

);

830

1

});

831

1

832

833

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

834

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

835

/*

836

#[test]

837

fn xcm_asset_erc20_precompiles_supply_and_balance() {

838

	ExtBuilder::default()

839

		.with_xcm_assets(vec![XcmAssetInitialization {

840

			asset_id: 1,

841

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

842

			name: "RelayToken",

843

			symbol: "Relay",

844

			decimals: 12,

845

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

846

}])

847

		.with_balances(vec![

848

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

849

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

850

])

851

		.build()

852

		.execute_with(|| {

853

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

854

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

855

856

			// Its address is

857

			let asset_precompile_address = Runtime::asset_id_to_account(

858

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

859

				relay_asset_id,

860

);

861

862

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

863

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

864

865

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

866

			Precompiles::new()

867

				.prepare_test(

868

					ALICE,

869

					asset_precompile_address,

870

					ForeignAssetsPCall::total_supply {},

871

872

				.expect_cost(3338)

873

				.expect_no_logs()

874

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

875

876

			// Access balanceOf through precompile

877

			Precompiles::new()

878

				.prepare_test(

879

					ALICE,

880

					asset_precompile_address,

881

					ForeignAssetsPCall::balance_of {

882

						who: Address(ALICE.into()),

883

},

884

885

				.expect_cost(3338)

886

				.expect_no_logs()

887

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

888

});

889

890

891

#[test]

892

fn xcm_asset_erc20_precompiles_transfer() {

893

	ExtBuilder::default()

894

		.with_xcm_assets(vec![XcmAssetInitialization {

895

			asset_id: 1,

896

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

897

			name: "RelayToken",

898

			symbol: "Relay",

899

			decimals: 12,

900

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

901

}])

902

		.with_balances(vec![

903

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

904

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

905

])

906

		.build()

907

		.execute_with(|| {

908

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

909

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

910

911

			// Its address is

912

			let asset_precompile_address = Runtime::asset_id_to_account(

913

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

914

				relay_asset_id,

915

);

916

917

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

918

			Precompiles::new()

919

				.prepare_test(

920

					ALICE,

921

					asset_precompile_address,

922

					ForeignAssetsPCall::transfer {

923

						to: Address(BOB.into()),

924

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

925

},

926

927

				.expect_cost(24695)

928

				.expect_log(log3(

929

					asset_precompile_address,

930

					SELECTOR_LOG_TRANSFER,

931

					H160::from(ALICE),

932

					H160::from(BOB),

933

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

934

))

935

				.execute_returns(true);

936

937

			// Make sure BOB has 400 UNIT

938

			Precompiles::new()

939

				.prepare_test(

940

					BOB,

941

					asset_precompile_address,

942

					ForeignAssetsPCall::balance_of {

943

						who: Address(BOB.into()),

944

},

945

946

				.expect_cost(3338)

947

				.expect_no_logs()

948

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

949

});

950

951

952

#[test]

953

fn xcm_asset_erc20_precompiles_approve() {

954

	ExtBuilder::default()

955

		.with_xcm_assets(vec![XcmAssetInitialization {

956

			asset_id: 1,

957

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

958

			name: "RelayToken",

959

			symbol: "Relay",

960

			decimals: 12,

961

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

962

}])

963

		.with_balances(vec![

964

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

965

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

966

])

967

		.build()

968

		.execute_with(|| {

969

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

970

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

971

972

			// Its address is

973

			let asset_precompile_address = Runtime::asset_id_to_account(

974

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

975

				relay_asset_id,

976

);

977

978

			// Aprove Bob for spending 400 UNIT from Alice

979

			Precompiles::new()

980

				.prepare_test(

981

					ALICE,

982

					asset_precompile_address,

983

					ForeignAssetsPCall::approve {

984

						spender: Address(BOB.into()),

985

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

986

},

987

988

				.expect_cost(15604)

989

				.expect_log(log3(

990

					asset_precompile_address,

991

					SELECTOR_LOG_APPROVAL,

992

					H160::from(ALICE),

993

					H160::from(BOB),

994

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

995

))

996

				.execute_returns(true);

997

998

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

999

			Precompiles::new()

1000

				.prepare_test(

1001

					BOB,

1002

					asset_precompile_address,

1003

					ForeignAssetsPCall::transfer_from {

1004

						from: Address(ALICE.into()),

1005

						to: Address(CHARLIE.into()),

1006

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

1007

},

1008

1009

				.expect_cost(29960)

1010

				.expect_log(log3(

1011

					asset_precompile_address,

1012

					SELECTOR_LOG_TRANSFER,

1013

					H160::from(ALICE),

1014

					H160::from(CHARLIE),

1015

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

1016

))

1017

				.execute_returns(true);

1018

1019

			// Make sure CHARLIE has 400 UNIT

1020

			Precompiles::new()

1021

				.prepare_test(

1022

					CHARLIE,

1023

					asset_precompile_address,

1024

					ForeignAssetsPCall::balance_of {

1025

						who: Address(CHARLIE.into()),

1026

},

1027

1028

				.expect_cost(3338)

1029

				.expect_no_logs()

1030

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

1031

});

1032

}*/

1033

1034

#[test]

1035

1

fn xtokens_precompiles_transfer() {

1036

1

	ExtBuilder::default()

1037

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1038

1

			asset_id: 1,

1039

1

			xcm_location: AssetHubLocation::get(),

1040

1

			name: "RelayToken",

1041

1

			symbol: "Relay",

1042

1

			decimals: 12,

1043

1

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

1044

1

}])

1045

1

		.with_balances(vec![

1046

1

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

1047

1

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

1048

1

])

1049

1

		.with_safe_xcm_version(3)

1050

1

		.build()

1051

1

		.execute_with(|| {

1052

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1053

1

1054

1

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

1055

1

			let asset_id: AssetId = 1;

1056

1

1057

1

			// Its address is

1058

1

			let asset_precompile_address =

1059

1

				Runtime::asset_id_to_account(FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, asset_id);

1060

1

1061

1

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

1062

1

			let destination = Location::new(

1063

1

1,

1064

1

				[Junction::AccountId32 {

1065

1

					network: None,

1066

1

					id: [1u8; 32],

1067

1

}],

1068

1

);

1069

1

1070

1

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

1071

1

			let inside2 = inside.clone();

1072

1

1073

1

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

1074

1

			Precompiles::new()

1075

1

				.prepare_test(

1076

1

					ALICE,

1077

1

					xtokens_precompile_address,

1078

1

					XtokensPCall::transfer {

1079

1

						currency_address: Address(asset_precompile_address.into()),

1080

1

						amount: 500_000_000_000_000u128.into(),

1081

1

						destination,

1082

1

						weight: 4_000_000,

1083

1

},

1084

1

1085

1

				.expect_cost(260283)

1086

1

				.expect_no_logs()

1087

1

				// We expect an evm subcall ERC20.burnFrom

1088

1

				.with_subcall_handle(move |subcall| {

1089

1

					let Subcall {

1090

1

						address,

1091

1

						transfer,

1092

1

						input,

1093

1

						target_gas: _,

1094

1

						is_static,

1095

1

						context,

1096

1

					} = subcall;

1097

1

1098

1

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

1099

1

					assert_eq!(

1100

1

						address,

1101

1

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

1102

1

);

1103

1

					assert_eq!(is_static, false);

1104

1105

1

					assert!(transfer.is_none());

1106

1107

1

					assert_eq!(

1108

1

						context.address,

1109

1

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

1110

1

);

1111

1

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

1112

1113

1

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

1114

1

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

1115

1

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

1116

1117

1

					inside2.set(true);

1118

1

1119

1

					SubcallOutput {

1120

1

						output: Default::default(),

1121

1

						cost: 149_000,

1122

1

						logs: vec![],

1123

1

						..SubcallOutput::succeed()

1124

1

1125

1

})

1126

1

				.execute_returns(())

1127

1

})

1128

1

1129

1130

#[test]

1131

1

fn xtokens_precompiles_transfer_multiasset() {

1132

1

	ExtBuilder::default()

1133

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1134

1

			asset_id: 1,

1135

1

			xcm_location: AssetHubLocation::get(),

1136

1

			name: "DOT",

1137

1

			symbol: "DOT",

1138

1

			decimals: 12,

1139

1

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

1140

1

}])

1141

1

		.with_balances(vec![

1142

1

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

1143

1

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

1144

1

])

1145

1

		.with_safe_xcm_version(3)

1146

1

		.build()

1147

1

		.execute_with(|| {

1148

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1149

1

1150

1

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

1151

1

			let destination = Location::new(

1152

1

1,

1153

1

				[Junction::AccountId32 {

1154

1

					network: None,

1155

1

					id: [1u8; 32],

1156

1

}],

1157

1

);

1158

1

1159

1

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

1160

1

			let inside2 = inside.clone();

1161

1

1162

1

			// This time we transfer it through TransferMultiAsset

1163

1

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

1164

1

			Precompiles::new()

1165

1

				.prepare_test(

1166

1

					ALICE,

1167

1

					xtokens_precompile_address,

1168

1

					XtokensPCall::transfer_multiasset {

1169

1

						// We want to transfer DOT

1170

1

						asset: AssetHubLocation::get(),

1171

1

						amount: 500_000_000_000_000u128.into(),

1172

1

						destination,

1173

1

						weight: 4_000_000,

1174

1

},

1175

1

1176

1

				.expect_cost(260283)

1177

1

				.expect_no_logs()

1178

1

				// We expect an evm subcall ERC20.burnFrom

1179

1

				.with_subcall_handle(move |subcall| {

1180

1

					let Subcall {

1181

1

						address,

1182

1

						transfer,

1183

1

						input,

1184

1

						target_gas: _,

1185

1

						is_static,

1186

1

						context,

1187

1

					} = subcall;

1188

1

1189

1

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

1190

1

					assert_eq!(

1191

1

						address,

1192

1

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

1193

1

);

1194

1

					assert_eq!(is_static, false);

1195

1196

1

					assert!(transfer.is_none());

1197

1198

1

					assert_eq!(

1199

1

						context.address,

1200

1

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

1201

1

);

1202

1

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

1203

1204

1

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

1205

1

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

1206

1

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

1207

1208

1

					inside2.set(true);

1209

1

1210

1

					SubcallOutput {

1211

1

						output: Default::default(),

1212

1

						cost: 149_000,

1213

1

						logs: vec![],

1214

1

						..SubcallOutput::succeed()

1215

1

1216

1

})

1217

1

				.execute_returns(());

1218

1

1219

1

			// Ensure that the subcall was actually called.

1220

1

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

1221

1

})

1222

1

1223

1224

#[test]

1225

1

fn xtokens_precompiles_transfer_native() {

1226

1

	ExtBuilder::default()

1227

1

		.with_balances(vec![

1228

1

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

1229

1

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

1230

1

])

1231

1

		.with_safe_xcm_version(3)

1232

1

		.build()

1233

1

		.execute_with(|| {

1234

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1235

1

1236

1

			// Its address is

1237

1

			let asset_precompile_address = H160::from_low_u64_be(2050);

1238

1

1239

1

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

1240

1

			let destination = Location::new(

1241

1

1,

1242

1

				[Junction::AccountId32 {

1243

1

					network: None,

1244

1

					id: [1u8; 32],

1245

1

}],

1246

1

);

1247

1

1248

1

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

1249

1

			Precompiles::new()

1250

1

				.prepare_test(

1251

1

					ALICE,

1252

1

					xtokens_precompile_address,

1253

1

					XtokensPCall::transfer {

1254

1

						currency_address: Address(asset_precompile_address),

1255

1

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

1256

1

						destination,

1257

1

						weight: 4_000_000,

1258

1

},

1259

1

1260

1

				.expect_cost(108683)

1261

1

				.expect_no_logs()

1262

1

				.execute_returns(());

1263

1

})

1264

1

1265

1266

1

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

1267

1

where

1268

1

	F: FnMut() -> (),

1269

1

1270

1

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

1271

1

		.build_storage()

1272

1

		.unwrap()

1273

1

		.into();

1274

1

	t.execute_with(|| {

1275

1

		System::set_block_consumed_resources(w, 0);

1276

1

		assertions()

1277

1

});

1278

1

1279

1280

#[test]

1281

#[rustfmt::skip]

1282

1

fn length_fee_is_sensible() {

1283

	use sp_runtime::testing::TestXt;

1284

1285

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

1286

1

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

1287

1

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

1288

1

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

1289

1

1290

9

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

1291

9

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

1292

9

				.inclusion_fee

1293

9

				.expect("fee should be calculated")

1294

9

				.len_fee

1295

9

};

1296

1297

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

1298

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

1299

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

1300

		//                             |           |

1301

1

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

1302

1

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

1303

1

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

1304

1

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

1305

1

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

1306

1

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

1307

1

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

1308

1

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

1309

1

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

1310

1

});

1311

1

1312

1313

#[test]

1314

1

fn multiplier_can_grow_from_zero() {

1315

	use frame_support::traits::Get;

1316

1317

1

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

1318

1

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

1319

1

		* RuntimeBlockWeights::get()

1320

1

			.get(DispatchClass::Normal)

1321

1

			.max_total

1322

1

			.unwrap();

1323

1

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

1324

1

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

1325

1

	run_with_system_weight(target * 101 / 100, || {

1326

1

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

1327

1

		assert!(

1328

1

			next > minimum_multiplier,

1329

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

1330

			next,

1331

			minimum_multiplier

1332

);

1333

1

})

1334

1

1335

1336

#[test]

1337

1

fn ethereum_invalid_transaction() {

1338

1

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

1339

1

		set_parachain_inherent_data();

1340

1

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

1341

1

		// on chain is rejected.

1342

1

		assert_eq!(

1343

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1344

1

			Err(

1345

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1346

1

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

1347

1

1348

1

1349

1

);

1350

1

});

1351

1

1352

1353

#[test]

1354

1

fn transfer_ed_0_substrate() {

1355

1

	ExtBuilder::default()

1356

1

		.with_balances(vec![

1357

1

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

1358

1

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

1359

1

])

1360

1

		.build()

1361

1

		.execute_with(|| {

1362

1

			// Substrate transfer

1363

1

			assert_ok!(Balances::transfer_allow_death(

1364

1

				origin_of(AccountId::from(ALICE)),

1365

1

				AccountId::from(BOB),

1366

1

				1 * UNIT,

1367

1

));

1368

			// 1 WEI is left in the account

1369

1

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

1370

1

});

1371

1

1372

1373

#[test]

1374

1

fn initial_gas_fee_is_correct() {

1375

	use fp_evm::FeeCalculator;

1376

1377

1

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

1378

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1379

1

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

1380

1381

1

		assert_eq!(

1382

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1383

1

1384

1

				2_500_000_000u128.into(),

1385

1

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

1386

1

1387

1

);

1388

1

});

1389

1

1390

1391

#[test]

1392

1

fn transfer_ed_0_evm() {

1393

1

	ExtBuilder::default()

1394

1

		.with_balances(vec![

1395

1

1396

1

				AccountId::from(ALICE),

1397

1

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

1398

1

),

1399

1

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

1400

1

])

1401

1

		.build()

1402

1

		.execute_with(|| {

1403

1

			set_parachain_inherent_data();

1404

1

			// EVM transfer

1405

1

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

1406

1

				source: H160::from(ALICE),

1407

1

				target: H160::from(BOB),

1408

1

				input: Vec::new(),

1409

1

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

1410

1

				gas_limit: 21_000u64,

1411

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1412

1

				max_priority_fee_per_gas: None,

1413

1

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

1414

1

				access_list: Vec::new(),

1415

1

				authorization_list: Vec::new(),

1416

1

})

1417

1

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

1418

			// 1 WEI is left in the account

1419

1

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

1420

1

});

1421

1

1422

1423

#[test]

1424

1

fn refund_ed_0_evm() {

1425

1

	ExtBuilder::default()

1426

1

		.with_balances(vec![

1427

1

1428

1

				AccountId::from(ALICE),

1429

1

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

1430

1

),

1431

1

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

1432

1

])

1433

1

		.build()

1434

1

		.execute_with(|| {

1435

1

			// EVM transfer that zeroes ALICE

1436

1

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

1437

1

				source: H160::from(ALICE),

1438

1

				target: H160::from(BOB),

1439

1

				input: Vec::new(),

1440

1

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

1441

1

				gas_limit: 21_777u64,

1442

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1443

1

				max_priority_fee_per_gas: None,

1444

1

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

1445

1

				access_list: Vec::new(),

1446

1

				authorization_list: Vec::new(),

1447

1

})

1448

1

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

1449

			// ALICE is refunded

1450

1

			assert_eq!(

1451

1

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

1452

1

				777 * BASE_FEE_GENISIS + existential_deposit(),

1453

1

);

1454

1

});

1455

1

1456

1457

#[test]

1458

1

fn author_does_receive_priority_fee() {

1459

1

	ExtBuilder::default()

1460

1

		.with_balances(vec![(

1461

1

			AccountId::from(BOB),

1462

1

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

1463

1

)])

1464

1

		.build()

1465

1

		.execute_with(|| {

1466

1

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

1467

1

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

1468

1

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

1469

1

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

1470

1

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

1471

1

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

1472

1

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

1473

1

1474

1

			// EVM transfer.

1475

1

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

1476

1

				source: H160::from(BOB),

1477

1

				target: H160::from(ALICE),

1478

1

				input: Vec::new(),

1479

1

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

1480

1

				gas_limit: 21_000u64,

1481

1

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

1482

1

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

1483

1

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

1484

1

				access_list: Vec::new(),

1485

1

				authorization_list: Vec::new(),

1486

1

})

1487

1

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

1488

1489

1

			let priority_fee = 200 * GIGAWEI * 21_000;

1490

1

			// Author free balance increased by priority fee.

1491

1

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

1492

1

});

1493

1

1494

1495

#[test]

1496

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

1497

1

	ExtBuilder::default()

1498

1

		.with_balances(vec![

1499

1

1500

1

				AccountId::from(BOB),

1501

1

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

1502

1

),

1503

1

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

1504

1

1505

1

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

1506

1

				existential_deposit(),

1507

1

),

1508

1

])

1509

1

		.build()

1510

1

		.execute_with(|| {

1511

1

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

1512

1

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

1513

1

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

1514

1

			// EVM transfer.

1515

1

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

1516

1

				source: H160::from(BOB),

1517

1

				target: H160::from(ALICE),

1518

1

				input: Vec::new(),

1519

1

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

1520

1

				gas_limit: 21_000u64,

1521

1

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

1522

1

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

1523

1

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

1524

1

				access_list: Vec::new(),

1525

1

				authorization_list: Vec::new(),

1526

1

})

1527

1

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

1528

1529

1

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

1530

1

1531

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

1532

1

1533

1

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

1534

1

1535

1

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

1536

1

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

1537

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1538

1

1539

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1540

1541

1

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

1542

1

});

1543

1

1544

1545

#[test]

1546

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

1547

	use fp_evm::FeeCalculator;

1548

1

	ExtBuilder::default()

1549

1

		.with_balances(vec![

1550

1

1551

1

				AccountId::from(BOB),

1552

1

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

1553

1

),

1554

1

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

1555

1

1556

1

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

1557

1

				existential_deposit(),

1558

1

),

1559

1

])

1560

1

		.build()

1561

1

		.execute_with(|| {

1562

1

			set_parachain_inherent_data();

1563

1

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

1564

1

			// EVM transfer.

1565

1

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

1566

1

				source: H160::from(BOB),

1567

1

				target: H160::from(ALICE),

1568

1

				input: Vec::new(),

1569

1

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

1570

1

				gas_limit: 21_000u64,

1571

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1572

1

				max_priority_fee_per_gas: None,

1573

1

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

1574

1

				access_list: Vec::new(),

1575

1

				authorization_list: Vec::new(),

1576

1

})

1577

1

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

1578

1579

1

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

1580

1

			// Fee is 1 GWEI base fee.

1581

1

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

1582

1

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

1583

1584

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

1585

1

1586

1

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

1587

1

1588

1

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

1589

1

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

1590

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

1591

1

1592

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

1593

1594

1

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

1595

1

});

1596

1

1597

1598

#[test]

1599

1

fn root_can_change_default_xcm_vers() {

1600

1

	ExtBuilder::default()

1601

1

		.with_balances(vec![

1602

1

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

1603

1

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

1604

1

])

1605

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1606

1

			asset_id: 1,

1607

1

			xcm_location: AssetHubLocation::get(),

1608

1

			name: "Dot",

1609

1

			symbol: "Dot",

1610

1

			decimals: 12,

1611

1

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

1612

1

}])

1613

1

		.build()

1614

1

		.execute_with(|| {

1615

1

			let source_id: moonbase_runtime::AssetId = 1;

1616

1

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

1617

1

			let asset = Asset {

1618

1

				id: AssetId(

1619

1

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

1620

1

						currency_id,

1621

1

1622

1

					.unwrap(),

1623

1

),

1624

1

				fun: Fungibility::Fungible(100_000_000_000_000),

1625

1

};

1626

1

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

1627

1

			// know with which version to send

1628

1

			assert_noop!(

1629

1

				PolkadotXcm::transfer_assets(

1630

1

					origin_of(AccountId::from(ALICE)),

1631

1

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

1632

1

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

1633

1

						parents: 0,

1634

1

						interior: [AccountId32 {

1635

1

							network: None,

1636

1

							id: [1u8; 32],

1637

1

}]

1638

1

						.into(),

1639

1

					})),

1640

1

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

1641

1

0,

1642

1

					WeightLimit::Unlimited

1643

1

),

1644

1

				pallet_xcm::Error::<Runtime>::LocalExecutionIncomplete

1645

1

);

1646

1647

			// Root sets the defaultXcm

1648

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

1649

1

				root_origin(),

1650

1

				Some(5)

1651

1

));

1652

1653

			// Now transferring does not fail

1654

1

			assert_ok!(PolkadotXcm::transfer_assets(

1655

1

				origin_of(AccountId::from(ALICE)),

1656

1

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

1657

1

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

1658

1

					parents: 0,

1659

1

					interior: [AccountId32 {

1660

1

						network: None,

1661

1

						id: [1u8; 32],

1662

1

}]

1663

1

					.into(),

1664

1

				})),

1665

1

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

1666

1

0,

1667

1

				WeightLimit::Unlimited

1668

1

));

1669

1

})

1670

1

1671

1672

#[test]

1673

1

fn transactor_cannot_use_more_than_max_weight() {

1674

1

	ExtBuilder::default()

1675

1

		.with_balances(vec![

1676

1

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

1677

1

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

1678

1

])

1679

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1680

1

			asset_id: 1,

1681

1

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

1682

1

			name: "RelayToken",

1683

1

			symbol: "Relay",

1684

1

			decimals: 12,

1685

1

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

1686

1

}])

1687

1

		.build()

1688

1

		.execute_with(|| {

1689

1

			let source_id: moonbase_runtime::AssetId = 1;

1690

1

			assert_ok!(XcmTransactor::register(

1691

1

				root_origin(),

1692

1

				AccountId::from(ALICE),

1693

1

0,

1694

1

));

1695

1696

			// Root can set transact info

1697

1

			assert_ok!(XcmTransactor::set_transact_info(

1698

1

				root_origin(),

1699

1

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

1700

1

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

1701

1

				3000.into(),

1702

1

				20000.into(),

1703

1

				None

1704

1

));

1705

			// Root can set transact info

1706

1

			assert_ok!(XcmTransactor::set_fee_per_second(

1707

1

				root_origin(),

1708

1

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

1709

1

1,

1710

1

));

1711

1712

1

			assert_noop!(

1713

1

				XcmTransactor::transact_through_derivative(

1714

1

					origin_of(AccountId::from(ALICE)),

1715

1

					moonbase_runtime::xcm_config::Transactors::Relay,

1716

1

0,

1717

1

					CurrencyPayment {

1718

1

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

1719

1

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

1720

1

)),

1721

1

						fee_amount: None

1722

1

},

1723

1

					vec![],

1724

1

					// 20000 is the max

1725

1

					TransactWeights {

1726

1

						transact_required_weight_at_most: 17001.into(),

1727

1

						overall_weight: None

1728

1

},

1729

1

					false

1730

1

),

1731

1

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

1732

1

);

1733

1

			assert_noop!(

1734

1

				XcmTransactor::transact_through_derivative(

1735

1

					origin_of(AccountId::from(ALICE)),

1736

1

					moonbase_runtime::xcm_config::Transactors::Relay,

1737

1

0,

1738

1

					CurrencyPayment {

1739

1

						currency: Currency::AsCurrencyId(

1740

1

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

1741

1

),

1742

1

						fee_amount: None

1743

1

},

1744

1

					vec![],

1745

1

					// 20000 is the max

1746

1

					TransactWeights {

1747

1

						transact_required_weight_at_most: 17001.into(),

1748

1

						overall_weight: None

1749

1

},

1750

1

					false

1751

1

),

1752

1

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

1753

1

);

1754

1

})

1755

1

1756

1757

#[test]

1758

1

fn root_can_use_hrmp_manage() {

1759

1

	ExtBuilder::default()

1760

1

		.with_balances(vec![

1761

1

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

1762

1

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

1763

1

])

1764

1

		.build()

1765

1

		.execute_with(|| {

1766

1

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

1767

1

			// But all rest checks pass

1768

1

			assert_noop!(

1769

1

				XcmTransactor::hrmp_manage(

1770

1

					root_origin(),

1771

1

					HrmpOperation::Accept {

1772

1

						para_id: 2000u32.into()

1773

1

},

1774

1

					CurrencyPayment {

1775

1

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

1776

1

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

1777

1

)),

1778

1

						fee_amount: Some(10000)

1779

1

},

1780

1

					// 20000 is the max

1781

1

					TransactWeights {

1782

1

						transact_required_weight_at_most: 17001.into(),

1783

1

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

1784

1

1785

1

),

1786

1

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

1787

1

);

1788

1

})

1789

1

1790

1791

#[test]

1792

1

fn transact_through_signed_precompile_works_v1() {

1793

1

	ExtBuilder::default()

1794

1

		.with_balances(vec![

1795

1

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

1796

1

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

1797

1

])

1798

1

		.with_safe_xcm_version(3)

1799

1

		.build()

1800

1

		.execute_with(|| {

1801

1

			// Destination

1802

1

			let dest = Location::parent();

1803

1

1804

1

			let fee_payer_asset = Location::parent();

1805

1

1806

1

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

1807

1

1808

1

			let xcm_transactor_v1_precompile_address = H160::from_low_u64_be(2054);

1809

1

1810

1

			// Root can set transact info

1811

1

			assert_ok!(XcmTransactor::set_transact_info(

1812

1

				root_origin(),

1813

1

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

1814

1

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

1815

1

				3000.into(),

1816

1

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

1817

1

				Some(4000.into())

1818

1

));

1819

			// Root can set transact info

1820

1

			assert_ok!(XcmTransactor::set_fee_per_second(

1821

1

				root_origin(),

1822

1

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

1823

1

1,

1824

1

));

1825

1826

1

			Precompiles::new()

1827

1

				.prepare_test(

1828

1

					ALICE,

1829

1

					xcm_transactor_v1_precompile_address,

1830

1

					XcmTransactorV1PCall::transact_through_signed_multilocation {

1831

1

						dest,

1832

1

						fee_asset: fee_payer_asset,

1833

1

						weight: 15000,

1834

1

						call: bytes.into(),

1835

1

},

1836

1

1837

1

				.expect_cost(30883)

1838

1

				.expect_no_logs()

1839

1

				.execute_returns(());

1840

1

});

1841

1

1842

1843

#[test]

1844

1

fn transact_through_signed_precompile_works_v2() {

1845

1

	ExtBuilder::default()

1846

1

		.with_balances(vec![

1847

1

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

1848

1

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

1849

1

])

1850

1

		.with_safe_xcm_version(3)

1851

1

		.build()

1852

1

		.execute_with(|| {

1853

1

			// Destination

1854

1

			let dest = Location::parent();

1855

1

1856

1

			let fee_payer_asset = Location::parent();

1857

1

1858

1

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

1859

1

1860

1

			let total_weight = 1_000_000_000u64;

1861

1

1862

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1863

1

1864

1

			Precompiles::new()

1865

1

				.prepare_test(

1866

1

					ALICE,

1867

1

					xcm_transactor_v2_precompile_address,

1868

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1869

1

						dest,

1870

1

						fee_asset: fee_payer_asset,

1871

1

						weight: 4_000_000,

1872

1

						call: bytes.into(),

1873

1

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

1874

1

						overall_weight: total_weight,

1875

1

},

1876

1

1877

1

				.expect_cost(30883)

1878

1

				.expect_no_logs()

1879

1

				.execute_returns(());

1880

1

});

1881

1

1882

1883

#[test]

1884

1

fn transact_through_signed_cannot_send_to_local_chain() {

1885

1

	ExtBuilder::default()

1886

1

		.with_balances(vec![

1887

1

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

1888

1

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

1889

1

])

1890

1

		.with_safe_xcm_version(3)

1891

1

		.build()

1892

1

		.execute_with(|| {

1893

1

			// Destination

1894

1

			let dest = Location::here();

1895

1

1896

1

			let fee_payer_asset = Location::parent();

1897

1

1898

1

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

1899

1

1900

1

			let total_weight = 1_000_000_000u64;

1901

1

1902

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

1903

1

1904

1

			Precompiles::new()

1905

1

				.prepare_test(

1906

1

					ALICE,

1907

1

					xcm_transactor_v2_precompile_address,

1908

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

1909

1

						dest,

1910

1

						fee_asset: fee_payer_asset,

1911

1

						weight: 4_000_000,

1912

1

						call: bytes.into(),

1913

1

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

1914

1

						overall_weight: total_weight,

1915

1

},

1916

1

1917

1

				.execute_reverts(|output| {

1918

1

					from_utf8(&output)

1919

1

						.unwrap()

1920

1

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

1921

1

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

1922

1

});

1923

1

});

1924

1

1925

1926

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

1927

#[test]

1928

1

fn account_id_32_encodes_like_32_byte_u8_slice() {

1929

1

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

1930

1

	let account_as_slice = [1u8; 32];

1931

1

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

1932

1

1933

1934

#[test]

1935

1

fn author_mapping_precompile_associate_update_and_clear() {

1936

1

	ExtBuilder::default()

1937

1

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

1938

1

		.build()

1939

1

		.execute_with(|| {

1940

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

1941

1

			let first_nimbus_id: NimbusId =

1942

1

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

1943

1

			let first_vrf_id: session_keys_primitives::VrfId =

1944

1

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

1945

1

			let second_nimbus_id: NimbusId =

1946

1

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

1947

1

			let second_vrf_id: session_keys_primitives::VrfId =

1948

1

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

1949

1

1950

1

			// Associate it

1951

1

			Precompiles::new()

1952

1

				.prepare_test(

1953

1

					ALICE,

1954

1

					author_mapping_precompile_address,

1955

1

					AuthorMappingPCall::add_association {

1956

1

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

1957

1

},

1958

1

1959

1

				.expect_cost(19935)

1960

1

				.expect_no_logs()

1961

1

				.execute_returns(());

1962

1

1963

1

			let expected_associate_event =

1964

1

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

1965

1

					nimbus_id: first_nimbus_id.clone(),

1966

1

					account_id: AccountId::from(ALICE),

1967

1

					keys: first_vrf_id.clone(),

1968

1

});

1969

1

			assert_eq!(last_event(), expected_associate_event);

1970

1971

			// Update it

1972

1

			Precompiles::new()

1973

1

				.prepare_test(

1974

1

					ALICE,

1975

1

					author_mapping_precompile_address,

1976

1

					AuthorMappingPCall::update_association {

1977

1

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

1978

1

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

1979

1

},

1980

1

1981

1

				.expect_cost(19452)

1982

1

				.expect_no_logs()

1983

1

				.execute_returns(());

1984

1

1985

1

			let expected_update_event =

1986

1

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

1987

1

					new_nimbus_id: second_nimbus_id.clone(),

1988

1

					account_id: AccountId::from(ALICE),

1989

1

					new_keys: second_vrf_id.clone(),

1990

1

});

1991

1

			assert_eq!(last_event(), expected_update_event);

1992

1993

			// Clear it

1994

1

			Precompiles::new()

1995

1

				.prepare_test(

1996

1

					ALICE,

1997

1

					author_mapping_precompile_address,

1998

1

					AuthorMappingPCall::clear_association {

1999

1

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

2000

1

},

2001

1

2002

1

				.expect_cost(19960)

2003

1

				.expect_no_logs()

2004

1

				.execute_returns(());

2005

1

2006

1

			let expected_clear_event =

2007

1

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

2008

1

					nimbus_id: second_nimbus_id,

2009

1

					account_id: AccountId::from(ALICE),

2010

1

					keys: second_vrf_id,

2011

1

});

2012

1

			assert_eq!(last_event(), expected_clear_event);

2013

1

});

2014

1

2015

2016

#[test]

2017

1

fn author_mapping_register_and_set_keys() {

2018

1

	ExtBuilder::default()

2019

1

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

2020

1

		.build()

2021

1

		.execute_with(|| {

2022

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2023

1

			let first_nimbus_id: NimbusId =

2024

1

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

2025

1

			let first_vrf_key: session_keys_primitives::VrfId =

2026

1

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

2027

1

			let second_nimbus_id: NimbusId =

2028

1

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

2029

1

			let second_vrf_key: session_keys_primitives::VrfId =

2030

1

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

2031

1

2032

1

			// Associate it

2033

1

			Precompiles::new()

2034

1

				.prepare_test(

2035

1

					ALICE,

2036

1

					author_mapping_precompile_address,

2037

1

					AuthorMappingPCall::set_keys {

2038

1

						keys: solidity::encode_arguments((

2039

1

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

2040

1

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

2041

1

))

2042

1

						.into(),

2043

1

},

2044

1

2045

1

				.expect_cost(22435)

2046

1

				.expect_no_logs()

2047

1

				.execute_returns(());

2048

1

2049

1

			let expected_associate_event =

2050

1

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

2051

1

					nimbus_id: first_nimbus_id.clone(),

2052

1

					account_id: AccountId::from(ALICE),

2053

1

					keys: first_vrf_key.clone(),

2054

1

});

2055

1

			assert_eq!(last_event(), expected_associate_event);

2056

2057

			// Update it

2058

1

			Precompiles::new()

2059

1

				.prepare_test(

2060

1

					ALICE,

2061

1

					author_mapping_precompile_address,

2062

1

					AuthorMappingPCall::set_keys {

2063

1

						keys: solidity::encode_arguments((

2064

1

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

2065

1

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

2066

1

))

2067

1

						.into(),

2068

1

},

2069

1

2070

1

				.expect_cost(22435)

2071

1

				.expect_no_logs()

2072

1

				.execute_returns(());

2073

1

2074

1

			let expected_update_event =

2075

1

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

2076

1

					new_nimbus_id: second_nimbus_id.clone(),

2077

1

					account_id: AccountId::from(ALICE),

2078

1

					new_keys: second_vrf_key.clone(),

2079

1

});

2080

1

			assert_eq!(last_event(), expected_update_event);

2081

1

});

2082

1

2083

2084

#[test]

2085

1

fn test_xcm_utils_ml_tp_account() {

2086

1

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

2087

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2088

1

		let expected_address_parent: H160 =

2089

1

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

2090

1

				.unwrap()

2091

1

				.into();

2092

1

2093

1

		Precompiles::new()

2094

1

			.prepare_test(

2095

1

				ALICE,

2096

1

				xcm_utils_precompile_address,

2097

1

				XcmUtilsPCall::multilocation_to_address {

2098

1

					location: Location::parent(),

2099

1

},

2100

1

2101

1

			.expect_cost(

2102

1

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

2103

1

					.read

2104

1

					.saturating_div(WEIGHT_PER_GAS)

2105

1

					.saturating_mul(2),

2106

1

2107

1

			.expect_no_logs()

2108

1

			.execute_returns(Address(expected_address_parent));

2109

1

2110

1

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

2111

1

		let expected_address_parachain: H160 =

2112

1

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

2113

1

				&parachain_2000_multilocation,

2114

1

2115

1

			.unwrap()

2116

1

			.into();

2117

1

2118

1

		Precompiles::new()

2119

1

			.prepare_test(

2120

1

				ALICE,

2121

1

				xcm_utils_precompile_address,

2122

1

				XcmUtilsPCall::multilocation_to_address {

2123

1

					location: parachain_2000_multilocation,

2124

1

},

2125

1

2126

1

			.expect_cost(

2127

1

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

2128

1

					.read

2129

1

					.saturating_div(WEIGHT_PER_GAS)

2130

1

					.saturating_mul(2),

2131

1

2132

1

			.expect_no_logs()

2133

1

			.execute_returns(Address(expected_address_parachain));

2134

1

2135

1

		let alice_in_parachain_2000_multilocation = Location::new(

2136

1

1,

2137

1

2138

1

				Parachain(2000),

2139

1

				AccountKey20 {

2140

1

					network: None,

2141

1

					key: ALICE,

2142

1

},

2143

1

],

2144

1

);

2145

1

		let expected_address_alice_in_parachain_2000 =

2146

1

			xcm_builder::HashedDescription::<

2147

1

				AccountId,

2148

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2149

1

			>::convert_location(&alice_in_parachain_2000_multilocation)

2150

1

			.unwrap()

2151

1

			.into();

2152

1

2153

1

		Precompiles::new()

2154

1

			.prepare_test(

2155

1

				ALICE,

2156

1

				xcm_utils_precompile_address,

2157

1

				XcmUtilsPCall::multilocation_to_address {

2158

1

					location: alice_in_parachain_2000_multilocation,

2159

1

},

2160

1

2161

1

			.expect_cost(

2162

1

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

2163

1

					.read

2164

1

					.saturating_div(WEIGHT_PER_GAS)

2165

1

					.saturating_mul(2),

2166

1

2167

1

			.expect_no_logs()

2168

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2169

1

});

2170

1

2171

2172

#[test]

2173

1

fn test_nested_batch_calls_from_xcm_transact() {

2174

1

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

2175

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2176

1

		// in a future polkadot-sdk version

2177

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2178

2179

1

		let mut valid_nested_calls =

2180

1

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

2181

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2182

8

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

2183

8

				calls: vec![valid_nested_calls],

2184

8

});

2185

8

2186

2187

1

		let valid_message = Xcm(vec![Transact {

2188

1

			origin_kind: OriginKind::SovereignAccount,

2189

1

			fallback_max_weight: None,

2190

1

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

2191

1

		}]);

2192

1

2193

1

		assert!(XcmExecutor::prepare(valid_message).is_ok());

2194

2195

1

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

2196

1

			calls: vec![valid_nested_calls],

2197

1

});

2198

1

2199

1

		let invalid_message = Xcm(vec![Transact {

2200

1

			origin_kind: OriginKind::SovereignAccount,

2201

1

			fallback_max_weight: None,

2202

1

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

2203

1

		}]);

2204

1

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

2205

1

		assert!(XcmExecutor::prepare(invalid_message).is_err());

2206

1

});

2207

1

2208

2209

#[test]

2210

1

fn test_xcm_utils_weight_message() {

2211

1

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

2212

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2213

1

		let expected_weight =

2214

1

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

2215

1

2216

1

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

2217

1

2218

1

		let input = XcmUtilsPCall::weight_message {

2219

1

			message: message.into(),

2220

1

};

2221

1

2222

1

		Precompiles::new()

2223

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2224

1

			.expect_cost(

2225

1

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

2226

1

					.read

2227

1

					.saturating_div(WEIGHT_PER_GAS),

2228

1

2229

1

			.expect_no_logs()

2230

1

			.execute_returns(expected_weight);

2231

1

});

2232

1

2233

2234

#[test]

2235

1

fn test_xcm_utils_get_units_per_second() {

2236

1

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

2237

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2238

1

		let location = SelfReserve::get();

2239

1

2240

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2241

1

2242

1

		let expected_units =

2243

1

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

2244

1

2245

1

		Precompiles::new()

2246

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2247

1

			.expect_cost(

2248

1

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

2249

1

					.read

2250

1

					.saturating_div(WEIGHT_PER_GAS)

2251

1

					.saturating_mul(2),

2252

1

2253

1

			.expect_no_logs()

2254

1

			.execute_returns(expected_units);

2255

1

});

2256

1

2257

2258

#[test]

2259

1

fn precompile_existence() {

2260

1

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

2261

1

		let precompiles = Precompiles::new();

2262

1

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

2263

1

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

2264

1

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

2265

1

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

2266

1

2267

1

		.into_iter()

2268

1

		.map(H160::from_low_u64_be)

2269

1

		.collect();

2270

2271

3001

		for i in 0..3000 {

2272

3000

			let address = H160::from_low_u64_be(i);

2273

3000

2274

3000

			if precompile_addresses.contains(&address) {

2275

48

				assert!(

2276

48

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

2277

					"is_precompile({}) should return true",

2278

2279

);

2280

2281

48

				assert!(

2282

48

					precompiles

2283

48

						.execute(&mut MockHandle::new(

2284

48

							address,

2285

48

							Context {

2286

48

								address,

2287

48

								caller: H160::zero(),

2288

48

								apparent_value: U256::zero()

2289

48

2290

48

),)

2291

48

						.is_some(),

2292

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

2293

2294

);

2295

			} else {

2296

2952

				assert!(

2297

2952

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

2298

					"is_precompile({}) should return false",

2299

2300

);

2301

2302

2952

				assert!(

2303

2952

					precompiles

2304

2952

						.execute(&mut MockHandle::new(

2305

2952

							address,

2306

2952

							Context {

2307

2952

								address,

2308

2952

								caller: H160::zero(),

2309

2952

								apparent_value: U256::zero()

2310

2952

2311

2952

),)

2312

2952

						.is_none(),

2313

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

2314

2315

);

2316

2317

2318

1

});

2319

1

2320

2321

#[test]

2322

1

fn removed_precompiles() {

2323

1

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

2324

1

		let precompiles = Precompiles::new();

2325

1

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

2326

2327

3000

		for i in 1..3000 {

2328

2999

			let address = H160::from_low_u64_be(i);

2329

2999

2330

2999

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

2331

2951

				continue;

2332

48

2333

48

2334

48

			if !removed_precompiles.contains(&i) {

2335

43

				assert!(

2336

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2337

43

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

2338

						_ => false,

2339

},

2340

					"{i} should be an active precompile"

2341

);

2342

43

				continue;

2343

5

2344

5

2345

5

			assert!(

2346

5

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

2347

5

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

2348

					_ => false,

2349

},

2350

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

2351

);

2352

2353

5

			precompiles

2354

5

				.prepare_test(Alice, address, [])

2355

5

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

2356

5

2357

1

})

2358

1

2359

2360

#[test]

2361

1

fn substrate_based_fees_zero_txn_costs_only_base_extrinsic() {

2362

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

2363

	use moonbase_runtime::{currency, EXTRINSIC_BASE_WEIGHT};

2364

2365

1

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

2366

1

		let size_bytes = 0;

2367

1

		let tip = 0;

2368

1

		let dispatch_info = DispatchInfo {

2369

1

			class: DispatchClass::Normal,

2370

1

			pays_fee: Pays::Yes,

2371

1

			call_weight: Weight::zero(),

2372

1

			extension_weight: Weight::zero(),

2373

1

};

2374

1

2375

1

		assert_eq!(

2376

1

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

2377

1

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

2378

1

);

2379

1

});

2380

1

2381

2382

#[test]

2383

1

fn deal_with_fees_handles_tip() {

2384

	use frame_support::traits::OnUnbalanced;

2385

	use moonbase_runtime::Treasury;

2386

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2387

2388

1

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

2389

1

		set_parachain_inherent_data();

2390

1

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

2391

1

		// in the Moonbeam runtime. It verifies that:

2392

1

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

2393

1

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

2394

1

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

2395

1

2396

1

		// The test details:

2397

1

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

2398

1

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

2399

1

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

2400

1

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

2401

1

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

2402

1

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

2403

1

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

2404

1

2405

1

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

2406

1

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

2407

1

			AccountId,

2408

1

		>>::issue(100);

2409

1

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

2410

1

			AccountId,

2411

1

		>>::issue(1000);

2412

1

2413

1

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

2414

1

		let total_supply_before = Balances::total_issuance();

2415

1

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

2416

1

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

2417

1

		assert_eq!(total_supply_before, 1_100);

2418

1

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

2419

2420

		// Step 3: Execute the fees handling logic.

2421

1

		DealWithSubstrateFeesAndTip::<

2422

1

			Runtime,

2423

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2424

1

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

2425

1

2426

1

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

2427

1

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

2428

1

2429

1

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

2430

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2431

1

2432

1

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

2433

1

		assert_eq!(

2434

1

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

2435

1

			treasury_fee_part,

2436

1

);

2437

2438

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

2439

1

		let total_supply_after = Balances::total_issuance();

2440

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2441

2442

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

2443

1

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

2444

1

		assert_eq!(

2445

1

			block_author_balance_after - block_author_balance_before,

2446

1

			1000,

2447

1

);

2448

1

});

2449

1

2450

2451

#[test]

2452

1

fn evm_revert_substrate_events() {

2453

1

	ExtBuilder::default()

2454

1

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

2455

1

		.build()

2456

1

		.execute_with(|| {

2457

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2458

1

2459

1

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

2460

1

			// Thus BatchAll will revert the transfer.

2461

1

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

2462

1

				source: ALICE.into(),

2463

1

				target: batch_precompile_address,

2464

1

				input: BatchPCall::batch_all {

2465

1

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

2466

1

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

2467

1

					call_data: vec![].into(),

2468

1

					gas_limit: vec![].into()

2469

1

2470

1

				.into(),

2471

1

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

2472

1

				gas_limit: 500_000,

2473

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2474

1

				max_priority_fee_per_gas: None,

2475

1

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

2476

1

				access_list: Vec::new(),

2477

1

				authorization_list: Vec::new(),

2478

1

})

2479

1

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

2480

2481

1

			let transfer_count = System::events()

2482

1

				.iter()

2483

4

				.filter(|r| match r.event {

2484

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

2485

6

					_ => false,

2486

6

})

2487

1

				.count();

2488

1

2489

1

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

2490

1

});

2491

1

2492

2493

#[test]

2494

1

fn evm_success_keeps_substrate_events() {

2495

1

	ExtBuilder::default()

2496

1

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

2497

1

		.build()

2498

1

		.execute_with(|| {

2499

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2500

1

2501

1

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

2502

1

				source: ALICE.into(),

2503

1

				target: batch_precompile_address,

2504

1

				input: BatchPCall::batch_all {

2505

1

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

2506

1

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

2507

1

					call_data: vec![].into(),

2508

1

					gas_limit: vec![].into()

2509

1

2510

1

				.into(),

2511

1

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

2512

1

				gas_limit: 500_000,

2513

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2514

1

				max_priority_fee_per_gas: None,

2515

1

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

2516

1

				access_list: Vec::new(),

2517

1

				authorization_list: Vec::new(),

2518

1

})

2519

1

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

2520

2521

1

			let transfer_count = System::events()

2522

1

				.iter()

2523

6

				.filter(|r| match r.event {

2524

1

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

2525

9

					_ => false,

2526

10

})

2527

1

				.count();

2528

1

2529

1

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

2530

1

});

2531

1

2532

2533

#[test]

2534

1

fn validate_transaction_fails_on_filtered_call() {

2535

	use sp_runtime::transaction_validity::{

2536

		InvalidTransaction, TransactionSource, TransactionValidityError,

2537

};

2538

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

2539

2540

1

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

2541

1

		let xt = UncheckedExtrinsic::new_bare(

2542

1

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

2543

1

				source: Default::default(),

2544

1

				target: H160::default(),

2545

1

				input: Vec::new(),

2546

1

				value: Default::default(),

2547

1

				gas_limit: Default::default(),

2548

1

				max_fee_per_gas: Default::default(),

2549

1

				max_priority_fee_per_gas: Default::default(),

2550

1

				nonce: Default::default(),

2551

1

				access_list: Default::default(),

2552

1

				authorization_list: Default::default(),

2553

1

2554

1

			.into(),

2555

1

);

2556

1

2557

1

		assert_eq!(

2558

1

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

2559

1

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

2560

1

);

2561

1

});

2562

1

2563

2564

#[cfg(test)]

2565

mod treasury_tests {

2566

	use super::*;

2567

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

2568

	use moonbase_runtime::XcmWeightTrader;

2569

	use sp_runtime::traits::Hash;

2570

2571

8

	fn expect_events(events: Vec<RuntimeEvent>) {

2572

8

		let block_events: Vec<RuntimeEvent> =

2573

59

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

2574

8

2575

8

		dbg!(events.clone());

2576

8

		dbg!(block_events.clone());

2577

8

2578

12

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

2579

8

2580

2581

13

	fn next_block() {

2582

13

		System::reset_events();

2583

13

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

2584

13

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

2585

13

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

2586

13

2587

2588

6

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

2589

6

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

2590

6

			.expect("failed to get account balance")

2591

6

2592

2593

	#[test]

2594

1

	fn test_treasury_spend_local_with_root_origin() {

2595

1

		let initial_treasury_balance = 1_000 * UNIT;

2596

1

		ExtBuilder::default()

2597

1

			.with_balances(vec![

2598

1

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

2599

1

				(Treasury::account_id(), initial_treasury_balance),

2600

1

])

2601

1

			.build()

2602

1

			.execute_with(|| {

2603

1

				let spend_amount = 100u128 * UNIT;

2604

1

				let spend_beneficiary = AccountId::from(BOB);

2605

1

2606

1

				next_block();

2607

1

2608

1

				// Perform treasury spending

2609

1

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

2610

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

2611

1

					root_origin(),

2612

1

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

2613

1

						amount: spend_amount,

2614

1

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

2615

1

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

2616

1

						valid_from: Some(valid_from),

2617

1

}))

2618

1

));

2619

2620

1

				let payout_period =

2621

1

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

2622

1

				let expected_events = [RuntimeEvent::Treasury(

2623

1

					pallet_treasury::Event::AssetSpendApproved {

2624

1

						index: 0,

2625

1

						asset_kind: NativeOrWithId::Native,

2626

1

						amount: spend_amount,

2627

1

						beneficiary: spend_beneficiary,

2628

1

						valid_from,

2629

1

						expire_at: payout_period + valid_from,

2630

1

},

2631

1

)]

2632

1

				.to_vec();

2633

1

				expect_events(expected_events);

2634

2635

6

				while System::block_number() < valid_from {

2636

5

					next_block();

2637

5

2638

2639

1

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

2640

2641

1

				let expected_events = [

2642

1

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

2643

1

						index: 0,

2644

1

						payment_id: (),

2645

1

}),

2646

1

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

2647

1

						from: Treasury::account_id(),

2648

1

						to: spend_beneficiary,

2649

1

						amount: spend_amount,

2650

1

}),

2651

1

2652

1

				.to_vec();

2653

1

				expect_events(expected_events);

2654

1

});

2655

1

2656

2657

	#[test]

2658

1

	fn test_treasury_spend_local_with_council_origin() {

2659

1

		let initial_treasury_balance = 1_000 * UNIT;

2660

1

		ExtBuilder::default()

2661

1

			.with_balances(vec![

2662

1

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

2663

1

				(Treasury::account_id(), initial_treasury_balance),

2664

1

])

2665

1

			.build()

2666

1

			.execute_with(|| {

2667

1

				let spend_amount = 100u128 * UNIT;

2668

1

				let spend_beneficiary = AccountId::from(BOB);

2669

1

2670

1

				next_block();

2671

1

2672

1

				// TreasuryCouncilCollective

2673

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2674

1

					root_origin(),

2675

1

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

2676

1

					Some(AccountId::from(ALICE)),

2677

1

2678

1

));

2679

2680

1

				next_block();

2681

1

2682

1

				// Perform treasury spending

2683

1

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

2684

1

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

2685

1

					amount: spend_amount,

2686

1

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

2687

1

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

2688

1

					valid_from: Some(valid_from),

2689

1

});

2690

1

				assert_ok!(TreasuryCouncilCollective::propose(

2691

1

					origin_of(AccountId::from(ALICE)),

2692

1

1,

2693

1

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

2694

1

					1_000

2695

1

));

2696

2697

1

				let payout_period =

2698

1

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

2699

1

				let expected_events = [

2700

1

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

2701

1

						index: 0,

2702

1

						asset_kind: NativeOrWithId::Native,

2703

1

						amount: spend_amount,

2704

1

						beneficiary: spend_beneficiary,

2705

1

						valid_from,

2706

1

						expire_at: payout_period + valid_from,

2707

1

}),

2708

1

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

2709

1

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

2710

1

						result: Ok(()),

2711

1

}),

2712

1

2713

1

				.to_vec();

2714

1

				expect_events(expected_events);

2715

2716

6

				while System::block_number() < valid_from {

2717

5

					next_block();

2718

5

2719

2720

1

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

2721

2722

1

				let expected_events = [

2723

1

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

2724

1

						index: 0,

2725

1

						payment_id: (),

2726

1

}),

2727

1

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

2728

1

						from: Treasury::account_id(),

2729

1

						to: spend_beneficiary,

2730

1

						amount: spend_amount,

2731

1

}),

2732

1

2733

1

				.to_vec();

2734

1

				expect_events(expected_events);

2735

1

});

2736

1

2737

2738

	#[test]

2739

1

	fn test_treasury_spend_foreign_asset_with_root_origin() {

2740

1

		let initial_treasury_balance = 1_000 * UNIT;

2741

1

		let asset_id = 1000100010001000u128;

2742

1

		ExtBuilder::default()

2743

1

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

2744

1

			.build()

2745

1

			.execute_with(|| {

2746

1

				let spend_amount = 100u128 * UNIT;

2747

1

				let spend_beneficiary = AccountId::from(BOB);

2748

1

2749

1

				let asset_location: Location = Location {

2750

1

					parents: 1,

2751

1

					interior: Junctions::Here,

2752

1

};

2753

1

2754

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2755

1

					root_origin(),

2756

1

					asset_id,

2757

1

					asset_location.clone(),

2758

1

12,

2759

1

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

2760

1

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

2761

1

));

2762

2763

1

				assert_ok!(XcmWeightTrader::add_asset(

2764

1

					root_origin(),

2765

1

					asset_location,

2766

1

					1u128

2767

1

));

2768

2769

1

				assert_ok!(EvmForeignAssets::mint_into(

2770

1

					asset_id,

2771

1

					Treasury::account_id(),

2772

1

					initial_treasury_balance.into()

2773

1

));

2774

2775

1

				assert_eq!(

2776

1

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

2777

1

					initial_treasury_balance.into(),

2778

					"Treasury balance not updated"

2779

);

2780

2781

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

2782

1

					root_origin(),

2783

1

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

2784

1

						amount: spend_amount,

2785

1

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

2786

1

						beneficiary: Box::new(spend_beneficiary),

2787

1

						valid_from: None,

2788

1

}))

2789

1

));

2790

2791

1

				let payout_period =

2792

1

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

2793

1

2794

1

				let current_block = System::block_number();

2795

1

				expect_events(vec![RuntimeEvent::Treasury(

2796

1

					pallet_treasury::Event::AssetSpendApproved {

2797

1

						index: 0,

2798

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2799

1

						amount: spend_amount,

2800

1

						beneficiary: spend_beneficiary,

2801

1

						valid_from: current_block,

2802

1

						expire_at: current_block + payout_period,

2803

1

},

2804

1

				)]);

2805

1

2806

1

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

2807

2808

1

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

2809

1

					index: 0,

2810

1

					payment_id: (),

2811

1

				})]);

2812

1

2813

1

				assert_eq!(

2814

1

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

2815

1

					(initial_treasury_balance - spend_amount).into(),

2816

					"Treasury balance not updated"

2817

);

2818

2819

1

				assert_eq!(

2820

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2821

1

					spend_amount.into(),

2822

					"Treasury payout failed"

2823

);

2824

1

});

2825

1

2826

2827

	#[test]

2828

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

2829

1

		let initial_treasury_balance = 1_000 * UNIT;

2830

1

		let asset_id = 1000100010001000u128;

2831

1

		ExtBuilder::default()

2832

1

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

2833

1

			.build()

2834

1

			.execute_with(|| {

2835

1

				let spend_amount = 100u128 * UNIT;

2836

1

				let spend_beneficiary = AccountId::from(BOB);

2837

1

2838

1

				let asset_location: Location = Location {

2839

1

					parents: 1,

2840

1

					interior: Junctions::Here,

2841

1

};

2842

1

2843

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

2844

1

					root_origin(),

2845

1

					asset_id,

2846

1

					asset_location.clone(),

2847

1

12,

2848

1

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

2849

1

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

2850

1

));

2851

2852

1

				assert_ok!(XcmWeightTrader::add_asset(

2853

1

					root_origin(),

2854

1

					asset_location,

2855

1

					1u128

2856

1

));

2857

2858

1

				assert_ok!(EvmForeignAssets::mint_into(

2859

1

					asset_id,

2860

1

					Treasury::account_id(),

2861

1

					initial_treasury_balance.into()

2862

1

));

2863

2864

1

				assert_eq!(

2865

1

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

2866

1

					initial_treasury_balance.into(),

2867

					"Treasury balance not updated"

2868

);

2869

2870

				// TreasuryCouncilCollective

2871

1

				assert_ok!(TreasuryCouncilCollective::set_members(

2872

1

					root_origin(),

2873

1

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

2874

1

					Some(AccountId::from(ALICE)),

2875

1

2876

1

));

2877

2878

				// Perform treasury spending

2879

1

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

2880

1

					amount: spend_amount,

2881

1

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

2882

1

					beneficiary: Box::new(spend_beneficiary),

2883

1

					valid_from: None,

2884

1

});

2885

1

				assert_ok!(TreasuryCouncilCollective::propose(

2886

1

					origin_of(AccountId::from(ALICE)),

2887

1

1,

2888

1

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

2889

1

					1_000

2890

1

));

2891

2892

1

				let payout_period =

2893

1

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

2894

1

2895

1

				let current_block = System::block_number();

2896

1

				let expected_events = [

2897

1

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

2898

1

						index: 0,

2899

1

						asset_kind: NativeOrWithId::WithId(asset_id),

2900

1

						amount: spend_amount,

2901

1

						beneficiary: spend_beneficiary,

2902

1

						valid_from: current_block,

2903

1

						expire_at: current_block + payout_period,

2904

1

}),

2905

1

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

2906

1

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

2907

1

						result: Ok(()),

2908

1

}),

2909

1

2910

1

				.to_vec();

2911

1

				expect_events(expected_events);

2912

1

2913

1

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

2914

2915

1

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

2916

1

					index: 0,

2917

1

					payment_id: (),

2918

1

				})]);

2919

1

2920

1

				assert_eq!(

2921

1

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

2922

1

					(initial_treasury_balance - spend_amount).into(),

2923

					"Treasury balance not updated"

2924

);

2925

2926

1

				assert_eq!(

2927

1

					get_asset_balance(&asset_id, &spend_beneficiary),

2928

1

					spend_amount.into(),

2929

					"Treasury payout failed"

2930

);

2931

1

});

2932

1

2933

2934

2935

#[cfg(test)]

2936

mod fee_tests {

2937

	use super::*;

2938

	use fp_evm::FeeCalculator;

2939

	use frame_support::{

2940

		traits::{ConstU128, OnFinalize},

2941

		weights::{ConstantMultiplier, WeightToFee},

2942

};

2943

	use moonbase_runtime::{

2944

		currency, BlockWeights, FastAdjustingFeeUpdate, LengthToFee, MinimumMultiplier,

2945

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

2946

};

2947

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

2948

2949

1

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

2950

1

	where

2951

1

		F: FnMut() -> (),

2952

1

2953

1

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

2954

1

			.build_storage()

2955

1

			.unwrap()

2956

1

			.into();

2957

1

		t.execute_with(|| {

2958

1

			System::set_block_consumed_resources(w, 0);

2959

1

			assertions()

2960

1

});

2961

1

2962

2963

	#[test]

2964

1

	fn test_multiplier_can_grow_from_zero() {

2965

1

		let minimum_multiplier = MinimumMultiplier::get();

2966

1

		let target = TargetBlockFullness::get()

2967

1

			* BlockWeights::get()

2968

1

				.get(DispatchClass::Normal)

2969

1

				.max_total

2970

1

				.unwrap();

2971

1

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

2972

1

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

2973

1

		run_with_system_weight(target * 101 / 100, || {

2974

1

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

2975

1

			assert!(

2976

1

				next > minimum_multiplier,

2977

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

2978

				next,

2979

				minimum_multiplier

2980

);

2981

1

})

2982

1

2983

2984

	#[test]

2985

1

	fn test_fee_calculation() {

2986

1

		let base_extrinsic = BlockWeights::get()

2987

1

			.get(DispatchClass::Normal)

2988

1

			.base_extrinsic;

2989

1

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

2990

1

		let extrinsic_len = 100u32;

2991

1

		let extrinsic_weight = 5_000u64;

2992

1

		let tip = 42u128;

2993

		type WeightToFeeImpl =

2994

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

2995

		type LengthToFeeImpl = LengthToFee;

2996

2997

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

2998

1

		let expected_fee =

2999

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3000

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

3001

1

					&Weight::from_parts(extrinsic_weight, 1),

3002

1

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

3003

1

				+ tip;

3004

1

3005

1

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

3006

1

			.build_storage()

3007

1

			.unwrap()

3008

1

			.into();

3009

1

		t.execute_with(|| {

3010

1

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

3011

1

			let actual_fee = TransactionPayment::compute_fee(

3012

1

				extrinsic_len,

3013

1

				&frame_support::dispatch::DispatchInfo {

3014

1

					class: DispatchClass::Normal,

3015

1

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

3016

1

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

3017

1

					extension_weight: Weight::zero(),

3018

1

},

3019

1

				tip,

3020

1

);

3021

1

3022

1

			assert_eq!(

3023

				expected_fee,

3024

				actual_fee,

3025

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

3026

				actual_fee - expected_fee

3027

);

3028

1

});

3029

1

3030

3031

	#[test]

3032

1

	fn test_min_gas_price_is_deterministic() {

3033

1

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

3034

1

			.build_storage()

3035

1

			.unwrap()

3036

1

			.into();

3037

1

		t.execute_with(|| {

3038

1

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

3039

1

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

3040

1

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

3041

1

			let expected: U256 = multiplier

3042

1

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

3043

1

				.into();

3044

1

3045

1

			assert_eq!(expected, actual);

3046

1

});

3047

1

3048

3049

	#[test]

3050

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3051

1

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

3052

1

			.build_storage()

3053

1

			.unwrap()

3054

1

			.into();

3055

1

		t.execute_with(|| {

3056

1

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

3057

1

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

3058

1

3059

1

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

3060

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3061

1

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

3062

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3063

1

3064

1

			assert_ne!(

3065

				a, b,

3066

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

3067

);

3068

1

});

3069

1

3070

3071

	#[test]

3072

1

	fn test_fee_scenarios() {

3073

		use sp_runtime::FixedU128;

3074

1

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

3075

1

			.build_storage()

3076

1

			.unwrap()

3077

1

			.into();

3078

1

		t.execute_with(|| {

3079

1

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

3080

12

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

3081

12

				let start_multiplier =

3082

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3083

12

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

3084

12

3085

12

				let block_weight = NORMAL_WEIGHT * fullness;

3086

3087

60004

				for i in 0..num_blocks {

3088

60004

					System::set_block_number(i as u32);

3089

60004

					System::set_block_consumed_resources(block_weight, 0);

3090

60004

					TransactionPayment::on_finalize(i as u32);

3091

60004

3092

3093

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3094

12

};

3095

3096

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

3097

			// they are expected to change when parameters that influence

3098

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

3099

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

3100

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

3101

3102

1

			assert_eq!(

3103

1

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

3104

1

				U256::from(998_600_980),

3105

1

);

3106

1

			assert_eq!(

3107

1

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

3108

1

				U256::from(999_600_080),

3109

1

);

3110

1

			assert_eq!(

3111

1

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

3112

1

				U256::from(1_000_600_180),

3113

1

);

3114

1

			assert_eq!(

3115

1

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

3116

1

				U256::from(1_002_603_380),

3117

1

);

3118

3119

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

3120

1

			assert_eq!(

3121

1

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

3122

1

				U256::from(431_710_642),

3123

1

);

3124

1

			assert_eq!(

3125

1

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

3126

1

				U256::from(786_627_866),

3127

1

);

3128

1

			assert_eq!(

3129

1

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

3130

1

				U256::from(1_433_329_383u128),

3131

1

);

3132

1

			assert_eq!(

3133

1

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

3134

1

				U256::from(4_758_812_897u128),

3135

1

);

3136

3137

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

3138

1

			assert_eq!(

3139

1

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

3140

1

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

3141

1

);

3142

1

			assert_eq!(

3143

1

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

3144

1

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

3145

1

);

3146

1

			assert_eq!(

3147

1

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

3148

1

				U256::from(5_653_326_895_069u128),

3149

1

);

3150

1

			assert_eq!(

3151

1

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

3152

1

				U256::from(31_250_000_000_000u128),

3153

1

				// upper bound enforced (min_gas_price * MaximumMultiplier)

3154

1

);

3155

1

});

3156

1

3157

3158

3159

#[cfg(test)]

3160

mod balance_tests {

3161

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

3162

	use frame_support::assert_ok;

3163

	use frame_support::traits::LockableCurrency;

3164

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

3165

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

3166

	use moonbeam_core_primitives::AccountId;

3167

3168

	#[test]

3169

1

	fn reserve_should_work_for_frozen_balance() {

3170

1

		let alice = AccountId::from(ALICE);

3171

		const ID_1: LockIdentifier = *b"1       ";

3172

3173

1

		ExtBuilder::default()

3174

1

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

3175

1

			.build()

3176

1

			.execute_with(|| {

3177

1

				// Check balances

3178

1

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

3179

1

				assert_eq!(account.free, 10);

3180

1

				assert_eq!(account.frozen, 0);

3181

1

				assert_eq!(account.reserved, 0);

3182

3183

1

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

3184

1

3185

1

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

3186

1

				assert_eq!(account.free, 10);

3187

1

				assert_eq!(account.frozen, 9);

3188

1

				assert_eq!(account.reserved, 0);

3189

3190

1

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

3191

3192

1

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

3193

1

				assert_eq!(account.free, 5);

3194

1

				assert_eq!(account.frozen, 9);

3195

1

				assert_eq!(account.reserved, 5);

3196

3197

1

				let previous_reserved_amount = account.reserved;

3198

1

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

3199

1

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

3200

1

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

3201

3202

1

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

3203

1

				assert_eq!(account.free, ed);

3204

1

				assert_eq!(account.frozen, 9);

3205

1

				assert_eq!(

3206

1

					account.reserved,

3207

1

					previous_reserved_amount.saturating_add(next_reserve)

3208

1

);

3209

1

});

3210

1

3211

3212

3213

moonbeam_runtime_common::generate_common_xcm_tests!(moonbase_runtime);