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

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

34

		StorageInfo, StorageInfoTrait,

35

},

36

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

37

	StorageHasher, Twox128,

38

};

39

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

40

use moonbase_runtime::{

41

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

42

	EvmForeignAssets, Executive, OpenTechCommitteeCollective, ParachainStaking, PolkadotXcm,

43

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

44

	TransactionPayment, TransactionPaymentAsGasPrice, Treasury, TreasuryCouncilCollective,

45

	XcmTransactor, FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, WEEKS,

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 sha3::{Digest, Keccak256};

70

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

71

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

72

use std::cell::Cell;

73

use std::rc::Rc;

74

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

75

76

type AuthorMappingPCall =

77

	pallet_evm_precompile_author_mapping::AuthorMappingPrecompileCall<Runtime>;

78

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

79

type CrowdloanRewardsPCall =

80

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

81

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

82

	Runtime,

83

	moonbase_runtime::xcm_config::XcmExecutorConfig,

84

>;

85

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

86

/*type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

87

	Runtime,

88

	ForeignAssetInstance,

89

>;*/

90

type XcmTransactorV1PCall =

91

	pallet_evm_precompile_xcm_transactor::v1::XcmTransactorPrecompileV1Call<Runtime>;

92

type XcmTransactorV2PCall =

93

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

94

95

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

96

const BASE_FEE_GENISIS: u128 = 10 * GIGAWEI / 4;

97

98

#[test]

99

1

fn xcmp_queue_controller_origin_is_root() {

100

1

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

101

1

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

102

1

	assert_ok!(

103

1

		<moonbase_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

104

1

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

105

1

);

106

1

107

108

#[test]

109

1

fn verify_pallet_prefixes() {

110

29

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

111

29

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

112

29

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

113

29

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

114

29

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

115

29

		// expand/storage.rs#L389-L401

116

29

		assert_eq!(

117

29

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

118

29

			Some(name)

119

29

);

120

29

121

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

122

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

123

1

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

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

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

130

1

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

131

1

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

132

1

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

133

1

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

134

1

	is_pallet_prefix::<moonbase_runtime::OpenTechCommitteeCollective>(

135

1

		"OpenTechCommitteeCollective",

136

1

);

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

155

13

	let prefix = |pallet_name, storage_name| {

156

13

		let mut res = [0u8; 32];

157

13

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

158

13

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

159

13

		res.to_vec()

160

13

};

161

1

	assert_eq!(

162

1

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

163

1

		vec![

164

1

			StorageInfo {

165

1

				pallet_name: b"Balances".to_vec(),

166

1

				storage_name: b"TotalIssuance".to_vec(),

167

1

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

168

1

				max_values: Some(1),

169

1

				max_size: Some(16),

170

1

},

171

1

			StorageInfo {

172

1

				pallet_name: b"Balances".to_vec(),

173

1

				storage_name: b"InactiveIssuance".to_vec(),

174

1

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

175

1

				max_values: Some(1),

176

1

				max_size: Some(16),

177

1

},

178

1

			StorageInfo {

179

1

				pallet_name: b"Balances".to_vec(),

180

1

				storage_name: b"Account".to_vec(),

181

1

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

182

1

				max_values: None,

183

1

				max_size: Some(100),

184

1

},

185

1

			StorageInfo {

186

1

				pallet_name: b"Balances".to_vec(),

187

1

				storage_name: b"Locks".to_vec(),

188

1

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

189

1

				max_values: None,

190

1

				max_size: Some(1287),

191

1

},

192

1

			StorageInfo {

193

1

				pallet_name: b"Balances".to_vec(),

194

1

				storage_name: b"Reserves".to_vec(),

195

1

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

196

1

				max_values: None,

197

1

				max_size: Some(1037),

198

1

},

199

1

			StorageInfo {

200

1

				pallet_name: b"Balances".to_vec(),

201

1

				storage_name: b"Holds".to_vec(),

202

1

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

203

1

				max_values: None,

204

1

				max_size: Some(55),

205

1

},

206

1

			StorageInfo {

207

1

				pallet_name: b"Balances".to_vec(),

208

1

				storage_name: b"Freezes".to_vec(),

209

1

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

210

1

				max_values: None,

211

1

				max_size: Some(37),

212

1

},

213

1

214

1

);

215

1

	assert_eq!(

216

1

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

217

1

		vec![StorageInfo {

218

1

			pallet_name: b"Sudo".to_vec(),

219

1

			storage_name: b"Key".to_vec(),

220

1

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

221

1

			max_values: Some(1),

222

1

			max_size: Some(20),

223

1

}]

224

1

);

225

1

	assert_eq!(

226

1

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

227

1

		vec![

228

1

			StorageInfo {

229

1

				pallet_name: b"Proxy".to_vec(),

230

1

				storage_name: b"Proxies".to_vec(),

231

1

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

232

1

				max_values: None,

233

1

				max_size: Some(845),

234

1

},

235

1

			StorageInfo {

236

1

				pallet_name: b"Proxy".to_vec(),

237

1

				storage_name: b"Announcements".to_vec(),

238

1

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

239

1

				max_values: None,

240

1

				max_size: Some(1837),

241

1

242

1

243

1

);

244

1

	assert_eq!(

245

1

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

246

1

		vec![StorageInfo {

247

1

			pallet_name: b"MaintenanceMode".to_vec(),

248

1

			storage_name: b"MaintenanceMode".to_vec(),

249

1

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

250

1

			max_values: Some(1),

251

1

			max_size: None,

252

1

},]

253

1

);

254

255

1

	assert_eq!(

256

1

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

257

1

		vec![

258

1

			StorageInfo {

259

1

				pallet_name: b"RelayStorageRoots".to_vec(),

260

1

				storage_name: b"RelayStorageRoot".to_vec(),

261

1

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

262

1

				max_values: None,

263

1

				max_size: Some(44),

264

1

},

265

1

			StorageInfo {

266

1

				pallet_name: b"RelayStorageRoots".to_vec(),

267

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

268

1

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

269

1

				max_values: Some(1),

270

1

				max_size: Some(121),

271

1

},

272

1

273

1

);

274

1

275

276

#[test]

277

1

fn test_collectives_storage_item_prefixes() {

278

7

	for StorageInfo { pallet_name, .. } in

279

8

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

280

281

7

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

282

283

284

7

	for StorageInfo { pallet_name, .. } in

285

8

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

286

287

7

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

288

289

1

290

291

#[test]

292

1

fn collective_set_members_root_origin_works() {

293

1

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

294

1

		// TreasuryCouncilCollective

295

1

		assert_ok!(TreasuryCouncilCollective::set_members(

296

1

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

297

1

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

298

1

			Some(AccountId::from(ALICE)),

299

1

300

1

));

301

		// OpenTechCommitteeCollective

302

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

303

1

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

304

1

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

305

1

			Some(AccountId::from(ALICE)),

306

1

307

1

));

308

1

});

309

1

310

311

#[test]

312

1

fn collective_set_members_general_admin_origin_works() {

313

	use moonbase_runtime::{

314

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

315

};

316

317

1

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

318

1

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

319

1

		let alice = AccountId::from(ALICE);

320

1

321

1

		// TreasuryCouncilCollective

322

1

		let _ = Utility::dispatch_as(

323

1

			root_caller.clone(),

324

1

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

325

1

			Box::new(

326

1

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

327

1

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

328

1

					prime: Some(alice),

329

1

					old_count: 2,

330

1

331

1

				.into(),

332

1

),

333

1

);

334

1

		// OpenTechCommitteeCollective

335

1

		let _ = Utility::dispatch_as(

336

1

			root_caller,

337

1

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

338

1

			Box::new(

339

1

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

340

1

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

341

1

					prime: Some(alice),

342

1

					old_count: 2,

343

1

344

1

				.into(),

345

1

),

346

1

);

347

1

348

1

		assert_eq!(

349

1

			System::events()

350

1

				.into_iter()

351

2

				.filter_map(|r| {

352

2

					match r.event {

353

2

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

354

2

							if result.is_ok() =>

355

2

356

2

							Some(true)

357

358

						_ => None,

359

360

2

})

361

1

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

362

1

				.len(),

363

1

364

1

365

1

});

366

1

367

368

#[test]

369

1

fn collective_set_members_signed_origin_does_not_work() {

370

1

	let alice = AccountId::from(ALICE);

371

1

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

372

1

		// TreasuryCouncilCollective

373

1

		assert!(TreasuryCouncilCollective::set_members(

374

1

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

375

1

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

376

1

			Some(AccountId::from(ALICE)),

377

1

378

1

379

1

		.is_err());

380

		// OpenTechCommitteeCollective

381

1

		assert!(OpenTechCommitteeCollective::set_members(

382

1

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

383

1

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

384

1

			Some(AccountId::from(ALICE)),

385

1

386

1

387

1

		.is_err());

388

1

});

389

1

390

391

#[test]

392

1

fn verify_pallet_indices() {

393

31

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

394

31

		assert_eq!(

395

31

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

396

31

			Some(index)

397

31

);

398

31

399

1

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

400

1

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

401

1

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

402

1

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

403

1

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

404

1

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

405

1

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

406

1

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

407

1

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

408

1

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

409

1

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

410

1

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

411

1

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

412

1

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

413

1

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

414

1

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

415

1

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

416

1

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

417

1

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

418

1

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

419

1

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

420

1

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

421

1

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

422

1

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

423

1

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

424

1

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

425

1

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

426

1

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

427

1

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

428

1

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

429

1

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

430

1

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

431

1

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

432

1

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

433

1

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

434

1

435

436

#[test]

437

1

fn verify_reserved_indices() {

438

	use frame_metadata::*;

439

440

1

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

441

1

		.build_storage()

442

1

		.unwrap()

443

1

		.into();

444

1

445

1

	t.execute_with(|| {

446

1

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

447

1

		let metadata = match metadata.1 {

448

1

			RuntimeMetadata::V14(metadata) => metadata,

449

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

450

};

451

		// 35: BaseFee

452

		// 36: pallet_assets::<Instance1>

453

1

		let reserved = vec![35, 36];

454

1

		let existing = metadata

455

1

			.pallets

456

1

			.iter()

457

48

			.map(|p| p.index)

458

1

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

459

2

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

460

1

});

461

1

462

463

#[test]

464

1

fn verify_proxy_type_indices() {

465

1

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

466

1

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

467

1

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

468

1

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

469

1

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

470

1

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

471

1

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

472

1

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

473

1

474

475

#[test]

476

1

fn join_collator_candidates() {

477

1

	ExtBuilder::default()

478

1

		.with_balances(vec![

479

1

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

480

1

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

481

1

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

482

1

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

483

1

])

484

1

		.with_collators(vec![

485

1

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

486

1

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

487

1

])

488

1

		.with_delegations(vec![

489

1

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

490

1

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

491

1

])

492

1

		.build()

493

1

		.execute_with(|| {

494

1

			assert_noop!(

495

1

				ParachainStaking::join_candidates(

496

1

					origin_of(AccountId::from(ALICE)),

497

1

					1_000 * UNIT,

498

1

					2u32

499

1

),

500

1

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

501

1

);

502

1

			assert_noop!(

503

1

				ParachainStaking::join_candidates(

504

1

					origin_of(AccountId::from(CHARLIE)),

505

1

					1_000 * UNIT,

506

1

					2u32

507

1

),

508

1

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

509

1

);

510

1

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

511

1

			assert_ok!(ParachainStaking::join_candidates(

512

1

				origin_of(AccountId::from(DAVE)),

513

1

				1_000 * UNIT,

514

1

				2u32

515

1

));

516

1

			assert_eq!(

517

1

				last_event(),

518

1

				RuntimeEvent::ParachainStaking(

519

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

520

1

						account: AccountId::from(DAVE),

521

1

						amount_locked: 1_000 * UNIT,

522

1

						new_total_amt_locked: 3_100 * UNIT

523

1

524

1

525

1

);

526

1

			let candidates = ParachainStaking::candidate_pool();

527

1

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

528

1

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

529

1

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

530

1

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

531

1

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

532

1

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

533

1

});

534

1

535

536

#[test]

537

1

fn transfer_through_evm_to_stake() {

538

1

	ExtBuilder::default()

539

1

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

540

1

		.build()

541

1

		.execute_with(|| {

542

1

			// Charlie has no balance => fails to stake

543

1

			assert_noop!(

544

1

				ParachainStaking::join_candidates(

545

1

					origin_of(AccountId::from(CHARLIE)),

546

1

					1_000 * UNIT,

547

1

					0u32

548

1

),

549

1

				DispatchError::Module(ModuleError {

550

1

					index: 12,

551

1

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

552

1

					message: Some("InsufficientBalance")

553

1

})

554

1

);

555

556

			// Alice transfer from free balance 2000 UNIT to Bob

557

1

			assert_ok!(Balances::transfer_allow_death(

558

1

				origin_of(AccountId::from(ALICE)),

559

1

				AccountId::from(BOB),

560

1

				2_000 * UNIT,

561

1

));

562

1

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

563

564

1

			let gas_limit = 100000u64;

565

1

			// Bob transfers 1000 UNIT to Charlie via EVM

566

1

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

567

1

				source: H160::from(BOB),

568

1

				target: H160::from(CHARLIE),

569

1

				input: Vec::new(),

570

1

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

571

1

				gas_limit,

572

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

573

1

				max_priority_fee_per_gas: None,

574

1

				nonce: None,

575

1

				access_list: Vec::new(),

576

1

				authorization_list: Vec::new(),

577

1

})

578

1

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

579

1

			assert_eq!(

580

1

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

581

1

				1_000 * UNIT,

582

1

);

583

584

			// Charlie can stake now

585

1

			assert_ok!(ParachainStaking::join_candidates(

586

1

				origin_of(AccountId::from(CHARLIE)),

587

1

				1_000 * UNIT,

588

1

				0u32,

589

1

			),);

590

1

			let candidates = ParachainStaking::candidate_pool();

591

1

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

592

1

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

593

1

});

594

1

595

596

#[test]

597

1

fn reward_block_authors() {

598

1

	ExtBuilder::default()

599

1

		.with_balances(vec![

600

1

			// Alice gets 100 extra tokens for her mapping deposit

601

1

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

602

1

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

603

1

])

604

1

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

605

1

		.with_delegations(vec![(

606

1

			AccountId::from(BOB),

607

1

			AccountId::from(ALICE),

608

1

			500 * UNIT,

609

1

)])

610

1

		.with_mappings(vec![(

611

1

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

612

1

			AccountId::from(ALICE),

613

1

)])

614

1

		.build()

615

1

		.execute_with(|| {

616

1

			increase_last_relay_slot_number(1);

617

1

			// Just before round 3

618

1

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

619

1

			// no rewards doled out yet

620

1

			assert_eq!(

621

1

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

622

1

				1_100 * UNIT,

623

1

);

624

1

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

625

1

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

626

1

			// rewards minted and distributed

627

1

			assert_eq!(

628

1

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

629

1

				1213666666584000000000,

630

1

);

631

1

			assert_eq!(

632

1

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

633

1

				541333333292000000000,

634

1

);

635

1

});

636

1

637

638

#[test]

639

1

fn reward_block_authors_with_parachain_bond_reserved() {

640

1

	ExtBuilder::default()

641

1

		.with_balances(vec![

642

1

			// Alice gets 100 extra tokens for her mapping deposit

643

1

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

644

1

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

645

1

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

646

1

])

647

1

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

648

1

		.with_delegations(vec![(

649

1

			AccountId::from(BOB),

650

1

			AccountId::from(ALICE),

651

1

			500 * UNIT,

652

1

)])

653

1

		.with_mappings(vec![(

654

1

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

655

1

			AccountId::from(ALICE),

656

1

)])

657

1

		.build()

658

1

		.execute_with(|| {

659

1

			increase_last_relay_slot_number(1);

660

1

			assert_ok!(ParachainStaking::set_inflation_distribution_config(

661

1

				root_origin(),

662

1

663

1

					InflationDistributionAccount {

664

1

						account: AccountId::from(CHARLIE),

665

1

						percent: Percent::from_percent(30),

666

1

},

667

1

					InflationDistributionAccount::default(),

668

1

669

1

				.into()

670

1

));

671

672

			// Stop just before round 2

673

1

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

674

1

675

1

			// no rewards doled out yet

676

1

			assert_eq!(

677

1

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

678

1

				1_100 * UNIT,

679

1

);

680

1

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

681

1

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

682

683

			// Go to round 2

684

1

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

685

1

686

1

			// 30% reserved for parachain bond

687

1

			assert_eq!(

688

1

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

689

1

				47515000000000000000,

690

1

);

691

692

			// Go to round 3

693

1

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

694

1

			// rewards minted and distributed

695

1

			assert_eq!(

696

1

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

697

1

				1182693333281650000000,

698

1

);

699

1

			assert_eq!(

700

1

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

701

1

				525841666640825000000,

702

1

);

703

			// 30% again reserved for parachain bond

704

1

			assert_eq!(

705

1

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

706

1

				94727725000000000000,

707

1

);

708

1

});

709

1

710

711

#[test]

712

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

713

1

	ExtBuilder::default()

714

1

		.with_balances(vec![

715

1

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

716

1

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

717

1

])

718

1

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

719

1

		.with_mappings(vec![(

720

1

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

721

1

			AccountId::from(ALICE),

722

1

)])

723

1

		.with_crowdloan_fund(3_000_000 * UNIT)

724

1

		.build()

725

1

		.execute_with(|| {

726

1

			// set parachain inherent data

727

1

			set_parachain_inherent_data();

728

1

			let init_block = CrowdloanRewards::init_vesting_block();

729

1

			// This matches the previous vesting

730

1

			let end_block = init_block + 4 * WEEKS;

731

1

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

732

1

			assert_ok!(

733

1

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

734

1

					calls: vec![

735

1

						RuntimeCall::CrowdloanRewards(

736

1

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

737

1

								rewards: vec![(

738

1

									[4u8; 32].into(),

739

1

									Some(AccountId::from(CHARLIE)),

740

1

									1_500_000 * UNIT

741

1

)]

742

1

743

1

),

744

1

						RuntimeCall::CrowdloanRewards(

745

1

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

746

1

								rewards: vec![(

747

1

									[5u8; 32].into(),

748

1

									Some(AccountId::from(DAVE)),

749

1

									1_500_000 * UNIT

750

1

)]

751

1

752

1

),

753

1

						RuntimeCall::CrowdloanRewards(

754

1

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

755

1

								lease_ending_block: end_block

756

1

757

1

758

1

759

1

})

760

1

				.dispatch(root_origin())

761

1

);

762

			// 30 percent initial payout

763

1

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

764

			// 30 percent initial payout

765

1

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

766

1

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

767

1

			assert_eq!(last_event(), expected);

768

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

769

1

			assert_ok!(

770

1

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

771

1

					calls: vec![RuntimeCall::CrowdloanRewards(

772

1

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

773

1

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

774

1

775

1

)]

776

1

})

777

1

				.dispatch(root_origin())

778

1

);

779

1

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

780

1

				index: 0,

781

1

				error: DispatchError::Module(ModuleError {

782

1

					index: 20,

783

1

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

784

1

					message: None,

785

1

}),

786

1

});

787

1

			assert_eq!(last_event(), expected_fail);

788

			// Claim 1 block.

789

1

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

790

1

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

791

792

1

			let vesting_period = 4 * WEEKS as u128;

793

1

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

794

1

795

1

			assert_eq!(

796

1

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

797

1

					.unwrap()

798

1

					.claimed_reward,

799

1

				(450_000 * UNIT) + per_block

800

1

);

801

1

			assert_eq!(

802

1

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

803

1

					.unwrap()

804

1

					.claimed_reward,

805

1

				(450_000 * UNIT) + per_block

806

1

);

807

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

808

1

			assert_eq!(

809

1

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

810

1

				(450_000 * UNIT) + per_block

811

1

);

812

1

			assert_eq!(

813

1

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

814

1

				(450_000 * UNIT) + per_block

815

1

);

816

1

			assert_noop!(

817

1

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

818

1

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

819

1

);

820

1

});

821

1

822

823

#[test]

824

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

825

1

	ExtBuilder::default()

826

1

		.with_balances(vec![

827

1

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

828

1

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

829

1

])

830

1

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

831

1

		.with_mappings(vec![(

832

1

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

833

1

			AccountId::from(ALICE),

834

1

)])

835

1

		.with_crowdloan_fund(3_000_000 * UNIT)

836

1

		.build()

837

1

		.execute_with(|| {

838

1

			// set parachain inherent data

839

1

			let init_block = CrowdloanRewards::init_vesting_block();

840

1

			// This matches the previous vesting

841

1

			let end_block = init_block + 4 * WEEKS;

842

1

843

1

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

844

1

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

845

1

846

1

			let public1 = pair1.public();

847

1

			let public2 = pair2.public();

848

1

849

1

			// signature:

850

1

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

851

1

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

852

1

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

853

1

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

854

1

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

855

1

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

856

1

857

1

			let signature1 = pair1.sign(&message);

858

1

			let signature2 = pair2.sign(&message);

859

1

860

1

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

861

1

			assert_ok!(

862

1

				// two relay accounts pointing at the same reward account

863

1

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

864

1

					calls: vec![

865

1

						RuntimeCall::CrowdloanRewards(

866

1

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

867

1

								rewards: vec![(

868

1

									public1.into(),

869

1

									Some(AccountId::from(CHARLIE)),

870

1

									1_500_000 * UNIT

871

1

)]

872

1

873

1

),

874

1

						RuntimeCall::CrowdloanRewards(

875

1

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

876

1

								rewards: vec![(

877

1

									public2.into(),

878

1

									Some(AccountId::from(CHARLIE)),

879

1

									1_500_000 * UNIT

880

1

)]

881

1

882

1

),

883

1

						RuntimeCall::CrowdloanRewards(

884

1

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

885

1

								lease_ending_block: end_block

886

1

887

1

888

1

889

1

})

890

1

				.dispatch(root_origin())

891

1

);

892

			// 30 percent initial payout

893

1

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

894

895

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

896

1

			assert_noop!(

897

1

				CrowdloanRewards::change_association_with_relay_keys(

898

1

					origin_of(AccountId::from(CHARLIE)),

899

1

					AccountId::from(DAVE),

900

1

					AccountId::from(CHARLIE),

901

1

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

902

1

),

903

1

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

904

1

);

905

906

			// this should be valid

907

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

908

1

				origin_of(AccountId::from(CHARLIE)),

909

1

				AccountId::from(DAVE),

910

1

				AccountId::from(CHARLIE),

911

1

				vec![

912

1

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

913

1

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

914

1

915

1

));

916

917

1

			assert_eq!(

918

1

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

919

1

					.unwrap()

920

1

					.claimed_reward,

921

1

				(900_000 * UNIT)

922

1

);

923

1

});

924

1

925

926

#[test]

927

1

fn claim_via_precompile() {

928

1

	ExtBuilder::default()

929

1

		.with_balances(vec![

930

1

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

931

1

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

932

1

])

933

1

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

934

1

		.with_mappings(vec![(

935

1

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

936

1

			AccountId::from(ALICE),

937

1

)])

938

1

		.with_crowdloan_fund(3_000_000 * UNIT)

939

1

		.build()

940

1

		.execute_with(|| {

941

1

			// set parachain inherent data

942

1

			set_parachain_inherent_data();

943

1

			let init_block = CrowdloanRewards::init_vesting_block();

944

1

			// This matches the previous vesting

945

1

			let end_block = init_block + 4 * WEEKS;

946

1

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

947

1

			assert_ok!(

948

1

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

949

1

					calls: vec![

950

1

						RuntimeCall::CrowdloanRewards(

951

1

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

952

1

								rewards: vec![(

953

1

									[4u8; 32].into(),

954

1

									Some(AccountId::from(CHARLIE)),

955

1

									1_500_000 * UNIT

956

1

)]

957

1

958

1

),

959

1

						RuntimeCall::CrowdloanRewards(

960

1

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

961

1

								rewards: vec![(

962

1

									[5u8; 32].into(),

963

1

									Some(AccountId::from(DAVE)),

964

1

									1_500_000 * UNIT

965

1

)]

966

1

967

1

),

968

1

						RuntimeCall::CrowdloanRewards(

969

1

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

970

1

								lease_ending_block: end_block

971

1

972

1

973

1

974

1

})

975

1

				.dispatch(root_origin())

976

1

);

977

978

			// 30 percent initial payout

979

1

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

980

			// 30 percent initial payout

981

1

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

982

983

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

984

1

985

1

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

986

1

			let gas_limit = 100000u64;

987

1

			let gas_price: U256 = BASE_FEE_GENISIS.into();

988

1

989

1

			// Construct the call data (selector, amount)

990

1

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

991

1

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

992

1

993

1

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

994

1

				source: H160::from(CHARLIE),

995

1

				target: crowdloan_precompile_address,

996

1

				input: call_data,

997

1

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

998

1

				gas_limit,

999

1

				max_fee_per_gas: gas_price,

1000

1

				max_priority_fee_per_gas: None,

1001

1

				nonce: None, // Use the next nonce

1002

1

				access_list: Vec::new(),

1003

1

				authorization_list: Vec::new(),

1004

1

})

1005

1

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

1006

1007

1

			let vesting_period = 4 * WEEKS as u128;

1008

1

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

1009

1

1010

1

			assert_eq!(

1011

1

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

1012

1

					.unwrap()

1013

1

					.claimed_reward,

1014

1

				(450_000 * UNIT) + per_block

1015

1

);

1016

1

})

1017

1

1018

1019

#[test]

1020

1

fn is_contributor_via_precompile() {

1021

1

	ExtBuilder::default()

1022

1

		.with_balances(vec![

1023

1

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

1024

1

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

1025

1

])

1026

1

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

1027

1

		.with_mappings(vec![(

1028

1

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

1029

1

			AccountId::from(ALICE),

1030

1

)])

1031

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1032

1

		.build()

1033

1

		.execute_with(|| {

1034

1

			// set parachain inherent data

1035

1

			let init_block = CrowdloanRewards::init_vesting_block();

1036

1

			// This matches the previous vesting

1037

1

			let end_block = init_block + 4 * WEEKS;

1038

1

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

1039

1

			assert_ok!(

1040

1

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

1041

1

					calls: vec![

1042

1

						RuntimeCall::CrowdloanRewards(

1043

1

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

1044

1

								rewards: vec![(

1045

1

									[4u8; 32].into(),

1046

1

									Some(AccountId::from(CHARLIE)),

1047

1

									1_500_000 * UNIT

1048

1

)]

1049

1

1050

1

),

1051

1

						RuntimeCall::CrowdloanRewards(

1052

1

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

1053

1

								rewards: vec![(

1054

1

									[5u8; 32].into(),

1055

1

									Some(AccountId::from(DAVE)),

1056

1

									1_500_000 * UNIT

1057

1

)]

1058

1

1059

1

),

1060

1

						RuntimeCall::CrowdloanRewards(

1061

1

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

1062

1

								lease_ending_block: end_block

1063

1

1064

1

1065

1

1066

1

})

1067

1

				.dispatch(root_origin())

1068

1

);

1069

1070

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1071

1

1072

1

			// Assert precompile reports Bob is not a contributor

1073

1

			Precompiles::new()

1074

1

				.prepare_test(

1075

1

					ALICE,

1076

1

					crowdloan_precompile_address,

1077

1

					CrowdloanRewardsPCall::is_contributor {

1078

1

						contributor: Address(BOB.into()),

1079

1

},

1080

1

1081

1

				.expect_cost(3338)

1082

1

				.expect_no_logs()

1083

1

				.execute_returns(false);

1084

1

1085

1

			// Assert precompile reports Charlie is a nominator

1086

1

			Precompiles::new()

1087

1

				.prepare_test(

1088

1

					ALICE,

1089

1

					crowdloan_precompile_address,

1090

1

					CrowdloanRewardsPCall::is_contributor {

1091

1

						contributor: Address(CHARLIE.into()),

1092

1

},

1093

1

1094

1

				.expect_cost(3338)

1095

1

				.expect_no_logs()

1096

1

				.execute_returns(true);

1097

1

})

1098

1

1099

1100

#[test]

1101

1

fn reward_info_via_precompile() {

1102

1

	ExtBuilder::default()

1103

1

		.with_balances(vec![

1104

1

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

1105

1

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

1106

1

])

1107

1

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

1108

1

		.with_mappings(vec![(

1109

1

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

1110

1

			AccountId::from(ALICE),

1111

1

)])

1112

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1113

1

		.build()

1114

1

		.execute_with(|| {

1115

1

			// set parachain inherent data

1116

1

			let init_block = CrowdloanRewards::init_vesting_block();

1117

1

			// This matches the previous vesting

1118

1

			let end_block = init_block + 4 * WEEKS;

1119

1

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

1120

1

			assert_ok!(

1121

1

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

1122

1

					calls: vec![

1123

1

						RuntimeCall::CrowdloanRewards(

1124

1

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

1125

1

								rewards: vec![(

1126

1

									[4u8; 32].into(),

1127

1

									Some(AccountId::from(CHARLIE)),

1128

1

									1_500_000 * UNIT

1129

1

)]

1130

1

1131

1

),

1132

1

						RuntimeCall::CrowdloanRewards(

1133

1

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

1134

1

								rewards: vec![(

1135

1

									[5u8; 32].into(),

1136

1

									Some(AccountId::from(DAVE)),

1137

1

									1_500_000 * UNIT

1138

1

)]

1139

1

1140

1

),

1141

1

						RuntimeCall::CrowdloanRewards(

1142

1

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

1143

1

								lease_ending_block: end_block

1144

1

1145

1

1146

1

1147

1

})

1148

1

				.dispatch(root_origin())

1149

1

);

1150

1151

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1152

1

1153

1

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

1154

1

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

1155

1

1156

1

			// Assert precompile reports correct Charlie reward info.

1157

1

			Precompiles::new()

1158

1

				.prepare_test(

1159

1

					ALICE,

1160

1

					crowdloan_precompile_address,

1161

1

					CrowdloanRewardsPCall::reward_info {

1162

1

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

1163

1

},

1164

1

1165

1

				.expect_cost(3338)

1166

1

				.expect_no_logs()

1167

1

				.execute_returns((expected_total, expected_claimed));

1168

1

})

1169

1

1170

1171

#[test]

1172

1

fn update_reward_address_via_precompile() {

1173

1

	ExtBuilder::default()

1174

1

		.with_balances(vec![

1175

1

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

1176

1

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

1177

1

])

1178

1

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

1179

1

		.with_mappings(vec![(

1180

1

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

1181

1

			AccountId::from(ALICE),

1182

1

)])

1183

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1184

1

		.build()

1185

1

		.execute_with(|| {

1186

1

			// set parachain inherent data

1187

1

			let init_block = CrowdloanRewards::init_vesting_block();

1188

1

			// This matches the previous vesting

1189

1

			let end_block = init_block + 4 * WEEKS;

1190

1

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

1191

1

			assert_ok!(

1192

1

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

1193

1

					calls: vec![

1194

1

						RuntimeCall::CrowdloanRewards(

1195

1

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

1196

1

								rewards: vec![(

1197

1

									[4u8; 32].into(),

1198

1

									Some(AccountId::from(CHARLIE)),

1199

1

									1_500_000 * UNIT

1200

1

)]

1201

1

1202

1

),

1203

1

						RuntimeCall::CrowdloanRewards(

1204

1

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

1205

1

								rewards: vec![(

1206

1

									[5u8; 32].into(),

1207

1

									Some(AccountId::from(DAVE)),

1208

1

									1_500_000 * UNIT

1209

1

)]

1210

1

1211

1

),

1212

1

						RuntimeCall::CrowdloanRewards(

1213

1

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

1214

1

								lease_ending_block: end_block

1215

1

1216

1

1217

1

1218

1

})

1219

1

				.dispatch(root_origin())

1220

1

);

1221

1222

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1223

1

1224

1

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

1225

1

			let gas_limit = 100000u64;

1226

1

			let gas_price: U256 = BASE_FEE_GENISIS.into();

1227

1

1228

1

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

1229

1

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

1230

1

			call_data[0..4]

1231

1

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

1232

1

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

1233

1

1234

1

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

1235

1

				source: H160::from(CHARLIE),

1236

1

				target: crowdloan_precompile_address,

1237

1

				input: call_data,

1238

1

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

1239

1

				gas_limit,

1240

1

				max_fee_per_gas: gas_price,

1241

1

				max_priority_fee_per_gas: None,

1242

1

				nonce: None, // Use the next nonce

1243

1

				access_list: Vec::new(),

1244

1

				authorization_list: Vec::new(),

1245

1

})

1246

1

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

1247

1248

1

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

1249

1

			assert_eq!(

1250

1

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

1251

1

					.unwrap()

1252

1

					.claimed_reward,

1253

1

				(450_000 * UNIT)

1254

1

);

1255

1

})

1256

1

1257

1258

#[test]

1259

1

fn create_and_manipulate_foreign_asset_using_root() {

1260

1

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

1261

1

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

1262

1

1263

1

		// Create foreign asset

1264

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1265

1

			moonbase_runtime::RuntimeOrigin::root(),

1266

1

1,

1267

1

			source_location.clone(),

1268

1

12,

1269

1

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

1270

1

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

1271

1

));

1272

1

		assert_eq!(

1273

1

			EvmForeignAssets::assets_by_id(1),

1274

1

			Some(source_location.clone())

1275

1

);

1276

1

		assert_eq!(

1277

1

			EvmForeignAssets::assets_by_location(&source_location),

1278

1

			Some((1, AssetStatus::Active))

1279

1

);

1280

1281

		// Freeze foreign asset

1282

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1283

1

			moonbase_runtime::RuntimeOrigin::root(),

1284

1

1,

1285

1

			true

1286

1

));

1287

1

		assert_eq!(

1288

1

			EvmForeignAssets::assets_by_location(&source_location),

1289

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1290

1

);

1291

1292

		// Unfreeze foreign asset

1293

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1294

1

			moonbase_runtime::RuntimeOrigin::root(),

1295

1

1,

1296

1

));

1297

1

		assert_eq!(

1298

1

			EvmForeignAssets::assets_by_location(&source_location),

1299

1

			Some((1, AssetStatus::Active))

1300

1

);

1301

1

});

1302

1

1303

1304

#[test]

1305

1

fn create_and_manipulate_foreign_asset_using_sibling() {

1306

1

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

1307

1

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

1308

1

		let para_location = asset_location.chain_location();

1309

1

		let para_account =

1310

1

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

1311

1

1312

1

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

1313

1

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

1314

1

1315

1

		// Create foreign asset

1316

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1317

1

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

1318

1

1,

1319

1

			asset_location.clone(),

1320

1

12,

1321

1

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

1322

1

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

1323

1

));

1324

1325

		// deposit is taken from the account

1326

1

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

1327

1328

1

		assert_eq!(

1329

1

			EvmForeignAssets::assets_by_id(1),

1330

1

			Some(asset_location.clone())

1331

1

);

1332

1

		assert_eq!(

1333

1

			EvmForeignAssets::assets_by_location(&asset_location),

1334

1

			Some((1, AssetStatus::Active))

1335

1

);

1336

1337

		// Freeze foreign asset

1338

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1339

1

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

1340

1

1,

1341

1

			true

1342

1

));

1343

1

		assert_eq!(

1344

1

			EvmForeignAssets::assets_by_location(&asset_location),

1345

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1346

1

);

1347

1348

		// Unfreeze foreign asset

1349

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1350

1

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

1351

1

1,

1352

1

));

