#![allow(clippy::derive_partial_eq_without_eq)]
use std::collections::BTreeMap;
use altair_runtime::constants::currency::{AIR, MILLI_AIR};
use cfg_primitives::{
currency_decimals, parachains, Balance, BlockNumber, CFG, MILLI_CFG, SAFE_XCM_VERSION,
};
use cfg_types::{
fee_keys::FeeKey,
tokens::{
usdc::{
lp_wrapped_usdc_metadata, CHAIN_ID_ETH_GOERLI_TESTNET, CONTRACT_ETH_GOERLI,
CURRENCY_ID_LP_ETH_GOERLI,
},
AssetMetadata, CrossChainTransferability, CurrencyId, CustomMetadata,
},
};
use cfg_utils::vec_to_fixed_array;
use cumulus_primitives_core::ParaId;
use hex_literal::hex;
use runtime_common::account_conversion::AccountConverter;
use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
use sc_service::{ChainType, Properties};
use serde::{Deserialize, Serialize};
use sp_core::{crypto::UncheckedInto, sr25519, Encode, Pair, Public, H160, U256};
use sp_runtime::traits::{IdentifyAccount, Verify};
use xcm::{
latest::MultiLocation,
prelude::{GeneralIndex, GeneralKey, PalletInstance, Parachain, X2, X3},
};
pub type AltairChainSpec = sc_service::GenericChainSpec<altair_runtime::GenesisConfig, Extensions>;
pub type CentrifugeChainSpec =
sc_service::GenericChainSpec<centrifuge_runtime::GenesisConfig, Extensions>;
pub type DevelopmentChainSpec =
sc_service::GenericChainSpec<development_runtime::GenesisConfig, Extensions>;
pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
TPublic::Pair::from_string(&format!("//{seed}"), None)
.expect("static values are valid; qed")
.public()
}
#[derive(
Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension,
)]
#[serde(deny_unknown_fields)]
pub struct Extensions {
pub relay_chain: String,
pub para_id: u32,
pub first_evm_block: BlockNumber,
}
impl Extensions {
pub fn try_get(chain_spec: &dyn sc_service::ChainSpec) -> Option<&Extensions> {
sc_chain_spec::get_extension(chain_spec.extensions())
}
}
fn development_extensions(para_id: u32) -> Extensions {
Extensions {
para_id,
relay_chain: "rococo-local".into(),
first_evm_block: 1,
}
}
pub fn get_altair_session_keys(keys: altair_runtime::AuraId) -> altair_runtime::SessionKeys {
altair_runtime::SessionKeys {
aura: keys.clone(),
block_rewards: keys,
}
}
pub fn get_centrifuge_session_keys(
keys: centrifuge_runtime::AuraId,
) -> centrifuge_runtime::SessionKeys {
centrifuge_runtime::SessionKeys {
aura: keys.clone(),
block_rewards: keys,
}
}
pub fn get_development_session_keys(
keys: development_runtime::AuraId,
) -> development_runtime::SessionKeys {
development_runtime::SessionKeys {
aura: keys.clone(),
block_rewards: keys,
}
}
type AccountPublic = <cfg_primitives::Signature as Verify>::Signer;
pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> cfg_primitives::AccountId
where
AccountPublic: From<<TPublic::Pair as Pair>::Public>,
{
AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
}
pub fn centrifuge_config() -> CentrifugeChainSpec {
CentrifugeChainSpec::from_json_bytes(
&include_bytes!("../res/genesis/centrifuge-genesis-spec-raw.json")[..],
)
.unwrap()
}
pub fn centrifuge_dev(para_id: ParaId) -> CentrifugeChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DCFG".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
CentrifugeChainSpec::from_genesis(
"Centrifuge Dev",
"centrifuge_dev",
ChainType::Live,
move || {
centrifuge_genesis(
vec![
(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<centrifuge_runtime::AuraId>("Alice"),
),
(
get_account_id_from_seed::<sr25519::Public>("Bob"),
get_from_seed::<centrifuge_runtime::AuraId>("Bob"),
),
(
get_account_id_from_seed::<sr25519::Public>("Charlie"),
get_from_seed::<centrifuge_runtime::AuraId>("Charlie"),
),
],
endowed_accounts(),
endowed_evm_accounts(),
Some(100000000 * CFG),
para_id,
council_members_bootstrap(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn centrifuge_local(para_id: ParaId) -> CentrifugeChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DCFG".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
CentrifugeChainSpec::from_genesis(
"Centrifuge Local",
"centrifuge_local",
ChainType::Local,
move || {
centrifuge_genesis(
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<centrifuge_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(100000000 * CFG),
para_id,
council_members_bootstrap(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn catalyst_config() -> CentrifugeChainSpec {
CentrifugeChainSpec::from_json_bytes(&include_bytes!("../res/catalyst-spec-raw.json")[..])
.unwrap()
}
pub fn catalyst_local(para_id: ParaId) -> CentrifugeChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "NCFG".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
CentrifugeChainSpec::from_genesis(
"Catalyst Local",
"catalyst_local",
ChainType::Local,
move || {
centrifuge_genesis(
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<altair_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(10000000 * CFG),
para_id,
Default::default(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn altair_config() -> AltairChainSpec {
AltairChainSpec::from_json_bytes(
&include_bytes!("../res/genesis/altair-genesis-spec-raw.json")[..],
)
.unwrap()
}
pub fn altair_dev(para_id: ParaId) -> AltairChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DAIR".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
AltairChainSpec::from_genesis(
"Altair Dev",
"altair_dev",
ChainType::Live,
move || {
altair_genesis(
vec![
(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<altair_runtime::AuraId>("Alice"),
),
(
get_account_id_from_seed::<sr25519::Public>("Bob"),
get_from_seed::<altair_runtime::AuraId>("Bob"),
),
(
get_account_id_from_seed::<sr25519::Public>("Charlie"),
get_from_seed::<altair_runtime::AuraId>("Charlie"),
),
],
endowed_accounts(),
endowed_evm_accounts(),
Some(100000000 * AIR),
para_id,
council_members_bootstrap(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn altair_local(para_id: ParaId) -> AltairChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DAIR".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
AltairChainSpec::from_genesis(
"Altair Local",
"altair_local",
ChainType::Local,
move || {
altair_genesis(
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<altair_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(100000000 * AIR),
para_id,
council_members_bootstrap(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn antares_config() -> AltairChainSpec {
AltairChainSpec::from_json_bytes(&include_bytes!("../res/antares-spec-raw.json")[..]).unwrap()
}
pub fn antares_local(para_id: ParaId) -> AltairChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "NAIR".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
AltairChainSpec::from_genesis(
"Antares Local",
"antares_local",
ChainType::Local,
move || {
altair_genesis(
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<altair_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(10000000 * AIR),
para_id,
Default::default(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn charcoal_config() -> AltairChainSpec {
AltairChainSpec::from_json_bytes(&include_bytes!("../res/charcoal-spec-raw.json")[..]).unwrap()
}
pub fn charcoal_local(para_id: ParaId) -> AltairChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "CAIR".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
AltairChainSpec::from_genesis(
"Charcoal Local",
"charcoal_local",
ChainType::Local,
move || {
altair_genesis(
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<altair_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(10000000 * AIR),
para_id,
Default::default(),
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn demo(para_id: ParaId) -> DevelopmentChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DEMO".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
DevelopmentChainSpec::from_genesis(
"Demo Live",
"demo_live",
ChainType::Live,
move || {
development_genesis(
hex!["e0c426785313bb7e712d66dce43ccb81a7eaef373784511fb508fff4b5df3305"].into(),
vec![(
hex!["068f3bd4ed27bb83da8fdebbb4deba6b3b3b83ff47c8abad11e5c48c74c20b11"].into(),
hex!["68d9baaa081802f8ec50d475b654810b158cdcb23e11c43815a6549f78f1b34f"]
.unchecked_into(),
)],
demo_endowed_accounts(),
vec![],
Some(100000000 * CFG),
para_id,
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn development(para_id: ParaId) -> DevelopmentChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DEVEL".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
DevelopmentChainSpec::from_genesis(
"Dev Live",
"devel_live",
ChainType::Live,
move || {
development_genesis(
get_account_id_from_seed::<sr25519::Public>("Alice"),
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<development_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(10000000 * CFG),
para_id,
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
pub fn development_local(para_id: ParaId) -> DevelopmentChainSpec {
let mut properties = Properties::new();
properties.insert("tokenSymbol".into(), "DEVEL".into());
properties.insert("tokenDecimals".into(), currency_decimals::NATIVE.into());
DevelopmentChainSpec::from_genesis(
"Dev Local",
"devel_local",
ChainType::Local,
move || {
development_genesis(
get_account_id_from_seed::<sr25519::Public>("Alice"),
vec![(
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_from_seed::<development_runtime::AuraId>("Alice"),
)],
endowed_accounts(),
endowed_evm_accounts(),
Some(10000000 * CFG),
para_id,
)
},
vec![],
None,
None,
None,
Some(properties),
development_extensions(para_id.into()),
)
}
fn demo_endowed_accounts() -> Vec<cfg_primitives::AccountId> {
vec![
hex!["e0c426785313bb7e712d66dce43ccb81a7eaef373784511fb508fff4b5df3305"].into(),
hex!["068f3bd4ed27bb83da8fdebbb4deba6b3b3b83ff47c8abad11e5c48c74c20b11"].into(),
hex!["2663e968d484dc12c488a5b74107c0c3b6bcf21a6672923b153e4b5a9170a878"].into(),
hex!["7671f8ee2c446ebd2b655ab5380b8004598d9663809cbb372f3de627a0e5eb32"].into(),
hex!["4681744964868d0f210b1161759958390a861b1733c65a6d04ac6b0ffe2f1e42"].into(),
hex!["6ae25829700ff7251861ac4a97235070b3e6e0883ce54ee53aa48400aa28d905"].into(),
hex!["b268e5eee003859659258de82991ce0dc47db15c5b3d32bd050f8b02d350530e"].into(),
hex!["fe110c5ece58c80fc7fb740b95776f9b640ae1c9f0842895a55d2e582e4e1076"].into(),
]
}
fn endowed_accounts() -> Vec<cfg_primitives::AccountId> {
vec![
get_account_id_from_seed::<sr25519::Public>("Alice"),
get_account_id_from_seed::<sr25519::Public>("Bob"),
get_account_id_from_seed::<sr25519::Public>("Charlie"),
get_account_id_from_seed::<sr25519::Public>("Dave"),
get_account_id_from_seed::<sr25519::Public>("Eve"),
get_account_id_from_seed::<sr25519::Public>("Ferdie"),
get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
]
}
fn endowed_evm_accounts() -> Vec<([u8; 20], Option<u64>)> {
vec![(
hex!["7F429e2e38BDeFa7a2E797e3BEB374a3955746a4"],
None,
)]
}
fn council_members_bootstrap() -> Vec<cfg_primitives::AccountId> {
endowed_accounts().into_iter().take(4).collect()
}
fn centrifuge_genesis(
initial_authorities: Vec<(centrifuge_runtime::AccountId, centrifuge_runtime::AuraId)>,
mut endowed_accounts: Vec<centrifuge_runtime::AccountId>,
endowed_evm_accounts: Vec<([u8; 20], Option<u64>)>,
total_issuance: Option<centrifuge_runtime::Balance>,
id: ParaId,
council_members: Vec<centrifuge_runtime::AccountId>,
) -> centrifuge_runtime::GenesisConfig {
let chain_id: u32 = id.into();
endowed_accounts.extend(endowed_evm_accounts.into_iter().map(|(addr, id)| {
let chain_id = id.unwrap_or_else(|| chain_id.into());
AccountConverter::<centrifuge_runtime::Runtime, centrifuge_runtime::LocationToAccountId>::convert_evm_address(chain_id, addr)
}));
let num_endowed_accounts = endowed_accounts.len();
let balances = match total_issuance {
Some(total_issuance) => {
let balance_per_endowed = total_issuance
.checked_div(num_endowed_accounts as centrifuge_runtime::Balance)
.unwrap_or(0 as centrifuge_runtime::Balance);
endowed_accounts
.iter()
.cloned()
.map(|k| (k, balance_per_endowed))
.collect()
}
None => vec![],
};
centrifuge_runtime::GenesisConfig {
system: centrifuge_runtime::SystemConfig {
code: centrifuge_runtime::WASM_BINARY
.expect("WASM binary was not build, please build it!")
.to_vec(),
},
balances: centrifuge_runtime::BalancesConfig { balances },
orml_asset_registry: Default::default(),
orml_tokens: centrifuge_runtime::OrmlTokensConfig { balances: vec![] },
elections: centrifuge_runtime::ElectionsConfig { members: vec![] },
council: centrifuge_runtime::CouncilConfig {
members: council_members,
phantom: Default::default(),
},
fees: centrifuge_runtime::FeesConfig {
initial_fees: vec![(
FeeKey::AnchorsCommit,
2_365_296_803_653,
)],
},
vesting: Default::default(),
parachain_info: centrifuge_runtime::ParachainInfoConfig { parachain_id: id },
collator_selection: centrifuge_runtime::CollatorSelectionConfig {
invulnerables: initial_authorities
.iter()
.cloned()
.map(|(acc, _)| acc)
.collect(),
candidacy_bond: 1 * CFG,
..Default::default()
},
collator_allowlist: Default::default(),
session: centrifuge_runtime::SessionConfig {
keys: initial_authorities
.iter()
.cloned()
.map(|(acc, aura)| {
(
acc.clone(), acc, get_centrifuge_session_keys(aura), )
})
.collect(),
},
aura_ext: Default::default(),
aura: Default::default(),
democracy: Default::default(),
parachain_system: Default::default(),
bridge: centrifuge_runtime::BridgeConfig {
chains: vec![0],
resources: vec![
(
hex!["00000000000000000000000000000009e974040e705c10fb4de576d6cc261900"],
hex!["50616c6c65744272696467652e7472616e73666572"].to_vec(),
),
],
relayers: vec![
hex!["d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"].into(),
hex!["c405224448dcd4259816b09cfedbd8df0e6796b16286ea18efa2d6343da5992e"].into(),
],
threshold: 1,
},
treasury: Default::default(),
block_rewards: centrifuge_runtime::BlockRewardsConfig {
collators: initial_authorities
.iter()
.cloned()
.map(|(acc, _)| acc)
.collect(),
collator_reward: 8_325 * MILLI_CFG,
total_reward: 10_048 * CFG,
},
block_rewards_base: Default::default(),
base_fee: Default::default(),
evm_chain_id: centrifuge_runtime::EVMChainIdConfig {
chain_id: chain_id.into(),
},
ethereum: Default::default(),
evm: centrifuge_runtime::EVMConfig {
accounts: precompile_account_genesis(),
},
liquidity_rewards_base: Default::default(),
polkadot_xcm: centrifuge_runtime::PolkadotXcmConfig {
safe_xcm_version: Some(SAFE_XCM_VERSION),
},
}
}
fn altair_genesis(
initial_authorities: Vec<(altair_runtime::AccountId, altair_runtime::AuraId)>,
mut endowed_accounts: Vec<altair_runtime::AccountId>,
endowed_evm_accounts: Vec<([u8; 20], Option<u64>)>,
total_issuance: Option<altair_runtime::Balance>,
id: ParaId,
council_members: Vec<altair_runtime::AccountId>,
) -> altair_runtime::GenesisConfig {
let chain_id: u32 = id.into();
endowed_accounts.extend(endowed_evm_accounts.into_iter().map(|(addr, id)| {
let chain_id = id.unwrap_or_else(|| chain_id.into());
AccountConverter::<centrifuge_runtime::Runtime, centrifuge_runtime::LocationToAccountId>::convert_evm_address(chain_id, addr)
}));
let num_endowed_accounts = endowed_accounts.len();
let balances = match total_issuance {
Some(total_issuance) => {
let balance_per_endowed = total_issuance
.checked_div(num_endowed_accounts as altair_runtime::Balance)
.unwrap_or(0 as altair_runtime::Balance);
endowed_accounts
.iter()
.cloned()
.map(|k| (k, balance_per_endowed))
.collect()
}
None => vec![],
};
altair_runtime::GenesisConfig {
system: altair_runtime::SystemConfig {
code: altair_runtime::WASM_BINARY
.expect("WASM binary was not build, please build it!")
.to_vec(),
},
balances: altair_runtime::BalancesConfig { balances },
orml_asset_registry: Default::default(),
orml_tokens: altair_runtime::OrmlTokensConfig { balances: vec![] },
elections: altair_runtime::ElectionsConfig { members: vec![] },
council: altair_runtime::CouncilConfig {
members: council_members,
phantom: Default::default(),
},
fees: altair_runtime::FeesConfig {
initial_fees: vec![(
FeeKey::AnchorsCommit,
2_365_296_803_653,
)],
},
vesting: Default::default(),
parachain_info: altair_runtime::ParachainInfoConfig { parachain_id: id },
collator_selection: altair_runtime::CollatorSelectionConfig {
invulnerables: initial_authorities
.iter()
.cloned()
.map(|(acc, _)| acc)
.collect(),
candidacy_bond: 1 * AIR,
..Default::default()
},
block_rewards: altair_runtime::BlockRewardsConfig {
collators: initial_authorities
.iter()
.cloned()
.map(|(acc, _)| acc)
.collect(),
collator_reward: 98_630 * MILLI_AIR,
total_reward: 98_630 * MILLI_AIR * 100,
},
block_rewards_base: Default::default(),
collator_allowlist: Default::default(),
session: altair_runtime::SessionConfig {
keys: initial_authorities
.iter()
.cloned()
.map(|(acc, aura)| {
(
acc.clone(), acc, get_altair_session_keys(aura), )
})
.collect(),
},
aura_ext: Default::default(),
aura: Default::default(),
democracy: Default::default(),
parachain_system: Default::default(),
treasury: Default::default(),
base_fee: Default::default(),
evm_chain_id: altair_runtime::EVMChainIdConfig {
chain_id: chain_id.into(),
},
ethereum: Default::default(),
evm: centrifuge_runtime::EVMConfig {
accounts: precompile_account_genesis(),
},
liquidity_rewards_base: Default::default(),
polkadot_xcm: altair_runtime::PolkadotXcmConfig {
safe_xcm_version: Some(SAFE_XCM_VERSION),
},
}
}
const DEV_USDT_CURRENCY_ID: CurrencyId = CurrencyId::ForeignAsset(1);
const DEV_AUSD_CURRENCY_ID: CurrencyId = CurrencyId::ForeignAsset(2);
fn development_genesis(
root_key: development_runtime::AccountId,
initial_authorities: Vec<(development_runtime::AccountId, development_runtime::AuraId)>,
mut endowed_accounts: Vec<development_runtime::AccountId>,
endowed_evm_accounts: Vec<([u8; 20], Option<u64>)>,
total_issuance: Option<development_runtime::Balance>,
id: ParaId,
) -> development_runtime::GenesisConfig {
let chain_id: u32 = id.into();
endowed_accounts.extend(endowed_evm_accounts.into_iter().map(|(addr, id)| {
let chain_id = id.unwrap_or_else(|| chain_id.into());
AccountConverter::<centrifuge_runtime::Runtime, centrifuge_runtime::LocationToAccountId>::convert_evm_address(chain_id, addr)
}));
let num_endowed_accounts = endowed_accounts.len();
let (balances, token_balances) = match total_issuance {
Some(total_issuance) => {
let balance_per_endowed = total_issuance
.checked_div(num_endowed_accounts as development_runtime::Balance)
.unwrap_or(0 as development_runtime::Balance);
(
endowed_accounts
.iter()
.cloned()
.map(|x| (x, balance_per_endowed))
.collect(),
endowed_accounts
.iter()
.cloned()
.flat_map(|x| {
vec![
(x.clone(), DEV_USDT_CURRENCY_ID, 1_000_000_000_000),
(x, DEV_AUSD_CURRENCY_ID, 1_000_000_000_000_000_000),
]
})
.collect(),
)
}
None => (vec![], vec![]),
};
let chain_id: u32 = id.into();
development_runtime::GenesisConfig {
system: development_runtime::SystemConfig {
code: development_runtime::WASM_BINARY
.expect("WASM binary was not build, please build it!")
.to_vec(),
},
balances: development_runtime::BalancesConfig { balances },
orml_asset_registry: development_runtime::OrmlAssetRegistryConfig {
assets: asset_registry_assets(),
last_asset_id: Default::default(),
},
orml_tokens: development_runtime::OrmlTokensConfig {
balances: token_balances,
},
elections: development_runtime::ElectionsConfig { members: vec![] },
council: development_runtime::CouncilConfig {
members: Default::default(),
phantom: Default::default(),
},
fees: development_runtime::FeesConfig {
initial_fees: vec![(
FeeKey::AnchorsCommit,
2_365_296_803_653,
)],
},
vesting: Default::default(),
sudo: development_runtime::SudoConfig {
key: Some(root_key),
},
parachain_info: development_runtime::ParachainInfoConfig { parachain_id: id },
collator_selection: development_runtime::CollatorSelectionConfig {
invulnerables: initial_authorities
.iter()
.cloned()
.map(|(acc, _)| acc)
.collect(),
candidacy_bond: 1 * CFG,
..Default::default()
},
collator_allowlist: Default::default(),
session: development_runtime::SessionConfig {
keys: initial_authorities
.iter()
.cloned()
.map(|(acc, aura)| {
(
acc.clone(), acc, get_development_session_keys(aura), )
})
.collect(),
},
bridge: development_runtime::BridgeConfig {
chains: vec![0],
resources: vec![
(
hex!["00000000000000000000000000000009e974040e705c10fb4de576d6cc261900"],
hex!["50616c6c65744272696467652e7472616e73666572"].to_vec(),
),
],
relayers: vec![
hex!["d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"].into(),
hex!["c405224448dcd4259816b09cfedbd8df0e6796b16286ea18efa2d6343da5992e"].into(),
],
threshold: 1,
},
aura_ext: Default::default(),
aura: Default::default(),
democracy: Default::default(),
parachain_system: Default::default(),
treasury: Default::default(),
block_rewards: development_runtime::BlockRewardsConfig {
collators: initial_authorities
.iter()
.cloned()
.map(|(acc, _)| acc)
.collect(),
collator_reward: 8_325 * MILLI_CFG,
total_reward: 10_048 * CFG,
},
base_fee: Default::default(),
evm_chain_id: development_runtime::EVMChainIdConfig {
chain_id: chain_id.into(),
},
ethereum: Default::default(),
evm: centrifuge_runtime::EVMConfig {
accounts: precompile_account_genesis(),
},
block_rewards_base: Default::default(),
liquidity_rewards_base: Default::default(),
polkadot_xcm: development_runtime::PolkadotXcmConfig {
safe_xcm_version: Some(SAFE_XCM_VERSION),
},
}
}
fn asset_registry_assets() -> Vec<(CurrencyId, Vec<u8>)> {
vec![
(
DEV_USDT_CURRENCY_ID,
AssetMetadata::<Balance, CustomMetadata> {
decimals: 6,
name: b"Tether USD".to_vec(),
symbol: b"USDT".to_vec(),
existential_deposit: 0u128,
location: Some(xcm::VersionedMultiLocation::V3(MultiLocation {
parents: 1,
interior: X3(
Parachain(parachains::rococo::rocksmine::ID),
PalletInstance(parachains::rococo::rocksmine::usdt::PALLET_INSTANCE),
GeneralIndex(parachains::rococo::rocksmine::usdt::GENERAL_INDEX),
),
})),
additional: CustomMetadata {
mintable: false,
permissioned: false,
pool_currency: true,
transferability: CrossChainTransferability::Xcm(Default::default()),
},
}
.encode(),
),
(
DEV_AUSD_CURRENCY_ID,
AssetMetadata::<Balance, CustomMetadata> {
decimals: 12,
name: b"Acala USD".to_vec(),
symbol: b"AUSD".to_vec(),
existential_deposit: 0u128,
location: Some(xcm::VersionedMultiLocation::V3(MultiLocation {
parents: 1,
interior: X2(
Parachain(parachains::rococo::acala::ID),
GeneralKey {
length: parachains::rococo::acala::AUSD_KEY.to_vec().len() as u8,
data: vec_to_fixed_array(parachains::rococo::acala::AUSD_KEY.to_vec()),
},
),
})),
additional: CustomMetadata {
mintable: false,
permissioned: false,
pool_currency: true,
transferability: CrossChainTransferability::Xcm(Default::default()),
},
}
.encode(),
),
(
CURRENCY_ID_LP_ETH_GOERLI,
lp_wrapped_usdc_metadata(
"LP Ethereum Wrapped USDC".as_bytes().to_vec(),
"LpEthUSDC".as_bytes().to_vec(),
development_runtime::liquidity_pools::LiquidityPoolsPalletIndex::get(),
CHAIN_ID_ETH_GOERLI_TESTNET,
CONTRACT_ETH_GOERLI,
true,
)
.encode(),
),
]
}
fn precompile_account_genesis() -> BTreeMap<H160, fp_evm::GenesisAccount> {
use fp_evm::GenesisAccount;
use runtime_common::evm::precompile::*;
let mut map = BTreeMap::new();
let to_genesis_account = |code: [u8; 5]| -> GenesisAccount {
GenesisAccount {
nonce: U256::zero(),
balance: U256::zero(),
storage: BTreeMap::new(),
code: code.to_vec(),
}
};
map.insert(
H160::from(ECRECOVER_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(SHA256_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(RIPEMD160_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(IDENTITY_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(MODEXP_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(BN128ADD_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(BN128MUL_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(BN128PAIRING_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(BLAKE2F_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(SHA3FIPS256_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(DISPATCH_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(ECRECOVERPUBLICKEY_ADDR),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map.insert(
H160::from(LP_AXELAR_GATEWAY),
to_genesis_account(PRECOMPILE_CODE_STORAGE),
);
map
}