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::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,

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_transaction_payment::Multiplier;

66

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

67

use parity_scale_codec::Encode;

68

use sha3::{Digest, Keccak256};

69

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

70

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

71

use std::cell::Cell;

72

use std::rc::Rc;

73

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

74

75

type AuthorMappingPCall =

76

	pallet_evm_precompile_author_mapping::AuthorMappingPrecompileCall<Runtime>;

77

type BatchPCall = pallet_evm_precompile_batch::BatchPrecompileCall<Runtime>;

78

type CrowdloanRewardsPCall =

79

	pallet_evm_precompile_crowdloan_rewards::CrowdloanRewardsPrecompileCall<Runtime>;

80

type XcmUtilsPCall = pallet_evm_precompile_xcm_utils::XcmUtilsPrecompileCall<

81

	Runtime,

82

	moonbase_runtime::xcm_config::XcmExecutorConfig,

83

>;

84

type XtokensPCall = pallet_evm_precompile_xtokens::XtokensPrecompileCall<Runtime>;

85

/*type ForeignAssetsPCall = pallet_evm_precompileset_assets_erc20::Erc20AssetsPrecompileSetCall<

86

	Runtime,

87

	ForeignAssetInstance,

88

>;*/

89

type XcmTransactorV1PCall =

90

	pallet_evm_precompile_xcm_transactor::v1::XcmTransactorPrecompileV1Call<Runtime>;

91

type XcmTransactorV2PCall =

92

	pallet_evm_precompile_xcm_transactor::v2::XcmTransactorPrecompileV2Call<Runtime>;

93

94

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

95

const BASE_FEE_GENISIS: u128 = 10 * GIGAWEI / 4;

96

97

#[test]

98

1