1353

1

		assert_eq!(

1354

1

			EvmForeignAssets::assets_by_location(&asset_location),

1355

1

			Some((1, AssetStatus::Active))

1356

1

);

1357

1

});

1358

1

1359

1360

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

1361

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

1362

/*

1363

#[test]

1364

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1365

	ExtBuilder::default()

1366

		.with_xcm_assets(vec![XcmAssetInitialization {

1367

			asset_id: 1,

1368

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

1369

			name: "RelayToken",

1370

			symbol: "Relay",

1371

			decimals: 12,

1372

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

1373

}])

1374

		.with_balances(vec![

1375

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

1376

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

1377

])

1378

		.build()

1379

		.execute_with(|| {

1380

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

1381

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

1382

1383

			// Its address is

1384

			let asset_precompile_address = Runtime::asset_id_to_account(

1385

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1386

				relay_asset_id,

1387

);

1388

1389

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

1390

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

1391

1392

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

1393

			Precompiles::new()

1394

				.prepare_test(

1395

					ALICE,

1396

					asset_precompile_address,

1397

					ForeignAssetsPCall::total_supply {},

1398

1399

				.expect_cost(3338)

1400

				.expect_no_logs()

1401

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

1402

1403

			// Access balanceOf through precompile

1404

			Precompiles::new()

1405

				.prepare_test(

1406

					ALICE,

1407

					asset_precompile_address,

1408

					ForeignAssetsPCall::balance_of {

1409

						who: Address(ALICE.into()),

1410

},

1411

1412

				.expect_cost(3338)

1413

				.expect_no_logs()

1414

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

1415

});

1416

1417

1418

#[test]

1419

fn xcm_asset_erc20_precompiles_transfer() {

1420

	ExtBuilder::default()

1421

		.with_xcm_assets(vec![XcmAssetInitialization {

1422

			asset_id: 1,

1423

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

1424

			name: "RelayToken",

1425

			symbol: "Relay",

1426

			decimals: 12,

1427

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

1428

}])

1429

		.with_balances(vec![

1430

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

1431

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

1432

])

1433

		.build()

1434

		.execute_with(|| {

1435

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

1436

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

1437

1438

			// Its address is

1439

			let asset_precompile_address = Runtime::asset_id_to_account(

1440

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1441

				relay_asset_id,

1442

);

1443

1444

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

1445

			Precompiles::new()

1446

				.prepare_test(

1447

					ALICE,

1448

					asset_precompile_address,

1449

					ForeignAssetsPCall::transfer {

1450

						to: Address(BOB.into()),

1451

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

1452

},

1453

1454

				.expect_cost(24695)

1455

				.expect_log(log3(

1456

					asset_precompile_address,

1457

					SELECTOR_LOG_TRANSFER,

1458

					H160::from(ALICE),

1459

					H160::from(BOB),

1460

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

1461

))

1462

				.execute_returns(true);

1463

1464

			// Make sure BOB has 400 UNIT

1465

			Precompiles::new()

1466

				.prepare_test(

1467

					BOB,

1468

					asset_precompile_address,

1469

					ForeignAssetsPCall::balance_of {

1470

						who: Address(BOB.into()),

1471

},

1472

1473

				.expect_cost(3338)

1474

				.expect_no_logs()

1475

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

1476

});

1477

1478

1479

#[test]

1480

fn xcm_asset_erc20_precompiles_approve() {

1481

	ExtBuilder::default()

1482

		.with_xcm_assets(vec![XcmAssetInitialization {

1483

			asset_id: 1,

1484

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

1485

			name: "RelayToken",

1486

			symbol: "Relay",

1487

			decimals: 12,

1488

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

1489

}])

1490

		.with_balances(vec![

1491

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

1492

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

1493

])

1494

		.build()

1495

		.execute_with(|| {

1496

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

1497

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

1498

1499

			// Its address is

1500

			let asset_precompile_address = Runtime::asset_id_to_account(

1501

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1502

				relay_asset_id,

1503

);

1504

1505

			// Aprove Bob for spending 400 UNIT from Alice

1506

			Precompiles::new()

1507

				.prepare_test(

1508

					ALICE,

1509

					asset_precompile_address,

1510

					ForeignAssetsPCall::approve {

1511

						spender: Address(BOB.into()),

1512

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

1513

},

1514

1515

				.expect_cost(15604)

1516

				.expect_log(log3(

1517

					asset_precompile_address,

1518

					SELECTOR_LOG_APPROVAL,

1519

					H160::from(ALICE),

1520

					H160::from(BOB),

1521

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

1522

))

1523

				.execute_returns(true);

1524

1525

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

1526

			Precompiles::new()

1527

				.prepare_test(

1528

					BOB,

1529

					asset_precompile_address,

1530

					ForeignAssetsPCall::transfer_from {

1531

						from: Address(ALICE.into()),

1532

						to: Address(CHARLIE.into()),

1533

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

1534

},

1535

1536

				.expect_cost(29960)

1537

				.expect_log(log3(

1538

					asset_precompile_address,

1539

					SELECTOR_LOG_TRANSFER,

1540

					H160::from(ALICE),

1541

					H160::from(CHARLIE),

1542

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

1543

))

1544

				.execute_returns(true);

1545

1546

			// Make sure CHARLIE has 400 UNIT

1547

			Precompiles::new()

1548

				.prepare_test(

1549

					CHARLIE,

1550

					asset_precompile_address,

1551

					ForeignAssetsPCall::balance_of {

1552

						who: Address(CHARLIE.into()),

1553

},

1554

1555

				.expect_cost(3338)

1556

				.expect_no_logs()

1557

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

1558

});

1559

}*/

