setup.rs

// This file is part of Acala.

// Copyright (C) 2020-2022 Acala Foundation.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

use acala_service::chain_spec::mandala::evm_genesis;
pub use codec::Encode;
use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;
use frame_support::traits::{GenesisBuild, OnFinalize, OnIdle, OnInitialize};
pub use frame_support::{assert_noop, assert_ok, traits::Currency};
pub use frame_system::RawOrigin;

pub use module_support::{
	mocks::MockAddressMapping, AddressMapping, CDPTreasury, DEXManager, Price, Rate, Ratio, RiskManager,
};

pub use orml_traits::{location::RelativeLocations, Change, GetByKey, MultiCurrency};

pub use primitives::currency::*;
pub use sp_core::H160;
use sp_io::hashing::keccak_256;
pub use sp_runtime::{
	traits::{AccountIdConversion, BadOrigin, BlakeTwo256, Convert, Hash, Zero},
	DispatchError, DispatchResult, FixedPointNumber, MultiAddress, Perbill, Permill,
};

pub use xcm::latest::prelude::*;

#[cfg(feature = "with-mandala-runtime")]
pub use mandala_imports::*;
#[cfg(feature = "with-mandala-runtime")]
mod mandala_imports {
	pub use mandala_runtime::{
		create_x2_parachain_multilocation, get_all_module_accounts, AcalaOracle, AccountId, AssetRegistry,
		AuctionManager, Authority, AuthoritysOriginId, Authorship, Balance, Balances, BlockNumber, Call, CdpEngine,
		CdpTreasury, CollatorSelection, CreateClassDeposit, CreateTokenDeposit, Currencies, CurrencyId,
		CurrencyIdConvert, DataDepositPerByte, DealWithFees, DefaultExchangeRate, Dex, EmergencyShutdown,
		EnabledTradingPairs, Event, EvmAccounts, ExistentialDeposits, FinancialCouncil, Get, GetNativeCurrencyId, Homa,
		HomaXcm, Honzon, IdleScheduler, Loans, MaxTipsOfPriority, MinRewardDistributeAmount, MinimumDebitValue,
		MultiLocation, NativeTokenExistentialDeposit, NetworkId, NftPalletId, OneDay, Origin, OriginCaller,
		PalletCurrency, ParachainInfo, ParachainSystem, Proxy, ProxyType, Runtime, Scheduler, Session, SessionKeys,
		SessionManager, SevenDays, StableAsset, StableAssetPalletId, System, Timestamp, TipPerWeightStep, TokenSymbol,
		Tokens, TransactionPayment, TreasuryAccount, TreasuryPalletId, UncheckedExtrinsic, Utility, Vesting, XcmConfig,
		XcmExecutor, EVM, NFT,
	};

	pub use runtime_common::{cent, dollar, millicent, ACA, AUSD, DOT, KSM, LDOT, LKSM};
	pub const NATIVE_CURRENCY: CurrencyId = ACA;
	pub const LIQUID_CURRENCY: CurrencyId = LDOT;
	pub const RELAY_CHAIN_CURRENCY: CurrencyId = DOT;
	pub const USD_CURRENCY: CurrencyId = AUSD;
	pub const LPTOKEN: CurrencyId = CurrencyId::DexShare(
		primitives::DexShare::Token(TokenSymbol::AUSD),
		primitives::DexShare::Token(TokenSymbol::DOT),
	);
}