fn xcmp_queue_controller_origin_is_root() {

99

1

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

100

1

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

101

1

	assert_ok!(

102

1

		<moonbase_runtime::Runtime as cumulus_pallet_xcmp_queue::Config

103

1

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

104

1

);

105

1

106

107

#[test]

108

1

fn verify_pallet_prefixes() {

109

32

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

110

32

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

111

32

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

112

32

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

113

32

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

114

32

		// expand/storage.rs#L389-L401

115

32

		assert_eq!(

116

32

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

117

32

			Some(name)

118

32

);

119

32

120

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

121

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

122

1

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

123

1

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

124

1

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

125

1

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

126

1

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

127

1

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

128

1

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

129

1

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

130

1

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

131

1

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

132

1

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

133

1

	is_pallet_prefix::<moonbase_runtime::OpenTechCommitteeCollective>(

134

1

		"OpenTechCommitteeCollective",

135

1

);

136

1

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

137

1

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

138

1

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

139

1

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

140

1

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

141

1

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

142

1

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

143

1

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

144

1

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

145

1

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

146

1

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

147

1

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

148

1

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

149

1

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

150

1

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

151

1

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

152

1

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

153

1

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

154

1

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

155

1

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

156

1

157

13

	let prefix = |pallet_name, storage_name| {

158

13

		let mut res = [0u8; 32];

159

13

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

160

13

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

161

13

		res.to_vec()

162

13

};

163

1

	assert_eq!(

164

1

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

165

1

		vec![

166

1

			StorageInfo {

167

1

				pallet_name: b"Balances".to_vec(),

168

1

				storage_name: b"TotalIssuance".to_vec(),

169

1

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

170

1

				max_values: Some(1),

171

1

				max_size: Some(16),

172

1

},

173

1

			StorageInfo {

174

1

				pallet_name: b"Balances".to_vec(),

175

1

				storage_name: b"InactiveIssuance".to_vec(),

176

1

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

177

1

				max_values: Some(1),

178

1

				max_size: Some(16),

179

1

},

180

1

			StorageInfo {

181

1

				pallet_name: b"Balances".to_vec(),

182

1

				storage_name: b"Account".to_vec(),

183

1

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

184

1

				max_values: None,

185

1

				max_size: Some(100),

186

1

},

187

1

			StorageInfo {

188

1

				pallet_name: b"Balances".to_vec(),

189

1

				storage_name: b"Locks".to_vec(),

190

1

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

191

1

				max_values: None,

192

1

				max_size: Some(1287),

193

1

},

194

1

			StorageInfo {

195

1

				pallet_name: b"Balances".to_vec(),

196

1

				storage_name: b"Reserves".to_vec(),

197

1

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

198

1

				max_values: None,

199

1

				max_size: Some(1037),

200

1

},

201

1

			StorageInfo {

202

1

				pallet_name: b"Balances".to_vec(),

203

1

				storage_name: b"Holds".to_vec(),

204

1

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

205

1

				max_values: None,

206

1

				max_size: Some(91),

207

1

},

208

1

			StorageInfo {

209

1

				pallet_name: b"Balances".to_vec(),

210

1

				storage_name: b"Freezes".to_vec(),

211

1

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

212

1

				max_values: None,

213

1

				max_size: Some(37),

214

1

},

215

1

216

1

);

217

1

	assert_eq!(

218

1

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

219

1

		vec![StorageInfo {

220

1

			pallet_name: b"Sudo".to_vec(),

221

1

			storage_name: b"Key".to_vec(),

222

1

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

223

1

			max_values: Some(1),

224

1

			max_size: Some(20),

225

1

}]

226

1

);

227

1

	assert_eq!(

228

1

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

229

1

		vec![

230

1

			StorageInfo {

231

1

				pallet_name: b"Proxy".to_vec(),

232

1

				storage_name: b"Proxies".to_vec(),

233

1

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

234

1

				max_values: None,

235

1

				max_size: Some(845),

236

1

},

237

1

			StorageInfo {

238

1

				pallet_name: b"Proxy".to_vec(),

239

1

				storage_name: b"Announcements".to_vec(),

240

1

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

241

1

				max_values: None,

242

1

				max_size: Some(1837),

243

1

244

1

245

1

);

246

1

	assert_eq!(

247

1

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

248

1

		vec![StorageInfo {

249

1

			pallet_name: b"MaintenanceMode".to_vec(),

250

1

			storage_name: b"MaintenanceMode".to_vec(),

251

1

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

252

1

			max_values: Some(1),

253

1

			max_size: None,

254

1

},]

255

1

);

256

257

1

	assert_eq!(

258

1

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

259

1

		vec![

260

1

			StorageInfo {

261

1

				pallet_name: b"RelayStorageRoots".to_vec(),

262

1

				storage_name: b"RelayStorageRoot".to_vec(),

263

1

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

264

1

				max_values: None,

265

1

				max_size: Some(44),

266

1

},

267

1

			StorageInfo {

268

1

				pallet_name: b"RelayStorageRoots".to_vec(),

269

1

				storage_name: b"RelayStorageRootKeys".to_vec(),

270

1

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

271

1

				max_values: Some(1),

272

1

				max_size: Some(121),

273

1

},

274

1

275

1

);

276

1

277

278

#[test]

279

1

fn test_collectives_storage_item_prefixes() {

280

7

	for StorageInfo { pallet_name, .. } in

281

8

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

282

283

7

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

284

285

286

7

	for StorageInfo { pallet_name, .. } in

287

8

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

288

289

7

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

290

291

1

292

293

#[test]

294

1

fn collective_set_members_root_origin_works() {

295

1

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

296

1

		// TreasuryCouncilCollective

297

1

		assert_ok!(TreasuryCouncilCollective::set_members(

298

1

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

299

1

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

300

1

			Some(AccountId::from(ALICE)),

301

1

302

1

));

303

		// OpenTechCommitteeCollective

304

1

		assert_ok!(OpenTechCommitteeCollective::set_members(

305

1

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

306

1

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

307

1

			Some(AccountId::from(ALICE)),

308

1

309

1

));

310

1

});

311

1

312

313

#[test]

314

1

fn collective_set_members_general_admin_origin_works() {

315

	use moonbase_runtime::{

316

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

317

};

318

319

1

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

320

1

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

321

1

		let alice = AccountId::from(ALICE);

322

1

323

1

		// TreasuryCouncilCollective

324

1

		let _ = Utility::dispatch_as(

325

1

			root_caller.clone(),

326

1

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

327

1

			Box::new(

328

1

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

329

1

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

330

1

					prime: Some(alice),

331

1

					old_count: 2,

332

1

333

1

				.into(),

334

1

),

335

1

);

336

1

		// OpenTechCommitteeCollective

337

1

		let _ = Utility::dispatch_as(

338

1

			root_caller,

339

1

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

340

1

			Box::new(

341

1

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

342

1

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

343

1

					prime: Some(alice),

344

1

					old_count: 2,

345

1

346

1

				.into(),

347

1

),

348

1

);

349

1

350

1

		assert_eq!(

351

1

			System::events()

352

1

				.into_iter()

353

2

				.filter_map(|r| {

354

2

					match r.event {

355

2

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

356

2

							if result.is_ok() =>

357

2

358

2

							Some(true)

359

360

						_ => None,

361

362

2

})

363

1

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

364

1

				.len(),

365

1

366

1

367

1

});

368

1

369

370

#[test]

371

1

fn collective_set_members_signed_origin_does_not_work() {

372

1

	let alice = AccountId::from(ALICE);

373

1

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

374

1

		// TreasuryCouncilCollective

375

1

		assert!(TreasuryCouncilCollective::set_members(

376

1

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

377

1

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

378

1

			Some(AccountId::from(ALICE)),

379

1

380

1

381

1

		.is_err());

382

		// OpenTechCommitteeCollective

383

1

		assert!(OpenTechCommitteeCollective::set_members(

384

1

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

385

1

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

386

1

			Some(AccountId::from(ALICE)),

387

1

388

1

389

1

		.is_err());

390

1

});

391

1

392

393

#[test]

394

1

fn verify_pallet_indices() {

395

34

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

396

34

		assert_eq!(

397

34

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

398

34

			Some(index)

399

34

);

400

34

401

1

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

402

1

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

403

1

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

404

1

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

405

1

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

406

1

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

407

1

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

408

1

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

409

1

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

410

1

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

411

1

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

412

1

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

413

1

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

414

1

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

415

1

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

416

1

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

417

1

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

418

1

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

419

1

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

420

1

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

421

1

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

422

1

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

423

1

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

424

1

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

425

1

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

426

1

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

427

1

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

428

1

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

429

1

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

430

1

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

431

1

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

432

1

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

433

1

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

434

1

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

435

1

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

436

1

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

437

1

438

439

#[test]

440

1

fn verify_reserved_indices() {

441

	use frame_metadata::*;

442

443

1

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

444

1

		.build_storage()

445

1

		.unwrap()

446

1

		.into();

447

1

448

1

	t.execute_with(|| {

449

1

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

450

1

		let metadata = match metadata.1 {

451

1

			RuntimeMetadata::V14(metadata) => metadata,

452

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

453

};

454

		// 35: BaseFee

455

		// 36: pallet_assets::<Instance1>

456

1

		let reserved = vec![35, 36];

457

1

		let existing = metadata

458

1

			.pallets

459

1

			.iter()

460

50

			.map(|p| p.index)

461

1

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

462

2

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

463

1

});

464

1

465

466

#[test]

467

1

fn verify_proxy_type_indices() {

468

1

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

469

1

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

470

1

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

471

1

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

472

1

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

473

1

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

474

1

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

475

1

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

476

1

477

478

#[test]

479

1

fn join_collator_candidates() {

480

1

	ExtBuilder::default()

481

1

		.with_balances(vec![

482

1

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

483

1

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

484

1

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

485

1

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

486

1

])

487

1

		.with_collators(vec![

488

1

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

489

1

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

490

1

])

491

1

		.with_delegations(vec![

492

1

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

493

1

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

494

1

])

495

1

		.build()

496

1

		.execute_with(|| {

497

1

			assert_noop!(

498

1

				ParachainStaking::join_candidates(

499

1

					origin_of(AccountId::from(ALICE)),

500

1

					1_000 * UNIT,

501

1

					2u32

502

1

),

503

1

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

504

1

);

505

1

			assert_noop!(

506

1

				ParachainStaking::join_candidates(

507

1

					origin_of(AccountId::from(CHARLIE)),

508

1

					1_000 * UNIT,

509

1

					2u32

510

1

),

511

1

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

512

1

);

513

1

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

514

1

			assert_ok!(ParachainStaking::join_candidates(

515

1

				origin_of(AccountId::from(DAVE)),

516

1

				1_000 * UNIT,

517

1

				2u32

518

1

));

519

1

			assert_eq!(

520

1

				last_event(),

521

1

				RuntimeEvent::ParachainStaking(

522

1

					pallet_parachain_staking::Event::JoinedCollatorCandidates {

523

1

						account: AccountId::from(DAVE),

524

1

						amount_locked: 1_000 * UNIT,

525

1

						new_total_amt_locked: 3_100 * UNIT

526

1

527

1

528

1

);

529

1

			let candidates = ParachainStaking::candidate_pool();

530

1

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

531

1

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

532

1

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

533

1

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

534

1

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

535

1

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

536

1

});

537

1

538

539

#[test]

540

1

fn transfer_through_evm_to_stake() {

541

1

	ExtBuilder::default()

542

1

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

543

1

		.build()

544

1

		.execute_with(|| {

545

1

			// Charlie has no balance => fails to stake

546

1

			assert_noop!(

547

1

				ParachainStaking::join_candidates(

548

1

					origin_of(AccountId::from(CHARLIE)),

549

1

					1_000 * UNIT,

550

1

					0u32

551

1

),

552

1

				DispatchError::Module(ModuleError {

553

1

					index: 12,

554

1

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

555

1

					message: Some("InsufficientBalance")

556

1

})

557

1

);

558

559

			// Alice transfer from free balance 2000 UNIT to Bob

560

1

			assert_ok!(Balances::transfer_allow_death(

561

1

				origin_of(AccountId::from(ALICE)),

562

1

				AccountId::from(BOB),

563

1

				2_000 * UNIT,

564

1

));

565

1

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

566

567

1

			let gas_limit = 100000u64;

568

1

			// Bob transfers 1000 UNIT to Charlie via EVM

569

1

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

570

1

				source: H160::from(BOB),

571

1

				target: H160::from(CHARLIE),

572

1

				input: Vec::new(),

573

1

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

574

1

				gas_limit,

575

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

576

1

				max_priority_fee_per_gas: None,

577

1

				nonce: None,

578

1

				access_list: Vec::new(),

579

1

})

580

1

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

581

1

			assert_eq!(

582

1

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

583

1

				1_000 * UNIT,

584

1

);

585

586

			// Charlie can stake now

587

1

			assert_ok!(ParachainStaking::join_candidates(

588

1

				origin_of(AccountId::from(CHARLIE)),

589

1

				1_000 * UNIT,

590

1

				0u32,

591

1

			),);

592

1

			let candidates = ParachainStaking::candidate_pool();

593

1

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

594

1

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

595

1

});

596

1

597

598

#[test]

599

1

fn reward_block_authors() {

600

1

	ExtBuilder::default()

601

1

		.with_balances(vec![

602

1

			// Alice gets 100 extra tokens for her mapping deposit

603

1

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

604

1

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

605

1

])

606

1

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

607

1

		.with_delegations(vec![(

608

1

			AccountId::from(BOB),

609

1

			AccountId::from(ALICE),

610

1

			500 * UNIT,

611

1

)])

612

1

		.with_mappings(vec![(

613

1

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

614

1

			AccountId::from(ALICE),

615

1

)])

616

1

		.build()

617

1

		.execute_with(|| {

618

1

			increase_last_relay_slot_number(1);

619

1

			// Just before round 3

620

1

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

621

1

			// no rewards doled out yet

622

1

			assert_eq!(

623

1

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

624

1

				1_100 * UNIT,

625

1

);

626

1

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

627

1

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

628

1

			// rewards minted and distributed

629

1

			assert_eq!(

630

1

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

631

1

				1213666666584000000000,

632

1

);

633

1

			assert_eq!(

634

1

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

635

1

				541333333292000000000,

636

1

);

637

1

});

638

1

639

640

#[test]

641

1

fn reward_block_authors_with_parachain_bond_reserved() {

642

1

	ExtBuilder::default()

643

1

		.with_balances(vec![

644

1

			// Alice gets 100 extra tokens for her mapping deposit

645

1

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

646

1

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

647

1

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

648

1

])

649

1

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

650

1

		.with_delegations(vec![(

651

1

			AccountId::from(BOB),

652

1

			AccountId::from(ALICE),

653

1

			500 * UNIT,

654

1

)])

655

1

		.with_mappings(vec![(

656

1

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

657

1

			AccountId::from(ALICE),

658

1

)])

659

1

		.build()

660

1

		.execute_with(|| {

661

1

			increase_last_relay_slot_number(1);

662

1

			assert_ok!(ParachainStaking::set_parachain_bond_account(

663

1

				root_origin(),

664

1

				AccountId::from(CHARLIE),

665

1

			),);

666

667

			// Stop just before round 2

668

1

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

669

1

670

1

			// no rewards doled out yet

671

1

			assert_eq!(

672

1

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

673

1

				1_100 * UNIT,

674

1

);

675

1

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

676

1

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

677

678

			// Go to round 2

679

1

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

680

1

681

1

			// 30% reserved for parachain bond

682

1

			assert_eq!(

683

1

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

684

1

				47515000000000000000,

685

1

);

686

687

			// Go to round 3

688

1

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

689

1

			// rewards minted and distributed

690

1

			assert_eq!(

691

1

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

692

1

				1182693333281650000000,

693

1

);

694

1

			assert_eq!(

695

1

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

696

1

				525841666640825000000,

697

1

);

698

			// 30% again reserved for parachain bond

699

1

			assert_eq!(

700

1

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

701

1

				94727725000000000000,

702

1

);

703

1

});

704

1

705

706

#[test]

707

1

fn initialize_crowdloan_addresses_with_batch_and_pay() {

708

1

	ExtBuilder::default()

709

1

		.with_balances(vec![

710

1

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

711

1

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

712

1

])

713

1

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

714

1

		.with_mappings(vec![(

715

1

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

716

1

			AccountId::from(ALICE),

717

1

)])

718

1

		.with_crowdloan_fund(3_000_000 * UNIT)

719

1

		.build()

720

1

		.execute_with(|| {

721

1

			// set parachain inherent data

722

1

			set_parachain_inherent_data();

723

1

			let init_block = CrowdloanRewards::init_vesting_block();

724

1

			// This matches the previous vesting

725

1

			let end_block = init_block + 4 * WEEKS;

726

1

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

727

1

			assert_ok!(

728

1

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

729

1

					calls: vec![

730

1

						RuntimeCall::CrowdloanRewards(

731

1

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

732

1

								rewards: vec![(

733

1

									[4u8; 32].into(),

734

1

									Some(AccountId::from(CHARLIE)),

735

1

									1_500_000 * UNIT

736

1

)]

737

1

738

1

),

739

1

						RuntimeCall::CrowdloanRewards(

740

1

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

741

1

								rewards: vec![(

742

1

									[5u8; 32].into(),

743

1

									Some(AccountId::from(DAVE)),

744

1

									1_500_000 * UNIT

745

1

)]

746

1

747

1

),

748

1

						RuntimeCall::CrowdloanRewards(

749

1

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

750

1

								lease_ending_block: end_block

751

1

752

1

753

1

754

1

})

755

1

				.dispatch(root_origin())

756

1

);

757

			// 30 percent initial payout

758

1

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

759

			// 30 percent initial payout

760

1

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

761

1

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

762

1

			assert_eq!(last_event(), expected);

763

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

764

1

			assert_ok!(

765

1

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

766

1

					calls: vec![RuntimeCall::CrowdloanRewards(

767

1

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

768

1

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

769

1

770

1

)]

771

1

})

772

1

				.dispatch(root_origin())

773

1

);

774

1

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

775

1

				index: 0,

776

1

				error: DispatchError::Module(ModuleError {

777

1

					index: 20,

778

1

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

779

1

					message: None,

780

1

}),

781

1

});

782

1

			assert_eq!(last_event(), expected_fail);

783

			// Claim 1 block.

784

1

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

785

1

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

786

787

1

			let vesting_period = 4 * WEEKS as u128;

788

1

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

789

1

790

1

			assert_eq!(

791

1

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

792

1

					.unwrap()

793

1

					.claimed_reward,

794

1

				(450_000 * UNIT) + per_block

795

1

);

796

1

			assert_eq!(

797

1

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

798

1

					.unwrap()

799

1

					.claimed_reward,

800

1

				(450_000 * UNIT) + per_block

801

1

);

802

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

803

1

			assert_eq!(

804

1

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

805

1

				(450_000 * UNIT) + per_block

806

1

);

807

1

			assert_eq!(

808

1

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

809

1

				(450_000 * UNIT) + per_block

810

1

);

811

1

			assert_noop!(

812

1

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

813

1

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

814

1

);

815

1

});

816

1

817

818

#[test]

819

1

fn initialize_crowdloan_address_and_change_with_relay_key_sig() {

820

1

	ExtBuilder::default()

821

1

		.with_balances(vec![

822

1

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

823

1

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

824

1

])

825

1

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

826

1

		.with_mappings(vec![(

827

1

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

828

1

			AccountId::from(ALICE),

829

1

)])

830

1

		.with_crowdloan_fund(3_000_000 * UNIT)

831

1

		.build()

832

1

		.execute_with(|| {

833

1

			// set parachain inherent data

834

1

			let init_block = CrowdloanRewards::init_vesting_block();

835

1

			// This matches the previous vesting

836

1

			let end_block = init_block + 4 * WEEKS;

837

1

838

1

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

839

1

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

840

1

841

1

			let public1 = pair1.public();

842

1

			let public2 = pair2.public();

843

1

844

1

			// signature:

845

1

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

846

1

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

847

1

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

848

1

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

849

1

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

850

1

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

851

1

852

1

			let signature1 = pair1.sign(&message);

853

1

			let signature2 = pair2.sign(&message);

854

1

855

1

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

856

1

			assert_ok!(

857

1

				// two relay accounts pointing at the same reward account

858

1

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

859

1

					calls: vec![

860

1

						RuntimeCall::CrowdloanRewards(

861

1

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

862

1

								rewards: vec![(

863

1

									public1.into(),

864

1

									Some(AccountId::from(CHARLIE)),

865

1

									1_500_000 * UNIT

866

1

)]

867

1

868

1

),

869

1

						RuntimeCall::CrowdloanRewards(

870

1

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

871

1

								rewards: vec![(

872

1

									public2.into(),

873

1

									Some(AccountId::from(CHARLIE)),

874

1

									1_500_000 * UNIT

875

1

)]

876

1

877

1

),

878

1

						RuntimeCall::CrowdloanRewards(

879

1

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

880

1

								lease_ending_block: end_block

881

1

882

1

883

1

884

1

})

885

1

				.dispatch(root_origin())

886

1

);

887

			// 30 percent initial payout

888

1

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

889

890

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

891

1

			assert_noop!(

892

1

				CrowdloanRewards::change_association_with_relay_keys(

893

1

					origin_of(AccountId::from(CHARLIE)),

894

1

					AccountId::from(DAVE),

895

1

					AccountId::from(CHARLIE),

896

1

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

897

1

),

898

1

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

899

1

);

900

901

			// this should be valid

902

1

			assert_ok!(CrowdloanRewards::change_association_with_relay_keys(

903

1

				origin_of(AccountId::from(CHARLIE)),

904

1

				AccountId::from(DAVE),

905

1

				AccountId::from(CHARLIE),

906

1

				vec![

907

1

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

908

1

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

909

1

910

1

));

911

912

1

			assert_eq!(

913

1

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

914

1

					.unwrap()

915

1

					.claimed_reward,

916

1

				(900_000 * UNIT)

917

1

);

918

1

});

919

1

920

921

#[test]

922

1

fn claim_via_precompile() {

923

1

	ExtBuilder::default()

924

1

		.with_balances(vec![

925

1

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

926

1

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

927

1

])

928

1

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

929

1

		.with_mappings(vec![(

930

1

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

931

1

			AccountId::from(ALICE),

932

1

)])

933

1

		.with_crowdloan_fund(3_000_000 * UNIT)

934

1

		.build()

935

1

		.execute_with(|| {

936

1

			// set parachain inherent data

937

1

			set_parachain_inherent_data();

938

1

			let init_block = CrowdloanRewards::init_vesting_block();

939

1

			// This matches the previous vesting

940

1

			let end_block = init_block + 4 * WEEKS;

941

1

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

942

1

			assert_ok!(

943

1

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

944

1

					calls: vec![

945

1

						RuntimeCall::CrowdloanRewards(

946

1

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

947

1

								rewards: vec![(

948

1

									[4u8; 32].into(),

949

1

									Some(AccountId::from(CHARLIE)),

950

1

									1_500_000 * UNIT

951

1

)]

952

1

953

1

),

954

1

						RuntimeCall::CrowdloanRewards(

955

1

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

956

1

								rewards: vec![(

957

1

									[5u8; 32].into(),

958

1

									Some(AccountId::from(DAVE)),

959

1

									1_500_000 * UNIT

960

1

)]

961

1

962

1

),

963

1

						RuntimeCall::CrowdloanRewards(

964

1

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

965

1

								lease_ending_block: end_block

966

1

967

1

968

1

969

1

})

970

1

				.dispatch(root_origin())

971

1

);

972

973

			// 30 percent initial payout

974

1

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

975

			// 30 percent initial payout

976

1

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

977

978

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

979

1

980

1

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

981

1

			let gas_limit = 100000u64;

982

1

			let gas_price: U256 = BASE_FEE_GENISIS.into();

983

1

984

1

			// Construct the call data (selector, amount)

985

1

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

986

1

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

987

1

988

1

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

989

1

				source: H160::from(CHARLIE),

990

1

				target: crowdloan_precompile_address,

991

1

				input: call_data,

992

1

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

993

1

				gas_limit,

994

1

				max_fee_per_gas: gas_price,

995

1

				max_priority_fee_per_gas: None,

996

1

				nonce: None, // Use the next nonce

997

1

				access_list: Vec::new(),

998

1

})

999

1

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

1000

1001

1

			let vesting_period = 4 * WEEKS as u128;

1002

1

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

1003

1

1004

1

			assert_eq!(

1005

1

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

1006

1

					.unwrap()

1007

1

					.claimed_reward,

1008

1

				(450_000 * UNIT) + per_block

1009

1

);

1010

1

})

1011

1

1012

1013

#[test]

1014

1

fn is_contributor_via_precompile() {

1015

1

	ExtBuilder::default()

1016

1

		.with_balances(vec![

1017

1

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

1018

1

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

1019

1

])

1020

1

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

1021

1

		.with_mappings(vec![(

1022

1

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

1023

1

			AccountId::from(ALICE),

1024

1

)])

1025

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1026

1

		.build()

1027

1

		.execute_with(|| {

1028

1

			// set parachain inherent data

1029

1

			let init_block = CrowdloanRewards::init_vesting_block();

1030

1

			// This matches the previous vesting

1031

1

			let end_block = init_block + 4 * WEEKS;

1032

1

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

1033

1

			assert_ok!(

1034

1

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

1035

1

					calls: vec![

1036

1

						RuntimeCall::CrowdloanRewards(

1037

1

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

1038

1

								rewards: vec![(

1039

1

									[4u8; 32].into(),

1040

1

									Some(AccountId::from(CHARLIE)),

1041

1

									1_500_000 * UNIT

1042

1

)]

1043

1

1044

1

),

1045

1

						RuntimeCall::CrowdloanRewards(

1046

1

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

1047

1

								rewards: vec![(

1048

1

									[5u8; 32].into(),

1049

1

									Some(AccountId::from(DAVE)),

1050

1

									1_500_000 * UNIT

1051

1

)]

1052

1

1053

1

),

1054

1

						RuntimeCall::CrowdloanRewards(

1055

1

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

1056

1

								lease_ending_block: end_block

1057

1

1058

1

1059

1

1060

1

})

1061

1

				.dispatch(root_origin())

1062

1

);

1063

1064

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1065

1

1066

1

			// Assert precompile reports Bob is not a contributor

1067

1

			Precompiles::new()

1068

1

				.prepare_test(

1069

1

					ALICE,

1070

1

					crowdloan_precompile_address,

1071

1

					CrowdloanRewardsPCall::is_contributor {

1072

1

						contributor: Address(BOB.into()),

1073

1

},

1074

1

1075

1

				.expect_cost(3338)

1076

1

				.expect_no_logs()

1077

1

				.execute_returns(false);

1078

1

1079

1

			// Assert precompile reports Charlie is a nominator

1080

1

			Precompiles::new()

1081

1

				.prepare_test(

1082

1

					ALICE,

1083

1

					crowdloan_precompile_address,

1084

1

					CrowdloanRewardsPCall::is_contributor {

1085

1

						contributor: Address(CHARLIE.into()),

1086

1

},

1087

1

1088

1

				.expect_cost(3338)

1089

1

				.expect_no_logs()

1090

1

				.execute_returns(true);

1091

1

})

1092

1

1093

1094

#[test]

1095

1

fn reward_info_via_precompile() {

1096

1

	ExtBuilder::default()

1097

1

		.with_balances(vec![

1098

1

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

1099

1

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

1100

1

])

1101

1

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

1102

1

		.with_mappings(vec![(

1103

1

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

1104

1

			AccountId::from(ALICE),

1105

1

)])

1106

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1107

1

		.build()

1108

1

		.execute_with(|| {

1109

1

			// set parachain inherent data

1110

1

			let init_block = CrowdloanRewards::init_vesting_block();

1111

1

			// This matches the previous vesting

1112

1

			let end_block = init_block + 4 * WEEKS;

1113

1

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

1114

1

			assert_ok!(

1115

1

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

1116

1

					calls: vec![

1117

1

						RuntimeCall::CrowdloanRewards(

1118

1

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

1119

1

								rewards: vec![(

1120

1

									[4u8; 32].into(),

1121

1

									Some(AccountId::from(CHARLIE)),

1122

1

									1_500_000 * UNIT

1123

1

)]

1124

1

1125

1

),

1126

1

						RuntimeCall::CrowdloanRewards(

1127

1

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

1128

1

								rewards: vec![(

1129

1

									[5u8; 32].into(),

1130

1

									Some(AccountId::from(DAVE)),

1131

1

									1_500_000 * UNIT

1132

1

)]

1133

1

1134

1

),

1135

1

						RuntimeCall::CrowdloanRewards(

1136

1

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

1137

1

								lease_ending_block: end_block

1138

1

1139

1

1140

1

1141

1

})

1142

1

				.dispatch(root_origin())

1143

1

);

1144

1145

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1146

1

1147

1

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

1148

1

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

1149

1

1150

1

			// Assert precompile reports correct Charlie reward info.

1151

1

			Precompiles::new()

1152

1

				.prepare_test(

1153

1

					ALICE,

1154

1

					crowdloan_precompile_address,

1155

1

					CrowdloanRewardsPCall::reward_info {

1156

1

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

1157

1

},

1158

1

1159

1

				.expect_cost(3338)

1160

1

				.expect_no_logs()

1161

1

				.execute_returns((expected_total, expected_claimed));

1162

1

})

1163

1

1164

1165

#[test]

1166

1

fn update_reward_address_via_precompile() {

1167

1

	ExtBuilder::default()

1168

1

		.with_balances(vec![

1169

1

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

1170

1

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

1171

1

])

1172

1

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

1173

1

		.with_mappings(vec![(

1174

1

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

1175

1

			AccountId::from(ALICE),

1176

1

)])

1177

1

		.with_crowdloan_fund(3_000_000 * UNIT)

1178

1

		.build()

1179

1

		.execute_with(|| {

1180

1

			// set parachain inherent data

1181

1

			let init_block = CrowdloanRewards::init_vesting_block();

1182

1

			// This matches the previous vesting

1183

1

			let end_block = init_block + 4 * WEEKS;

1184

1

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

1185

1

			assert_ok!(

1186

1

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

1187

1

					calls: vec![

1188

1

						RuntimeCall::CrowdloanRewards(

1189

1

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

1190

1

								rewards: vec![(

1191

1

									[4u8; 32].into(),

1192

1

									Some(AccountId::from(CHARLIE)),

1193

1

									1_500_000 * UNIT

1194

1

)]

1195

1

1196

1

),

1197

1

						RuntimeCall::CrowdloanRewards(

1198

1

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

1199

1

								rewards: vec![(

1200

1

									[5u8; 32].into(),

1201

1

									Some(AccountId::from(DAVE)),

1202

1

									1_500_000 * UNIT

1203

1

)]

1204

1

1205

1

),

1206

1

						RuntimeCall::CrowdloanRewards(

1207

1

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

1208

1

								lease_ending_block: end_block

1209

1

1210

1

1211

1

1212

1

})

1213

1

				.dispatch(root_origin())

1214

1

);

1215

1216

1

			let crowdloan_precompile_address = H160::from_low_u64_be(2049);

1217

1

1218

1

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

1219

1

			let gas_limit = 100000u64;

1220

1

			let gas_price: U256 = BASE_FEE_GENISIS.into();

1221

1

1222

1

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

1223

1

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

1224

1

			call_data[0..4]

1225

1

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

1226

1

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

1227

1

1228

1

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

1229

1

				source: H160::from(CHARLIE),

1230

1

				target: crowdloan_precompile_address,

1231

1

				input: call_data,

1232

1

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

1233

1

				gas_limit,

1234

1

				max_fee_per_gas: gas_price,

1235

1

				max_priority_fee_per_gas: None,

1236

1

				nonce: None, // Use the next nonce

1237

1

				access_list: Vec::new(),

1238

1

})

1239

1

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

1240

1241

1

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

1242

1

			assert_eq!(

1243

1

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

1244

1

					.unwrap()

1245

1

					.claimed_reward,

1246

1

				(450_000 * UNIT)

1247

1

);

1248

1

})

1249

1

1250

1251

#[test]

1252

1

fn create_and_manipulate_foreign_asset_using_root() {

1253

1

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

1254

1

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

1255

1

1256

1

		// Create foreign asset

1257

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1258

1

			moonbase_runtime::RuntimeOrigin::root(),

1259

1

1,

1260

1

			source_location.clone(),

1261

1

12,

1262

1

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

1263

1

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

1264

1

));

1265

1

		assert_eq!(

1266

1

			EvmForeignAssets::assets_by_id(1),

1267

1

			Some(source_location.clone())

1268

1

);

1269

1

		assert_eq!(

1270

1

			EvmForeignAssets::assets_by_location(&source_location),

1271

1

			Some((1, AssetStatus::Active))

1272

1

);

1273

1274

		// Freeze foreign asset

1275

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1276

1

			moonbase_runtime::RuntimeOrigin::root(),

1277

1

1,

1278

1

			true

1279

1

));

1280

1

		assert_eq!(

1281

1

			EvmForeignAssets::assets_by_location(&source_location),

1282

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1283

1

);

1284

1285

		// Unfreeze foreign asset

1286

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1287

1

			moonbase_runtime::RuntimeOrigin::root(),

1288

1

1,

1289

1

));

1290

1

		assert_eq!(

1291

1

			EvmForeignAssets::assets_by_location(&source_location),

1292

1

			Some((1, AssetStatus::Active))

1293

1

);

1294

1

});

1295

1

1296

1297

#[test]

1298

1

fn create_and_manipulate_foreign_asset_using_sibling() {

1299

1

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

1300

1

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

1301

1

		let para_location = asset_location.chain_location();

1302

1

		let para_account =

1303

1

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

1304

1

1305

1

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

1306

1

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

1307

1

1308

1

		// Create foreign asset

1309

1

		assert_ok!(EvmForeignAssets::create_foreign_asset(

1310

1

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

1311

1

1,

1312

1

			asset_location.clone(),

1313

1

12,

1314

1

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

1315

1

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

1316

1

));

1317

1318

		// deposit is taken from the account

1319

1

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

1320

1321

1

		assert_eq!(

1322

1

			EvmForeignAssets::assets_by_id(1),

1323

1

			Some(asset_location.clone())

1324

1

);

1325

1

		assert_eq!(

1326

1

			EvmForeignAssets::assets_by_location(&asset_location),

1327

1

			Some((1, AssetStatus::Active))

1328

1

);

1329

1330

		// Freeze foreign asset

1331

1

		assert_ok!(EvmForeignAssets::freeze_foreign_asset(

1332

1

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

1333

1

1,

1334

1

			true

1335

1

));

1336

1

		assert_eq!(

1337

1

			EvmForeignAssets::assets_by_location(&asset_location),

1338

1

			Some((1, AssetStatus::FrozenXcmDepositAllowed))

1339

1

);

1340

1341

		// Unfreeze foreign asset

1342

1

		assert_ok!(EvmForeignAssets::unfreeze_foreign_asset(

1343

1

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

1344

1

1,

1345

1

));

1346

1

		assert_eq!(

1347

1

			EvmForeignAssets::assets_by_location(&asset_location),

1348

1

			Some((1, AssetStatus::Active))

1349

1

);

1350

1

});

1351

1

1352

1353

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

1354

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

1355

/*

1356

#[test]

1357

fn xcm_asset_erc20_precompiles_supply_and_balance() {

1358

	ExtBuilder::default()

1359

		.with_xcm_assets(vec![XcmAssetInitialization {

1360

			asset_id: 1,

1361

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

1362

			name: "RelayToken",

1363

			symbol: "Relay",

1364

			decimals: 12,

1365

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

1366

}])

1367

		.with_balances(vec![

1368

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

1369

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

1370

])

1371

		.build()

1372

		.execute_with(|| {

1373

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

1374

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

1375

1376

			// Its address is

1377

			let asset_precompile_address = Runtime::asset_id_to_account(

1378

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1379

				relay_asset_id,

1380

);

1381

1382

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

1383

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

1384

1385

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

1386

			Precompiles::new()

1387

				.prepare_test(

1388

					ALICE,

1389

					asset_precompile_address,

1390

					ForeignAssetsPCall::total_supply {},

1391

1392

				.expect_cost(3338)

1393

				.expect_no_logs()

1394

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

1395

1396

			// Access balanceOf through precompile

1397

			Precompiles::new()

1398

				.prepare_test(

1399

					ALICE,

1400

					asset_precompile_address,

1401

					ForeignAssetsPCall::balance_of {

1402

						who: Address(ALICE.into()),

1403

},

1404

1405

				.expect_cost(3338)

1406

				.expect_no_logs()

1407

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

1408

});

1409

1410

1411

#[test]

1412

fn xcm_asset_erc20_precompiles_transfer() {

1413

	ExtBuilder::default()

1414

		.with_xcm_assets(vec![XcmAssetInitialization {

1415

			asset_id: 1,

1416

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

1417

			name: "RelayToken",

1418

			symbol: "Relay",

1419

			decimals: 12,

1420

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

1421

}])

1422

		.with_balances(vec![

1423

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

1424

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

1425

])

1426

		.build()

1427

		.execute_with(|| {

1428

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

1429

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

1430

1431

			// Its address is

1432

			let asset_precompile_address = Runtime::asset_id_to_account(

1433

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1434

				relay_asset_id,

1435

);

1436

1437

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

1438

			Precompiles::new()

1439

				.prepare_test(

1440

					ALICE,

1441

					asset_precompile_address,

1442

					ForeignAssetsPCall::transfer {

1443

						to: Address(BOB.into()),

1444

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

1445

},

1446

1447

				.expect_cost(24695)

1448

				.expect_log(log3(

1449

					asset_precompile_address,

1450

					SELECTOR_LOG_TRANSFER,

1451

					H160::from(ALICE),

1452

					H160::from(BOB),

1453

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

1454

))

1455

				.execute_returns(true);

1456

1457

			// Make sure BOB has 400 UNIT

1458

			Precompiles::new()

1459

				.prepare_test(

1460

					BOB,

1461

					asset_precompile_address,

1462

					ForeignAssetsPCall::balance_of {

1463

						who: Address(BOB.into()),

1464

},

1465

1466

				.expect_cost(3338)

1467

				.expect_no_logs()

1468

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

1469

});

1470

1471

1472

#[test]

1473

fn xcm_asset_erc20_precompiles_approve() {

1474

	ExtBuilder::default()

1475

		.with_xcm_assets(vec![XcmAssetInitialization {

1476

			asset_id: 1,

1477

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

1478

			name: "RelayToken",

1479

			symbol: "Relay",

1480

			decimals: 12,

1481

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

1482

}])

1483

		.with_balances(vec![

1484

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

1485

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

1486

])

1487

		.build()

1488

		.execute_with(|| {

1489

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

1490

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

1491

1492

			// Its address is

1493

			let asset_precompile_address = Runtime::asset_id_to_account(

1494

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1495

				relay_asset_id,

1496

);

1497

1498

			// Aprove Bob for spending 400 UNIT from Alice

1499

			Precompiles::new()

1500

				.prepare_test(

1501

					ALICE,

1502

					asset_precompile_address,

1503

					ForeignAssetsPCall::approve {

1504

						spender: Address(BOB.into()),

1505

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

1506

},

1507

1508

				.expect_cost(15604)

1509

				.expect_log(log3(

1510

					asset_precompile_address,

1511

					SELECTOR_LOG_APPROVAL,

1512

					H160::from(ALICE),

1513

					H160::from(BOB),

1514

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

1515

))

1516

				.execute_returns(true);

1517

1518

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

1519

			Precompiles::new()

1520

				.prepare_test(

1521

					BOB,

1522

					asset_precompile_address,

1523

					ForeignAssetsPCall::transfer_from {

1524

						from: Address(ALICE.into()),

1525

						to: Address(CHARLIE.into()),

1526

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

1527

},

1528

1529

				.expect_cost(29960)

1530

				.expect_log(log3(

1531

					asset_precompile_address,

1532

					SELECTOR_LOG_TRANSFER,

1533

					H160::from(ALICE),

1534

					H160::from(CHARLIE),

1535

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

1536

))

1537

				.execute_returns(true);

1538

1539

			// Make sure CHARLIE has 400 UNIT

1540

			Precompiles::new()

1541

				.prepare_test(

1542

					CHARLIE,

1543

					asset_precompile_address,

1544

					ForeignAssetsPCall::balance_of {

1545

						who: Address(CHARLIE.into()),

1546

},

1547

1548

				.expect_cost(3338)

1549

				.expect_no_logs()

1550

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

1551

});

1552

}*/

1553

1554

#[test]

1555

1

fn xtokens_precompiles_transfer() {

1556

1

	ExtBuilder::default()

1557

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1558

1

			asset_id: 1,

1559

1

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

1560

1

			name: "RelayToken",

1561

1

			symbol: "Relay",

1562

1

			decimals: 12,

1563

1

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

1564

1

}])

1565

1

		.with_balances(vec![

1566

1

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

1567

1

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

1568

1

])

1569

1

		.with_safe_xcm_version(3)

1570

1

		.build()

1571

1

		.execute_with(|| {

1572

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1573

1

1574

1

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

1575

1

			let relay_asset_id: AssetId = 1;

1576

1

1577

1

			// Its address is

1578

1

			let asset_precompile_address = Runtime::asset_id_to_account(

1579

1

				FOREIGN_ASSET_PRECOMPILE_ADDRESS_PREFIX,

1580

1

				relay_asset_id,

1581

1

);

1582

1

1583

1

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

1584

1

			let destination = Location::new(

1585

1

1,

1586

1

				[Junction::AccountId32 {

1587

1

					network: None,

1588

1

					id: [1u8; 32],

1589

1

}],

1590

1

);

1591

1

1592

1

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

1593

1

			let inside2 = inside.clone();

1594

1

1595

1

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

1596

1

			Precompiles::new()

1597

1

				.prepare_test(

1598

1

					ALICE,

1599

1

					xtokens_precompile_address,

1600

1

					XtokensPCall::transfer {

1601

1

						currency_address: Address(asset_precompile_address.into()),

1602

1

						amount: 500_000_000_000_000u128.into(),

1603

1

						destination,

1604

1

						weight: 4_000_000,

1605

1

},

1606

1

1607

1

				.expect_cost(178255)

1608

1

				.expect_no_logs()

1609

1

				// We expect an evm subcall ERC20.burnFrom

1610

1

				.with_subcall_handle(move |subcall| {

1611

1

					let Subcall {

1612

1

						address,

1613

1

						transfer,

1614

1

						input,

1615

1

						target_gas: _,

1616

1

						is_static,

1617

1

						context,

1618

1

					} = subcall;

1619

1

1620

1

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

1621

1

					assert_eq!(

1622

1

						address,

1623

1

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

1624

1

);

1625

1

					assert_eq!(is_static, false);

1626

1627

1

					assert!(transfer.is_none());

1628

1629

1

					assert_eq!(

1630

1

						context.address,

1631

1

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

1632

1

);

1633

1

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

1634

1635

1

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

1636

1

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

1637

1

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

1638

1639

1

					inside2.set(true);

1640

1

1641

1

					SubcallOutput {

1642

1

						output: Default::default(),

1643

1

						cost: 149_000,

1644

1

						logs: vec![],

1645

1

						..SubcallOutput::succeed()

1646

1

1647

1

})

1648

1

				.execute_returns(())

1649

1

})

1650

1

1651

1652

#[test]

1653

1

fn xtokens_precompiles_transfer_multiasset() {

1654

1

	ExtBuilder::default()

1655

1

		.with_xcm_assets(vec![XcmAssetInitialization {

1656

1

			asset_id: 1,

1657

1

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

1658

1

			name: "RelayToken",

1659

1

			symbol: "Relay",

1660

1

			decimals: 12,

1661

1

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

1662

1

}])

1663

1

		.with_balances(vec![

1664

1

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

1665

1

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

1666

1

])

1667

1

		.with_safe_xcm_version(3)

1668

1

		.build()

1669

1

		.execute_with(|| {

1670

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1671

1

1672

1

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

1673

1

			let destination = Location::new(

1674

1

1,

1675

1

				[Junction::AccountId32 {

1676

1

					network: None,

1677

1

					id: [1u8; 32],

1678

1

}],

1679

1

);

1680

1

1681

1

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

1682

1

			let inside2 = inside.clone();

1683

1

1684

1

			// This time we transfer it through TransferMultiAsset

1685

1

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

1686

1

			Precompiles::new()

1687

1

				.prepare_test(

1688

1

					ALICE,

1689

1

					xtokens_precompile_address,

1690

1

					XtokensPCall::transfer_multiasset {

1691

1

						// We want to transfer the relay token

1692

1

						asset: Location::parent(),

1693

1

						amount: 500_000_000_000_000u128.into(),

1694

1

						destination,

1695

1

						weight: 4_000_000,

1696

1

},

1697

1

1698

1

				.expect_cost(178255)

1699

1

				.expect_no_logs()

1700

1

				// We expect an evm subcall ERC20.burnFrom

1701

1

				.with_subcall_handle(move |subcall| {

1702

1

					let Subcall {

1703

1

						address,

1704

1

						transfer,

1705

1

						input,

1706

1

						target_gas: _,

1707

1

						is_static,

1708

1

						context,

1709

1

					} = subcall;

1710

1

1711

1

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

1712

1

					assert_eq!(

1713

1

						address,

1714

1

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

1715

1

);

1716

1

					assert_eq!(is_static, false);

1717

1718

1

					assert!(transfer.is_none());

1719

1720

1

					assert_eq!(

1721

1

						context.address,

1722

1

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

1723

1

);

1724

1

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

1725

1726

1

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

1727

1

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

1728

1

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

1729

1730

1

					inside2.set(true);

1731

1

1732

1

					SubcallOutput {

1733

1

						output: Default::default(),

1734

1

						cost: 149_000,

1735

1

						logs: vec![],

1736

1

						..SubcallOutput::succeed()

1737

1

1738

1

})

1739

1

				.execute_returns(());

1740

1

1741

1

			// Ensure that the subcall was actually called.

1742

1

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

1743

1

})

1744

1

1745

1746

#[test]

1747

1

fn xtokens_precompiles_transfer_native() {

1748

1

	ExtBuilder::default()

1749

1

		.with_balances(vec![

1750

1

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

1751

1

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

1752

1

])

1753

1

		.with_safe_xcm_version(3)

1754

1

		.build()

1755

1

		.execute_with(|| {

1756

1

			let xtokens_precompile_address = H160::from_low_u64_be(2052);

1757

1

1758

1

			// Its address is

1759

1

			let asset_precompile_address = H160::from_low_u64_be(2050);

1760

1

1761

1

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

1762

1

			let destination = Location::new(

1763

1

1,

1764

1

				[Junction::AccountId32 {

1765

1

					network: None,

1766

1

					id: [1u8; 32],

1767

1

}],

1768

1

);

1769

1

1770

1

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

1771

1

			Precompiles::new()

1772

1

				.prepare_test(

1773

1

					ALICE,

1774

1

					xtokens_precompile_address,

1775

1

					XtokensPCall::transfer {

1776

1

						currency_address: Address(asset_precompile_address),

1777

1

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

1778

1

						destination,

1779

1

						weight: 4_000_000,

1780

1

},

1781

1

1782

1

				.expect_cost(26655)

1783

1

				.expect_no_logs()

1784

1

				.execute_returns(());

1785

1

})

1786

1

1787

1788

1

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

1789

1

where

1790

1

	F: FnMut() -> (),

1791

1

1792

1

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

1793

1

		.build_storage()

1794

1

		.unwrap()

1795

1

		.into();

1796

1

	t.execute_with(|| {

1797

1

		System::set_block_consumed_resources(w, 0);

1798

1

		assertions()

1799

1

});

1800

1

1801

1802

#[test]

1803

#[rustfmt::skip]

1804

1

fn length_fee_is_sensible() {

1805

	use sp_runtime::testing::TestXt;

1806

1807

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

1808

1

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

1809

1

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

1810

1

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

1811

1

1812

9

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

1813

9

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

1814

9

				.inclusion_fee

1815

9

				.expect("fee should be calculated")

1816

9

				.len_fee

1817

9

};

1818

1819

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

1820

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

1821

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

1822

		//                             |           |

1823

1

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

1824

1

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

1825

1

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

1826

1

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

1827

1

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

1828

1

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

1829

1

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

1830

1

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

1831

1

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

1832

1

});

1833

1

1834

1835

#[test]

1836

1

fn multiplier_can_grow_from_zero() {

1837

	use frame_support::traits::Get;

1838

1839

1

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

1840

1

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

1841

1

		* RuntimeBlockWeights::get()

1842

1

			.get(DispatchClass::Normal)

1843

1

			.max_total

1844

1

			.unwrap();

1845

1

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

1846

1

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

1847

1

	run_with_system_weight(target * 101 / 100, || {

1848

1

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

1849

1

		assert!(

1850

1

			next > minimum_multiplier,

1851

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

1852

			next,

1853

			minimum_multiplier

1854

);

1855

1

})

1856

1

1857

1858

#[test]

1859

1

fn ethereum_invalid_transaction() {

1860

1

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

1861

1

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

1862

1

		// on chain is rejected.

1863

1

		assert_eq!(

1864

1

			Executive::apply_extrinsic(unchecked_eth_tx(INVALID_ETH_TX)),

1865

1

			Err(

1866

1

				sp_runtime::transaction_validity::TransactionValidityError::Invalid(

1867

1

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

1868

1

1869

1

1870

1

);

1871

1

});

1872

1

1873

1874

#[test]

1875

1

fn transfer_ed_0_substrate() {

1876

1

	ExtBuilder::default()

1877

1

		.with_balances(vec![

1878

1

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

1879

1

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

1880

1

])

1881

1

		.build()

1882

1

		.execute_with(|| {

1883

1

			// Substrate transfer

1884

1

			assert_ok!(Balances::transfer_allow_death(

1885

1

				origin_of(AccountId::from(ALICE)),

1886

1

				AccountId::from(BOB),

1887

1

				1 * UNIT,

1888

1

));

1889

			// 1 WEI is left in the account

1890

1

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

1891

1

});

1892

1

1893

1894

#[test]

1895

1

fn initial_gas_fee_is_correct() {

1896

	use fp_evm::FeeCalculator;

1897

1898

1

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

1899

1

		let multiplier = TransactionPayment::next_fee_multiplier();

1900

1

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

1901

1902

1

		assert_eq!(

1903

1

			TransactionPaymentAsGasPrice::min_gas_price(),

1904

1

1905

1

				2_500_000_000u128.into(),

1906

1

				Weight::from_parts(41_742_000u64, 0)

1907

1

1908

1

);

1909

1

});

1910

1

1911

1912

#[test]

1913

1

fn transfer_ed_0_evm() {

1914

1

	ExtBuilder::default()

1915

1

		.with_balances(vec![

1916

1

1917

1

				AccountId::from(ALICE),

1918

1

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

1919

1

),

1920

1

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

1921

1

])

1922

1

		.build()

1923

1

		.execute_with(|| {

1924

1

			set_parachain_inherent_data();

1925

1

			// EVM transfer

1926

1

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

1927

1

				source: H160::from(ALICE),

1928

1

				target: H160::from(BOB),

1929

1

				input: Vec::new(),

1930

1

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

1931

1

				gas_limit: 21_000u64,

1932

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1933

1

				max_priority_fee_per_gas: None,

1934

1

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

1935

1

				access_list: Vec::new(),

1936

1

})

1937

1

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

1938

			// 1 WEI is left in the account

1939

1

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

1940

1

});

1941

1

1942

1943

#[test]

1944

1

fn refund_ed_0_evm() {

1945

1

	ExtBuilder::default()

1946

1

		.with_balances(vec![

1947

1

1948

1

				AccountId::from(ALICE),

1949

1

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

1950

1

),

1951

1

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

1952

1

])

1953

1

		.build()

1954

1

		.execute_with(|| {

1955

1

			// EVM transfer that zeroes ALICE

1956

1

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

1957

1

				source: H160::from(ALICE),

1958

1

				target: H160::from(BOB),

1959

1

				input: Vec::new(),

1960

1

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

1961

1

				gas_limit: 21_777u64,

1962

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

1963

1

				max_priority_fee_per_gas: None,

1964

1

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

1965

1

				access_list: Vec::new(),

1966

1

})

1967

1

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

1968

			// ALICE is refunded

1969

1

			assert_eq!(

1970

1

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

1971

1

				777 * BASE_FEE_GENISIS + existential_deposit(),

1972

1

);

1973

1

});

1974

1

1975

1976

#[test]

1977

1

fn author_does_receive_priority_fee() {

1978

1

	ExtBuilder::default()

1979

1

		.with_balances(vec![(

1980

1

			AccountId::from(BOB),

1981

1

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

1982

1

)])

1983

1

		.build()

1984

1

		.execute_with(|| {

1985

1

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

1986

1

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

1987

1

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

1988

1

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

1989

1

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

1990

1

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

1991

1

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

1992

1

1993

1

			// EVM transfer.

1994

1

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

1995

1

				source: H160::from(BOB),

1996

1

				target: H160::from(ALICE),

1997

1

				input: Vec::new(),

1998

1

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

1999

1

				gas_limit: 21_000u64,

2000

1

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

2001

1

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

2002

1

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

2003

1

				access_list: Vec::new(),

2004

1

})

2005

1

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

2006

2007

1

			let priority_fee = 200 * GIGAWEI * 21_000;

2008

1

			// Author free balance increased by priority fee.

2009

1

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

2010

1

});

2011

1

2012

2013

#[test]

2014

1

fn total_issuance_after_evm_transaction_with_priority_fee() {

2015

1

	ExtBuilder::default()

2016

1

		.with_balances(vec![

2017

1

2018

1

				AccountId::from(BOB),

2019

1

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

2020

1

),

2021

1

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

2022

1

2023

1

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

2024

1

				existential_deposit(),

2025

1

),

2026

1

])

2027

1

		.build()

2028

1

		.execute_with(|| {

2029

1

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

2030

1

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

2031

1

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

2032

1

			// EVM transfer.

2033

1

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

2034

1

				source: H160::from(BOB),

2035

1

				target: H160::from(ALICE),

2036

1

				input: Vec::new(),

2037

1

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

2038

1

				gas_limit: 21_000u64,

2039

1

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

2040

1

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

2041

1

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

2042

1

				access_list: Vec::new(),

2043

1

})

2044

1

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

2045

2046

1

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

2047

1

2048

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

2049

1

2050

1

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

2051

1

2052

1

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

2053

1

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

2054

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

2055

1

2056

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

2057

2058

1

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

2059

1

});

2060

1

2061

2062

#[test]

2063

1

fn total_issuance_after_evm_transaction_without_priority_fee() {

2064

	use fp_evm::FeeCalculator;

2065

1

	ExtBuilder::default()

2066

1

		.with_balances(vec![

2067

1

2068

1

				AccountId::from(BOB),

2069

1

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

2070

1

),

2071

1

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

2072

1

2073

1

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

2074

1

				existential_deposit(),

2075

1

),

2076

1

])

2077

1

		.build()

2078

1

		.execute_with(|| {

2079

1

			set_parachain_inherent_data();

2080

1

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

2081

1

			// EVM transfer.

2082

1

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

2083

1

				source: H160::from(BOB),

2084

1

				target: H160::from(ALICE),

2085

1

				input: Vec::new(),

2086

1

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

2087

1

				gas_limit: 21_000u64,

2088

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2089

1

				max_priority_fee_per_gas: None,

2090

1

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

2091

1

				access_list: Vec::new(),

2092

1

})

2093

1

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

2094

2095

1

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

2096

1

			// Fee is 1 GWEI base fee.

2097

1

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

2098

1

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

2099

2100

1

			let base_fee: Balance = BASE_FEE_GENISIS * 21_000;

2101

1

2102

1

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

2103

1

2104

1

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

2105

1

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

2106

1

			let burnt_base_fee_part: Balance = base_fee - treasury_base_fee_part;

2107

1

2108

1

			assert_eq!(issuance_after, issuance_before - burnt_base_fee_part);

2109

2110

1

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

2111

1

});

2112

1

2113

2114

#[test]

2115

1

fn root_can_change_default_xcm_vers() {

2116

1

	ExtBuilder::default()

2117

1

		.with_balances(vec![

2118

1

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

2119

1

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

2120

1

])

2121

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2122

1

			asset_id: 1,

2123

1

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

2124

1

			name: "RelayToken",

2125

1

			symbol: "Relay",

2126

1

			decimals: 12,

2127

1

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

2128

1

}])

2129

1

		.build()

2130

1

		.execute_with(|| {

2131

1

			let source_id: moonbase_runtime::AssetId = 1;

2132

1

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

2133

1

			let asset = Asset {

2134

1

				id: AssetId(

2135

1

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

2136

1

						currency_id,

2137

1

2138

1

					.unwrap(),

2139

1

),

2140

1

				fun: Fungibility::Fungible(100_000_000_000_000),

2141

1

};

2142

1

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

2143

1

			// know with which version to send

2144

1

			assert_noop!(

2145

1

				PolkadotXcm::transfer_assets(

2146

1

					origin_of(AccountId::from(ALICE)),

2147

1

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

2148

1

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

2149

1

						parents: 0,

2150

1

						interior: [AccountId32 {

2151

1

							network: None,

2152

1

							id: [1u8; 32],

2153

1

}]

2154

1

						.into(),

2155

1

					})),

2156

1

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

2157

1

0,

2158

1

					WeightLimit::Unlimited

2159

1

),

2160

1

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

2161

1

);