1560

1561

#[test]

1562

1

fn xtokens_precompiles_transfer() {

1563

1

	ExtBuilder::default()

1564

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1565

1

			asset_id: 1,

1566

1

			xcm_location: AssetHubLocation::get(),

1567

1

			name: "RelayToken",

1568

1

			symbol: "Relay",

1569

1

			decimals: 12,

1570

1

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

1571

1

}])

1572

1

		.with_balances(vec![

1573

1

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

1574

1

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

1575

1

])

1576

1

		.with_safe_xcm_version(3)

1577

1

		.build()

1578

1

		.execute_with(|| {

1579

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1580

1

1581

1

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

1582

1

			let asset_id: AssetId = 1;

1583

1

1584

1

			// Its address is

1585

1

			let asset_precompile_address =

1586

1

				Runtime::asset_id_to_account(FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX, asset_id);

1587

1

1588

1

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

1589

1

			let destination = Location::new(

1590

1

1,

1591

1

				[Junction::AccountId32 {

1592

1

					network: None,

1593

1

					id: [1u8; 32],

1594

1

}],

1595

1

);

1596

1

1597

1

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

1598

1

			let inside2 = inside.clone();

1599

1

1600

1

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

1601

1

			Precompiles::new()

1602

1

				.prepare_test(

1603

1

					ALICE,

1604

1

					xtokens_precompile_address,

1605

1

					XtokensPCall::transfer {

1606

1

						currency_address: Address(asset_precompile_address.into()),

1607

1

						amount: 500_000_000_000_000u128.into(),

1608

1

						destination,

1609

1

						weight: 4_000_000,

1610

1

},

1611

1

1612

1

				.expect_cost(238472)

1613

1

				.expect_no_logs()

1614

1

				// We expect an evm subcall ERC20.burnFrom

1615

1

				.with_subcall_handle(move |subcall| {

1616

1

					let Subcall {

1617

1

						address,

1618

1

						transfer,

1619

1

						input,

1620

1

						target_gas: _,

1621

1

						is_static,

1622

1

						context,

1623

1

					} = subcall;

1624

1

1625

1

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

1626

1

					assert_eq!(

1627

1

						address,

1628

1

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

1629

1

);

1630

1

					assert_eq!(is_static, false);

1631

1632

1

					assert!(transfer.is_none());

1633

1634

1

					assert_eq!(

1635

1

						context.address,

1636

1

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

1637

1

);

1638

1

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

1639

1640

1

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

1641

1

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

1642

1

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

1643

1644

1

					inside2.set(true);

1645

1

1646

1

					SubcallOutput {

1647

1

						output: Default::default(),

1648

1

						cost: 149_000,

1649

1

						logs: vec![],

1650

1

						..SubcallOutput::succeed()

1651

1

1652

1

})

1653

1

				.execute_returns(())

1654

1

})

1655

1

1656

1657

#[test]

1658

1

fn xtokens_precompiles_transfer_multiasset() {

1659

1

	ExtBuilder::default()

1660

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1661

1

			asset_id: 1,

1662

1

			xcm_location: AssetHubLocation::get(),

1663

1

			name: "DOT",

1664

1

			symbol: "DOT",

1665

1

			decimals: 12,

1666

1

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

1667

1

}])