#[cfg(feature = "with-karura-runtime")]
pub use karura_imports::*;
#[cfg(feature = "with-karura-runtime")]
mod karura_imports {
	pub use frame_support::{assert_ok, parameter_types, weights::Weight};
	pub use karura_runtime::{
		constants::parachains, create_x2_parachain_multilocation, get_all_module_accounts, AcalaOracle, AccountId,
		AssetRegistry, AuctionManager, Authority, AuthoritysOriginId, Balance, Balances, BlockNumber, Call, CdpEngine,
		CdpTreasury, CreateClassDeposit, CreateTokenDeposit, Currencies, CurrencyId, CurrencyIdConvert,
		DataDepositPerByte, DefaultExchangeRate, Dex, EmergencyShutdown, Event, EvmAccounts, ExistentialDeposits,
		FinancialCouncil, Get, GetNativeCurrencyId, Homa, HomaXcm, Honzon, IdleScheduler, KarPerSecond,
		KaruraFoundationAccounts, KsmPerSecond, KusamaBondingDuration, KusdPerSecond, Loans, MaxTipsOfPriority,
		MinimumDebitValue, MultiLocation, NativeTokenExistentialDeposit, NetworkId, NftPalletId, OneDay, Origin,
		OriginCaller, ParachainAccount, ParachainInfo, ParachainSystem, PolkadotXcm, Proxy, ProxyType, Ratio,
		RelayChainBlockNumberProvider, Runtime, Scheduler, Session, SessionManager, SevenDays, System, Timestamp,
		TipPerWeightStep, TokenSymbol, Tokens, TreasuryPalletId, Utility, Vesting, XTokens, XcmConfig, XcmExecutor,
		EVM, NFT,
	};
	pub use module_asset_registry::AssetMetadata;
	pub use primitives::TradingPair;
	pub use runtime_common::{calculate_asset_ratio, cent, dollar, millicent, KAR, KSM, KUSD, LKSM};
	pub use sp_runtime::{traits::AccountIdConversion, FixedPointNumber};
	pub use xcm::latest::prelude::*;

	parameter_types! {
		pub EnabledTradingPairs: Vec<TradingPair> = vec![
			TradingPair::from_currency_ids(USD_CURRENCY, NATIVE_CURRENCY).unwrap(),
			TradingPair::from_currency_ids(USD_CURRENCY, RELAY_CHAIN_CURRENCY).unwrap(),
			TradingPair::from_currency_ids(USD_CURRENCY, LIQUID_CURRENCY).unwrap(),
			TradingPair::from_currency_ids(RELAY_CHAIN_CURRENCY, NATIVE_CURRENCY).unwrap(),
		];
		pub TreasuryAccount: AccountId = TreasuryPalletId::get().into_account();
	}

	pub const NATIVE_CURRENCY: CurrencyId = KAR;
	pub const LIQUID_CURRENCY: CurrencyId = LKSM;
	pub const RELAY_CHAIN_CURRENCY: CurrencyId = KSM;
	pub const USD_CURRENCY: CurrencyId = KUSD;
	pub const LPTOKEN: CurrencyId = CurrencyId::DexShare(
		primitives::DexShare::Token(TokenSymbol::KUSD),
		primitives::DexShare::Token(TokenSymbol::KSM),
	);

	parameter_types! {
		// Initial fee pool size. one extrinsic=0.0025 KAR, one block=100 extrinsics.
		// 20 blocks trigger an swap, so total balance=0.0025*100*20=5 KAR
		pub FeePoolSize: Balance = 5 * dollar(KAR);
		// one extrinsic fee=0.0025KAR, one block=100 extrinsics, threshold=0.25+0.1=0.35KAR
		pub SwapBalanceThreshold: Balance = Ratio::saturating_from_rational(35, 100).saturating_mul_int(dollar(KAR));
		// tokens used as fee charge. the token should have corresponding dex swap pool enabled.
		pub InitialTokenFeePool: Vec<(CurrencyId, Balance)> = vec![
			(KSM, FeePoolSize::get()),
			(KUSD, FeePoolSize::get()),
			// this one is to simulate not enough native asset so wouldn't take effect
			(LKSM, NativeTokenExistentialDeposit::get() - 1),
		];
	}