2162

2163

			// Root sets the defaultXcm

2164

1

			assert_ok!(PolkadotXcm::force_default_xcm_version(

2165

1

				root_origin(),

2166

1

				Some(5)

2167

1

));

2168

2169

			// Now transferring does not fail

2170

1

			assert_ok!(PolkadotXcm::transfer_assets(

2171

1

				origin_of(AccountId::from(ALICE)),

2172

1

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

2173

1

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

2174

1

					parents: 0,

2175

1

					interior: [AccountId32 {

2176

1

						network: None,

2177

1

						id: [1u8; 32],

2178

1

}]

2179

1

					.into(),

2180

1

				})),

2181

1

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

2182

1

0,

2183

1

				WeightLimit::Unlimited

2184

1

));

2185

1

})

2186

1

2187

2188

#[test]

2189

1

fn transactor_cannot_use_more_than_max_weight() {

2190

1

	ExtBuilder::default()

2191

1

		.with_balances(vec![

2192

1

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

2193

1

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

2194

1

])

2195

1

		.with_xcm_assets(vec![XcmAssetInitialization {

2196

1

			asset_id: 1,

2197

1

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

2198

1

			name: "RelayToken",

2199

1

			symbol: "Relay",

2200

1

			decimals: 12,

2201

1

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

2202

1

}])

2203

1

		.build()

2204

1

		.execute_with(|| {

2205

1

			let source_id: moonbase_runtime::AssetId = 1;

2206

1

			assert_ok!(XcmTransactor::register(

2207

1

				root_origin(),

2208

1

				AccountId::from(ALICE),

2209

1

0,

2210

1

));

2211

2212

			// Root can set transact info

2213

1

			assert_ok!(XcmTransactor::set_transact_info(

2214

1

				root_origin(),

2215

1

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

2216

1

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

2217

1

				3000.into(),

2218

1

				20000.into(),

2219

1

				None

2220

1

));

2221

			// Root can set transact info

2222

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2223

1

				root_origin(),

2224

1

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

2225

1

1,

2226

1

));

2227

2228

1

			assert_noop!(

2229

1

				XcmTransactor::transact_through_derivative(

2230

1

					origin_of(AccountId::from(ALICE)),

2231

1

					moonbase_runtime::xcm_config::Transactors::Relay,

2232

1

0,

2233

1

					CurrencyPayment {

2234

1

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

2235

1

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

2236

1

)),

2237

1

						fee_amount: None

2238

1

},

2239

1

					vec![],

2240

1

					// 20000 is the max

2241

1

					TransactWeights {

2242

1

						transact_required_weight_at_most: 17001.into(),

2243

1

						overall_weight: None

2244

1

},

2245

1

					false

2246

1

),