1668

1

		.with_balances(vec![

1669

1

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

1670

1

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

1671

1

])

1672

1

		.with_safe_xcm_version(3)

1673

1

		.build()

1674

1

		.execute_with(|| {

1675

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1676

1

1677

1

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

1678

1

			let destination = Location::new(

1679

1

1,

1680

1

				[Junction::AccountId32 {

1681

1

					network: None,

1682

1

					id: [1u8; 32],

1683

1

}],

1684

1

);

1685

1

1686

1

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

1687

1

			let inside2 = inside.clone();

1688

1

1689

1

			// This time we transfer it through TransferMultiAsset

1690

1

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

1691

1

			Precompiles::new()

1692

1

				.prepare_test(

1693

1

					ALICE,

1694

1

					xtokens_precompile_address,

1695

1

					XtokensPCall::transfer_multiasset {

1696

1

						// We want to transfer DOT

1697

1

						asset: AssetHubLocation::get(),

1698

1

						amount: 500_000_000_000_000u128.into(),

1699

1

						destination,

1700

1

						weight: 4_000_000,

1701

1

},

1702

1

1703

1

				.expect_cost(238472)

1704

1

				.expect_no_logs()

1705

1

				// We expect an evm subcall ERC20.burnFrom

1706

1

				.with_subcall_handle(move |subcall| {

1707

1

					let Subcall {

1708

1

						address,

1709

1

						transfer,

1710

1

						input,

1711

1

						target_gas: _,

1712

1

						is_static,

1713

1

						context,

1714

1

					} = subcall;

1715

1

1716

1

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

1717

1

					assert_eq!(

1718

1

						address,

1719

1

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

1720

1

);

1721

1

					assert_eq!(is_static, false);

1722

1723

1

					assert!(transfer.is_none());

1724

1725

1

					assert_eq!(

1726

1

						context.address,

1727

1

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

1728

1

);

1729

1

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

1730

1731

1

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

1732

1

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

1733

1

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

1734

1735

1

					inside2.set(true);

1736

1

1737

1

					SubcallOutput {

1738

1

						output: Default::default(),

1739

1

						cost: 149_000,

1740

1

						logs: vec![],

1741

1

						..SubcallOutput::succeed()

1742

1

1743

1

})

1744

1

				.execute_returns(());

1745

1

1746

1

			// Ensure that the subcall was actually called.

1747

1

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

1748

1

})

1749

1

1750

1751

#[test]

1752

1

fn xtokens_precompiles_transfer_native() {

1753

1

	ExtBuilder::default()

1754

1

		.with_balances(vec![

1755

1

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

1756

1

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

1757

1

])

1758

1

		.with_safe_xcm_version(3)

1759

1

		.build()

1760

1

		.execute_with(|| {

1761

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1762

1

1763

1

			// Its address is

1764

1

			let asset_precompile_address = H160::from_low_u64_be(2050);

1765

1

1766

1

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

1767

1

			let destination = Location::new(

1768

1

1,

1769

1

				[Junction::AccountId32 {

1770

1

					network: None,

1771

1

					id: [1u8; 32],

1772

1

}],

1773

1

);

1774

1

1775

1

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

1776

1

			Precompiles::new()

1777

1

				.prepare_test(

1778

1

					ALICE,

1779

1

					xtokens_precompile_address,

1780

1

					XtokensPCall::transfer {

1781

1

						currency_address: Address(asset_precompile_address),

1782

1

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

1783

1

						destination,

1784

1

						weight: 4_000_000,

1785

1

},

1786

1

1787

1

				.expect_cost(86872)

1788

1

				.expect_no_logs()

1789

1

				.execute_returns(());

1790

1

})

1791

1

1792

1793

1

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

1794

1

where

1795

1

	F: FnMut() -> (),

1796

1

1797

1

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

1798

1

		.build_storage()

1799

1

		.unwrap()

1800

1

		.into();

1801

1

	t.execute_with(|| {

1802

1

		System::set_block_consumed_resources(w, 0);

1803

1

		assertions()

1804

1

});

1805

1

1806

1807

#[test]

1808

#[rustfmt::skip]

1809

1

fn length_fee_is_sensible() {

1810

	use sp_runtime::testing::TestXt;

1811

1812

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

1813

1

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

1814

1

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

1815

1

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

1816

1

1817

9

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

1818

9

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

1819

9

				.inclusion_fee

1820

9

				.expect("fee should be calculated")

1821

9

				.len_fee

1822

9

};

1823

1824

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

1825

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

1826

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

1827

		//                             |           |

1828

1

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

1829

1

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

1830

1

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

1831

1

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

1832

1

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

1833

1

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

1834

1

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

1835

1

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

1836

1

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

1837

1

});

1838

1

1839

1840

#[test]

1841

1

fn multiplier_can_grow_from_zero() {

1842

	use frame_support::traits::Get;

1843

1844

1

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

1845

1

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

1846

1

		* RuntimeBlockWeights::get()

1847

1

			.get(DispatchClass::Normal)

1848

1

			.max_total

1849

1

			.unwrap();

1850

1

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

1851

1

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

1852

1

	run_with_system_weight(target * 101 / 100, || {

1853

1

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

1854

1

		assert!(

1855

1

			next > minimum_multiplier,

1856

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

1857

			next,

1858

			minimum_multiplier

1859

);

1860

1

})

1861

1

1862

1863

#[test]

1864

1

fn ethereum_invalid_transaction() {

1865

1

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

1866

1

		set_parachain_inherent_data();

1867

1

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

1868

1

		// on chain is rejected.

1869

1

		assert_eq!(

1870

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1871

1

			Err(

1872

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1873

1

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

1874

1

1875

1

1876

1

);

1877

1

});

1878

1

1879

1880

#[test]

1881

1

fn transfer_ed_0_substrate() {

1882

1

	ExtBuilder::default()

1883

1

		.with_balances(vec![

1884

1

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

1885

1

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

1886

1

])

1887

1

		.build()

1888

1

		.execute_with(|| {

1889

1

			// Substrate transfer

1890

1

			assert_ok!(Balances::transfer_allow_death(

1891

1

				origin_of(AccountId::from(ALICE)),

1892

1

				AccountId::from(BOB),

1893

1

				1 * UNIT,

1894

1

));

1895

			// 1 WEI is left in the account

1896

1

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

1897

1

});

1898

1

1899

1900

#[test]

1901

1

fn initial_gas_fee_is_correct() {

1902

	use fp_evm::FeeCalculator;

1903

1904

1

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

1905

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1906

1

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

1907

1908

1

		assert_eq!(

1909

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1910

1

1911

1

				2_500_000_000u128.into(),

1912

1

				Weight::from_parts(41_742_000u64, 0)

1913

1

1914

1

);

1915

1

});

1916

1

1917

1918

#[test]

1919

1

fn transfer_ed_0_evm() {

1920

1

	ExtBuilder::default()

1921

1

		.with_balances(vec![

1922

1

1923

1

				AccountId::from(ALICE),

1924

1

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

1925

1

),

1926

1

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

1927

1

])

1928

1

		.build()

1929

1

		.execute_with(|| {

1930

1

			set_parachain_inherent_data();

1931

1

			// EVM transfer

1932

1

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

1933

1

				source: H160::from(ALICE),

1934

1

				target: H160::from(BOB),

1935

1

				input: Vec::new(),

1936

1

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

1937

1

				gas_limit: 21_000u64,

1938

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1939

1

				max_priority_fee_per_gas: None,

1940

1

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

1941

1

				access_list: Vec::new(),

1942

1

				authorization_list: Vec::new(),

1943

1

})

1944

1

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

1945

			// 1 WEI is left in the account

1946

1

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

1947

1

});

1948

1

1949

1950

#[test]

1951

1

fn refund_ed_0_evm() {

1952

1

	ExtBuilder::default()

1953

1

		.with_balances(vec![

1954

1

1955

1

				AccountId::from(ALICE),

1956

1

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

1957

1

),

1958

1

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

1959

1

])

1960

1

		.build()

1961

1

		.execute_with(|| {

1962

1

			// EVM transfer that zeroes ALICE

1963

1

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

1964

1

				source: H160::from(ALICE),

1965

1

				target: H160::from(BOB),

1966

1

				input: Vec::new(),

1967

1

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

1968

1

				gas_limit: 21_777u64,

1969

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1970

1

				max_priority_fee_per_gas: None,

1971

1

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

1972

1

				access_list: Vec::new(),

1973

1

				authorization_list: Vec::new(),

1974

1

})

1975

1

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

1976

			// ALICE is refunded

1977

1

			assert_eq!(

1978

1

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

1979

1

				777 * BASE_FEE_GENISIS + existential_deposit(),

1980

1

);

1981

1

});