	pub fn initiate_asset_registry() {
		// BNC: ForeignAsset(0)
		assert_ok!(module_asset_registry::Pallet::<Runtime>::do_register_foreign_asset(
			&(
				1,
				X2(
					Parachain(parachains::bifrost::ID),
					GeneralKey(parachains::bifrost::BNC_KEY.to_vec()),
				)
			)
				.into(),
			&AssetMetadata {
				name: "BNC".as_bytes().to_vec(),
				symbol: "BNC".as_bytes().to_vec(),
				decimals: 12,
				minimal_balance: 800 * (10u128.saturating_pow(12))
			}
		));
		// VSKSM: ForeignAsset(1)
		assert_ok!(module_asset_registry::Pallet::<Runtime>::do_register_foreign_asset(
			&(
				1,
				X2(
					Parachain(parachains::bifrost::ID),
					GeneralKey(parachains::bifrost::VSKSM_KEY.to_vec()),
				)
			)
				.into(),
			&AssetMetadata {
				name: "VSKSM".as_bytes().to_vec(),
				symbol: "VSKSM".as_bytes().to_vec(),
				decimals: 12,
				minimal_balance: 10 * (10u128.saturating_pow(12))
			}
		));
		// PHA: ForeignAsset(2)
		assert_ok!(module_asset_registry::Pallet::<Runtime>::do_register_foreign_asset(
			&(1, X1(Parachain(parachains::phala::ID))).into(),
			&AssetMetadata {
				name: "PHA".as_bytes().to_vec(),
				symbol: "PHA".as_bytes().to_vec(),
				decimals: 12,
				minimal_balance: 4000 * (10u128.saturating_pow(12))
			}
		));
	}
	pub const BNC: CurrencyId = CurrencyId::ForeignAsset(0);
	pub const VSKSM: CurrencyId = CurrencyId::ForeignAsset(1);
	pub const PHA: CurrencyId = CurrencyId::ForeignAsset(2);
}

#[cfg(feature = "with-acala-runtime")]
pub use acala_imports::*;
#[cfg(feature = "with-acala-runtime")]
mod acala_imports {
	pub use acala_runtime::{
		create_x2_parachain_multilocation, get_all_module_accounts, AcalaFoundationAccounts, AcalaOracle, AccountId,
		AssetRegistry, AuctionManager, Authority, AuthoritysOriginId, Balance, Balances, BlockNumber, Call, CdpEngine,
		CdpTreasury, CreateClassDeposit, CreateTokenDeposit, Currencies, CurrencyId, CurrencyIdConvert,
		DataDepositPerByte, DefaultExchangeRate, Dex, EmergencyShutdown, Event, EvmAccounts, ExistentialDeposits,
		FinancialCouncil, Get, GetNativeCurrencyId, HomaLite, Honzon, IdleScheduler, Loans, MaxTipsOfPriority,
		MinimumDebitValue, MultiLocation, NativeTokenExistentialDeposit, NetworkId, NftPalletId, OneDay, Origin,
		OriginCaller, ParachainAccount, ParachainInfo, ParachainSystem, PolkadotXcm, Proxy, ProxyType,
		RelayChainBlockNumberProvider, RelayChainSovereignSubAccount, Runtime, Scheduler, Session, SessionManager,
		SevenDays, System, Timestamp, TipPerWeightStep, TokenSymbol, Tokens, TreasuryPalletId, Utility, Vesting,
		XTokens, XcmConfig, XcmExecutor, XcmUnbondFee, EVM, NFT,
	};
	pub use frame_support::parameter_types;
	pub use primitives::TradingPair;
	pub use runtime_common::{cent, dollar, millicent, ACA, AUSD, DOT, LDOT};
	pub use sp_runtime::traits::AccountIdConversion;

	parameter_types! {
		pub EnabledTradingPairs: Vec<TradingPair> = vec![
			TradingPair::from_currency_ids(USD_CURRENCY, NATIVE_CURRENCY).unwrap(),
			TradingPair::from_currency_ids(USD_CURRENCY, RELAY_CHAIN_CURRENCY).unwrap(),
			TradingPair::from_currency_ids(USD_CURRENCY, LIQUID_CURRENCY).unwrap(),
		];
		pub TreasuryAccount: AccountId = TreasuryPalletId::get().into_account();
	}

	pub const NATIVE_CURRENCY: CurrencyId = ACA;
	pub const LIQUID_CURRENCY: CurrencyId = LDOT;
	pub const RELAY_CHAIN_CURRENCY: CurrencyId = DOT;
	pub const USD_CURRENCY: CurrencyId = AUSD;
	pub const LPTOKEN: CurrencyId = CurrencyId::DexShare(
		primitives::DexShare::Token(TokenSymbol::AUSD),
		primitives::DexShare::Token(TokenSymbol::DOT),
	);
}