2247

1

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

2248

1

);

2249

1

			assert_noop!(

2250

1

				XcmTransactor::transact_through_derivative(

2251

1

					origin_of(AccountId::from(ALICE)),

2252

1

					moonbase_runtime::xcm_config::Transactors::Relay,

2253

1

0,

2254

1

					CurrencyPayment {

2255

1

						currency: Currency::AsCurrencyId(

2256

1

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

2257

1

),

2258

1

						fee_amount: None

2259

1

},

2260

1

					vec![],

2261

1

					// 20000 is the max

2262

1

					TransactWeights {

2263

1

						transact_required_weight_at_most: 17001.into(),

2264

1

						overall_weight: None

2265

1

},

2266

1

					false

2267

1

),

2268

1

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

2269

1

);

2270

1

})

2271

1

2272

2273

#[test]

2274

1

fn root_can_use_hrmp_manage() {

2275

1

	ExtBuilder::default()

2276

1

		.with_balances(vec![

2277

1

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

2278

1

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

2279

1

])

2280

1

		.build()

2281

1

		.execute_with(|| {

2282

1

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

2283

1

			// But all rest checks pass

2284

1

			assert_noop!(

2285

1

				XcmTransactor::hrmp_manage(

2286

1

					root_origin(),

2287

1

					HrmpOperation::Accept {

2288

1

						para_id: 2000u32.into()

2289

1

},

2290

1

					CurrencyPayment {

2291

1

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

2292

1

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

2293

1

)),

2294

1

						fee_amount: Some(10000)

2295

1

},

2296

1

					// 20000 is the max

2297

1

					TransactWeights {

2298

1

						transact_required_weight_at_most: 17001.into(),

2299

1

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

2300

1

2301

1

),

2302

1

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

2303

1

);

2304

1

})