1982

1

1983

1984

#[test]

1985

1

fn author_does_receive_priority_fee() {

1986

1

	ExtBuilder::default()

1987

1

		.with_balances(vec![(

1988

1

			AccountId::from(BOB),

1989

1

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

1990

1

)])

1991

1

		.build()

1992

1

		.execute_with(|| {

1993

1

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

1994

1

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

1995

1

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

1996

1

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

1997

1

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

1998

1

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

1999

1

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

2000

1

2001

1

			// EVM transfer.

2002

1

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

2003

1

				source: H160::from(BOB),

2004

1

				target: H160::from(ALICE),

2005

1

				input: Vec::new(),

2006

1

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

2007

1

				gas_limit: 21_000u64,

2008

1

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

2009

1

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

2010

1

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

2011

1

				access_list: Vec::new(),

2012

1

				authorization_list: Vec::new(),

2013

1

})

2014

1

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

2015

2016

1

			let priority_fee = 200 * GIGAWEI * 21_000;

2017

1

			// Author free balance increased by priority fee.

2018

1

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

2019

1

});

2020

1

2021

2022

#[test]

2023

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

2024

1

	ExtBuilder::default()

2025

1

		.with_balances(vec![

2026

1

2027

1

				AccountId::from(BOB),

2028

1

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

2029

1

),

2030

1

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

2031

1

2032

1

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

2033

1

				existential_deposit(),

2034

1

),

2035

1

])

2036

1

		.build()

2037

1

		.execute_with(|| {

2038

1

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

2039

1

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

2040

1

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

2041

1

			// EVM transfer.

2042

1

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

2043

1

				source: H160::from(BOB),

2044

1

				target: H160::from(ALICE),

2045

1

				input: Vec::new(),

2046

1

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

2047

1

				gas_limit: 21_000u64,

2048

1

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

2049

1

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

2050

1

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

2051

1

				access_list: Vec::new(),

2052

1

				authorization_list: Vec::new(),

2053

1

})

2054

1

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

2055

2056

1

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

2057

1

2058

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

2059

1

2060

1

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

2061

1

2062

1

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

2063

1

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

2064

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

2065

1

2066

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

2067

2068

1

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

2069

1

});

2070

1

2071

2072

#[test]

2073

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

2074

	use fp_evm::FeeCalculator;

2075

1

	ExtBuilder::default()

2076

1

		.with_balances(vec![

2077

1

2078

1

				AccountId::from(BOB),

2079

1

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

2080

1

),

2081

1

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

2082

1

2083

1

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

2084

1

				existential_deposit(),

2085

1

),

2086

1

])

2087

1

		.build()

2088

1

		.execute_with(|| {

2089

1

			set_parachain_inherent_data();

2090

1

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

2091

1

			// EVM transfer.

2092

1

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

2093

1

				source: H160::from(BOB),

2094

1

				target: H160::from(ALICE),

2095

1

				input: Vec::new(),

2096

1

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

2097

1

				gas_limit: 21_000u64,

2098

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2099

1

				max_priority_fee_per_gas: None,

2100

1

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

2101

1

				access_list: Vec::new(),

2102

1

				authorization_list: Vec::new(),

2103

1

})

2104

1

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

2105

2106

1

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

2107

1

			// Fee is 1 GWEI base fee.

2108

1

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

2109

1

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

2110

2111

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

2112

1

2113

1

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

2114

1

2115

1

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

2116

1

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

2117

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

2118

1

2119

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

2120

2121

1

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

2122

1

});

2123

1

2124

2125

#[test]

2126

1

fn root_can_change_default_xcm_vers() {

2127

1

	ExtBuilder::default()

2128

1

		.with_balances(vec![

2129

1

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

2130

1

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

2131

1

])

2132

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2133

1

			asset_id: 1,

2134

1

			xcm_location: AssetHubLocation::get(),

2135

1

			name: "Dot",

2136

1

			symbol: "Dot",

2137

1

			decimals: 12,

2138

1

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

2139

1

}])

2140

1

		.build()

2141

1

		.execute_with(|| {

2142

1

			let source_id: moonbase_runtime::AssetId = 1;

2143

1

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

2144

1

			let asset = Asset {

2145

1

				id: AssetId(

2146

1

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

2147

1

						currency_id,

2148

1

2149

1

					.unwrap(),

2150

1

),

2151

1

				fun: Fungibility::Fungible(100_000_000_000_000),

2152

1

};

2153

1

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

2154

1

			// know with which version to send

2155

1

			assert_noop!(

2156

1

				PolkadotXcm::transfer_assets(

2157

1

					origin_of(AccountId::from(ALICE)),

2158

1

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

2159

1

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

2160

1

						parents: 0,

2161

1

						interior: [AccountId32 {

2162

1

							network: None,

2163

1

							id: [1u8; 32],

2164

1

}]

2165

1

						.into(),

2166

1

					})),

2167

1

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

2168

1

0,

2169

1

					WeightLimit::Unlimited

2170

1

),

2171

1

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

2172

1

);

2173

2174

			// Root sets the defaultXcm

2175

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

2176

1

				root_origin(),

2177

1

				Some(5)

2178

1

));

2179

2180

			// Now transferring does not fail

2181

1

			assert_ok!(PolkadotXcm::transfer_assets(

2182

1

				origin_of(AccountId::from(ALICE)),

2183

1

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

2184

1

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

2185

1

					parents: 0,

2186

1

					interior: [AccountId32 {

2187

1

						network: None,

2188

1

						id: [1u8; 32],

2189

1

}]

2190

1

					.into(),

2191

1

				})),

2192

1

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

2193

1

0,

2194

1

				WeightLimit::Unlimited

2195

1

));

2196

1

})

2197

1

2198

2199

#[test]

2200

1

fn transactor_cannot_use_more_than_max_weight() {

2201

1

	ExtBuilder::default()

2202

1

		.with_balances(vec![

2203

1

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

2204

1

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

2205

1

])

2206

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2207

1

			asset_id: 1,

2208

1

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

2209

1

			name: "RelayToken",

2210

1

			symbol: "Relay",

2211

1

			decimals: 12,

2212

1

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

2213

1

}])

2214

1

		.build()

2215

1

		.execute_with(|| {

2216

1

			let source_id: moonbase_runtime::AssetId = 1;

2217

1

			assert_ok!(XcmTransactor::register(

2218

1

				root_origin(),

2219

1

				AccountId::from(ALICE),

2220

1

0,

2221

1

));

2222

2223

			// Root can set transact info

2224

1

			assert_ok!(XcmTransactor::set_transact_info(

2225

1

				root_origin(),

2226

1

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

2227

1

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

2228

1

				3000.into(),

2229

1

				20000.into(),

2230

1

				None

2231

1

));

2232

			// Root can set transact info

2233

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2234

1

				root_origin(),

2235

1

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

2236

1

1,

2237

1

));

2238

2239

1

			assert_noop!(

2240

1

				XcmTransactor::transact_through_derivative(

2241

1

					origin_of(AccountId::from(ALICE)),

2242

1

					moonbase_runtime::xcm_config::Transactors::Relay,

2243

1

0,

2244

1

					CurrencyPayment {

2245

1

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

2246

1

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

2247

1

)),

2248

1

						fee_amount: None

2249

1

},

2250

1

					vec![],

2251

1

					// 20000 is the max

2252

1

					TransactWeights {

2253

1

						transact_required_weight_at_most: 17001.into(),

2254

1

						overall_weight: None

2255

1

},

2256

1

					false

2257

1

),

2258

1

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

2259

1

);

2260

1

			assert_noop!(

2261

1

				XcmTransactor::transact_through_derivative(

2262

1

					origin_of(AccountId::from(ALICE)),

2263

1

					moonbase_runtime::xcm_config::Transactors::Relay,

2264

1

0,

2265

1

					CurrencyPayment {

2266

1

						currency: Currency::AsCurrencyId(

2267

1

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

2268

1

),

2269

1

						fee_amount: None

2270

1

},

2271

1

					vec![],

2272

1

					// 20000 is the max

2273

1

					TransactWeights {

2274

1

						transact_required_weight_at_most: 17001.into(),

2275

1

						overall_weight: None

2276

1

},

2277

1

					false

2278

1

),

2279

1

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

2280

1

);

2281

1

})

2282

1

2283

2284

#[test]

2285

1

fn root_can_use_hrmp_manage() {

2286

1

	ExtBuilder::default()

2287

1

		.with_balances(vec![

2288

1

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

2289

1

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

2290

1

])

2291

1

		.build()

2292

1

		.execute_with(|| {

2293

1

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

2294

1

			// But all rest checks pass

2295

1

			assert_noop!(

2296

1

				XcmTransactor::hrmp_manage(

2297

1

					root_origin(),

2298

1

					HrmpOperation::Accept {

2299

1

						para_id: 2000u32.into()

2300

1

},

2301

1

					CurrencyPayment {

2302

1

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

2303

1

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

2304

1

)),

2305

1

						fee_amount: Some(10000)

2306

1

},

2307

1

					// 20000 is the max

2308

1

					TransactWeights {

2309

1

						transact_required_weight_at_most: 17001.into(),

2310

1

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

2311

1

2312

1

),

2313

1

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

2314

1

);

2315

1

})

2316

1

2317

2318

#[test]

2319

1

fn transact_through_signed_precompile_works_v1() {

2320

1

	ExtBuilder::default()

2321

1

		.with_balances(vec![

2322

1

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

2323

1

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

2324

1

])

2325

1

		.with_safe_xcm_version(3)

2326

1

		.build()

2327

1

		.execute_with(|| {

2328

1

			// Destination

2329

1

			let dest = Location::parent();

2330

1

2331

1

			let fee_payer_asset = Location::parent();

2332

1

2333

1

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

2334

1

2335

1

			let xcm_transactor_v1_precompile_address = H160::from_low_u64_be(2054);

2336

1

2337

1

			// Root can set transact info

2338

1

			assert_ok!(XcmTransactor::set_transact_info(

2339

1

				root_origin(),

2340

1

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

2341

1

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

2342

1

				3000.into(),

2343

1

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

2344

1

				Some(4000.into())

2345

1

));

2346

			// Root can set transact info

2347

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2348

1

				root_origin(),

2349

1

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

2350

1

1,

2351

1

));

2352

2353

1

			Precompiles::new()

2354

1

				.prepare_test(

2355

1

					ALICE,

2356

1

					xcm_transactor_v1_precompile_address,

2357

1

					XcmTransactorV1PCall::transact_through_signed_multilocation {

2358

1

						dest,

2359

1

						fee_asset: fee_payer_asset,

2360

1

						weight: 15000,

2361

1

						call: bytes.into(),

2362

1

},

2363

1

2364

1

				.expect_cost(23418)

2365

1

				.expect_no_logs()

2366

1

				.execute_returns(());

2367

1

});

2368

1

2369

2370

#[test]

2371

1