const ORACLE1: [u8; 32] = [0u8; 32];
const ORACLE2: [u8; 32] = [1u8; 32];
const ORACLE3: [u8; 32] = [2u8; 32];
const ORACLE4: [u8; 32] = [3u8; 32];
const ORACLE5: [u8; 32] = [4u8; 32];

#[allow(dead_code)]
pub const DEFAULT: [u8; 32] = [0u8; 32];

pub const ALICE: [u8; 32] = [4u8; 32];
pub const BOB: [u8; 32] = [5u8; 32];
pub const CHARLIE: [u8; 32] = [6u8; 32];
pub const DAVE: [u8; 32] = [7u8; 32];

pub const INIT_TIMESTAMP: u64 = 30_000;
pub const BLOCK_TIME: u64 = 1000;

pub fn run_to_block(n: u32) {
	while System::block_number() < n {
		Scheduler::on_finalize(System::block_number());
		System::set_block_number(System::block_number() + 1);
		Timestamp::set_timestamp((System::block_number() as u64 * BLOCK_TIME) + INIT_TIMESTAMP);
		CdpEngine::on_initialize(System::block_number());
		Scheduler::on_initialize(System::block_number());
		Scheduler::on_initialize(System::block_number());
		Session::on_initialize(System::block_number());
		SessionManager::on_initialize(System::block_number());
		IdleScheduler::on_idle(System::block_number(), u64::MAX);
	}
}

pub fn set_relaychain_block_number(number: BlockNumber) {
	ParachainSystem::on_initialize(number);

	let (relay_storage_root, proof) = RelayStateSproofBuilder::default().into_state_root_and_proof();

	assert_ok!(ParachainSystem::set_validation_data(
		Origin::none(),
		cumulus_primitives_parachain_inherent::ParachainInherentData {
			validation_data: cumulus_primitives_core::PersistedValidationData {
				parent_head: Default::default(),
				relay_parent_number: number,
				relay_parent_storage_root: relay_storage_root,
				max_pov_size: Default::default(),
			},
			relay_chain_state: proof,
			downward_messages: Default::default(),
			horizontal_messages: Default::default(),
		}
	));
}

pub struct ExtBuilder {
	balances: Vec<(AccountId, CurrencyId, Balance)>,
	parachain_id: u32,
}

impl Default for ExtBuilder {
	fn default() -> Self {
		Self {
			balances: vec![],
			parachain_id: 2000,
		}
	}
}

impl ExtBuilder {
	pub fn balances(mut self, balances: Vec<(AccountId, CurrencyId, Balance)>) -> Self {
		self.balances = balances;
		self
	}

	#[allow(dead_code)]
	pub fn parachain_id(mut self, parachain_id: u32) -> Self {
		self.parachain_id = parachain_id;
		self
	}

