pub fn existential_deposit() -> u128 {

	<Runtime as pallet_balances::Config>::ExistentialDeposit::get()

}

pub fn rpc_run_to_block(n: u32) {

	while System::block_number() < n {

		Ethereum::on_finalize(System::block_number());

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

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

	}

}

pub fn run_to_block(n: u32, author: Option<NimbusId>) {

	while System::block_number() < n {

		match author {

			Some(ref author) => {

				let pre_digest = Digest {

					logs: vec![DigestItem::PreRuntime(NIMBUS_ENGINE_ID, author.encode())],

				};

				System::reset_events();

				System::initialize(

					&(System::block_number() + 1),

					&System::parent_hash(),

					&pre_digest,

				);

			}

		increase_last_relay_slot_number(1);

		// Initialize the new block

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

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

		// Finalize the block

		ParachainStaking::on_finalize(System::block_number());

}

pub fn last_event() -> RuntimeEvent {

	System::events().pop().expect("Event expected").event

}

	fn default() -> ExtBuilder {

		ExtBuilder {

			balances: vec![],

			delegations: vec![],

			collators: vec![],

			inflation: InflationInfo {

				expect: Range {

					min: 100_000 * MOVR,

					ideal: 200_000 * MOVR,

					max: 500_000 * MOVR,

				},

				// not used

				annual: Range {

					min: Perbill::from_percent(50),

					ideal: Perbill::from_percent(50),

					max: Perbill::from_percent(50),

				},

				// unrealistically high parameterization, only for testing

				round: Range {

					min: Perbill::from_percent(5),

					ideal: Perbill::from_percent(5),

					max: Perbill::from_percent(5),

				},

			},

			mappings: vec![],

			crowdloan_fund: 0,

			chain_id: CHAIN_ID,

			evm_accounts: BTreeMap::new(),

			xcm_assets: vec![],

			evm_native_foreign_assets: false,

			safe_xcm_version: None,

			opened_bridges: vec![],

		}

	}

	pub fn with_evm_accounts(mut self, accounts: BTreeMap<H160, GenesisAccount>) -> Self {

		self.evm_accounts = accounts;

		self

	}

	pub fn with_balances(mut self, balances: Vec<(AccountId, Balance)>) -> Self {

		self.balances = balances;

		self

	}

	pub fn with_collators(mut self, collators: Vec<(AccountId, Balance)>) -> Self {

		self.collators = collators;

		self

	}

	pub fn with_delegations(mut self, delegations: Vec<(AccountId, AccountId, Balance)>) -> Self {

		self.delegations = delegations

			.into_iter()

			.map(|d| (d.0, d.1, d.2, Percent::zero()))

			.collect();

		self

	}

	pub fn with_crowdloan_fund(mut self, crowdloan_fund: Balance) -> Self {

		self.crowdloan_fund = crowdloan_fund;

		self

	}

	pub fn with_mappings(mut self, mappings: Vec<(NimbusId, AccountId)>) -> Self {

		self.mappings = mappings;

		self

	}

	pub fn with_xcm_assets(mut self, xcm_assets: Vec<XcmAssetInitialization>) -> Self {

		self.xcm_assets = xcm_assets;

		self

	}

	pub fn with_evm_native_foreign_assets(mut self) -> Self {

		self.evm_native_foreign_assets = true;

		self

	}

	pub fn with_safe_xcm_version(mut self, safe_xcm_version: u32) -> Self {

		self.safe_xcm_version = Some(safe_xcm_version);

		self

	}

	pub fn with_open_bridges(

		mut self,

		opened_bridges: Vec<(Location, InteriorLocation, Option<bp_moonbeam::LaneId>)>,

	) -> Self {

		self.opened_bridges = opened_bridges;

		self

	}

	pub fn build(self) -> sp_io::TestExternalities {

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

			.build_storage()

			.unwrap();

		parachain_info::GenesisConfig::<Runtime> {

			parachain_id: <bp_moonriver::Moonriver as bp_runtime::Parachain>::PARACHAIN_ID.into(),

			_config: Default::default(),

		}

		.assimilate_storage(&mut t)

		.unwrap();

		pallet_balances::GenesisConfig::<Runtime> {

			balances: self.balances,

		}

		.assimilate_storage(&mut t)

		.unwrap();

		pallet_parachain_staking::GenesisConfig::<Runtime> {

			candidates: self.collators,

			delegations: self.delegations,

			inflation_config: self.inflation,

			collator_commission: Perbill::from_percent(20),

			parachain_bond_reserve_percent: Percent::from_percent(30),

			blocks_per_round: 2 * HOURS,

			num_selected_candidates: 8,

		}

		.assimilate_storage(&mut t)

		.unwrap();

		pallet_crowdloan_rewards::GenesisConfig::<Runtime> {

			funded_amount: self.crowdloan_fund,

		}

		.assimilate_storage(&mut t)

		.unwrap();

		pallet_author_mapping::GenesisConfig::<Runtime> {

			mappings: self.mappings,

		}

		.assimilate_storage(&mut t)

		.unwrap();

		let genesis_config = pallet_evm_chain_id::GenesisConfig::<Runtime> {

			chain_id: self.chain_id,

			..Default::default()

		};

		genesis_config.assimilate_storage(&mut t).unwrap();

		let genesis_config = pallet_evm::GenesisConfig::<Runtime> {

			accounts: self.evm_accounts,

			..Default::default()

		};

		genesis_config.assimilate_storage(&mut t).unwrap();

		let genesis_config = pallet_ethereum::GenesisConfig::<Runtime> {

			..Default::default()

		};

		genesis_config.assimilate_storage(&mut t).unwrap();

		let genesis_config = pallet_xcm::GenesisConfig::<Runtime> {

			safe_xcm_version: self.safe_xcm_version,

			..Default::default()

		};

		genesis_config.assimilate_storage(&mut t).unwrap();

		let genesis_config = pallet_transaction_payment::GenesisConfig::<Runtime> {

			multiplier: Multiplier::from(10u128),

			..Default::default()

		};

		genesis_config.assimilate_storage(&mut t).unwrap();

		let genesis_config = pallet_xcm_bridge::GenesisConfig::<Runtime, XcmOverPolkadotInstance> {

			opened_bridges: self.opened_bridges,

			_phantom: Default::default(),

		};

		genesis_config.assimilate_storage(&mut t).unwrap();

		let mut ext = sp_io::TestExternalities::new(t);

		let xcm_assets = self.xcm_assets.clone();

		ext.execute_with(|| {

			// Mock hrmp egress_channels

			cumulus_pallet_parachain_system::RelevantMessagingState::<Runtime>::put(

				MessagingStateSnapshot {

					dmq_mqc_head: Default::default(),

					relay_dispatch_queue_remaining_capacity: Default::default(),

					ingress_channels: vec![],

					egress_channels: vec![(

						1_000.into(),

						AbridgedHrmpChannel {

							max_capacity: u32::MAX,

							max_total_size: u32::MAX,

							max_message_size: u32::MAX,

							msg_count: 0,

							total_size: 0,

							mqc_head: None,

						},

					)],

				},

			);

			for xcm_asset_initialization in xcm_assets {

				let asset_id: AssetId = xcm_asset_initialization.asset_type.clone().into();

				if self.evm_native_foreign_assets {

					let AssetType::Xcm(location) = xcm_asset_initialization.asset_type;

					let metadata = xcm_asset_initialization.metadata.clone();

					EvmForeignAssets::register_foreign_asset(

						asset_id,

						xcm::VersionedLocation::from(location).try_into().unwrap(),

						metadata.decimals,

						metadata.symbol.try_into().unwrap(),

						metadata.name.try_into().unwrap(),

					)

					.expect("register evm native foreign asset");

					if xcm_asset_initialization.is_sufficient {

						XcmWeightTrader::add_asset(

							root_origin(),

							xcm::VersionedLocation::from(location).try_into().unwrap(),

							MOVR, // 1 to 1 ratio

						)

						.expect("register evm native foreign asset as sufficient");

					}

					for (account, balance) in xcm_asset_initialization.balances {

						EvmForeignAssets::mint_into(asset_id.into(), account, balance.into())

							.expect("mint evm native foreign asset");

					}

					AssetManager::register_foreign_asset(

						root_origin(),

						xcm_asset_initialization.asset_type,

						xcm_asset_initialization.metadata,

						1,

						xcm_asset_initialization.is_sufficient,

					)

					.unwrap();

					for (account, balance) in xcm_asset_initialization.balances {

						Assets::mint(

							origin_of(AssetManager::account_id()),

							asset_id.into(),

							account,

							balance,

						)

						.unwrap();

					}

			System::set_block_number(1);

		});

		ext

	}

pub fn origin_of(account_id: AccountId) -> <Runtime as frame_system::Config>::RuntimeOrigin {

	<Runtime as frame_system::Config>::RuntimeOrigin::signed(account_id)

}

pub fn inherent_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

	<Runtime as frame_system::Config>::RuntimeOrigin::none()

}

pub fn root_origin() -> <Runtime as frame_system::Config>::RuntimeOrigin {

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

}

pub fn set_parachain_inherent_data() {

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

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

	let mut relay_sproof = RelayStateSproofBuilder::default();

	relay_sproof.para_id = bp_moonriver::PARACHAIN_ID.into();

	relay_sproof.included_para_head = Some(HeadData(vec![1, 2, 3]));

	let additional_key_values = vec![(

		moonbeam_core_primitives::well_known_relay_keys::TIMESTAMP_NOW.to_vec(),

		sp_timestamp::Timestamp::default().encode(),

	)];

	relay_sproof.additional_key_values = additional_key_values;

	let (relay_parent_storage_root, relay_chain_state) = relay_sproof.into_state_root_and_proof();

	let vfp = PersistedValidationData {

		relay_parent_number: 1u32,

		relay_parent_storage_root,

		..Default::default()

	};

	let parachain_inherent_data = ParachainInherentData {

		validation_data: vfp,

		relay_chain_state: relay_chain_state,

		downward_messages: Default::default(),

		horizontal_messages: Default::default(),

	};

	assert_ok!(RuntimeCall::ParachainSystem(

		cumulus_pallet_parachain_system::Call::<Runtime>::set_validation_data {

			data: parachain_inherent_data

		}

	)

	.dispatch(inherent_origin()));

}

pub fn unchecked_eth_tx(raw_hex_tx: &str) -> UncheckedExtrinsic {

	let converter = TransactionConverter;

	converter.convert_transaction(ethereum_transaction(raw_hex_tx))

}

pub fn ethereum_transaction(raw_hex_tx: &str) -> pallet_ethereum::Transaction {

	let bytes = hex::decode(raw_hex_tx).expect("Transaction bytes.");

	let transaction = ethereum::EnvelopedDecodable::decode(&bytes[..]);

	assert!(transaction.is_ok());

	transaction.unwrap()

}

pub(crate) fn increase_last_relay_slot_number(amount: u64) {

	let last_relay_slot = u64::from(AsyncBacking::slot_info().unwrap_or_default().0);

	frame_support::storage::unhashed::put(

		&frame_support::storage::storage_prefix(b"AsyncBacking", b"SlotInfo"),

		&((Slot::from(last_relay_slot + amount), 0)),

	);

}