fn transact_through_signed_precompile_works_v2() {

2372

1

	ExtBuilder::default()

2373

1

		.with_balances(vec![

2374

1

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

2375

1

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

2376

1

])

2377

1

		.with_safe_xcm_version(3)

2378

1

		.build()

2379

1

		.execute_with(|| {

2380

1

			// Destination

2381

1

			let dest = Location::parent();

2382

1

2383

1

			let fee_payer_asset = Location::parent();

2384

1

2385

1

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

2386

1

2387

1

			let total_weight = 1_000_000_000u64;

2388

1

2389

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2390

1

2391

1

			Precompiles::new()

2392

1

				.prepare_test(

2393

1

					ALICE,

2394

1

					xcm_transactor_v2_precompile_address,

2395

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2396

1

						dest,

2397

1

						fee_asset: fee_payer_asset,

2398

1

						weight: 4_000_000,

2399

1

						call: bytes.into(),

2400

1

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

2401

1

						overall_weight: total_weight,

2402

1

},

2403

1

2404

1

				.expect_cost(23418)

2405

1

				.expect_no_logs()

2406

1

				.execute_returns(());

2407

1

});

2408

1

2409

2410

#[test]

2411

1

fn transact_through_signed_cannot_send_to_local_chain() {

2412

1

	ExtBuilder::default()

2413

1

		.with_balances(vec![

2414

1

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

2415

1

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

2416

1

])

2417

1

		.with_safe_xcm_version(3)

2418

1

		.build()

2419

1

		.execute_with(|| {

2420

1

			// Destination

2421

1

			let dest = Location::here();

2422

1

2423

1

			let fee_payer_asset = Location::parent();

2424

1

2425

1

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

2426

1

2427

1

			let total_weight = 1_000_000_000u64;

2428

1

2429

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2430

1

2431

1

			Precompiles::new()

2432

1

				.prepare_test(

2433

1

					ALICE,

2434

1

					xcm_transactor_v2_precompile_address,

2435

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2436

1

						dest,

2437

1

						fee_asset: fee_payer_asset,

2438

1

						weight: 4_000_000,

2439

1

						call: bytes.into(),

2440

1

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

2441

1

						overall_weight: total_weight,

2442

1

},

2443

1

2444

1

				.execute_reverts(|output| {

2445

1

					from_utf8(&output)

2446

1

						.unwrap()

2447

1

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

2448

1

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

2449

1

});

2450

1

});

2451

1

2452

2453

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

2454

#[test]

2455

1

fn account_id_32_encodes_like_32_byte_u8_slice() {

2456

1

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

2457

1

	let account_as_slice = [1u8; 32];

2458

1

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

2459

1

2460

2461

#[test]

2462

1

fn author_mapping_precompile_associate_update_and_clear() {

2463

1

	ExtBuilder::default()

2464

1

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

2465

1

		.build()

2466

1

		.execute_with(|| {

2467

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2468

1

			let first_nimbus_id: NimbusId =

2469

1

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

2470

1

			let first_vrf_id: session_keys_primitives::VrfId =

2471

1

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

2472

1

			let second_nimbus_id: NimbusId =

2473

1

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

2474

1

			let second_vrf_id: session_keys_primitives::VrfId =

2475

1

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

2476

1

2477

1

			// Associate it

2478

1

			Precompiles::new()

2479

1

				.prepare_test(

2480

1

					ALICE,

2481

1

					author_mapping_precompile_address,

2482

1

					AuthorMappingPCall::add_association {

2483

1

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

2484

1

},

2485

1

2486

1

				.expect_cost(16017)

2487

1

				.expect_no_logs()

2488

1

				.execute_returns(());

2489

1

2490

1

			let expected_associate_event =

2491

1

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

2492

1

					nimbus_id: first_nimbus_id.clone(),

2493

1

					account_id: AccountId::from(ALICE),

2494

1

					keys: first_vrf_id.clone(),

2495

1

});

2496

1

			assert_eq!(last_event(), expected_associate_event);

2497

2498

			// Update it

2499

1

			Precompiles::new()

2500

1

				.prepare_test(

2501

1

					ALICE,

2502

1

					author_mapping_precompile_address,

2503

1

					AuthorMappingPCall::update_association {

2504

1

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

2505

1

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

2506

1

},

2507

1

2508

1

				.expect_cost(15532)

2509

1

				.expect_no_logs()

2510

1

				.execute_returns(());

2511

1

2512

1

			let expected_update_event =

2513

1

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

2514

1

					new_nimbus_id: second_nimbus_id.clone(),

2515

1

					account_id: AccountId::from(ALICE),

2516

1

					new_keys: second_vrf_id.clone(),

2517

1

});

2518

1

			assert_eq!(last_event(), expected_update_event);

2519

2520

			// Clear it

2521

1

			Precompiles::new()

2522

1

				.prepare_test(

2523

1

					ALICE,

2524

1

					author_mapping_precompile_address,

2525

1

					AuthorMappingPCall::clear_association {

2526

1

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

2527

1

},

2528

1

2529

1

				.expect_cost(16037)

2530

1

				.expect_no_logs()

2531

1

				.execute_returns(());

2532

1

2533

1

			let expected_clear_event =

2534

1

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

2535

1

					nimbus_id: second_nimbus_id,

2536

1

					account_id: AccountId::from(ALICE),

2537

1

					keys: second_vrf_id,

2538

1

});

2539

1

			assert_eq!(last_event(), expected_clear_event);

2540

1

});

2541

1

2542

2543

#[test]

2544

1

fn author_mapping_register_and_set_keys() {

2545

1

	ExtBuilder::default()

2546

1

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

2547

1

		.build()

2548

1

		.execute_with(|| {

2549

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2550

1

			let first_nimbus_id: NimbusId =

2551

1

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

2552

1

			let first_vrf_key: session_keys_primitives::VrfId =

2553

1

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

2554

1

			let second_nimbus_id: NimbusId =

2555

1

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

2556

1

			let second_vrf_key: session_keys_primitives::VrfId =

2557

1

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

2558

1

2559

1

			// Associate it

2560

1

			Precompiles::new()

2561

1

				.prepare_test(

2562

1

					ALICE,

2563

1

					author_mapping_precompile_address,

2564

1

					AuthorMappingPCall::set_keys {

2565

1

						keys: solidity::encode_arguments((

2566

1

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

2567

1

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

2568

1

))

2569

1

						.into(),

2570

1

},

2571

1

2572

1

				.expect_cost(17820)

2573

1

				.expect_no_logs()

2574

1

				.execute_returns(());

2575

1

2576

1

			let expected_associate_event =

2577

1

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

2578

1

					nimbus_id: first_nimbus_id.clone(),

2579

1

					account_id: AccountId::from(ALICE),

2580

1

					keys: first_vrf_key.clone(),

2581

1

});

2582

1

			assert_eq!(last_event(), expected_associate_event);

2583

2584

			// Update it

2585

1

			Precompiles::new()

2586

1

				.prepare_test(

2587

1

					ALICE,

2588

1

					author_mapping_precompile_address,

2589

1

					AuthorMappingPCall::set_keys {

2590

1

						keys: solidity::encode_arguments((

2591

1

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

2592

1

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

2593

1

))

2594

1

						.into(),

2595

1

},

2596

1

2597

1

				.expect_cost(17820)

2598

1

				.expect_no_logs()

2599

1

				.execute_returns(());

2600

1

2601

1

			let expected_update_event =

2602

1

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

2603

1

					new_nimbus_id: second_nimbus_id.clone(),

2604

1

					account_id: AccountId::from(ALICE),

2605

1

					new_keys: second_vrf_key.clone(),

2606

1

});

2607

1

			assert_eq!(last_event(), expected_update_event);

2608

1

});

2609

1

2610

2611

#[test]

2612

1

fn test_xcm_utils_ml_tp_account() {

2613

1

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

2614

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2615

1

		let expected_address_parent: H160 =

2616

1

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

2617

1

				.unwrap()

2618

1

				.into();

2619

1

2620

1

		Precompiles::new()

2621

1

			.prepare_test(

2622

1

				ALICE,

2623

1

				xcm_utils_precompile_address,

2624

1

				XcmUtilsPCall::multilocation_to_address {

2625

1

					location: Location::parent(),

2626

1

},

2627

1

2628

1

			.expect_cost(3338)

2629

1

			.expect_no_logs()

2630

1

			.execute_returns(Address(expected_address_parent));

2631

1

2632

1

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

2633

1

		let expected_address_parachain: H160 =

2634

1

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

2635

1

				&parachain_2000_multilocation,

2636

1

2637

1

			.unwrap()

2638

1

			.into();

2639

1

2640

1

		Precompiles::new()

2641

1

			.prepare_test(

2642

1

				ALICE,

2643

1

				xcm_utils_precompile_address,

2644

1

				XcmUtilsPCall::multilocation_to_address {

2645

1

					location: parachain_2000_multilocation,

2646

1

},

2647

1

2648

1

			.expect_cost(3338)

2649

1

			.expect_no_logs()

2650

1

			.execute_returns(Address(expected_address_parachain));

2651

1

2652

1

		let alice_in_parachain_2000_multilocation = Location::new(

2653

1

1,

2654

1

2655

1

				Parachain(2000),

2656

1

				AccountKey20 {

2657

1

					network: None,

2658

1

					key: ALICE,

2659

1

},

2660

1

],

2661

1

);

2662

1

		let expected_address_alice_in_parachain_2000 =

2663

1

			xcm_builder::HashedDescription::<

2664

1

				AccountId,

2665

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2666

1

			>::convert_location(&alice_in_parachain_2000_multilocation)

2667

1

			.unwrap()

2668

1

			.into();

2669

1

2670

1

		Precompiles::new()

2671

1

			.prepare_test(

2672

1

				ALICE,

2673

1

				xcm_utils_precompile_address,

2674

1

				XcmUtilsPCall::multilocation_to_address {

2675

1

					location: alice_in_parachain_2000_multilocation,

2676

1

},

2677

1

2678

1

			.expect_cost(3338)

2679

1

			.expect_no_logs()

2680

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2681

1

});

2682

1

2683

2684

#[test]

2685

1

fn test_nested_batch_calls_from_xcm_transact() {

2686

1

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

2687

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2688

1

		// in a future polkadot-sdk version

2689

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2690

2691

1

		let mut valid_nested_calls =

2692

1

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

2693

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2694

8

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

2695

8

				calls: vec![valid_nested_calls],

2696

8

});

2697

8

2698

2699

1

		let valid_message = Xcm(vec![Transact {

2700

1

			origin_kind: OriginKind::SovereignAccount,

2701

1

			fallback_max_weight: None,

2702

1

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

2703

1

		}]);

2704

1

2705

1

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

2706

2707

1

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

2708

1

			calls: vec![valid_nested_calls],

2709

1

});

2710

1

2711

1

		let invalid_message = Xcm(vec![Transact {

2712

1

			origin_kind: OriginKind::SovereignAccount,

2713

1

			fallback_max_weight: None,

2714

1

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

2715

1

		}]);

2716

1

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

2717

1

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

2718

1

});

2719

1

2720

2721

#[test]

2722

1

fn test_xcm_utils_weight_message() {

2723

1

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

2724

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2725

1

		let expected_weight =

2726

1

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

2727

1

2728

1

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

2729

1

2730

1

		let input = XcmUtilsPCall::weight_message {

2731

1

			message: message.into(),

2732

1

};

2733

1

2734

1

		Precompiles::new()

2735

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2736

1

			.expect_cost(1669)

2737

1

			.expect_no_logs()

2738

1

			.execute_returns(expected_weight);

2739

1

});

2740

1

2741

2742

#[test]

2743

1

fn test_xcm_utils_get_units_per_second() {

2744

1

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

2745

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2746

1

		let location = SelfReserve::get();

2747

1

2748

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2749

1

2750

1

		let expected_units =

2751

1

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

2752

1

2753

1

		Precompiles::new()

2754

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2755

1

			.expect_cost(3338)

2756

1

			.expect_no_logs()

2757

1

			.execute_returns(expected_units);

2758

1

});

2759

1

2760

2761

#[test]

2762

1