2305

1

2306

2307

#[test]

2308

1

fn transact_through_signed_precompile_works_v1() {

2309

1

	ExtBuilder::default()

2310

1

		.with_balances(vec![

2311

1

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

2312

1

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

2313

1

])

2314

1

		.with_safe_xcm_version(3)

2315

1

		.build()

2316

1

		.execute_with(|| {

2317

1

			// Destination

2318

1

			let dest = Location::parent();

2319

1

2320

1

			let fee_payer_asset = Location::parent();

2321

1

2322

1

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

2323

1

2324

1

			let xcm_transactor_v1_precompile_address = H160::from_low_u64_be(2054);

2325

1

2326

1

			// Root can set transact info

2327

1

			assert_ok!(XcmTransactor::set_transact_info(

2328

1

				root_origin(),

2329

1

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

2330

1

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

2331

1

				3000.into(),

2332

1

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

2333

1

				Some(4000.into())

2334

1

));

2335

			// Root can set transact info

2336

1

			assert_ok!(XcmTransactor::set_fee_per_second(

2337

1

				root_origin(),

2338

1

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

2339

1

1,

2340

1

));

2341

2342

1

			Precompiles::new()

2343

1

				.prepare_test(

2344

1

					ALICE,

2345

1

					xcm_transactor_v1_precompile_address,

2346

1

					XcmTransactorV1PCall::transact_through_signed_multilocation {

2347

1

						dest,

2348

1

						fee_asset: fee_payer_asset,

2349

1

						weight: 15000,

2350

1

						call: bytes.into(),

2351

1

},

2352

1

2353

1

				.expect_cost(25190)

2354

1

				.expect_no_logs()

2355

1

				.execute_returns(());

2356

1

});

2357

1

2358

2359

#[test]

2360

1

fn transact_through_signed_precompile_works_v2() {

2361

1

	ExtBuilder::default()

2362

1

		.with_balances(vec![

2363

1

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

2364

1

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

2365

1

])

2366

1

		.with_safe_xcm_version(3)

2367

1

		.build()

2368

1

		.execute_with(|| {

2369

1

			// Destination

2370

1

			let dest = Location::parent();

2371

1

2372

1

			let fee_payer_asset = Location::parent();

2373

1

2374

1

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

2375

1

2376

1

			let total_weight = 1_000_000_000u64;

2377

1

2378

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2379

1

2380

1

			Precompiles::new()

2381

1

				.prepare_test(

2382

1

					ALICE,

2383

1

					xcm_transactor_v2_precompile_address,

2384

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2385

1

						dest,

2386

1

						fee_asset: fee_payer_asset,

2387

1

						weight: 4_000_000,

2388

1

						call: bytes.into(),

2389

1

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

2390

1

						overall_weight: total_weight,

2391

1

},

2392

1

2393

1

				.expect_cost(25190)

2394

1

				.expect_no_logs()

2395

1

				.execute_returns(());

2396

1

});

2397

1

2398

2399

#[test]

2400

1

fn transact_through_signed_cannot_send_to_local_chain() {

2401

1

	ExtBuilder::default()

2402

1

		.with_balances(vec![

2403

1

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

2404

1

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

2405

1

])

2406

1

		.with_safe_xcm_version(3)

2407

1

		.build()

2408

1

		.execute_with(|| {

2409

1

			// Destination

2410

1

			let dest = Location::here();

2411

1

2412

1

			let fee_payer_asset = Location::parent();

2413

1

2414

1

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

2415

1

2416

1

			let total_weight = 1_000_000_000u64;

2417

1

2418

1

			let xcm_transactor_v2_precompile_address = H160::from_low_u64_be(2061);

2419

1

2420

1

			Precompiles::new()

2421

1

				.prepare_test(

2422

1

					ALICE,

2423

1

					xcm_transactor_v2_precompile_address,

2424

1

					XcmTransactorV2PCall::transact_through_signed_multilocation {

2425

1

						dest,

2426

1

						fee_asset: fee_payer_asset,

2427

1

						weight: 4_000_000,

2428

1

						call: bytes.into(),

2429

1

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

2430

1

						overall_weight: total_weight,

2431

1

},

2432

1

2433

1

				.execute_reverts(|output| {

2434

1

					from_utf8(&output)

2435

1

						.unwrap()

2436

1

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

2437

1

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

2438

1

});

2439

1

});

2440

1

2441

2442

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

2443

#[test]

2444

1

fn account_id_32_encodes_like_32_byte_u8_slice() {

2445

1

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

2446

1

	let account_as_slice = [1u8; 32];

2447

1

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

2448

1

2449

2450

#[test]

2451

1

fn author_mapping_precompile_associate_update_and_clear() {

2452

1

	ExtBuilder::default()

2453

1

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

2454

1

		.build()

2455

1

		.execute_with(|| {

2456

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2457

1

			let first_nimbus_id: NimbusId =

2458

1

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

2459

1

			let first_vrf_id: session_keys_primitives::VrfId =

2460

1

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

2461

1

			let second_nimbus_id: NimbusId =

2462

1

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

2463

1

			let second_vrf_id: session_keys_primitives::VrfId =

2464

1

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

2465

1

2466

1

			// Associate it

2467

1

			Precompiles::new()

2468

1

				.prepare_test(

2469

1

					ALICE,

2470

1

					author_mapping_precompile_address,

2471

1

					AuthorMappingPCall::add_association {

2472

1

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

2473

1

},

2474

1

2475

1

				.expect_cost(16024)

2476

1

				.expect_no_logs()

2477

1

				.execute_returns(());

2478

1

2479

1

			let expected_associate_event =

2480

1

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

2481

1

					nimbus_id: first_nimbus_id.clone(),

2482

1

					account_id: AccountId::from(ALICE),

2483

1

					keys: first_vrf_id.clone(),

2484

1

});

2485

1

			assert_eq!(last_event(), expected_associate_event);

2486

2487

			// Update it

2488

1

			Precompiles::new()

2489

1

				.prepare_test(

2490

1

					ALICE,

2491

1

					author_mapping_precompile_address,

2492

1

					AuthorMappingPCall::update_association {

2493

1

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

2494

1

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

2495

1

},

2496

1

2497

1

				.expect_cost(15552)

2498

1

				.expect_no_logs()

2499

1

				.execute_returns(());

2500

1

2501

1

			let expected_update_event =

2502

1

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

2503

1

					new_nimbus_id: second_nimbus_id.clone(),

2504

1

					account_id: AccountId::from(ALICE),

2505

1

					new_keys: second_vrf_id.clone(),

2506

1

});

2507

1

			assert_eq!(last_event(), expected_update_event);

2508

2509

			// Clear it

2510

1

			Precompiles::new()

2511

1

				.prepare_test(

2512

1

					ALICE,

2513

1

					author_mapping_precompile_address,

2514

1

					AuthorMappingPCall::clear_association {

2515

1

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

2516

1

},

2517

1

2518

1

				.expect_cost(16038)

2519

1

				.expect_no_logs()

2520

1

				.execute_returns(());

2521

1

2522

1

			let expected_clear_event =

2523

1

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

2524

1

					nimbus_id: second_nimbus_id,

2525

1

					account_id: AccountId::from(ALICE),

2526

1

					keys: second_vrf_id,

2527

1

});

2528

1

			assert_eq!(last_event(), expected_clear_event);

2529

1

});

2530

1

2531

2532

#[test]

2533

1

fn author_mapping_register_and_set_keys() {

2534

1

	ExtBuilder::default()

2535

1

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

2536

1

		.build()

2537

1

		.execute_with(|| {

2538

1

			let author_mapping_precompile_address = H160::from_low_u64_be(2055);

2539

1

			let first_nimbus_id: NimbusId =

2540

1

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

2541

1

			let first_vrf_key: session_keys_primitives::VrfId =

2542

1

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

2543

1

			let second_nimbus_id: NimbusId =

2544

1

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

2545

1

			let second_vrf_key: session_keys_primitives::VrfId =

2546

1

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

2547

1

2548

1

			// Associate it

2549

1

			Precompiles::new()

2550

1

				.prepare_test(

2551

1

					ALICE,

2552

1

					author_mapping_precompile_address,

2553

1

					AuthorMappingPCall::set_keys {

2554

1

						keys: solidity::encode_arguments((

2555

1

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

2556

1

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

2557

1

))

2558

1

						.into(),

2559

1

},

2560

1

2561

1

				.expect_cost(17829)

2562

1

				.expect_no_logs()

2563

1

				.execute_returns(());

2564

1

2565

1

			let expected_associate_event =

2566

1

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

2567

1

					nimbus_id: first_nimbus_id.clone(),

2568

1

					account_id: AccountId::from(ALICE),

2569

1

					keys: first_vrf_key.clone(),

2570

1

});

2571

1

			assert_eq!(last_event(), expected_associate_event);

2572

2573

			// Update it

2574

1

			Precompiles::new()

2575

1

				.prepare_test(

2576

1

					ALICE,

2577

1

					author_mapping_precompile_address,

2578

1

					AuthorMappingPCall::set_keys {

2579

1

						keys: solidity::encode_arguments((

2580

1

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

2581

1

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

2582

1

))

2583

1

						.into(),

2584

1

},

2585

1

2586

1

				.expect_cost(17829)

2587

1

				.expect_no_logs()

2588

1

				.execute_returns(());

2589

1

2590

1

			let expected_update_event =

2591

1

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

2592

1

					new_nimbus_id: second_nimbus_id.clone(),

2593

1

					account_id: AccountId::from(ALICE),

2594

1

					new_keys: second_vrf_key.clone(),

2595

1

});

2596

1

			assert_eq!(last_event(), expected_update_event);

2597

1

});

2598

1

2599

2600

#[test]

2601

1

fn test_xcm_utils_ml_tp_account() {

2602

1

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

2603

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2604

1

		let expected_address_parent: H160 =

2605

1

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

2606

1

				.unwrap()

2607

1

				.into();

2608

1

2609

1

		Precompiles::new()

2610

1

			.prepare_test(

2611

1

				ALICE,

2612

1

				xcm_utils_precompile_address,

2613

1

				XcmUtilsPCall::multilocation_to_address {

2614

1

					location: Location::parent(),

2615

1

},

2616

1

2617

1

			.expect_cost(3338)

2618

1

			.expect_no_logs()

2619

1

			.execute_returns(Address(expected_address_parent));

2620

1

2621

1

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

2622

1

		let expected_address_parachain: H160 =

2623

1

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

2624

1

				&parachain_2000_multilocation,

2625

1

2626

1

			.unwrap()

2627

1

			.into();

2628

1

2629

1

		Precompiles::new()

2630

1

			.prepare_test(

2631

1

				ALICE,

2632

1

				xcm_utils_precompile_address,

2633

1

				XcmUtilsPCall::multilocation_to_address {

2634

1

					location: parachain_2000_multilocation,

2635

1

},

2636

1

2637

1

			.expect_cost(3338)

2638

1

			.expect_no_logs()

2639

1

			.execute_returns(Address(expected_address_parachain));

2640

1

2641

1

		let alice_in_parachain_2000_multilocation = Location::new(

2642

1

1,

2643

1

2644

1

				Parachain(2000),

2645

1

				AccountKey20 {

2646

1

					network: None,

2647

1

					key: ALICE,

2648

1

},

2649

1

],

2650

1

);

2651

1

		let expected_address_alice_in_parachain_2000 =

2652

1

			xcm_builder::HashedDescription::<

2653

1

				AccountId,

2654

1

				xcm_builder::DescribeFamily<xcm_builder::DescribeAllTerminal>,

2655

1

			>::convert_location(&alice_in_parachain_2000_multilocation)

2656

1

			.unwrap()

2657

1

			.into();

2658

1

2659

1

		Precompiles::new()

2660

1

			.prepare_test(

2661

1

				ALICE,

2662

1

				xcm_utils_precompile_address,

2663

1

				XcmUtilsPCall::multilocation_to_address {

2664

1

					location: alice_in_parachain_2000_multilocation,

2665

1

},

2666

1

2667

1

			.expect_cost(3338)

2668

1

			.expect_no_logs()

2669

1

			.execute_returns(Address(expected_address_alice_in_parachain_2000));

2670

1

});

2671

1

2672

2673

#[test]

2674

1

fn test_nested_batch_calls_from_xcm_transact() {

2675

1

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

2676

1

		// This ensures we notice if MAX_XCM_DECODE_DEPTH changes

2677

1

		// in a future polkadot-sdk version

2678

1

		assert_eq!(xcm::MAX_XCM_DECODE_DEPTH, 8);

2679

2680

1

		let mut valid_nested_calls =

2681

1

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

2682

9

		for _ in 0..xcm::MAX_XCM_DECODE_DEPTH {

2683

8

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

2684

8

				calls: vec![valid_nested_calls],

2685

8

});

2686

8

2687

2688

1

		let valid_message = Xcm(vec![Transact {

2689

1

			origin_kind: OriginKind::SovereignAccount,

2690

1

			fallback_max_weight: None,

2691

1

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

2692

1

		}]);

2693

1

2694

1

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

2695

2696

1

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

2697

1

			calls: vec![valid_nested_calls],

2698

1

});

2699

1

2700

1

		let invalid_message = Xcm(vec![Transact {

2701

1

			origin_kind: OriginKind::SovereignAccount,

2702

1

			fallback_max_weight: None,

2703

1

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

2704

1

		}]);

2705

1

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

2706

1

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

2707

1

});