	pub fn build(self) -> sp_io::TestExternalities {
		let evm_genesis_accounts = evm_genesis(vec![]);

		let mut t = frame_system::GenesisConfig::default()
			.build_storage::<Runtime>()
			.unwrap();

		let native_currency_id = GetNativeCurrencyId::get();
		let existential_deposit = NativeTokenExistentialDeposit::get();
		let initial_enabled_trading_pairs = EnabledTradingPairs::get();

		#[cfg(feature = "with-mandala-runtime")]
		GenesisBuild::<Runtime>::assimilate_storage(
			&ecosystem_renvm_bridge::GenesisConfig {
				ren_vm_public_key: hex_literal::hex!["4b939fc8ade87cb50b78987b1dda927460dc456a"],
			},
			&mut t,
		)
		.unwrap();

		module_dex::GenesisConfig::<Runtime> {
			initial_enabled_trading_pairs: initial_enabled_trading_pairs,
			initial_listing_trading_pairs: Default::default(),
			initial_added_liquidity_pools: vec![],
		}
		.assimilate_storage(&mut t)
		.unwrap();

		pallet_balances::GenesisConfig::<Runtime> {
			balances: self
				.balances
				.clone()
				.into_iter()
				.filter(|(_, currency_id, _)| *currency_id == native_currency_id)
				.map(|(account_id, _, initial_balance)| (account_id, initial_balance))
				.chain(
					get_all_module_accounts()
						.iter()
						.map(|x| (x.clone(), existential_deposit)),
				)
				.collect::<Vec<_>>(),
		}
		.assimilate_storage(&mut t)
		.unwrap();

		orml_tokens::GenesisConfig::<Runtime> {
			balances: self
				.balances
				.into_iter()
				.filter(|(_, currency_id, _)| *currency_id != native_currency_id)
				.collect::<Vec<_>>(),
		}
		.assimilate_storage(&mut t)
		.unwrap();

		pallet_membership::GenesisConfig::<Runtime, pallet_membership::Instance5> {
			members: vec![
				AccountId::from(ORACLE1),
				AccountId::from(ORACLE2),
				AccountId::from(ORACLE3),
				AccountId::from(ORACLE4),
				AccountId::from(ORACLE5),
			],
			phantom: Default::default(),
		}
		.assimilate_storage(&mut t)
		.unwrap();

		module_evm::GenesisConfig::<Runtime> {
			accounts: evm_genesis_accounts,
		}
		.assimilate_storage(&mut t)
		.unwrap();

		module_session_manager::GenesisConfig::<Runtime> { session_duration: 10 }
			.assimilate_storage(&mut t)
			.unwrap();

		<parachain_info::GenesisConfig as GenesisBuild<Runtime>>::assimilate_storage(
			&parachain_info::GenesisConfig {
				parachain_id: self.parachain_id.into(),
			},
			&mut t,
		)
		.unwrap();

		<pallet_xcm::GenesisConfig as GenesisBuild<Runtime>>::assimilate_storage(
			&pallet_xcm::GenesisConfig {
				safe_xcm_version: Some(2),
			},
			&mut t,
		)
		.unwrap();

		let mut ext = sp_io::TestExternalities::new(t);
		ext.execute_with(|| System::set_block_number(1));
		ext
	}
}

pub fn set_oracle_price(prices: Vec<(CurrencyId, Price)>) {
	AcalaOracle::on_finalize(0);
	assert_ok!(AcalaOracle::feed_values(
		Origin::signed(AccountId::from(ORACLE1)),
		prices.clone(),
	));
	assert_ok!(AcalaOracle::feed_values(
		Origin::signed(AccountId::from(ORACLE2)),
		prices.clone(),
	));
	assert_ok!(AcalaOracle::feed_values(
		Origin::signed(AccountId::from(ORACLE3)),
		prices.clone(),
	));
	assert_ok!(AcalaOracle::feed_values(
		Origin::signed(AccountId::from(ORACLE4)),
		prices.clone(),
	));
	assert_ok!(AcalaOracle::feed_values(
		Origin::signed(AccountId::from(ORACLE5)),
		prices,
	));
}

pub fn alice_key() -> libsecp256k1::SecretKey {
	libsecp256k1::SecretKey::parse(&keccak_256(b"Alice")).unwrap()
}

pub fn bob_key() -> libsecp256k1::SecretKey {
	libsecp256k1::SecretKey::parse(&keccak_256(b"Bob")).unwrap()
}

pub fn alice() -> AccountId {
	let address = EvmAccounts::eth_address(&alice_key());
	let mut data = [0u8; 32];
	data[0..4].copy_from_slice(b"evm:");
	data[4..24].copy_from_slice(&address[..]);
	AccountId::from(Into::<[u8; 32]>::into(data))
}

pub fn bob() -> AccountId {
	let address = EvmAccounts::eth_address(&bob_key());
	let mut data = [0u8; 32];
	data[0..4].copy_from_slice(b"evm:");
	data[4..24].copy_from_slice(&address[..]);
	AccountId::from(Into::<[u8; 32]>::into(data))
}