fn precompile_existence() {

2763

1

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

2764

1

		let precompiles = Precompiles::new();

2765

1

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

2766

1

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

2767

1

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

2768

1

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

2769

1

2770

1

		.into_iter()

2771

1

		.map(H160::from_low_u64_be)

2772

1

		.collect();

2773

2774

3001

		for i in 0..3000 {

2775

3000

			let address = H160::from_low_u64_be(i);

2776

3000

2777

3000

			if precompile_addresses.contains(&address) {

2778

48

				assert!(

2779

48

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

2780

					"is_precompile({}) should return true",

2781

2782

);

2783

2784

48

				assert!(

2785

48

					precompiles

2786

48

						.execute(&mut MockHandle::new(

2787

48

							address,

2788

48

							Context {

2789

48

								address,

2790

48

								caller: H160::zero(),

2791

48

								apparent_value: U256::zero()

2792

48

2793

48

),)

2794

48

						.is_some(),

2795

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

2796

2797

);

2798

			} else {

2799

2952

				assert!(

2800

2952

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

2801

					"is_precompile({}) should return false",

2802

2803

);

2804

2805

2952

				assert!(

2806

2952

					precompiles

2807

2952

						.execute(&mut MockHandle::new(

2808

2952

							address,

2809

2952

							Context {

2810

2952

								address,

2811

2952

								caller: H160::zero(),

2812

2952

								apparent_value: U256::zero()

2813

2952

2814

2952

),)

2815

2952

						.is_none(),

2816

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

2817

2818

);

2819

2820

2821

1

});

2822

1

2823

2824

#[test]

2825

1

fn removed_precompiles() {

2826

1

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

2827

1

		let precompiles = Precompiles::new();

2828

1

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

2829

2830

3000

		for i in 1..3000 {

2831

2999

			let address = H160::from_low_u64_be(i);

2832

2999

2833

2999

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

2834

2951

				continue;

2835

48

2836

48

2837

48

			if !removed_precompiles.contains(&i) {

2838

43

				assert!(

2839

43

					match precompiles.is_active_precompile(address, 100_000u64) {

2840

43

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

2841

						_ => false,

2842

},

2843

					"{i} should be an active precompile"

2844

);

2845

43

				continue;

2846

5

2847

5

2848

5

			assert!(

2849

5

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

2850

5

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

2851

					_ => false,

2852

},

2853

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

2854

);

2855

2856

5

			precompiles

2857

5

				.prepare_test(Alice, address, [])

2858

5

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

2859

5

2860

1

})

2861

1

2862

2863

#[test]

2864

1

fn substrate_based_fees_zero_txn_costs_only_base_extrinsic() {

2865

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

2866

	use moonbase_runtime::{currency, EXTRINSIC_BASE_WEIGHT};

2867

2868

1

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

2869

1

		let size_bytes = 0;

2870

1

		let tip = 0;

2871

1

		let dispatch_info = DispatchInfo {

2872

1

			class: DispatchClass::Normal,

2873

1

			pays_fee: Pays::Yes,

2874

1

			call_weight: Weight::zero(),

2875

1

			extension_weight: Weight::zero(),

2876

1

};

2877

1

2878

1

		assert_eq!(

2879

1

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

2880

1

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

2881

1

);

2882

1

});

2883

1

2884

2885

#[test]

2886

1

fn deal_with_fees_handles_tip() {

2887

	use frame_support::traits::OnUnbalanced;

2888

	use moonbase_runtime::Treasury;

2889

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2890

2891

1

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

2892

1

		set_parachain_inherent_data();

2893

1

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

2894

1

		// in the Moonbeam runtime. It verifies that:

2895

1

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

2896

1

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

2897

1

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

2898

1

2899

1

		// The test details:

2900

1

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

2901

1

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

2902

1

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

2903

1

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

2904

1

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

2905

1

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

2906

1

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

2907

1

2908

1

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

2909

1

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

2910

1

			AccountId,

2911

1

		>>::issue(100);

2912

1

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

2913

1

			AccountId,

2914

1

		>>::issue(1000);

2915

1

2916

1

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

2917

1

		let total_supply_before = Balances::total_issuance();

2918

1

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

2919

1

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

2920

1

		assert_eq!(total_supply_before, 1_100);

2921

1

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

2922

2923

		// Step 3: Execute the fees handling logic.

2924

1

		DealWithSubstrateFeesAndTip::<

2925

1

			Runtime,

2926

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2927

1

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

2928

1

2929

1

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

2930

1

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

2931

1

2932

1

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

2933

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2934

1

2935

1

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

2936

1

		assert_eq!(

2937

1

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

2938

1

			treasury_fee_part,

2939

1

);

2940

2941

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

2942

1

		let total_supply_after = Balances::total_issuance();

2943

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2944

2945

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

2946

1

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

2947

1

		assert_eq!(

2948

1

			block_author_balance_after - block_author_balance_before,

2949

1

			1000,

2950

1

);

2951

1

});

2952

1

2953

2954

#[test]

2955

1

fn evm_revert_substrate_events() {

2956

1

	ExtBuilder::default()

2957

1

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

2958

1

		.build()

2959

1

		.execute_with(|| {

2960

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2961

1

2962

1

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

2963

1

			// Thus BatchAll will revert the transfer.

2964

1

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

2965

1

				source: ALICE.into(),

2966

1

				target: batch_precompile_address,

2967

1

				input: BatchPCall::batch_all {

2968

1

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

2969

1

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

2970

1

					call_data: vec![].into(),

2971

1

					gas_limit: vec![].into()

2972

1

2973

1

				.into(),

2974

1

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

2975

1

				gas_limit: 500_000,

2976

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2977

1

				max_priority_fee_per_gas: None,

2978

1

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

2979

1

				access_list: Vec::new(),

2980

1

				authorization_list: Vec::new(),

2981

1

})

2982

1

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

2983

2984

1

			let transfer_count = System::events()

2985

1

				.iter()

2986

4

				.filter(|r| match r.event {

2987

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

2988

6

					_ => false,

2989

6

})

2990

1

				.count();

2991

1

2992

1

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

2993

1

});

2994

1

2995

2996

#[test]

2997

1

fn evm_success_keeps_substrate_events() {

2998

1

	ExtBuilder::default()

2999

1

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

3000

1

		.build()

3001

1

		.execute_with(|| {

3002

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

3003

1

3004

1

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

3005

1

				source: ALICE.into(),

3006

1

				target: batch_precompile_address,

3007

1

				input: BatchPCall::batch_all {

3008

1

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

3009

1

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

3010

1

					call_data: vec![].into(),

3011

1

					gas_limit: vec![].into()

3012

1

3013

1

				.into(),

3014

1

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

3015

1

				gas_limit: 500_000,

3016

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

3017

1

				max_priority_fee_per_gas: None,

3018

1

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

3019

1

				access_list: Vec::new(),

3020

1

				authorization_list: Vec::new(),

3021

1

})

3022

1

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

3023

3024

1

			let transfer_count = System::events()

3025

1

				.iter()

3026

6

				.filter(|r| match r.event {

3027

1

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

3028

9

					_ => false,

3029

10

})

3030

1

				.count();

3031

1

3032

1

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

3033

1

});

3034

1

3035

3036

#[test]

3037

1

fn validate_transaction_fails_on_filtered_call() {

3038

	use sp_runtime::transaction_validity::{

3039

		InvalidTransaction, TransactionSource, TransactionValidityError,

3040

};

3041

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

3042

3043

1

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

3044

1

		let xt = UncheckedExtrinsic::new_bare(

3045

1

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

3046

1

				source: Default::default(),

3047

1

				target: H160::default(),

3048

1

				input: Vec::new(),

3049

1

				value: Default::default(),

3050

1

				gas_limit: Default::default(),

3051

1

				max_fee_per_gas: Default::default(),

3052

1

				max_priority_fee_per_gas: Default::default(),

3053

1

				nonce: Default::default(),

3054

1

				access_list: Default::default(),

3055

1

				authorization_list: Default::default(),

3056

1

3057

1

			.into(),

3058

1

);

3059

1

3060

1

		assert_eq!(

3061

1

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

3062

1

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

3063

1

);

3064

1

});

3065

1

3066

3067

#[cfg(test)]

3068

mod treasury_tests {

3069

	use super::*;

3070

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

3071

	use moonbase_runtime::XcmWeightTrader;

3072

	use sp_runtime::traits::Hash;

3073

3074

8

	fn expect_events(events: Vec<RuntimeEvent>) {

3075

8

		let block_events: Vec<RuntimeEvent> =

3076

59

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

3077

8

3078

8

		dbg!(events.clone());

3079

8

		dbg!(block_events.clone());

3080

8

3081

12

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

3082

8

3083

3084

13

	fn next_block() {

3085

13

		System::reset_events();

3086

13

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

3087

13

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

3088

13

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

3089

13

3090

3091

6

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

3092

6

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

3093

6

			.expect("failed to get account balance")

3094

6

3095

3096

	#[test]

3097

1

	fn test_treasury_spend_local_with_root_origin() {

3098

1

		let initial_treasury_balance = 1_000 * UNIT;

3099

1

		ExtBuilder::default()

3100

1

			.with_balances(vec![

3101

1

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

3102

1

				(Treasury::account_id(), initial_treasury_balance),

3103

1

])

3104

1

			.build()

3105

1

			.execute_with(|| {

3106

1

				let spend_amount = 100u128 * UNIT;

3107

1

				let spend_beneficiary = AccountId::from(BOB);

3108

1

3109

1

				next_block();

3110

1

3111

1

				// Perform treasury spending

3112

1

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

3113

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

3114

1

					root_origin(),

3115

1

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

3116

1

						amount: spend_amount,

3117

1

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

3118

1

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

3119

1

						valid_from: Some(valid_from),

3120

1

}))

3121

1

));

3122

3123

1

				let payout_period =

3124

1

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

3125

1

				let expected_events = [RuntimeEvent::Treasury(

3126

1

					pallet_treasury::Event::AssetSpendApproved {

3127

1

						index: 0,

3128

1

						asset_kind: NativeOrWithId::Native,

3129

1

						amount: spend_amount,

3130

1

						beneficiary: spend_beneficiary,

3131

1

						valid_from,

3132

1

						expire_at: payout_period + valid_from,

3133

1

},

3134

1

)]

3135

1

				.to_vec();

3136

1

				expect_events(expected_events);

3137

3138

6

				while System::block_number() < valid_from {

3139

5

					next_block();

3140

5

3141

3142

1

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

3143

3144

1

				let expected_events = [

3145

1

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

3146

1

						index: 0,

3147

1

						payment_id: (),

3148

1

}),

3149

1

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

3150

1

						from: Treasury::account_id(),

3151

1

						to: spend_beneficiary,

3152

1

						amount: spend_amount,

3153

1

}),

3154

1

3155

1

				.to_vec();

3156

1

				expect_events(expected_events);

3157

1

});

3158

1

3159

3160

	#[test]

3161

1

	fn test_treasury_spend_local_with_council_origin() {

3162

1

		let initial_treasury_balance = 1_000 * UNIT;

3163

1

		ExtBuilder::default()

3164

1

			.with_balances(vec![

3165

1

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

3166

1

				(Treasury::account_id(), initial_treasury_balance),

3167

1

])

3168

1

			.build()

3169

1

			.execute_with(|| {

3170

1

				let spend_amount = 100u128 * UNIT;

3171

1

				let spend_beneficiary = AccountId::from(BOB);

3172

1

3173

1

				next_block();

3174

1

3175

1

				// TreasuryCouncilCollective

3176

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3177

1

					root_origin(),

3178

1

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

3179

1

					Some(AccountId::from(ALICE)),

3180

1

3181

1

));

3182

3183

1

				next_block();

3184

1

3185

1

				// Perform treasury spending

3186

1

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

3187

1

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

3188

1

					amount: spend_amount,

3189

1

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

3190

1

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

3191

1

					valid_from: Some(valid_from),

3192

1

});

3193

1

				assert_ok!(TreasuryCouncilCollective::propose(

3194

1

					origin_of(AccountId::from(ALICE)),

3195

1

1,

3196

1

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

3197

1

					1_000

3198

1

));

3199

3200

1

				let payout_period =

3201

1

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

3202

1

				let expected_events = [

3203

1

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

3204

1

						index: 0,

3205

1

						asset_kind: NativeOrWithId::Native,

3206

1

						amount: spend_amount,

3207

1

						beneficiary: spend_beneficiary,

3208

1

						valid_from,

3209

1

						expire_at: payout_period + valid_from,

3210

1

}),

3211

1

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

3212

1

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

3213

1

						result: Ok(()),

3214

1

}),

3215

1

3216

1

				.to_vec();

3217

1

				expect_events(expected_events);

3218

3219

6

				while System::block_number() < valid_from {

3220

5

					next_block();

3221

5

3222

3223

1

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

3224

3225

1

				let expected_events = [

3226

1

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

3227

1

						index: 0,

3228

1

						payment_id: (),

3229

1

}),

3230

1

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

3231

1

						from: Treasury::account_id(),

3232

1

						to: spend_beneficiary,

3233

1

						amount: spend_amount,

3234

1

}),

3235

1

3236

1

				.to_vec();

3237

1

				expect_events(expected_events);

3238

1

});

3239

1

3240

3241

	#[test]

3242

1

	fn test_treasury_spend_foreign_asset_with_root_origin() {

3243

1

		let initial_treasury_balance = 1_000 * UNIT;

3244

1

		let asset_id = 1000100010001000u128;

3245

1

		ExtBuilder::default()

3246

1

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

3247

1

			.build()

3248

1

			.execute_with(|| {

3249

1

				let spend_amount = 100u128 * UNIT;

3250

1

				let spend_beneficiary = AccountId::from(BOB);

3251

1

3252

1

				let asset_location: Location = Location {

3253

1

					parents: 1,

3254

1

					interior: Junctions::Here,

3255

1

};

3256

1

3257

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

3258

1

					root_origin(),

3259

1

					asset_id,

3260

1

					asset_location.clone(),

3261

1

12,

3262

1

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

3263

1

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

3264

1

));

3265

3266

1

				assert_ok!(XcmWeightTrader::add_asset(

3267

1

					root_origin(),

3268

1

					asset_location,

3269

1

					1u128

3270

1

));

3271

3272

1

				assert_ok!(EvmForeignAssets::mint_into(

3273

1

					asset_id,

3274

1

					Treasury::account_id(),

3275

1

					initial_treasury_balance.into()

3276

1

));

3277

3278

1

				assert_eq!(

3279

1

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

3280

1

					initial_treasury_balance.into(),

3281

					"Treasury balance not updated"

3282

);

3283

3284

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

3285

1

					root_origin(),

3286

1

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

3287

1

						amount: spend_amount,

3288

1

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

3289

1

						beneficiary: Box::new(spend_beneficiary),

3290

1

						valid_from: None,

3291

1

}))