2708

1

2709

2710

#[test]

2711

1

fn test_xcm_utils_weight_message() {

2712

1

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

2713

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2714

1

		let expected_weight =

2715

1

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

2716

1

2717

1

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

2718

1

2719

1

		let input = XcmUtilsPCall::weight_message {

2720

1

			message: message.into(),

2721

1

};

2722

1

2723

1

		Precompiles::new()

2724

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2725

1

			.expect_cost(1669)

2726

1

			.expect_no_logs()

2727

1

			.execute_returns(expected_weight);

2728

1

});

2729

1

2730

2731

#[test]

2732

1

fn test_xcm_utils_get_units_per_second() {

2733

1

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

2734

1

		let xcm_utils_precompile_address = H160::from_low_u64_be(2060);

2735

1

		let location = SelfReserve::get();

2736

1

2737

1

		let input = XcmUtilsPCall::get_units_per_second { location };

2738

1

2739

1

		let expected_units =

2740

1

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

2741

1

2742

1

		Precompiles::new()

2743

1

			.prepare_test(ALICE, xcm_utils_precompile_address, input)

2744

1

			.expect_cost(3338)

2745

1

			.expect_no_logs()

2746

1

			.execute_returns(expected_units);

2747

1

});

2748

1

2749

2750

#[test]

2751

1

fn precompile_existence() {

2752

1

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

2753

1

		let precompiles = Precompiles::new();

2754

1

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

2755

1

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

2756

1

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

2757

1

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

2758

1

2759

1

		.into_iter()

2760

1

		.map(H160::from_low_u64_be)

2761

1

		.collect();

2762

2763

3001

		for i in 0..3000 {

2764

3000

			let address = H160::from_low_u64_be(i);

2765

3000

2766

3000

			if precompile_addresses.contains(&address) {

2767

41

				assert!(

2768

41

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

2769

					"is_precompile({}) should return true",

2770

2771

);

2772

2773

41

				assert!(

2774

41

					precompiles

2775

41

						.execute(&mut MockHandle::new(

2776

41

							address,

2777

41

							Context {

2778

41

								address,

2779

41

								caller: H160::zero(),

2780

41

								apparent_value: U256::zero()

2781

41

2782

41

),)

2783

41

						.is_some(),

2784

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

2785

2786

);

2787

			} else {

2788

2959

				assert!(

2789

2959

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

2790

					"is_precompile({}) should return false",

2791

2792

);

2793

2794

2959

				assert!(

2795

2959

					precompiles

2796

2959

						.execute(&mut MockHandle::new(

2797

2959

							address,

2798

2959

							Context {

2799

2959

								address,

2800

2959

								caller: H160::zero(),

2801

2959

								apparent_value: U256::zero()

2802

2959

2803

2959

),)

2804

2959

						.is_none(),

2805

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

2806

2807

);

2808

2809

2810

1

});

2811

1

2812

2813

#[test]

2814

1

fn removed_precompiles() {

2815

1

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

2816

1

		let precompiles = Precompiles::new();

2817

1

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

2818

2819

3000

		for i in 1..3000 {

2820

2999

			let address = H160::from_low_u64_be(i);

2821

2999

2822

2999

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

2823

2958

				continue;

2824

41

2825

41

2826

41

			if !removed_precompiles.contains(&i) {

2827

36

				assert!(

2828

36

					match precompiles.is_active_precompile(address, 100_000u64) {

2829

36

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

2830

						_ => false,

2831

},

2832

					"{i} should be an active precompile"

2833

);

2834

36

				continue;

2835

5

2836

5

2837

5

			assert!(

2838

5

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

2839

5

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

2840

					_ => false,

2841

},

2842

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

2843

);

2844

2845

5

			precompiles

2846

5

				.prepare_test(Alice, address, [])

2847

5

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

2848

5

2849

1

})

2850

1

2851

2852

#[test]

2853

1

fn substrate_based_fees_zero_txn_costs_only_base_extrinsic() {

2854

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

2855

	use moonbase_runtime::{currency, EXTRINSIC_BASE_WEIGHT};

2856

2857

1

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

2858

1

		let size_bytes = 0;

2859

1

		let tip = 0;

2860

1

		let dispatch_info = DispatchInfo {

2861

1

			class: DispatchClass::Normal,

2862

1

			pays_fee: Pays::Yes,

2863

1

			call_weight: Weight::zero(),

2864

1

			extension_weight: Weight::zero(),

2865

1

};

2866

1

2867

1

		assert_eq!(

2868

1

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

2869

1

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

2870

1

);

2871

1

});

2872

1

2873

2874

#[test]

2875

1

fn deal_with_fees_handles_tip() {

2876

	use frame_support::traits::OnUnbalanced;

2877

	use moonbase_runtime::Treasury;

2878

	use moonbeam_runtime_common::deal_with_fees::DealWithSubstrateFeesAndTip;

2879

2880

1

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

2881

1

		set_parachain_inherent_data();

2882

1

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

2883

1

		// in the Moonbeam runtime. It verifies that:

2884

1

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

2885

1

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

2886

1

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

2887

1

2888

1

		// The test details:

2889

1

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

2890

1

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

2891

1

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

2892

1

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

2893

1

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

2894

1

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

2895

1

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

2896

1

2897

1

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

2898

1

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

2899

1

			AccountId,

2900

1

		>>::issue(100);

2901

1

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

2902

1

			AccountId,

2903

1

		>>::issue(1000);

2904

1

2905

1

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

2906

1

		let total_supply_before = Balances::total_issuance();

2907

1

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

2908

1

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

2909

1

		assert_eq!(total_supply_before, 1_100);

2910

1

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

2911

2912

		// Step 3: Execute the fees handling logic.

2913

1

		DealWithSubstrateFeesAndTip::<

2914

1

			Runtime,

2915

1

			dynamic_params::runtime_config::FeesTreasuryProportion,

2916

1

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

2917

1

2918

1

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

2919

1

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

2920

1

2921

1

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

2922

1

		let burnt_fee_part: Balance = 100 - treasury_fee_part;

2923

1

2924

1

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

2925

1

		assert_eq!(

2926

1

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

2927

1

			treasury_fee_part,

2928

1

);

2929

2930

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

2931

1

		let total_supply_after = Balances::total_issuance();

2932

1

		assert_eq!(total_supply_before - total_supply_after, burnt_fee_part,);

2933

2934

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

2935

1

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

2936

1

		assert_eq!(

2937

1

			block_author_balance_after - block_author_balance_before,

2938

1

			1000,

2939

1

);

2940

1

});

2941

1

2942

2943

#[test]

2944

1

fn evm_revert_substrate_events() {

2945

1

	ExtBuilder::default()

2946

1

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

2947

1

		.build()

2948

1

		.execute_with(|| {

2949

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2950

1

2951

1

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

2952

1

			// Thus BatchAll will revert the transfer.

2953

1

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

2954

1

				source: ALICE.into(),

2955

1

				target: batch_precompile_address,

2956

1

				input: BatchPCall::batch_all {

2957

1

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

2958

1

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

2959

1

					call_data: vec![].into(),

2960

1

					gas_limit: vec![].into()

2961

1

2962

1

				.into(),

2963

1

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

2964

1

				gas_limit: 500_000,

2965

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

2966

1

				max_priority_fee_per_gas: None,

2967

1

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

2968

1

				access_list: Vec::new(),

2969

1

})

2970

1

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

2971

2972

1

			let transfer_count = System::events()

2973

1

				.iter()

2974

6

				.filter(|r| match r.event {

2975

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

2976

6

					_ => false,

2977

6

})

2978

1

				.count();

2979

1

2980

1

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

2981

1

});

2982

1

2983

2984

#[test]

2985

1

fn evm_success_keeps_substrate_events() {

2986

1

	ExtBuilder::default()

2987

1

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

2988

1

		.build()

2989

1

		.execute_with(|| {

2990

1

			let batch_precompile_address = H160::from_low_u64_be(2056);

2991

1

2992

1

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

2993

1

				source: ALICE.into(),

2994

1

				target: batch_precompile_address,

2995

1

				input: BatchPCall::batch_all {

2996

1

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

2997

1

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

2998

1

					call_data: vec![].into(),

2999

1

					gas_limit: vec![].into()

3000

1

3001

1

				.into(),

3002

1

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

3003

1

				gas_limit: 500_000,

3004

1

				max_fee_per_gas: U256::from(BASE_FEE_GENISIS),

3005

1

				max_priority_fee_per_gas: None,

3006

1

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

3007

1

				access_list: Vec::new(),

3008

1

})

3009

1

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

3010

3011

1

			let transfer_count = System::events()

3012

1

				.iter()

3013

10

				.filter(|r| match r.event {

3014

1

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

3015

9

					_ => false,

3016

10

})

3017

1

				.count();

3018

1

3019

1

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

3020

1

});

3021

1

3022

3023

#[test]

3024

1

fn validate_transaction_fails_on_filtered_call() {

3025

	use sp_runtime::transaction_validity::{

3026

		InvalidTransaction, TransactionSource, TransactionValidityError,

3027

};

3028

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

3029

3030

1

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

3031

1

		let xt = UncheckedExtrinsic::new_bare(

3032

1

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

3033

1

				source: Default::default(),

3034

1

				target: H160::default(),

3035

1

				input: Vec::new(),

3036

1

				value: Default::default(),

3037

1

				gas_limit: Default::default(),

3038

1

				max_fee_per_gas: Default::default(),

3039

1

				max_priority_fee_per_gas: Default::default(),

3040

1

				nonce: Default::default(),

3041

1

				access_list: Default::default(),

3042

1

3043

1

			.into(),

3044

1

);

3045

1

3046

1

		assert_eq!(

3047

1

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

3048

1

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

3049

1

);

3050

1

});

