git.delta.rocks / unique-network / refs/commits / c8aac156edde

5193source = "registry+https://github.com/rust-lang/crates.io-index"5193source = "registry+https://github.com/rust-lang/crates.io-index"
5194checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"5194checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"
5195
5196[[package]]
5197name = "opal-runtime"
5198version = "0.1.0"
5199dependencies = [
5200 "cumulus-pallet-aura-ext",
5201 "cumulus-pallet-dmp-queue",
5202 "cumulus-pallet-parachain-system",
5203 "cumulus-pallet-xcm",
5204 "cumulus-pallet-xcmp-queue",
5205 "cumulus-primitives-core",
5206 "cumulus-primitives-timestamp",
5207 "cumulus-primitives-utility",
5208 "derivative",
5209 "fp-rpc",
5210 "fp-self-contained",
5211 "frame-benchmarking",
5212 "frame-executive",
5213 "frame-support",
5214 "frame-system",
5215 "frame-system-benchmarking",
5216 "frame-system-rpc-runtime-api",
5217 "hex-literal",
5218 "orml-vesting",
5219 "pallet-aura",
5220 "pallet-balances",
5221 "pallet-base-fee",
5222 "pallet-common",
5223 "pallet-ethereum",
5224 "pallet-evm",
5225 "pallet-evm-coder-substrate",
5226 "pallet-evm-contract-helpers",
5227 "pallet-evm-migration",
5228 "pallet-evm-transaction-payment",
5229 "pallet-fungible",
5230 "pallet-inflation",
5231 "pallet-nonfungible",
5232 "pallet-randomness-collective-flip",
5233 "pallet-refungible",
5234 "pallet-sudo",
5235 "pallet-template-transaction-payment",
5236 "pallet-timestamp",
5237 "pallet-transaction-payment",
5238 "pallet-transaction-payment-rpc-runtime-api",
5239 "pallet-treasury",
5240 "pallet-unique",
5241 "pallet-unq-scheduler",
5242 "pallet-xcm",
5243 "parachain-info",
5244 "parity-scale-codec",
5245 "polkadot-parachain",
5246 "scale-info",
5247 "serde",
5248 "smallvec",
5249 "sp-api",
5250 "sp-arithmetic",
5251 "sp-block-builder",
5252 "sp-consensus-aura",
5253 "sp-core",
5254 "sp-inherents",
5255 "sp-io",
5256 "sp-offchain",
5257 "sp-runtime",
5258 "sp-session",
5259 "sp-std",
5260 "sp-transaction-pool",
5261 "sp-version",
5262 "substrate-wasm-builder",
5263 "unique-runtime-common",
5264 "up-data-structs",
5265 "up-evm-mapping",
5266 "up-rpc",
5267 "xcm",
5268 "xcm-builder",
5269 "xcm-executor",
5270]
51955271
5196[[package]]5272[[package]]
5197name = "opaque-debug"5273name = "opaque-debug"
8259 "cc",8335 "cc",
8260]8336]
8337
8338[[package]]
8339name = "quartz-runtime"
8340version = "0.1.0"
8341dependencies = [
8342 "cumulus-pallet-aura-ext",
8343 "cumulus-pallet-dmp-queue",
8344 "cumulus-pallet-parachain-system",
8345 "cumulus-pallet-xcm",
8346 "cumulus-pallet-xcmp-queue",
8347 "cumulus-primitives-core",
8348 "cumulus-primitives-timestamp",
8349 "cumulus-primitives-utility",
8350 "derivative",
8351 "fp-rpc",
8352 "fp-self-contained",
8353 "frame-benchmarking",
8354 "frame-executive",
8355 "frame-support",
8356 "frame-system",
8357 "frame-system-benchmarking",
8358 "frame-system-rpc-runtime-api",
8359 "hex-literal",
8360 "orml-vesting",
8361 "pallet-aura",
8362 "pallet-balances",
8363 "pallet-base-fee",
8364 "pallet-common",
8365 "pallet-ethereum",
8366 "pallet-evm",
8367 "pallet-evm-coder-substrate",
8368 "pallet-evm-contract-helpers",
8369 "pallet-evm-migration",
8370 "pallet-evm-transaction-payment",
8371 "pallet-fungible",
8372 "pallet-inflation",
8373 "pallet-nonfungible",
8374 "pallet-randomness-collective-flip",
8375 "pallet-refungible",
8376 "pallet-sudo",
8377 "pallet-template-transaction-payment",
8378 "pallet-timestamp",
8379 "pallet-transaction-payment",
8380 "pallet-transaction-payment-rpc-runtime-api",
8381 "pallet-treasury",
8382 "pallet-unique",
8383 "pallet-unq-scheduler",
8384 "pallet-xcm",
8385 "parachain-info",
8386 "parity-scale-codec",
8387 "polkadot-parachain",
8388 "scale-info",
8389 "serde",
8390 "smallvec",
8391 "sp-api",
8392 "sp-arithmetic",
8393 "sp-block-builder",
8394 "sp-consensus-aura",
8395 "sp-core",
8396 "sp-inherents",
8397 "sp-io",
8398 "sp-offchain",
8399 "sp-runtime",
8400 "sp-session",
8401 "sp-std",
8402 "sp-transaction-pool",
8403 "sp-version",
8404 "substrate-wasm-builder",
8405 "unique-runtime-common",
8406 "up-data-structs",
8407 "up-evm-mapping",
8408 "up-rpc",
8409 "xcm",
8410 "xcm-builder",
8411 "xcm-executor",
8412]
82618413
8262[[package]]8414[[package]]
8263name = "quick-error"8415name = "quick-error"
11787 "jsonrpc-core",11939 "jsonrpc-core",
11788 "jsonrpc-pubsub",11940 "jsonrpc-pubsub",
11789 "log",11941 "log",
11942 "opal-runtime",
11790 "pallet-ethereum",11943 "pallet-ethereum",
11791 "pallet-transaction-payment-rpc",11944 "pallet-transaction-payment-rpc",
11945 "pallet-transaction-payment-rpc-runtime-api",
11792 "parity-scale-codec",11946 "parity-scale-codec",
11793 "parking_lot 0.11.2",11947 "parking_lot 0.11.2",
11794 "polkadot-cli",11948 "polkadot-cli",
11795 "polkadot-parachain",11949 "polkadot-parachain",
11796 "polkadot-primitives",11950 "polkadot-primitives",
11797 "polkadot-service",11951 "polkadot-service",
11798 "polkadot-test-service",11952 "polkadot-test-service",
11953 "quartz-runtime",
11799 "sc-basic-authorship",11954 "sc-basic-authorship",
11800 "sc-chain-spec",11955 "sc-chain-spec",
11801 "sc-cli",11956 "sc-cli",
11834 "substrate-prometheus-endpoint",11989 "substrate-prometheus-endpoint",
11835 "unique-rpc",11990 "unique-rpc",
11836 "unique-runtime",11991 "unique-runtime",
11992 "unique-runtime-common",
11837 "up-data-structs",11993 "up-data-structs",
11994 "up-rpc",
11838]11995]
1183911996
11840[[package]]11997[[package]]
11849 "futures 0.3.21",12006 "futures 0.3.21",
11850 "jsonrpc-core",12007 "jsonrpc-core",
11851 "jsonrpc-pubsub",12008 "jsonrpc-pubsub",
12009 "pallet-common",
11852 "pallet-ethereum",12010 "pallet-ethereum",
11853 "pallet-transaction-payment-rpc",12011 "pallet-transaction-payment-rpc",
11854 "pallet-transaction-payment-rpc-runtime-api",12012 "pallet-transaction-payment-rpc-runtime-api",
11864 "sc-rpc-api",12022 "sc-rpc-api",
11865 "sc-service",12023 "sc-service",
11866 "sc-transaction-pool",12024 "sc-transaction-pool",
12025 "serde",
11867 "sp-api",12026 "sp-api",
11868 "sp-block-builder",12027 "sp-block-builder",
11869 "sp-blockchain",12028 "sp-blockchain",
11878 "substrate-frame-rpc-system",12037 "substrate-frame-rpc-system",
11879 "tokio 0.2.25",12038 "tokio 0.2.25",
11880 "uc-rpc",12039 "uc-rpc",
11881 "unique-runtime",12040 "unique-runtime-common",
11882 "up-rpc",12041 "up-rpc",
11883]12042]
1188412043
11949 "sp-transaction-pool",12108 "sp-transaction-pool",
11950 "sp-version",12109 "sp-version",
11951 "substrate-wasm-builder",12110 "substrate-wasm-builder",
12111 "unique-runtime-common",
11952 "up-data-structs",12112 "up-data-structs",
11953 "up-evm-mapping",12113 "up-evm-mapping",
11954 "up-rpc",12114 "up-rpc",
11957 "xcm-executor",12117 "xcm-executor",
11958]12118]
12119
12120[[package]]
12121name = "unique-runtime-common"
12122version = "0.1.0"
12123dependencies = [
12124 "fp-rpc",
12125 "frame-support",
12126 "frame-system",
12127 "pallet-common",
12128 "parity-scale-codec",
12129 "scale-info",
12130 "sp-consensus-aura",
12131 "sp-core",
12132 "sp-runtime",
12133]
1195912134
11960[[package]]12135[[package]]
11961name = "universal-hash"12136name = "universal-hash"