3292

1

));

3293

3294

1

				let payout_period =

3295

1

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

3296

1

3297

1

				let current_block = System::block_number();

3298

1

				expect_events(vec![RuntimeEvent::Treasury(

3299

1

					pallet_treasury::Event::AssetSpendApproved {

3300

1

						index: 0,

3301

1

						asset_kind: NativeOrWithId::WithId(asset_id),

3302

1

						amount: spend_amount,

3303

1

						beneficiary: spend_beneficiary,

3304

1

						valid_from: current_block,

3305

1

						expire_at: current_block + payout_period,

3306

1

},

3307

1

				)]);

3308

1

3309

1

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

3310

3311

1

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

3312

1

					index: 0,

3313

1

					payment_id: (),

3314

1

				})]);

3315

1

3316

1

				assert_eq!(

3317

1

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

3318

1

					(initial_treasury_balance - spend_amount).into(),

3319

					"Treasury balance not updated"

3320

);

3321

3322

1

				assert_eq!(

3323

1

					get_asset_balance(&asset_id, &spend_beneficiary),

3324

1

					spend_amount.into(),

3325

					"Treasury payout failed"

3326

);

3327

1

});

3328

1

3329

3330

	#[test]

3331

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

3332

1

		let initial_treasury_balance = 1_000 * UNIT;

3333

1

		let asset_id = 1000100010001000u128;

3334

1

		ExtBuilder::default()

3335

1

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

3336

1

			.build()

3337

1

			.execute_with(|| {

3338

1

				let spend_amount = 100u128 * UNIT;

3339

1

				let spend_beneficiary = AccountId::from(BOB);

3340

1

3341

1

				let asset_location: Location = Location {

3342

1

					parents: 1,

3343

1

					interior: Junctions::Here,

3344

1

};

3345

1

3346

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

3347

1

					root_origin(),

3348

1

					asset_id,

3349

1

					asset_location.clone(),

3350

1

12,

3351

1

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

3352

1

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

3353

1

));

3354

3355

1

				assert_ok!(XcmWeightTrader::add_asset(

3356

1

					root_origin(),

3357

1

					asset_location,

3358

1

					1u128

3359

1

));

3360

3361

1

				assert_ok!(EvmForeignAssets::mint_into(

3362

1

					asset_id,

3363

1

					Treasury::account_id(),

3364

1

					initial_treasury_balance.into()

3365

1

));

3366

3367

1

				assert_eq!(

3368

1

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

3369

1

					initial_treasury_balance.into(),

3370

					"Treasury balance not updated"

3371

);

3372

3373

				// TreasuryCouncilCollective

3374

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3375

1

					root_origin(),

3376

1

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

3377

1

					Some(AccountId::from(ALICE)),

3378

1

3379

1

));

3380

3381

				// Perform treasury spending

3382

1

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

3383

1

					amount: spend_amount,

3384

1

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

3385

1

					beneficiary: Box::new(spend_beneficiary),

3386

1

					valid_from: None,

3387

1

});

3388

1

				assert_ok!(TreasuryCouncilCollective::propose(

3389

1

					origin_of(AccountId::from(ALICE)),

3390

1

1,

3391

1

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

3392

1

					1_000

3393

1

));

3394

3395

1

				let payout_period =

3396

1

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

3397

1

3398

1

				let current_block = System::block_number();

3399

1

				let expected_events = [

3400

1

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

3401

1

						index: 0,

3402

1

						asset_kind: NativeOrWithId::WithId(asset_id),

3403

1

						amount: spend_amount,

3404

1

						beneficiary: spend_beneficiary,

3405

1

						valid_from: current_block,

3406

1

						expire_at: current_block + payout_period,

3407

1

}),

3408

1

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

3409

1

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

3410

1

						result: Ok(()),

3411

1

}),

3412

1

3413

1

				.to_vec();

3414

1

				expect_events(expected_events);

3415

1

3416

1

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

3417

3418

1

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

3419

1

					index: 0,

3420

1

					payment_id: (),

3421

1

				})]);

3422

1

3423

1

				assert_eq!(

3424

1

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

3425

1

					(initial_treasury_balance - spend_amount).into(),

3426

					"Treasury balance not updated"

3427

);

3428

3429

1

				assert_eq!(

3430

1

					get_asset_balance(&asset_id, &spend_beneficiary),

3431

1

					spend_amount.into(),

3432

					"Treasury payout failed"

3433

);

3434

1

});

3435

1

3436

3437

3438

#[cfg(test)]

3439

mod fee_tests {

3440

	use super::*;

3441

	use fp_evm::FeeCalculator;

3442

	use frame_support::{

3443

		traits::{ConstU128, OnFinalize},

3444

		weights::{ConstantMultiplier, WeightToFee},

3445

};

3446

	use moonbase_runtime::{

3447

		currency, BlockWeights, FastAdjustingFeeUpdate, LengthToFee, MinimumMultiplier,

3448

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

3449

};

3450

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

3451

3452

1

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

3453

1

	where

3454

1

		F: FnMut() -> (),

3455

1

3456

1

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

3457

1

			.build_storage()

3458

1

			.unwrap()

3459

1

			.into();

3460

1

		t.execute_with(|| {

3461

1

			System::set_block_consumed_resources(w, 0);

3462

1

			assertions()

3463

1

});

3464

1

3465

3466

	#[test]

3467

1

	fn test_multiplier_can_grow_from_zero() {

3468

1

		let minimum_multiplier = MinimumMultiplier::get();

3469

1

		let target = TargetBlockFullness::get()

3470

1

			* BlockWeights::get()

3471

1

				.get(DispatchClass::Normal)

3472

1

				.max_total

3473

1

				.unwrap();

3474

1

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

3475

1

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

3476

1

		run_with_system_weight(target * 101 / 100, || {

3477

1

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

3478

1

			assert!(

3479

1

				next > minimum_multiplier,

3480

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

3481

				next,

3482

				minimum_multiplier

3483

);

3484

1

})

3485

1

3486

3487

	#[test]

3488

1

	fn test_fee_calculation() {

3489

1

		let base_extrinsic = BlockWeights::get()

3490

1

			.get(DispatchClass::Normal)

3491

1

			.base_extrinsic;

3492

1

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

3493

1

		let extrinsic_len = 100u32;

3494

1

		let extrinsic_weight = 5_000u64;

3495

1

		let tip = 42u128;

3496

		type WeightToFeeImpl =

3497

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

3498

		type LengthToFeeImpl = LengthToFee;

3499

3500

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

3501

1

		let expected_fee =

3502

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3503

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

3504

1

					&Weight::from_parts(extrinsic_weight, 1),

3505

1

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

3506

1

				+ tip;

3507

1

3508

1

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

3509

1

			.build_storage()

3510

1

			.unwrap()

3511

1

			.into();

3512

1

		t.execute_with(|| {

3513

1

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

3514

1

			let actual_fee = TransactionPayment::compute_fee(

3515

1

				extrinsic_len,

3516

1

				&frame_support::dispatch::DispatchInfo {

3517

1

					class: DispatchClass::Normal,

3518

1

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

3519

1

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

3520

1

					extension_weight: Weight::zero(),

3521

1

},

3522

1

				tip,

3523

1

);

3524

1

3525

1

			assert_eq!(

3526

				expected_fee,

3527

				actual_fee,

3528

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

3529

				actual_fee - expected_fee

3530

);

3531

1

});

3532

1

3533

3534

	#[test]

3535

1

	fn test_min_gas_price_is_deterministic() {

3536

1

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

3537

1

			.build_storage()

3538

1

			.unwrap()

3539

1

			.into();

3540

1

		t.execute_with(|| {

3541

1

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

3542

1

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

3543

1

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

3544

1

			let expected: U256 = multiplier

3545

1

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

3546

1

				.into();

3547

1

3548

1

			assert_eq!(expected, actual);

3549

1

});

3550

1

3551

3552

	#[test]

3553

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3554

1

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

3555

1

			.build_storage()

3556

1

			.unwrap()

3557

1

			.into();

3558

1

		t.execute_with(|| {

3559

1

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

3560

1

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

3561

1

3562

1

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

3563

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3564

1

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

3565

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3566

1

3567

1

			assert_ne!(

3568

				a, b,

3569

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

3570

);

3571

1

});

3572

1

3573

3574

	#[test]

3575

1

	fn test_fee_scenarios() {

3576

		use sp_runtime::FixedU128;

3577

1

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

3578

1

			.build_storage()

3579

1

			.unwrap()

3580

1

			.into();

3581

1

		t.execute_with(|| {

3582

1

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

3583

12

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

3584

12

				let start_multiplier =

3585

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3586

12

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

3587

12

3588

12

				let block_weight = NORMAL_WEIGHT * fullness;

3589

3590

60004

				for i in 0..num_blocks {

3591

60004

					System::set_block_number(i as u32);

3592

60004

					System::set_block_consumed_resources(block_weight, 0);

3593

60004

					TransactionPayment::on_finalize(i as u32);

3594

60004

3595

3596

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3597

12

};

3598

3599

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

3600

			// they are expected to change when parameters that influence

3601

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

3602

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

3603

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

3604

3605

1

			assert_eq!(

3606

1

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

3607

1

				U256::from(998_600_980),

3608

1

);

3609

1

			assert_eq!(

3610

1

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

3611

1

				U256::from(999_600_080),

3612

1

);

3613

1

			assert_eq!(

3614

1

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

3615

1

				U256::from(1_000_600_180),

3616

1

);

3617

1

			assert_eq!(

3618

1

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

3619

1

				U256::from(1_002_603_380),

3620

1

);

3621

3622

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

3623

1

			assert_eq!(

3624

1

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

3625

1

				U256::from(431_710_642),

3626

1

);

3627

1

			assert_eq!(

3628

1

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

3629

1

				U256::from(786_627_866),

3630

1

);

3631

1

			assert_eq!(

3632

1

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

3633

1

				U256::from(1_433_329_383u128),

3634

1

);

3635

1

			assert_eq!(

3636

1

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

3637

1

				U256::from(4_758_812_897u128),

3638

1

);

3639

3640

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

3641

1

			assert_eq!(

3642

1

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

3643

1

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

3644

1

);

3645

1

			assert_eq!(

3646

1

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

3647

1

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

3648

1

);

3649

1

			assert_eq!(

3650

1

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

3651

1

				U256::from(5_653_326_895_069u128),

3652

1

);

3653

1

			assert_eq!(

3654

1

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

3655

1

				U256::from(31_250_000_000_000u128),

3656

1

				// upper bound enforced (min_gas_price * MaximumMultiplier)

3657

1

);

3658

1

});

3659

1

3660

3661

3662

#[cfg(test)]

3663

mod balance_tests {

3664

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

3665

	use frame_support::assert_ok;

3666

	use frame_support::traits::LockableCurrency;

3667

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

3668

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

3669

	use moonbeam_core_primitives::AccountId;

3670

3671

	#[test]

3672

1

	fn reserve_should_work_for_frozen_balance() {

3673

1

		let alice = AccountId::from(ALICE);

3674

		const ID_1: LockIdentifier = *b"1       ";

3675

3676

1

		ExtBuilder::default()

3677

1

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

3678

1

			.build()

3679

1

			.execute_with(|| {

3680

1

				// Check balances

3681

1

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

3682

1

				assert_eq!(account.free, 10);

3683

1

				assert_eq!(account.frozen, 0);

3684

1

				assert_eq!(account.reserved, 0);

3685

3686

1

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

3687

1

3688

1

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

3689

1

				assert_eq!(account.free, 10);

3690

1

				assert_eq!(account.frozen, 9);

3691

1

				assert_eq!(account.reserved, 0);

3692

3693

1

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

3694

3695

1

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

3696

1

				assert_eq!(account.free, 5);

3697

1

				assert_eq!(account.frozen, 9);

3698

1

				assert_eq!(account.reserved, 5);

3699

3700

1

				let previous_reserved_amount = account.reserved;

3701

1

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

3702

1

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

3703

1

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

3704

3705

1

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

3706

1

				assert_eq!(account.free, ed);

3707

1

				assert_eq!(account.frozen, 9);

3708

1

				assert_eq!(

3709

1

					account.reserved,

3710

1

					previous_reserved_amount.saturating_add(next_reserve)

3711

1

);

3712

1

});

3713

1

3714