3051

1

3052

3053

#[cfg(test)]

3054

mod treasury_tests {

3055

	use super::*;

3056

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

3057

	use moonbase_runtime::XcmWeightTrader;

3058

	use sp_runtime::traits::Hash;

3059

3060

8

	fn expect_events(events: Vec<RuntimeEvent>) {

3061

8

		let block_events: Vec<RuntimeEvent> =

3062

59

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

3063

8

3064

8

		dbg!(events.clone());

3065

8

		dbg!(block_events.clone());

3066

8

3067

12

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

3068

8

3069

3070

13

	fn next_block() {

3071

13

		System::reset_events();

3072

13

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

3073

13

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

3074

13

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

3075

13

3076

3077

6

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

3078

6

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

3079

6

			.expect("failed to get account balance")

3080

6

3081

3082

	#[test]

3083

1

	fn test_treasury_spend_local_with_root_origin() {

3084

1

		let initial_treasury_balance = 1_000 * UNIT;

3085

1

		ExtBuilder::default()

3086

1

			.with_balances(vec![

3087

1

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

3088

1

				(Treasury::account_id(), initial_treasury_balance),

3089

1

])

3090

1

			.build()

3091

1

			.execute_with(|| {

3092

1

				let spend_amount = 100u128 * UNIT;

3093

1

				let spend_beneficiary = AccountId::from(BOB);

3094

1

3095

1

				next_block();

3096

1

3097

1

				// Perform treasury spending

3098

1

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

3099

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

3100

1

					root_origin(),

3101

1

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

3102

1

						amount: spend_amount,

3103

1

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

3104

1

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

3105

1

						valid_from: Some(valid_from),

3106

1

}))

3107

1

));

3108

3109

1

				let payout_period =

3110

1

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

3111

1

				let expected_events = [RuntimeEvent::Treasury(

3112

1

					pallet_treasury::Event::AssetSpendApproved {

3113

1

						index: 0,

3114

1

						asset_kind: NativeOrWithId::Native,

3115

1

						amount: spend_amount,

3116

1

						beneficiary: spend_beneficiary,

3117

1

						valid_from,

3118

1

						expire_at: payout_period + valid_from,

3119

1

},

3120

1

)]

3121

1

				.to_vec();

3122

1

				expect_events(expected_events);

3123

3124

6

				while System::block_number() < valid_from {

3125

5

					next_block();

3126

5

3127

3128

1

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

3129

3130

1

				let expected_events = [

3131

1

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

3132

1

						index: 0,

3133

1

						payment_id: (),

3134

1

}),

3135

1

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

3136

1

						from: Treasury::account_id(),

3137

1

						to: spend_beneficiary,

3138

1

						amount: spend_amount,

3139

1

}),

3140

1

3141

1

				.to_vec();

3142

1

				expect_events(expected_events);

3143

1

});

3144

1

3145

3146

	#[test]

3147

1

	fn test_treasury_spend_local_with_council_origin() {

3148

1

		let initial_treasury_balance = 1_000 * UNIT;

3149

1

		ExtBuilder::default()

3150

1

			.with_balances(vec![

3151

1

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

3152

1

				(Treasury::account_id(), initial_treasury_balance),

3153

1

])

3154

1

			.build()

3155

1

			.execute_with(|| {

3156

1

				let spend_amount = 100u128 * UNIT;

3157

1

				let spend_beneficiary = AccountId::from(BOB);

3158

1

3159

1

				next_block();

3160

1

3161

1

				// TreasuryCouncilCollective

3162

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3163

1

					root_origin(),

3164

1

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

3165

1

					Some(AccountId::from(ALICE)),

3166

1

3167

1

));

3168

3169

1

				next_block();

3170

1

3171

1

				// Perform treasury spending

3172

1

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

3173

1

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

3174

1

					amount: spend_amount,

3175

1

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

3176

1

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

3177

1

					valid_from: Some(valid_from),

3178

1

});

3179

1

				assert_ok!(TreasuryCouncilCollective::propose(

3180

1

					origin_of(AccountId::from(ALICE)),

3181

1

1,

3182

1

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

3183

1

					1_000

3184

1

));

3185

3186

1

				let payout_period =

3187

1

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

3188

1

				let expected_events = [

3189

1

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

3190

1

						index: 0,

3191

1

						asset_kind: NativeOrWithId::Native,

3192

1

						amount: spend_amount,

3193

1

						beneficiary: spend_beneficiary,

3194

1

						valid_from,

3195

1

						expire_at: payout_period + valid_from,

3196

1

}),

3197

1

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

3198

1

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

3199

1

						result: Ok(()),

3200

1

}),

3201

1

3202

1

				.to_vec();

3203

1

				expect_events(expected_events);

3204

3205

6

				while System::block_number() < valid_from {

3206

5

					next_block();

3207

5

3208

3209

1

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

3210

3211

1

				let expected_events = [

3212

1

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

3213

1

						index: 0,

3214

1

						payment_id: (),

3215

1

}),

3216

1

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

3217

1

						from: Treasury::account_id(),

3218

1

						to: spend_beneficiary,

3219

1

						amount: spend_amount,

3220

1

}),

3221

1

3222

1

				.to_vec();

3223

1

				expect_events(expected_events);

3224

1

});

3225

1

3226

3227

	#[test]

3228

1

	fn test_treasury_spend_foreign_asset_with_root_origin() {

3229

1

		let initial_treasury_balance = 1_000 * UNIT;

3230

1

		let asset_id = 1000100010001000u128;

3231

1

		ExtBuilder::default()

3232

1

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

3233

1

			.build()

3234

1

			.execute_with(|| {

3235

1

				let spend_amount = 100u128 * UNIT;

3236

1

				let spend_beneficiary = AccountId::from(BOB);

3237

1

3238

1

				let asset_location: Location = Location {

3239

1

					parents: 1,

3240

1

					interior: Junctions::Here,

3241

1

};

3242

1

3243

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

3244

1

					root_origin(),

3245

1

					asset_id,

3246

1

					asset_location.clone(),

3247

1

12,

3248

1

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

3249

1

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

3250

1

));

3251

3252

1

				assert_ok!(XcmWeightTrader::add_asset(

3253

1

					root_origin(),

3254

1

					asset_location,

3255

1

					1u128

3256

1

));

3257

3258

1

				assert_ok!(EvmForeignAssets::mint_into(

3259

1

					asset_id,

3260

1

					Treasury::account_id(),

3261

1

					initial_treasury_balance.into()

3262

1

));

3263

3264

1

				assert_eq!(

3265

1

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

3266

1

					initial_treasury_balance.into(),

3267

					"Treasury balance not updated"

3268

);

3269

3270

1

				assert_ok!(moonbase_runtime::Sudo::sudo(

3271

1

					root_origin(),

3272

1

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

3273

1

						amount: spend_amount,

3274

1

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

3275

1

						beneficiary: Box::new(spend_beneficiary),

3276

1

						valid_from: None,

3277

1

}))

3278

1

));

3279

3280

1

				let payout_period =

3281

1

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

3282

1

3283

1

				let current_block = System::block_number();

3284

1

				expect_events(vec![RuntimeEvent::Treasury(

3285

1

					pallet_treasury::Event::AssetSpendApproved {

3286

1

						index: 0,

3287

1

						asset_kind: NativeOrWithId::WithId(asset_id),

3288

1

						amount: spend_amount,

3289

1

						beneficiary: spend_beneficiary,

3290

1

						valid_from: current_block,

3291

1

						expire_at: current_block + payout_period,

3292

1

},

3293

1

				)]);

3294

1

3295

1

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

3296

3297

1

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

3298

1

					index: 0,

3299

1

					payment_id: (),

3300

1

				})]);

3301

1

3302

1

				assert_eq!(

3303

1

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

3304

1

					(initial_treasury_balance - spend_amount).into(),

3305

					"Treasury balance not updated"

3306

);

3307

3308

1

				assert_eq!(

3309

1

					get_asset_balance(&asset_id, &spend_beneficiary),

3310

1

					spend_amount.into(),

3311

					"Treasury payout failed"

3312

);

3313

1

});

3314

1

3315

3316

	#[test]

3317

1

	fn test_treasury_spend_foreign_asset_with_council_origin() {

3318

1

		let initial_treasury_balance = 1_000 * UNIT;

3319

1

		let asset_id = 1000100010001000u128;

3320

1

		ExtBuilder::default()

3321

1

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

3322

1

			.build()

3323

1

			.execute_with(|| {

3324

1

				let spend_amount = 100u128 * UNIT;

3325

1

				let spend_beneficiary = AccountId::from(BOB);

3326

1

3327

1

				let asset_location: Location = Location {

3328

1

					parents: 1,

3329

1

					interior: Junctions::Here,

3330

1

};

3331

1

3332

1

				assert_ok!(EvmForeignAssets::create_foreign_asset(

3333

1

					root_origin(),

3334

1

					asset_id,

3335

1

					asset_location.clone(),

3336

1

12,

3337

1

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

3338

1

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

3339

1

));

3340

3341

1

				assert_ok!(XcmWeightTrader::add_asset(

3342

1

					root_origin(),

3343

1

					asset_location,

3344

1

					1u128

3345

1

));

3346

3347

1

				assert_ok!(EvmForeignAssets::mint_into(

3348

1

					asset_id,

3349

1

					Treasury::account_id(),

3350

1

					initial_treasury_balance.into()

3351

1

));

3352

3353

1

				assert_eq!(

3354

1

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

3355

1

					initial_treasury_balance.into(),

3356

					"Treasury balance not updated"

3357

);

3358

3359

				// TreasuryCouncilCollective

3360

1

				assert_ok!(TreasuryCouncilCollective::set_members(

3361

1

					root_origin(),

3362

1

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

3363

1

					Some(AccountId::from(ALICE)),

3364

1

3365

1

));

3366

3367

				// Perform treasury spending

3368

1

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

3369

1

					amount: spend_amount,

3370

1

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

3371

1

					beneficiary: Box::new(spend_beneficiary),

3372

1

					valid_from: None,

3373

1

});

3374

1

				assert_ok!(TreasuryCouncilCollective::propose(

3375

1

					origin_of(AccountId::from(ALICE)),

3376

1

1,

3377

1

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

3378

1

					1_000

3379

1

));

3380

3381

1

				let payout_period =

3382

1

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

3383

1

3384

1

				let current_block = System::block_number();

3385

1

				let expected_events = [

3386

1

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

3387

1

						index: 0,

3388

1

						asset_kind: NativeOrWithId::WithId(asset_id),

3389

1

						amount: spend_amount,

3390

1

						beneficiary: spend_beneficiary,

3391

1

						valid_from: current_block,

3392

1

						expire_at: current_block + payout_period,

3393

1

}),

3394

1

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

3395

1

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

3396

1

						result: Ok(()),

3397

1

}),

3398

1

3399

1

				.to_vec();

3400

1

				expect_events(expected_events);

3401

1

3402

1

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

3403

3404

1

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

3405

1

					index: 0,

3406

1

					payment_id: (),

3407

1

				})]);

3408

1

3409

1

				assert_eq!(

3410

1

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

3411

1

					(initial_treasury_balance - spend_amount).into(),

3412

					"Treasury balance not updated"

3413

);

3414

3415

1

				assert_eq!(

3416

1

					get_asset_balance(&asset_id, &spend_beneficiary),

3417

1

					spend_amount.into(),

3418

					"Treasury payout failed"

3419

);

3420

1

});

3421

1

3422

3423

3424

/// Run these tests:

3425

/// cargo test --color=always -p moonbase-runtime --features bridge-stagenet --test integration_test bridge_tests -- --nocapture

3426

#[cfg(all(any(feature = "bridge-stagenet", feature = "bridge-betanet"), test))]

3427

mod bridge_tests {

3428

	use crate::common::{origin_of, root_origin, ExtBuilder, XcmAssetInitialization, ALICE, BOB};

3429

	use bp_messages::target_chain::DispatchMessageData;

3430

	use bp_messages::ReceptionResult;

3431

	use bp_runtime::messages::MessageDispatchResult;

3432

	use cumulus_primitives_core::AggregateMessageOrigin;

3433

	use frame_support::assert_ok;

3434

	use frame_support::pallet_prelude::{Hooks, PalletInfoAccess};

3435

	use moonbase_runtime::bridge_config::{

3436

		SourceGlobalConsensusNetwork, SourceParachain, TargetBridgeLocation,

3437

		TargetGlobalConsensusNetwork, TargetParachain, WithMessagesInstance,

3438

};

3439

	use moonbase_runtime::currency::{KILOWEI, UNIT};

3440

	use moonbase_runtime::xcm_config::CurrencyId;

3441

	use moonbase_runtime::{

3442

		Balances, BridgeMessages, BridgeXcmOver, MessageQueue, PolkadotXcm, Runtime, RuntimeEvent,

3443

		System,

3444

};

3445

	use moonbeam_core_primitives::AccountId;

3446

	use pallet_bridge_messages::LanesManager;

3447

	use pallet_xcm_bridge::XcmBlobMessageDispatchResult::Dispatched;

3448

	use parity_scale_codec::Encode;

3449

	use sp_runtime::traits::Convert;

3450

	use xcm::latest::Junctions::X1;

3451

	use xcm::latest::{

3452

		Asset, AssetFilter, AssetId, Fungibility, Junctions, Location, WeightLimit, WildAsset, Xcm,

3453

};

3454