5    'pallets/*',5    'pallets/*',
6    'client/*',6    'client/*',
7    'primitives/*',7    'primitives/*',
8    'runtime',8    'runtime/*',
9    'crates/*',9    'crates/*',
10]10]
11[profile.release]11[profile.release]

27-   [Unique Wallet and UI](https://uniqueapps.usetech.com/#/nft)27-   [Unique Wallet and UI](https://uniqueapps.usetech.com/#/nft)
28-   [NFT Asset for Unity Framework](https://github.com/usetech-llc/nft_unity)28-   [NFT Asset for Unity Framework](https://github.com/usetech-llc/nft_unity)
2929
30Please see our [walk-thorugh instructions](doc/hackusama_walk_through.md) to try everything out!30Please see our [walk-through instructions](doc/hackusama_walk_through.md) to try everything out!
3131
32## Application Development32## Application Development
3333
158```158```
159assetRegistry -> registerForeignAsset(location, metadata)159assetRegistry -> registerForeignAsset(location, metadata)
160location:160location:
161	V0(X2(Parent, Parachain(PARA_ID))) 161	V0(X2(Parent, Parachain(PARA_ID)))
162metadata:162metadata:
163	name         OPL163	name         OPL
164	symbol       OPL164	symbol       OPL
170```170```
171polkadotXcm -> reserveTransferAssets171polkadotXcm -> reserveTransferAssets
172dest:172dest:
173	V0(X2(Parent, Parachain(<KARURA_PARA_ID>))) 173	V0(X2(Parent, Parachain(<KARURA_PARA_ID>)))
174beneficiary:174beneficiary:
175	X1(AccountId(Any, <ACCOUNT>))175	X1(AccountId(Any, <ACCOUNT>))
176assets:176assets:
177	V1(Concrete(0,Here), Fungible(<AMOUNT>))177	V1(Concrete(0,Here), Fungible(<AMOUNT>))
178feeAssetItem: 178feeAssetItem:
179	0	179	0
180weightLimit:180weightLimit:
181	<LIMIT>181	<LIMIT>
182```	182```
183183
184The result will be displayed in ChainState   184The result will be displayed in ChainState
185tokens -> accounts	185tokens -> accounts
186186
187### To send tokens from Karura to Opal:187### To send tokens from Karura to Opal:
188```188```
197dest:197dest:
198	V1198	V1
199	(199	(
200		Parents:1, 200		Parents:1,
201		X2(Parachain(<KARURA_PARA_ID>), AccountId(Any, <ACCOUNT>)201		X2(Parachain(<KARURA_PARA_ID>), AccountId(Any, <ACCOUNT>)
202	)202	)
203destWeight:203destWeight:

168[dependencies.serde_json]168[dependencies.serde_json]
169version = '1.0.68'169version = '1.0.68'
170170
171[dependencies.sc-consensus-manual-seal]
172git = 'https://github.com/paritytech/substrate.git'
173branch = 'polkadot-v0.9.17'
171174
172################################################################################175################################################################################
173# Cumulus dependencies176# Cumulus dependencies
238################################################################################241################################################################################
239# Local dependencies242# Local dependencies
243
244[dependencies.unique-runtime-common]
245default-features = false
246path = "../../runtime/common"
240247
241[dependencies.unique-runtime]248[dependencies.unique-runtime]
242path = '../../runtime'249path = '../../runtime/unique'
250optional = true
251
252[dependencies.quartz-runtime]
253path = '../../runtime/quartz'
254optional = true
255
256[dependencies.opal-runtime]
257path = '../../runtime/opal'
243258
244[dependencies.up-data-structs]259[dependencies.up-data-structs]
245path = "../../primitives/data-structs"260path = "../../primitives/data-structs"
246default-features = false261default-features = false
262
263[dependencies.up-rpc]
264path = "../../primitives/rpc"
265
266[dependencies.pallet-transaction-payment-rpc-runtime-api]
267git = 'https://github.com/paritytech/substrate.git'
268branch = 'polkadot-v0.9.17'
247269
248################################################################################270################################################################################
249# Package271# Package
283fp-rpc = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.17" }305fp-rpc = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.17" }
284pallet-ethereum = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.17" }306pallet-ethereum = { git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.17" }
285307
286unique-rpc = { path = "../rpc" }308unique-rpc = { default-features = false, path = "../rpc" }
287309
288[features]310[features]
289default = []311default = ["unique-runtime", "quartz-runtime"]
290runtime-benchmarks = [312runtime-benchmarks = [
291    'unique-runtime/runtime-benchmarks',313    'unique-runtime/runtime-benchmarks',
292    'polkadot-service/runtime-benchmarks',314    'polkadot-service/runtime-benchmarks',

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17use cumulus_primitives_core::ParaId;17use cumulus_primitives_core::ParaId;
18use unique_runtime::*;
19use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};18use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup};
20use sc_service::ChainType;19use sc_service::ChainType;
21use sp_core::{sr25519, Pair, Public};20use sp_core::{sr25519, Pair, Public};
25use serde::{Deserialize, Serialize};24use serde::{Deserialize, Serialize};
26use serde_json::map::Map;25use serde_json::map::Map;
2726
28/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.27use unique_runtime_common::types::*;
28
29/// The `ChainSpec` parameterized for the unique runtime.
30#[cfg(feature = "unique-runtime")]
29pub type ChainSpec = sc_service::GenericChainSpec<unique_runtime::GenesisConfig, Extensions>;31pub type UniqueChainSpec = sc_service::GenericChainSpec<unique_runtime::GenesisConfig, Extensions>;
32
33/// The `ChainSpec` parameterized for the quartz runtime.
34#[cfg(feature = "quartz-runtime")]
35pub type QuartzChainSpec = sc_service::GenericChainSpec<quartz_runtime::GenesisConfig, Extensions>;
36
37/// The `ChainSpec` parameterized for the opal runtime.
38pub type OpalChainSpec = sc_service::GenericChainSpec<opal_runtime::GenesisConfig, Extensions>;
39
40pub enum RuntimeId {
41	Unique,
42	Quartz,
43	Opal,
44	Unknown(String),
45}
46
47pub trait RuntimeIdentification {
48	fn runtime_id(&self) -> RuntimeId;
49}
50
51impl RuntimeIdentification for Box<dyn sc_service::ChainSpec> {
52	fn runtime_id(&self) -> RuntimeId {
53		#[cfg(feature = "unique-runtime")]
54		if self.id().starts_with("unique") {
55			return RuntimeId::Unique;
56		}
57
58		#[cfg(feature = "quartz-runtime")]
59		if self.id().starts_with("quartz") {
60			return RuntimeId::Quartz;
61		}
62
63		if self.id().starts_with("opal") || self.id() == "dev" || self.id() == "local_testnet" {
64			return RuntimeId::Opal;
65		}
66
67		RuntimeId::Unknown(self.id().into())
68	}
69}
70
71pub enum ServiceId {
72	Prod,
73	Dev,
74}
75
76pub trait ServiceIdentification {
77	fn service_id(&self) -> ServiceId;
78}
79
80impl ServiceIdentification for Box<dyn sc_service::ChainSpec> {
81	fn service_id(&self) -> ServiceId {
82		if self.id().ends_with("dev") {
83			ServiceId::Dev
84		} else {
85			ServiceId::Prod
86		}
87	}
88}
3089
31/// Helper function to generate a crypto pair from seed90/// Helper function to generate a crypto pair from seed
32pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {91pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
62	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()121	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
63}122}
64123
65pub fn development_config() -> ChainSpec {124pub fn development_config() -> OpalChainSpec {
66	let mut properties = Map::new();125	let mut properties = Map::new();
67	properties.insert("tokenSymbol".into(), "OPL".into());126	properties.insert("tokenSymbol".into(), "OPL".into());
68	properties.insert("tokenDecimals".into(), 15.into());127	properties.insert("tokenDecimals".into(), 15.into());
69	properties.insert("ss58Format".into(), 42.into());128	properties.insert("ss58Format".into(), 42.into());
70129
71	ChainSpec::from_genesis(130	OpalChainSpec::from_genesis(
72		// Name131		// Name
73		"Development",132		"Development",
74		// ID133		// ID
107	)166	)
108}167}
109168
110pub fn local_testnet_rococo_config() -> ChainSpec {169pub fn local_testnet_rococo_config() -> OpalChainSpec {
111	ChainSpec::from_genesis(170	OpalChainSpec::from_genesis(
112		// Name171		// Name
113		"Local Testnet",172		"Local Testnet",
114		// ID173		// ID
157	)216	)
158}217}
159
160pub fn local_testnet_westend_config() -> ChainSpec {
161	ChainSpec::from_genesis(
162		// Name
163		"Local Testnet",
164		// ID
165		"local_testnet",
166		ChainType::Local,
167		move || {
168			testnet_genesis(
169				// Sudo account
170				get_account_id_from_seed::<sr25519::Public>("Alice"),
171				vec![
172					get_from_seed::<AuraId>("Alice"),
173					get_from_seed::<AuraId>("Bob"),
174					get_from_seed::<AuraId>("Charlie"),
175					get_from_seed::<AuraId>("Dave"),
176					get_from_seed::<AuraId>("Eve"),
177				],
178				// Pre-funded accounts
179				vec![
180					get_account_id_from_seed::<sr25519::Public>("Alice"),
181					get_account_id_from_seed::<sr25519::Public>("Bob"),
182					get_account_id_from_seed::<sr25519::Public>("Charlie"),
183					get_account_id_from_seed::<sr25519::Public>("Dave"),
184					get_account_id_from_seed::<sr25519::Public>("Eve"),
185					get_account_id_from_seed::<sr25519::Public>("Ferdie"),
186					get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
187					get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
188					get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
189					get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
190					get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
191					get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
192				],
193				1000.into(),
194			)
195		},
196		// Bootnodes
197		vec![],
198		// Telemetry
199		None,
200		// Protocol ID
201		None,
202		None,
203		// Properties
204		None,
205		// Extensions
206		Extensions {
207			relay_chain: "westend-local".into(),
208			para_id: 1000,
209		},
210	)
211}
212218
213fn testnet_genesis(219fn testnet_genesis(
214	root_key: AccountId,220	root_key: AccountId,
215	initial_authorities: Vec<AuraId>,221	initial_authorities: Vec<AuraId>,
216	endowed_accounts: Vec<AccountId>,222	endowed_accounts: Vec<AccountId>,
217	id: ParaId,223	id: ParaId,
218) -> GenesisConfig {224) -> opal_runtime::GenesisConfig {
225	use opal_runtime::*;
226
219	GenesisConfig {227	GenesisConfig {
220		system: unique_runtime::SystemConfig {228		system: SystemConfig {
221			code: unique_runtime::WASM_BINARY229			code: WASM_BINARY
222				.expect("WASM binary was not build, please build it!")230				.expect("WASM binary was not build, please build it!")
223				.to_vec(),231				.to_vec(),
224		},232		},
235			key: Some(root_key),243			key: Some(root_key),
236		},244		},
237		vesting: VestingConfig { vesting: vec![] },245		vesting: VestingConfig { vesting: vec![] },
238		parachain_info: unique_runtime::ParachainInfoConfig { parachain_id: id },246		parachain_info: ParachainInfoConfig { parachain_id: id },
239		parachain_system: Default::default(),247		parachain_system: Default::default(),
240		aura: unique_runtime::AuraConfig {248		aura: AuraConfig {
241			authorities: initial_authorities,249			authorities: initial_authorities,
242		},250		},
243		aura_ext: Default::default(),251		aura_ext: Default::default(),

33// limitations under the License.33// limitations under the License.
3434
35use crate::{35use crate::{
36	chain_spec,36	chain_spec::{self, RuntimeId, RuntimeIdentification, ServiceId, ServiceIdentification},
37	cli::{Cli, RelayChainCli, Subcommand},37	cli::{Cli, RelayChainCli, Subcommand},
38	service::{new_partial, ParachainRuntimeExecutor},38	service::{new_partial, start_node, start_dev_node},
39};39};
40
41#[cfg(feature = "unique-runtime")]
42use crate::service::UniqueRuntimeExecutor;
43
44#[cfg(feature = "quartz-runtime")]
45use crate::service::QuartzRuntimeExecutor;
46
47use crate::service::OpalRuntimeExecutor;
48
40use codec::Encode;49use codec::Encode;
41use cumulus_primitives_core::ParaId;50use cumulus_primitives_core::ParaId;
42use cumulus_client_service::genesis::generate_genesis_block;51use cumulus_client_service::genesis::generate_genesis_block;
43use log::info;52use log::info;
44use unique_runtime::Block;
45use polkadot_parachain::primitives::AccountIdConversion;53use polkadot_parachain::primitives::AccountIdConversion;
46use sc_cli::{54use sc_cli::{
47	ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,55	ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams,
54use sp_runtime::traits::Block as BlockT;62use sp_runtime::traits::Block as BlockT;
55use std::{io::Write, net::SocketAddr};63use std::{io::Write, net::SocketAddr};
64
65use unique_runtime_common::types::Block;
66
67macro_rules! no_runtime_err {
68	($chain_name:expr) => {
69		format!(
70			"No runtime valid runtime was found for chain {}",
71			$chain_name
72		)
73	};
74}
5675
57fn load_spec(id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {76fn load_spec(id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
58	Ok(match id {77	Ok(match id {
59		"westend-local" => Box::new(chain_spec::local_testnet_westend_config()),78		"dev" => Box::new(chain_spec::development_config()),
60		"rococo-local" => Box::new(chain_spec::local_testnet_rococo_config()),79		"" | "local" => Box::new(chain_spec::local_testnet_rococo_config()),
61		"dev" => Box::new(chain_spec::development_config()),80		path => {
81			let path = std::path::PathBuf::from(path);
62		"" | "local" => Box::new(chain_spec::local_testnet_rococo_config()),82			let chain_spec = Box::new(chain_spec::OpalChainSpec::from_json_file(path.clone())?)
83				as Box<dyn sc_service::ChainSpec>;
84
85			match chain_spec.runtime_id() {
86				#[cfg(feature = "unique-runtime")]
63		path => Box::new(chain_spec::ChainSpec::from_json_file(87				RuntimeId::Unique => Box::new(chain_spec::UniqueChainSpec::from_json_file(path)?),
88
89				#[cfg(feature = "quartz-runtime")]
64			std::path::PathBuf::from(path),90				RuntimeId::Quartz => Box::new(chain_spec::QuartzChainSpec::from_json_file(path)?),
65		)?),91
92				RuntimeId::Opal => chain_spec,
93				RuntimeId::Unknown(chain) => return Err(no_runtime_err!(chain)),
94			}
95		}
66	})96	})
67}97}
6898
69impl SubstrateCli for Cli {99impl SubstrateCli for Cli {
70	// TODO use args100	// TODO use args
71	fn impl_name() -> String {101	fn impl_name() -> String {
72		"Opal Node".into()102		"Unique Node".into()
73	}103	}
74104
75	fn impl_version() -> String {105	fn impl_version() -> String {
78	// TODO use args108	// TODO use args
79	fn description() -> String {109	fn description() -> String {
80		format!(110		format!(
81			"Opal Node\n\nThe command-line arguments provided first will be \111			"Unique Node\n\nThe command-line arguments provided first will be \
82		passed to the parachain node, while the arguments provided after -- will be passed \112		passed to the parachain node, while the arguments provided after -- will be passed \
83		to the relaychain node.\n\n\113		to the relaychain node.\n\n\
84		{} [parachain-args] -- [relaychain-args]",114		{} [parachain-args] -- [relaychain-args]",
85			Self::executable_name()115			Self::executable_name()
86		)116		)
87	}117	}
103		load_spec(id)133		load_spec(id)
104	}134	}
105135
106	fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {136	fn native_runtime_version(chain_spec: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
137		match chain_spec.runtime_id() {
138			#[cfg(feature = "unique-runtime")]
107		&unique_runtime::VERSION139			RuntimeId::Unique => &unique_runtime::VERSION,
140
141			#[cfg(feature = "quartz-runtime")]
142			RuntimeId::Quartz => &quartz_runtime::VERSION,
143
144			RuntimeId::Opal => &opal_runtime::VERSION,
145			RuntimeId::Unknown(chain) => panic!("{}", no_runtime_err!(chain)),
146		}
108	}147	}
109}148}
110149
111impl SubstrateCli for RelayChainCli {150impl SubstrateCli for RelayChainCli {
112	// TODO use args151	// TODO use args
113	fn impl_name() -> String {152	fn impl_name() -> String {
114		"Opal Node".into()153		"Unique Node".into()
115	}154	}
116155
117	fn impl_version() -> String {156	fn impl_version() -> String {
118		env!("SUBSTRATE_CLI_IMPL_VERSION").into()157		env!("SUBSTRATE_CLI_IMPL_VERSION").into()
119	}158	}
120	// TODO use args159	// TODO use args
121	fn description() -> String {160	fn description() -> String {
122		"Opal Node\n\nThe command-line arguments provided first will be \161		"Unique Node\n\nThe command-line arguments provided first will be \
123		passed to the parachain node, while the arguments provided after -- will be passed \162		passed to the parachain node, while the arguments provided after -- will be passed \
124		to the relaychain node.\n\n\163		to the relaychain node.\n\n\
125		parachain-collator [parachain-args] -- [relaychain-args]"164		parachain-collator [parachain-args] -- [relaychain-args]"
126			.into()165			.into()
127	}166	}
128167
157		.ok_or_else(|| "Could not find wasm file in genesis state!".into())196		.ok_or_else(|| "Could not find wasm file in genesis state!".into())
158}197}
159198
160macro_rules! construct_async_run {199macro_rules! async_run_with_runtime {
161	(|$components:ident, $cli:ident, $cmd:ident, $config:ident| $( $code:tt )* ) => {{200	(
162		let runner = $cli.create_runner($cmd)?;201		$runtime_api:path, $executor:path,
202		$runner:ident, $components:ident, $cli:ident, $cmd:ident, $config:ident,
203		$( $code:tt )*
204	) => {
163		runner.async_run(|$config| {205		$runner.async_run(|$config| {
164			let $components = new_partial::<206			let $components = new_partial::<
165				_207				$runtime_api, $executor, _
166			>(208			>(
167				&$config,209				&$config,
168				crate::service::parachain_build_import_queue,210				crate::service::parachain_build_import_queue,
169			)?;211			)?;
170			let task_manager = $components.task_manager;212			let task_manager = $components.task_manager;
213
171			{ $( $code )* }.map(|v| (v, task_manager))214			{ $( $code )* }.map(|v| (v, task_manager))
172		})215		})
173	}}216	};
174}217}
218
219macro_rules! construct_async_run {
220	(|$components:ident, $cli:ident, $cmd:ident, $config:ident| $( $code:tt )* ) => {{
221		let runner = $cli.create_runner($cmd)?;
222
223		match runner.config().chain_spec.runtime_id() {
224			#[cfg(feature = "unique-runtime")]
225			RuntimeId::Unique => async_run_with_runtime!(
226				unique_runtime::RuntimeApi, UniqueRuntimeExecutor,
227				runner, $components, $cli, $cmd, $config, $( $code )*
228			),
229
230			#[cfg(feature = "quartz-runtime")]
231			RuntimeId::Quartz => async_run_with_runtime!(
232				quartz_runtime::RuntimeApi, QuartzRuntimeExecutor,
233				runner, $components, $cli, $cmd, $config, $( $code )*
234			),
235
236			RuntimeId::Opal => async_run_with_runtime!(
237				opal_runtime::RuntimeApi, OpalRuntimeExecutor,
238				runner, $components, $cli, $cmd, $config, $( $code )*
239			),
240
241			RuntimeId::Unknown(chain) => Err(no_runtime_err!(chain).into())
242		}
243	}}
244}
245
246macro_rules! start_node_using_chain_runtime {
247	($start_node_fn:ident($config:expr $(, $($args:expr),+)?) $($code:tt)*) => {
248		match $config.chain_spec.runtime_id() {
249			#[cfg(feature = "unique-runtime")]
250			RuntimeId::Unique => $start_node_fn::<
251				unique_runtime::Runtime,
252				unique_runtime::RuntimeApi,
253				UniqueRuntimeExecutor,
254			>($config $(, $($args),+)?) $($code)*,
255
256			#[cfg(feature = "quartz-runtime")]
257			RuntimeId::Quartz => $start_node_fn::<
258				quartz_runtime::Runtime,
259				quartz_runtime::RuntimeApi,
260				QuartzRuntimeExecutor,
261			>($config $(, $($args),+)?) $($code)*,
262
263			RuntimeId::Opal => $start_node_fn::<
264				opal_runtime::Runtime,
265				opal_runtime::RuntimeApi,
266				OpalRuntimeExecutor,
267			>($config $(, $($args),+)?) $($code)*,
268
269			RuntimeId::Unknown(chain) => Err(no_runtime_err!(chain).into()),
270		}
271	};
272}
175273
176/// Parse command line arguments into service configuration.274/// Parse command line arguments into service configuration.
177pub fn run() -> Result<()> {275pub fn run() -> Result<()> {
274			if cfg!(feature = "runtime-benchmarks") {372			if cfg!(feature = "runtime-benchmarks") {
275				let runner = cli.create_runner(cmd)?;373				let runner = cli.create_runner(cmd)?;
276
277				runner.sync_run(|config| cmd.run::<Block, ParachainRuntimeExecutor>(config))374				runner.sync_run(|config| match config.chain_spec.runtime_id() {
375					#[cfg(feature = "unique-runtime")]
376					RuntimeId::Unique => cmd.run::<Block, UniqueRuntimeExecutor>(config),
377
378					#[cfg(feature = "quartz-runtime")]
379					RuntimeId::Quartz => cmd.run::<Block, QuartzRuntimeExecutor>(config),
380
381					RuntimeId::Opal => cmd.run::<Block, OpalRuntimeExecutor>(config),
382					RuntimeId::Unknown(chain) => Err(no_runtime_err!(chain).into()),
383				})
278			} else {384			} else {
279				Err("Benchmarking wasn't enabled when building the node. \385				Err("Benchmarking wasn't enabled when building the node. \
280				You can enable it with `--features runtime-benchmarks`."386				You can enable it with `--features runtime-benchmarks`."
285			let runner = cli.create_runner(&cli.run.normalize())?;391			let runner = cli.create_runner(&cli.run.normalize())?;
286392
287			runner.run_node_until_exit(|config| async move {393			runner.run_node_until_exit(|config| async move {
288				let para_id = chain_spec::Extensions::try_get(&*config.chain_spec)394				let extensions = chain_spec::Extensions::try_get(&*config.chain_spec);
395
396				let service_id = config.chain_spec.service_id();
397				let relay_chain_id = extensions.map(|e| e.relay_chain.clone());
398				let is_dev_service = matches![service_id, ServiceId::Dev]
399					|| relay_chain_id == Some("dev-service".into());
400
401				if is_dev_service {
402					info!("Running Dev service");
403
404					return start_node_using_chain_runtime! {
405						start_dev_node(config).map_err(Into::into)
406					};
407				};
408
409				let para_id = extensions
289					.map(|e| e.para_id)410					.map(|e| e.para_id)
290					.ok_or("Could not find parachain ID in chain-spec.")?;411					.ok_or("Could not find parachain ID in chain-spec.")?;
291412
292				let polkadot_cli = RelayChainCli::new(413				let polkadot_cli = RelayChainCli::new(
296						.chain(cli.relaychain_args.iter()),417						.chain(cli.relaychain_args.iter()),
297				);418				);
298419
299				let id = ParaId::from(para_id);420				let para_id = ParaId::from(para_id);
300421
301				let parachain_account =422				let parachain_account =
302					AccountIdConversion::<polkadot_primitives::v0::AccountId>::into_account(&id);423					AccountIdConversion::<polkadot_primitives::v0::AccountId>::into_account(
424						&para_id,
425					);
303426
304				let state_version =427				let state_version =
315				)438				)
316				.map_err(|err| format!("Relay chain argument error: {}", err))?;439				.map_err(|err| format!("Relay chain argument error: {}", err))?;
317440
318				info!("Parachain id: {:?}", id);441				info!("Parachain id: {:?}", para_id);
319				info!("Parachain Account: {}", parachain_account);442				info!("Parachain Account: {}", parachain_account);
320				info!("Parachain genesis state: {}", genesis_state);443				info!("Parachain genesis state: {}", genesis_state);
321				info!("Parachain genesis hash: {}", genesis_hash);444				info!("Parachain genesis hash: {}", genesis_hash);
328					}451					}
329				);452				);
330453
454				start_node_using_chain_runtime! {
331				crate::service::start_node(config, polkadot_config, id)455					start_node(config, polkadot_config, para_id)
332					.await456						.await
333					.map(|r| r.0)457						.map(|r| r.0)
334					.map_err(Into::into)458						.map_err(Into::into)
459				}
335			})460			})
336		}461		}
337	}462	}