use codec::{Decode, Encode};
use grandpa::AuthorityId as GrandpaId;
use pallet_asset::{ClassicTickerImport, TickerRegistrationConfig};
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
use pallet_staking::StakerStatus;
use polymesh_common_utilities::{constants::currency::POLY, protocol_fee::ProtocolOp, GC_DID};
use polymesh_primitives::{
AccountId, IdentityId, InvestorUid, Moment, PosRatio, Signatory, Signature, SmartExtensionType,
Ticker,
};
use sc_chain_spec::ChainType;
use sc_service::Properties;
use sc_telemetry::TelemetryEndpoints;
use serde_json::json;
use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
use sp_consensus_babe::AuthorityId as BabeId;
use sp_core::{sr25519, Pair, Public};
use sp_runtime::{
traits::{IdentifyAccount, Verify},
PerThing,
};
#[cfg(feature = "std")]
use sp_runtime::{Deserialize, Serialize};
use std::convert::TryInto;
const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polymesh.live/submit/";
type AccountPublic = <Signature as Verify>::Signer;
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()
}
pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
where
AccountPublic: From<<TPublic::Pair as Pair>::Public>,
{
AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
}
fn seeded_acc_id(seed: &str) -> AccountId {
get_account_id_from_seed::<sr25519::Public>(seed)
}
pub fn get_authority_keys_from_seed(seed: &str, uniq: bool) -> InitialAuth {
if uniq {
(
seeded_acc_id(&format!("{}//stash", seed)),
seeded_acc_id(seed),
get_from_seed::<GrandpaId>(&format!("{}//gran", seed)),
get_from_seed::<BabeId>(&format!("{}//babe", seed)),
get_from_seed::<ImOnlineId>(&format!("{}//imon", seed)),
get_from_seed::<AuthorityDiscoveryId>(&format!("{}//auth", seed)),
)
} else {
(
seeded_acc_id(&format!("{}//stash", seed)),
seeded_acc_id(seed),
get_from_seed::<GrandpaId>(seed),
get_from_seed::<BabeId>(seed),
get_from_seed::<ImOnlineId>(seed),
get_from_seed::<AuthorityDiscoveryId>(seed),
)
}
}
fn polymath_props() -> Properties {
json!({ "ss58Format": 12, "tokenDecimals": 6, "tokenSymbol": "POLYX" })
.as_object()
.unwrap()
.clone()
}
macro_rules! session_keys {
() => {
fn session_keys(
grandpa: GrandpaId,
babe: BabeId,
im_online: ImOnlineId,
authority_discovery: AuthorityDiscoveryId,
) -> rt::SessionKeys {
rt::SessionKeys {
babe,
grandpa,
im_online,
authority_discovery,
}
}
};
}
macro_rules! asset {
() => {
pallet_asset::GenesisConfig {
ticker_registration_config: ticker_registration_config(),
classic_migration_tconfig: TickerRegistrationConfig {
max_ticker_length: 12,
registration_length: Some(1640995199999),
},
versions: vec![
(SmartExtensionType::TransferManager, 5000),
(SmartExtensionType::Offerings, 5000),
(SmartExtensionType::SmartWallet, 5000),
],
classic_migration_contract_did: IdentityId::from(1),
classic_migration_tickers: classic_reserved_tickers(),
reserved_country_currency_codes: currency_codes(),
}
};
}
fn ticker_registration_config() -> TickerRegistrationConfig<Moment> {
TickerRegistrationConfig {
max_ticker_length: 12,
registration_length: Some(5_184_000_000),
}
}
fn currency_codes() -> Vec<Ticker> {
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
#[derive(Encode, Decode, Clone, Debug, PartialEq, Eq)]
pub struct FiatCurrency<String> {
pub codes: Vec<String>,
}
let currency_file = include_str!("data/currency_symbols.json");
let currency_data: FiatCurrency<String> = serde_json::from_str(¤cy_file).unwrap();
currency_data
.codes
.into_iter()
.map(|y| y.as_bytes().try_into().unwrap())
.collect()
}
#[allow(unreachable_code)]
fn classic_reserved_tickers() -> Vec<ClassicTickerImport> {
#[cfg(feature = "runtime-benchmarks")]
return Vec::new();
let reserved_tickers_file = include_str!("data/reserved_classic_tickers.json");
serde_json::from_str(&reserved_tickers_file).unwrap()
}
macro_rules! checkpoint {
() => {{
use polymesh_primitives::calendar::{CalendarPeriod, CalendarUnit::Week};
let period = CalendarPeriod {
unit: Week,
amount: 1,
};
pallet_asset::checkpoint::GenesisConfig {
schedules_max_complexity: period.complexity(),
}
}};
}
type Identity = (
AccountId,
IdentityId,
IdentityId,
InvestorUid,
Option<Moment>,
);
type InitialAuth = (
AccountId,
AccountId,
GrandpaId,
BabeId,
ImOnlineId,
AuthorityDiscoveryId,
);
fn adjust_last<'a>(bytes: &'a mut [u8], n: u8) -> &'a str {
bytes[bytes.len() - 1] = n + b'0';
core::str::from_utf8(bytes).unwrap()
}
fn cdd_provider(n: u8) -> Identity {
(
seeded_acc_id(adjust_last(&mut { *b"cdd_provider_0" }, n)),
IdentityId::from(n as u128),
IdentityId::from(n as u128),
InvestorUid::from(adjust_last(&mut { *b"uid0" }, n).as_bytes()),
None,
)
}
fn gc_mem(n: u8) -> Identity {
(
seeded_acc_id(adjust_last(&mut { *b"governance_committee_0" }, n)),
IdentityId::from(1 as u128),
IdentityId::from(2 + n as u128),
InvestorUid::from(adjust_last(&mut { *b"uid3" }, n)),
None,
)
}
fn polymath_mem(n: u8) -> Identity {
(
seeded_acc_id(adjust_last(&mut { *b"polymath_0" }, n)),
IdentityId::from(1 as u128),
IdentityId::from(2 + n as u128),
InvestorUid::from(adjust_last(&mut { *b"uid3" }, n)),
None,
)
}
const STASH: u128 = 5_000_000 * POLY;
const ENDOWMENT: u128 = 100_000_000 * POLY;
fn identities(
initial_authorities: &[InitialAuth],
initial_identities: &[Identity],
) -> (
Vec<(
IdentityId,
AccountId,
AccountId,
u128,
StakerStatus<AccountId>,
)>,
Vec<Identity>,
Vec<(AccountId, IdentityId)>,
) {
let num_initial_identities = initial_identities.len() as u128;
let mut identity_counter = num_initial_identities;
let authority_identities = initial_authorities
.iter()
.map(|x| {
identity_counter += 1;
let did = IdentityId::from(identity_counter);
let investor_uid = InvestorUid::from(did.as_ref());
(x.1.clone(), IdentityId::from(1), did, investor_uid, None)
})
.collect::<Vec<_>>();
let all_identities = initial_identities
.iter()
.cloned()
.chain(authority_identities.iter().cloned())
.collect::<Vec<_>>();
identity_counter = num_initial_identities;
let secondary_keys = initial_authorities
.iter()
.map(|x| {
identity_counter += 1;
(x.0.clone(), IdentityId::from(identity_counter))
})
.collect::<Vec<_>>();
let stakers = authority_identities
.iter()
.cloned()
.zip(initial_authorities.iter().cloned())
.map(|((_, _, did, ..), x)| {
(
did,
x.0.clone(),
x.1.clone(),
STASH,
pallet_staking::StakerStatus::Validator,
)
})
.collect::<Vec<_>>();
(stakers, all_identities, secondary_keys)
}
fn balances(inits: &[InitialAuth], endoweds: &[AccountId]) -> Vec<(AccountId, u128)> {
endoweds
.iter()
.map(|k: &AccountId| (k.clone(), ENDOWMENT))
.chain(inits.iter().map(|x| (x.1.clone(), ENDOWMENT)))
.chain(inits.iter().map(|x| (x.0.clone(), STASH)))
.collect()
}
fn bridge_signers() -> Vec<Signatory<AccountId>> {
let signer =
|seed| Signatory::Account(AccountId::from(get_from_seed::<sr25519::Public>(seed).0));
vec![
signer("relay_1"),
signer("relay_2"),
signer("relay_3"),
signer("relay_4"),
signer("relay_5"),
]
}
fn frame(wasm_binary: Option<&[u8]>) -> frame_system::GenesisConfig {
frame_system::GenesisConfig {
code: wasm_binary.expect("WASM binary was not generated").to_vec(),
changes_trie_config: Default::default(),
}
}
macro_rules! session {
($inits:expr, $build:expr) => {
pallet_session::GenesisConfig {
keys: $inits
.iter()
.map(|x| {
let sks = $build(x.2.clone(), x.3.clone(), x.4.clone(), x.5.clone());
(x.0.clone(), x.0.clone(), sks)
})
.collect::<Vec<_>>(),
}
};
}
macro_rules! staking {
($auths:expr, $stakers:expr, $cap:expr) => {
pallet_staking::GenesisConfig {
minimum_validator_count: 1,
validator_count: $auths.len() as u32,
validator_commission_cap: $cap,
stakers: $stakers,
invulnerables: $auths.iter().map(|x| x.0.clone()).collect(),
slash_reward_fraction: sp_runtime::Perbill::from_percent(10),
min_bond_threshold: 5_000_000_000_000,
..Default::default()
}
};
}
macro_rules! pips {
($period:expr, $limit: expr) => {
pallet_pips::GenesisConfig {
prune_historical_pips: false,
min_proposal_deposit: 0,
default_enactment_period: $period,
max_pip_skip_count: 1,
active_pip_limit: $limit,
pending_pip_expiry: <_>::default(),
}
};
}
macro_rules! cdd_membership {
($($member:expr),*) => {
pallet_group::GenesisConfig {
active_members_limit: u32::MAX,
active_members: vec![$(IdentityId::from($member)),*, GC_DID],
phantom: Default::default(),
}
};
}
macro_rules! committee_membership {
($($member:expr),*) => {
pallet_group::GenesisConfig {
active_members_limit: 20,
active_members: vec![$(IdentityId::from($member)),*],
phantom: Default::default(),
}
};
}
macro_rules! corporate_actions {
() => {
pallet_corporate_actions::GenesisConfig {
max_details_length: 1024,
}
};
}
macro_rules! committee {
($rc:expr) => {
committee!($rc, (1, 2))
};
($rc:expr, $vote:expr) => {
pallet_committee::GenesisConfig {
vote_threshold: $vote,
members: vec![],
release_coordinator: IdentityId::from($rc),
expires_after: <_>::default(),
phantom: Default::default(),
}
};
}
fn protocol_fees() -> Vec<(ProtocolOp, u128)> {
vec![
(ProtocolOp::AssetCreateAsset, 10_000 * 1_000_000),
(ProtocolOp::AssetRegisterTicker, 2_500 * 1_000_000),
]
}
macro_rules! protocol_fee {
() => {
pallet_protocol_fee::GenesisConfig {
base_fees: protocol_fees(),
coefficient: PosRatio(1, 1),
}
};
}
pub mod general {
use super::*;
use polymesh_runtime_develop::{self as rt, constants::time};
pub type ChainSpec = sc_service::GenericChainSpec<rt::runtime::GenesisConfig>;
session_keys!();
fn genesis(
initial_authorities: Vec<InitialAuth>,
root_key: AccountId,
endowed_accounts: Vec<AccountId>,
enable_println: bool,
) -> rt::runtime::GenesisConfig {
let init_ids = [
cdd_provider(1),
cdd_provider(2),
gc_mem(1),
gc_mem(2),
gc_mem(3),
];
let (stakers, all_identities, secondary_keys) = identities(&initial_authorities, &init_ids);
rt::runtime::GenesisConfig {
frame_system: Some(frame(rt::WASM_BINARY)),
pallet_asset: Some(asset!()),
pallet_checkpoint: Some(checkpoint!()),
pallet_identity: Some(pallet_identity::GenesisConfig {
identities: all_identities,
secondary_keys,
..Default::default()
}),
pallet_balances: Some(pallet_balances::GenesisConfig {
balances: balances(&initial_authorities, &endowed_accounts),
}),
pallet_bridge: Some(pallet_bridge::GenesisConfig {
admin: initial_authorities[0].1.clone(),
creator: initial_authorities[0].1.clone(),
signatures_required: 1,
signers: bridge_signers(),
timelock: 10,
bridge_limit: (100_000_000 * POLY, 1000),
}),
pallet_indices: Some(pallet_indices::GenesisConfig { indices: vec![] }),
pallet_sudo: Some(pallet_sudo::GenesisConfig { key: root_key }),
pallet_session: Some(session!(initial_authorities, session_keys)),
pallet_staking: Some(staking!(
initial_authorities,
stakers,
PerThing::from_rational_approximation(1u64, 4u64)
)),
pallet_pips: Some(pips!(time::MINUTES, 25)),
pallet_im_online: Some(Default::default()),
pallet_authority_discovery: Some(Default::default()),
pallet_babe: Some(Default::default()),
pallet_grandpa: Some(Default::default()),
pallet_contracts: Some(pallet_contracts::GenesisConfig {
current_schedule: pallet_contracts::Schedule {
enable_println,
..Default::default()
},
}),
pallet_group_Instance1: Some(committee_membership!(3, 4, 5, 6)),
pallet_committee_Instance1: Some(committee!(6)),
pallet_group_Instance2: Some(cdd_membership!(1, 2, 6)),
pallet_group_Instance3: Some(committee_membership!(3)),
pallet_committee_Instance3: Some(committee!(3)),
pallet_group_Instance4: Some(committee_membership!(4)),
pallet_committee_Instance4: Some(committee!(4)),
pallet_protocol_fee: Some(protocol_fee!()),
pallet_settlement: Some(Default::default()),
pallet_multisig: Some(pallet_multisig::GenesisConfig {
transaction_version: 1,
}),
pallet_corporate_actions: Some(corporate_actions!()),
}
}
fn develop_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![get_authority_keys_from_seed("Alice", false)],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("Bob"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
true,
)
}
fn config(
name: &str,
id: &str,
ctype: ChainType,
genesis: impl 'static + Sync + Send + Fn() -> rt::runtime::GenesisConfig,
) -> ChainSpec {
let props = Some(polymath_props());
ChainSpec::from_genesis(name, id, ctype, genesis, vec![], None, None, props, None)
}
pub fn develop_config() -> ChainSpec {
config(
"Development",
"dev",
ChainType::Development,
develop_genesis,
)
}
fn local_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![
get_authority_keys_from_seed("Alice", false),
get_authority_keys_from_seed("Bob", false),
],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("Charlie"),
seeded_acc_id("Dave"),
seeded_acc_id("Charlie//stash"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
true,
)
}
pub fn local_config() -> ChainSpec {
config(
"Local Development",
"local_dev",
ChainType::Local,
local_genesis,
)
}
}
pub mod alcyone_testnet {
use super::*;
use polymesh_runtime_testnet::{self as rt, constants::time};
pub type ChainSpec = sc_service::GenericChainSpec<rt::runtime::GenesisConfig>;
session_keys!();
fn genesis(
initial_authorities: Vec<InitialAuth>,
root_key: AccountId,
endowed_accounts: Vec<AccountId>,
enable_println: bool,
) -> rt::runtime::GenesisConfig {
let init_ids = [
cdd_provider(1),
cdd_provider(2),
polymath_mem(1),
polymath_mem(2),
polymath_mem(3),
];
let (stakers, all_identities, secondary_keys) = identities(&initial_authorities, &init_ids);
rt::runtime::GenesisConfig {
frame_system: Some(frame(rt::WASM_BINARY)),
pallet_asset: Some(asset!()),
pallet_checkpoint: Some(checkpoint!()),
pallet_identity: Some(pallet_identity::GenesisConfig {
identities: all_identities,
secondary_keys,
..Default::default()
}),
pallet_balances: Some(pallet_balances::GenesisConfig {
balances: balances(&initial_authorities, &endowed_accounts),
}),
pallet_bridge: Some(pallet_bridge::GenesisConfig {
admin: seeded_acc_id("polymath_1"),
creator: seeded_acc_id("polymath_1"),
signatures_required: 3,
signers: bridge_signers(),
timelock: time::MINUTES * 15,
bridge_limit: (30_000_000_000, time::DAYS),
}),
pallet_indices: Some(pallet_indices::GenesisConfig { indices: vec![] }),
pallet_sudo: Some(pallet_sudo::GenesisConfig { key: root_key }),
pallet_session: Some(session!(initial_authorities, session_keys)),
pallet_staking: Some(staking!(initial_authorities, stakers, PerThing::zero())),
pallet_pips: Some(pips!(time::DAYS * 7, 1000)),
pallet_im_online: Some(Default::default()),
pallet_authority_discovery: Some(Default::default()),
pallet_babe: Some(Default::default()),
pallet_grandpa: Some(Default::default()),
pallet_contracts: Some(pallet_contracts::GenesisConfig {
current_schedule: pallet_contracts::Schedule {
enable_println,
..Default::default()
},
}),
pallet_group_Instance1: Some(committee_membership!(3, 4, 5)),
pallet_committee_Instance1: Some(committee!(3, (2, 3))),
pallet_group_Instance2: Some(cdd_membership!(1, 2, 3)),
pallet_group_Instance3: Some(committee_membership!(3)),
pallet_committee_Instance3: Some(committee!(3)),
pallet_group_Instance4: Some(committee_membership!(3)),
pallet_committee_Instance4: Some(committee!(3)),
pallet_protocol_fee: Some(protocol_fee!()),
pallet_settlement: Some(Default::default()),
pallet_multisig: Some(pallet_multisig::GenesisConfig {
transaction_version: 1,
}),
pallet_corporate_actions: Some(corporate_actions!()),
}
}
fn develop_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![get_authority_keys_from_seed("Alice", false)],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("Bob"),
seeded_acc_id("Bob//stash"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
true,
)
}
pub fn develop_config() -> ChainSpec {
let boot_nodes = vec![];
ChainSpec::from_genesis(
"Polymesh Alcyone Develop",
"dev_alcyone",
ChainType::Development,
develop_genesis,
boot_nodes,
None,
None,
Some(polymath_props()),
Default::default(),
)
}
fn local_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![
get_authority_keys_from_seed("Alice", false),
get_authority_keys_from_seed("Bob", false),
],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("Charlie"),
seeded_acc_id("Dave"),
seeded_acc_id("Charlie//stash"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
true,
)
}
pub fn local_config() -> ChainSpec {
let boot_nodes = vec![];
ChainSpec::from_genesis(
"Polymesh Alcyone Local",
"local_alcyone",
ChainType::Local,
local_genesis,
boot_nodes,
None,
None,
Some(polymath_props()),
Default::default(),
)
}
}
pub mod polymesh_mainnet {
use super::*;
use polymesh_runtime_mainnet::{self as rt, constants::time};
pub type ChainSpec = sc_service::GenericChainSpec<rt::runtime::GenesisConfig>;
session_keys!();
fn genesis(
initial_authorities: Vec<InitialAuth>,
root_key: AccountId,
endowed_accounts: Vec<AccountId>,
enable_println: bool,
) -> rt::runtime::GenesisConfig {
let init_ids = [
cdd_provider(1),
cdd_provider(2),
polymath_mem(1),
polymath_mem(2),
polymath_mem(3),
];
let (stakers, all_identities, secondary_keys) = identities(&initial_authorities, &init_ids);
rt::runtime::GenesisConfig {
frame_system: Some(frame(rt::WASM_BINARY)),
pallet_asset: Some(asset!()),
pallet_checkpoint: Some(checkpoint!()),
pallet_identity: Some(pallet_identity::GenesisConfig {
identities: all_identities,
secondary_keys,
..Default::default()
}),
pallet_balances: Some(pallet_balances::GenesisConfig {
balances: balances(&initial_authorities, &endowed_accounts),
}),
pallet_bridge: Some(pallet_bridge::GenesisConfig {
admin: seeded_acc_id("polymath_1"),
creator: seeded_acc_id("polymath_1"),
signatures_required: 3,
signers: bridge_signers(),
timelock: time::MINUTES * 15,
bridge_limit: (30_000_000_000, time::DAYS),
}),
pallet_indices: Some(pallet_indices::GenesisConfig { indices: vec![] }),
pallet_sudo: Some(pallet_sudo::GenesisConfig { key: root_key }),
pallet_session: Some(session!(initial_authorities, session_keys)),
pallet_staking: Some(staking!(initial_authorities, stakers, PerThing::zero())),
pallet_pips: Some(pips!(time::DAYS * 7, 1000)),
pallet_im_online: Some(Default::default()),
pallet_authority_discovery: Some(Default::default()),
pallet_babe: Some(Default::default()),
pallet_grandpa: Some(Default::default()),
pallet_contracts: Some(pallet_contracts::GenesisConfig {
current_schedule: pallet_contracts::Schedule {
enable_println,
..Default::default()
},
}),
pallet_group_Instance1: Some(committee_membership!(3, 4, 5)),
pallet_committee_Instance1: Some(committee!(3, (2, 3))),
pallet_group_Instance2: Some(cdd_membership!(1, 2, 3)),
pallet_group_Instance3: Some(committee_membership!(3)),
pallet_committee_Instance3: Some(committee!(3)),
pallet_group_Instance4: Some(committee_membership!(3)),
pallet_committee_Instance4: Some(committee!(3)),
pallet_protocol_fee: Some(protocol_fee!()),
pallet_settlement: Some(Default::default()),
pallet_multisig: Some(pallet_multisig::GenesisConfig {
transaction_version: 1,
}),
pallet_corporate_actions: Some(corporate_actions!()),
}
}
fn bootstrap_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![
get_authority_keys_from_seed("Alice", false),
get_authority_keys_from_seed("Bob", false),
get_authority_keys_from_seed("Charlie", false),
],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("cdd_provider_1"),
seeded_acc_id("cdd_provider_2"),
seeded_acc_id("polymath_1"),
seeded_acc_id("polymath_2"),
seeded_acc_id("polymath_3"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
false,
)
}
pub fn bootstrap_config() -> ChainSpec {
let boot_nodes = vec![
"/dns4/buffron-bootnode-1.polymesh.live/tcp/30333/p2p/12D3KooWAhsJHrHJ5Wk5v6sensyjJu2afJFanq4acxbMqhWje2pw".parse().expect("Unable to parse bootnode"),
"/dns4/buffron-bootnode-2.polymesh.live/tcp/30333/p2p/12D3KooWQZ1mfWzKAzK5eXMqk4qupQqTshtWFSiSbhKS5D6Ycz1M".parse().expect("Unable to parse bootnode"),
];
ChainSpec::from_genesis(
"Polymesh Mainnet",
"mainnet",
ChainType::Live,
bootstrap_genesis,
boot_nodes,
Some(
TelemetryEndpoints::new(vec![(STAGING_TELEMETRY_URL.to_string(), 0)])
.expect("Mainnet bootstrap telemetry url is valid; qed"),
),
Some(&*"/polymath/mainnet/1"),
Some(polymath_props()),
Default::default(),
)
}
fn develop_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![get_authority_keys_from_seed("Alice", false)],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("Bob"),
seeded_acc_id("Bob//stash"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
true,
)
}
pub fn develop_config() -> ChainSpec {
let boot_nodes = vec![];
ChainSpec::from_genesis(
"Polymesh Mainnet Develop",
"dev_mainnet",
ChainType::Development,
develop_genesis,
boot_nodes,
None,
None,
Some(polymath_props()),
Default::default(),
)
}
fn local_genesis() -> rt::runtime::GenesisConfig {
genesis(
vec![
get_authority_keys_from_seed("Alice", false),
get_authority_keys_from_seed("Bob", false),
],
seeded_acc_id("Alice"),
vec![
seeded_acc_id("Charlie"),
seeded_acc_id("Dave"),
seeded_acc_id("Charlie//stash"),
seeded_acc_id("relay_1"),
seeded_acc_id("relay_2"),
seeded_acc_id("relay_3"),
seeded_acc_id("relay_4"),
seeded_acc_id("relay_5"),
],
true,
)
}
pub fn local_config() -> ChainSpec {
let boot_nodes = vec![];
ChainSpec::from_genesis(
"Polymesh Mainnet Local",
"local_mainnet",
ChainType::Local,
local_genesis,
boot_nodes,
None,
None,
Some(polymath_props()),
Default::default(),
)
}
}