	use xcm::prelude::{

3455

		AccountKey20, BuyExecution, ClearOrigin, DepositAsset, DescendOrigin, Fungible,

3456

		GlobalConsensus, PalletInstance, ReserveAssetDeposited, SetTopic, UniversalOrigin,

3457

		XCM_VERSION,

3458

};

3459

	use xcm::{VersionedAssets, VersionedInteriorLocation, VersionedLocation, VersionedXcm};

3460

	use xcm_builder::BridgeMessage;

3461

3462

	fn currency_to_asset(currency_id: CurrencyId, amount: u128) -> Asset {

3463

		Asset {

3464

			id: AssetId(

3465

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

3466

					currency_id,

3467

3468

					.unwrap(),

3469

),

3470

			fun: Fungibility::Fungible(amount),

3471

3472

3473

3474

	fn next_block() {

3475

		System::reset_events();

3476

3477

		let next_block = System::block_number() + 1u32;

3478

3479

		System::set_block_number(next_block);

3480

		System::on_initialize(next_block);

3481

		MessageQueue::on_initialize(next_block);

3482

3483

3484

	#[test]

3485

	fn transfer_asset() {

3486

		frame_support::__private::sp_tracing::init_for_tests();

3487

3488

		ExtBuilder::default()

3489

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

3490

			.with_safe_xcm_version(XCM_VERSION)

3491

			.with_open_bridges(vec![(

3492

				Location::new(1, [SourceParachain::get()]),

3493

				Junctions::from([

3494

					TargetGlobalConsensusNetwork::get().into(),

3495

					TargetParachain::get(),

3496

]),

3497

				Some(Default::default()),

3498

)])

3499

			.build()

3500

			.execute_with(|| {

3501

				assert_ok!(PolkadotXcm::force_xcm_version(

3502

					root_origin(),

3503

					Box::new(TargetBridgeLocation::get()),

3504

					XCM_VERSION

3505

));

3506

3507

				let asset = currency_to_asset(CurrencyId::SelfReserve, KILOWEI);

3508

3509

				let message_data = BridgeMessages::outbound_message_data(Default::default(), 1u64);

3510

				assert!(message_data.is_none());

3511

3512

				assert_ok!(PolkadotXcm::transfer_assets(

3513

					origin_of(AccountId::from(ALICE)),

3514

					Box::new(VersionedLocation::V5(TargetBridgeLocation::get())),

3515

					Box::new(VersionedLocation::V5(Location {

3516

						parents: 0,

3517

						interior: [AccountKey20 {

3518

							network: None,

3519

							key: ALICE,

3520

}]

3521

						.into(),

3522

					})),

3523

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

3524

0,

3525

					WeightLimit::Unlimited

3526

));

3527

3528

				let message_data = BridgeMessages::outbound_message_data(Default::default(), 1u64);

3529

				assert!(message_data.is_some());

3530

})

3531

3532

3533

	#[test]

3534

	fn receive_message() {

3535

		frame_support::__private::sp_tracing::init_for_tests();

3536

3537

		ExtBuilder::default()

3538

			.with_balances(vec![

3539

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

3540

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

3541

])

3542

			.with_xcm_assets(vec![XcmAssetInitialization {

3543

				asset_id: 1,

3544

				xcm_location: Location::new(

3545

2,

3546

3547

						GlobalConsensus(TargetGlobalConsensusNetwork::get()),

3548

						TargetParachain::get(),

3549

						PalletInstance(<Balances as PalletInfoAccess>::index() as u8),

3550

],

3551

),

3552

				name: "xcToken",

3553

				symbol: "xcToken",

3554

				decimals: 18,

3555

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

3556

}])

3557

			.with_safe_xcm_version(XCM_VERSION)

3558

			.with_open_bridges(vec![(

3559

				Location::new(1, [SourceParachain::get()]),

3560

				Junctions::from([

3561

					TargetGlobalConsensusNetwork::get().into(),

3562

					TargetParachain::get(),

3563

]),

3564

				Some(Default::default()),

3565

)])

3566

			.build()

3567

			.execute_with(|| {

3568

				assert_ok!(PolkadotXcm::force_xcm_version(

3569

					root_origin(),

3570

					Box::new(TargetBridgeLocation::get()),

3571

					XCM_VERSION

3572

));

3573

3574

				let bridge_message: BridgeMessage = BridgeMessage {

3575

					universal_dest: VersionedInteriorLocation::V5(

3576

3577

							GlobalConsensus(SourceGlobalConsensusNetwork::get()),

3578

							SourceParachain::get(),

3579

3580

						.into(),

3581

),

3582

					message: VersionedXcm::V5(Xcm([

3583

						UniversalOrigin(GlobalConsensus(TargetGlobalConsensusNetwork::get())),

3584

						DescendOrigin(X1([TargetParachain::get()].into())),

3585

						ReserveAssetDeposited(

3586

							vec![Asset {

3587

								id: AssetId(Location::new(

3588

2,

3589

3590

										GlobalConsensus(TargetGlobalConsensusNetwork::get()),

3591

										TargetParachain::get(),

3592

										PalletInstance(

3593

											<Balances as PalletInfoAccess>::index() as u8

3594

),

3595

],

3596

)),

3597

								fun: Fungible(UNIT * 2),

3598

}]

3599

							.into(),

3600

),

3601

						ClearOrigin,

3602

						BuyExecution {

3603

							fees: Asset {

3604

								id: AssetId(Location::new(

3605

2,

3606

3607

										GlobalConsensus(TargetGlobalConsensusNetwork::get()),

3608

										TargetParachain::get(),

3609

										PalletInstance(

3610

											<Balances as PalletInfoAccess>::index() as u8

3611

),

3612

],

3613

)),

3614

								fun: Fungible(UNIT / 2),

3615

},

3616

							weight_limit: WeightLimit::Unlimited,

3617

},

3618

						DepositAsset {

3619

							assets: AssetFilter::Wild(WildAsset::AllCounted(1)),

3620

							beneficiary: Location::new(

3621

0,

3622

								[AccountKey20 {

3623

									network: None,

3624

									key: ALICE,

3625

}],

3626

),

3627

},

3628

						SetTopic([

3629

							24, 73, 92, 41, 231, 15, 196, 44, 136, 120, 145, 143, 224, 187, 112,

3630

							187, 47, 89, 154, 44, 193, 175, 174, 249, 30, 194, 97, 183, 171, 39,

3631

							87, 147,

3632

]),

3633

3634

					.into())),

3635

};

3636

3637

				let mut inbound_lane = LanesManager::<Runtime, WithMessagesInstance>::new()

3638

					.active_inbound_lane(Default::default())

3639

					.unwrap();

3640

3641

				let msg = DispatchMessageData {

3642

					payload: Ok(bridge_message.encode()),

3643

};

3644

				let result =

3645

					inbound_lane.receive_message::<BridgeXcmOver>(&AccountId::from(ALICE), 1, msg);

3646

3647

				assert_eq!(

3648

					result,

3649

					ReceptionResult::Dispatched(MessageDispatchResult {

3650

						unspent_weight: Default::default(),

3651

						dispatch_level_result: Dispatched

3652

})

3653

);

3654

3655

				// Produce next block

3656

				next_block();

3657

				// Confirm that the xcm message was successfully processed

3658

				assert!(System::events().iter().any(|evt| {

3659

					matches!(

3660

						evt.event,

3661

						RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed {

3662

							origin: AggregateMessageOrigin::Here,

3663

							success: true,

3664

..

3665

})

3666

3667

				}));

3668

});

3669

3670

3671

3672

#[cfg(test)]

3673

mod fee_tests {

3674

	use super::*;

3675

	use fp_evm::FeeCalculator;

3676

	use frame_support::{

3677

		traits::{ConstU128, OnFinalize},

3678

		weights::{ConstantMultiplier, WeightToFee},

3679

};

3680

	use moonbase_runtime::{

3681

		currency, BlockWeights, FastAdjustingFeeUpdate, LengthToFee, MinimumMultiplier,

3682

		TargetBlockFullness, TransactionPaymentAsGasPrice, NORMAL_WEIGHT, WEIGHT_PER_GAS,

3683

};

3684

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

3685

3686

1

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

3687

1

	where

3688

1

		F: FnMut() -> (),

3689

1

3690

1

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

3691

1

			.build_storage()

3692

1

			.unwrap()

3693

1

			.into();

3694

1

		t.execute_with(|| {

3695

1

			System::set_block_consumed_resources(w, 0);

3696

1

			assertions()

3697

1

});

3698

1

3699

3700

	#[test]

3701

1

	fn test_multiplier_can_grow_from_zero() {

3702

1

		let minimum_multiplier = MinimumMultiplier::get();

3703

1

		let target = TargetBlockFullness::get()

3704

1

			* BlockWeights::get()

3705

1

				.get(DispatchClass::Normal)

3706

1

				.max_total

3707

1

				.unwrap();

3708

1

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

3709

1

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

3710

1

		run_with_system_weight(target * 101 / 100, || {

3711

1

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

3712

1

			assert!(

3713

1

				next > minimum_multiplier,

3714

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

3715

				next,

3716

				minimum_multiplier

3717

);

3718

1

})

3719

1

3720

3721

	#[test]

3722

1

	fn test_fee_calculation() {

3723

1

		let base_extrinsic = BlockWeights::get()

3724

1

			.get(DispatchClass::Normal)

3725

1

			.base_extrinsic;

3726

1

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

3727

1

		let extrinsic_len = 100u32;

3728

1

		let extrinsic_weight = 5_000u64;

3729

1

		let tip = 42u128;

3730

		type WeightToFeeImpl =

3731

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

3732

		type LengthToFeeImpl = LengthToFee;

3733

3734

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

3735

1

		let expected_fee =

3736

1

			WeightToFeeImpl::weight_to_fee(&base_extrinsic)

3737

1

				+ multiplier.saturating_mul_int(WeightToFeeImpl::weight_to_fee(

3738

1

					&Weight::from_parts(extrinsic_weight, 1),

3739

1

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

3740

1

				+ tip;

3741

1

3742

1

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

3743

1

			.build_storage()

3744

1

			.unwrap()

3745

1

			.into();

3746

1

		t.execute_with(|| {

3747

1

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

3748

1

			let actual_fee = TransactionPayment::compute_fee(

3749

1

				extrinsic_len,

3750

1

				&frame_support::dispatch::DispatchInfo {

3751

1

					class: DispatchClass::Normal,

3752

1

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

3753

1

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

3754

1

					extension_weight: Weight::zero(),

3755

1

},

3756

1

				tip,

3757

1

);

3758

1

3759

1

			assert_eq!(

3760

				expected_fee,

3761

				actual_fee,

3762

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

3763

				actual_fee - expected_fee

3764

);

3765

1

});

3766

1

3767

3768

	#[test]

3769

1

	fn test_min_gas_price_is_deterministic() {

3770

1

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

3771

1

			.build_storage()

3772

1

			.unwrap()

3773

1

			.into();

3774

1

		t.execute_with(|| {

3775

1

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

3776

1

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

3777

1

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

3778

1

			let expected: U256 = multiplier

3779

1

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

3780

1

				.into();

3781

1

3782

1

			assert_eq!(expected, actual);

3783

1

});

3784

1

3785

3786

	#[test]

3787

1

	fn test_min_gas_price_has_no_precision_loss_from_saturating_mul_int() {

3788

1

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

3789

1

			.build_storage()

3790

1

			.unwrap()

3791

1

			.into();

3792

1

		t.execute_with(|| {

3793

1

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

3794

1

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

3795

1

3796

1

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

3797

1

			let a = TransactionPaymentAsGasPrice::min_gas_price();

3798

1

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

3799

1

			let b = TransactionPaymentAsGasPrice::min_gas_price();

3800

1

3801

1

			assert_ne!(

3802

				a, b,

3803

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

3804

);

3805

1

});

3806

1

3807

3808

	#[test]

3809

1

	fn test_fee_scenarios() {

3810

		use sp_runtime::FixedU128;

3811

1

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

3812

1

			.build_storage()

3813

1

			.unwrap()

3814

1

			.into();

3815

1

		t.execute_with(|| {

3816

1

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

3817

12

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

3818

12

				let start_multiplier =

3819

12

					FixedU128::from_rational(start_gas_price, weight_fee_per_gas);

3820

12

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

3821

12

3822

12

				let block_weight = NORMAL_WEIGHT * fullness;

3823

3824

60004

				for i in 0..num_blocks {

3825

60004

					System::set_block_number(i as u32);

3826

60004

					System::set_block_consumed_resources(block_weight, 0);

3827

60004

					TransactionPayment::on_finalize(i as u32);

3828

60004

3829

3830

12

				TransactionPaymentAsGasPrice::min_gas_price().0

3831

12

};

3832

3833

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

3834

			// they are expected to change when parameters that influence

3835

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

3836

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

3837

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

3838

3839

1

			assert_eq!(

3840

1

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

3841

1

				U256::from(998_600_980),

3842

1

);

3843

1

			assert_eq!(

3844

1

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

3845

1

				U256::from(999_600_080),

3846

1

);

3847

1

			assert_eq!(

3848

1

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

3849

1

				U256::from(1_000_600_180),

3850

1

);

3851

1

			assert_eq!(

3852

1

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

3853

1

				U256::from(1_002_603_380),

3854

1

);

3855

3856

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

3857

1

			assert_eq!(

3858

1

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

3859

1

				U256::from(431_710_642),

3860

1

);

3861

1

			assert_eq!(

3862

1

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

3863

1

				U256::from(786_627_866),

3864

1

);

3865

1

			assert_eq!(

3866

1

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

3867

1

				U256::from(1_433_329_383u128),

3868

1

);

3869

1

			assert_eq!(

3870

1

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

3871

1

				U256::from(4_758_812_897u128),

3872

1

);

3873

3874

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

3875

1

			assert_eq!(

3876

1

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

3877

1

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

3878

1

);

3879

1

			assert_eq!(

3880

1

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

3881

1

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

3882

1

);

3883

1

			assert_eq!(

3884

1

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

3885

1

				U256::from(5_653_326_895_069u128),

3886

1

);

3887

1

			assert_eq!(

3888

1

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

3889

1

				U256::from(31_250_000_000_000u128),

3890

1

				// upper bound enforced (min_gas_price * MaximumMultiplier)

3891

1

);

3892

1

});

3893

1

3894