difftreelog
Adjust node and rpc to work with different runtimes
in: master
7 files changed
Cargo.lockdiffbeforeafterboth11942 "opal-runtime",11942 "opal-runtime",11943 "pallet-ethereum",11943 "pallet-ethereum",11944 "pallet-transaction-payment-rpc",11944 "pallet-transaction-payment-rpc",11945 "pallet-transaction-payment-rpc-runtime-api",11945 "parity-scale-codec",11946 "parity-scale-codec",11946 "parking_lot 0.11.2",11947 "parking_lot 0.11.2",11947 "polkadot-cli",11948 "polkadot-cli",11988 "substrate-prometheus-endpoint",11989 "substrate-prometheus-endpoint",11989 "unique-rpc",11990 "unique-rpc",11990 "unique-runtime",11991 "unique-runtime",11992 "unique-runtime-common",11991 "up-data-structs",11993 "up-data-structs",11994 "up-rpc",11992]11995]119931199611994[[package]]11997[[package]]12003 "futures 0.3.21",12006 "futures 0.3.21",12004 "jsonrpc-core",12007 "jsonrpc-core",12005 "jsonrpc-pubsub",12008 "jsonrpc-pubsub",12006 "opal-runtime",12009 "pallet-common",12007 "pallet-ethereum",12010 "pallet-ethereum",12008 "pallet-transaction-payment-rpc",12011 "pallet-transaction-payment-rpc",12009 "pallet-transaction-payment-rpc-runtime-api",12012 "pallet-transaction-payment-rpc-runtime-api",12010 "pallet-unique",12013 "pallet-unique",12011 "quartz-runtime",12012 "sc-client-api",12014 "sc-client-api",12013 "sc-consensus-aura",12015 "sc-consensus-aura",12014 "sc-consensus-epochs",12016 "sc-consensus-epochs",12020 "sc-rpc-api",12022 "sc-rpc-api",12021 "sc-service",12023 "sc-service",12022 "sc-transaction-pool",12024 "sc-transaction-pool",12025 "serde",12023 "sp-api",12026 "sp-api",12024 "sp-block-builder",12027 "sp-block-builder",12025 "sp-blockchain",12028 "sp-blockchain",12034 "substrate-frame-rpc-system",12037 "substrate-frame-rpc-system",12035 "tokio 0.2.25",12038 "tokio 0.2.25",12036 "uc-rpc",12039 "uc-rpc",12037 "unique-runtime",12040 "unique-runtime-common",12038 "up-rpc",12041 "up-rpc",12039]12042]120401204312118name = "unique-runtime-common"12121name = "unique-runtime-common"12119version = "0.1.0"12122version = "0.1.0"12120dependencies = [12123dependencies = [12124 "fp-rpc",12121 "frame-support",12125 "frame-support",12122 "frame-system",12126 "frame-system",12127 "pallet-common",12123 "parity-scale-codec",12128 "parity-scale-codec",12124 "scale-info",12129 "scale-info",12130 "sp-consensus-aura",12125 "sp-core",12131 "sp-core",12126 "sp-runtime",12132 "sp-runtime",12127]12133]node/cli/Cargo.tomldiffbeforeafterboth--- a/node/cli/Cargo.toml
+++ b/node/cli/Cargo.toml
@@ -238,6 +238,10 @@
################################################################################
# Local dependencies
+[dependencies.unique-runtime-common]
+default-features = false
+path = "../../runtime/common"
+
[dependencies.unique-runtime]
path = '../../runtime/unique'
optional = true
@@ -254,6 +258,13 @@
path = "../../primitives/data-structs"
default-features = false
+[dependencies.up-rpc]
+path = "../../primitives/rpc"
+
+[dependencies.pallet-transaction-payment-rpc-runtime-api]
+git = 'https://github.com/paritytech/substrate.git'
+branch = 'polkadot-v0.9.17'
+
################################################################################
# Package
@@ -295,7 +306,7 @@
unique-rpc = { default-features = false, path = "../rpc" }
[features]
-default = ["unique-runtime"]
+default = ["unique-runtime", "quartz-runtime", "opal-runtime"]
runtime-benchmarks = [
'unique-runtime/runtime-benchmarks',
'polkadot-service/runtime-benchmarks',
node/cli/src/chain_spec.rsdiffbeforeafterboth--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -24,20 +24,33 @@
use serde::{Deserialize, Serialize};
use serde_json::map::Map;
-#[cfg(feature = "unique-runtime")]
-use unique_runtime as runtime;
+use unique_runtime_common::types::*;
-#[cfg(feature = "quartz-runtime")]
-use quartz_runtime as runtime;
+/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
+pub type ChainSpec = sc_service::GenericChainSpec<unique_runtime::GenesisConfig, Extensions>;
-#[cfg(feature = "opal-runtime")]
-use opal_runtime as runtime;
+pub trait RuntimeIdentification {
+ fn is_unique(&self) -> bool;
+
+ fn is_quartz(&self) -> bool;
-use runtime::{*, opaque::*};
+ fn is_opal(&self) -> bool;
+}
-/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
-pub type ChainSpec = sc_service::GenericChainSpec<runtime::GenesisConfig, Extensions>;
+impl RuntimeIdentification for Box<dyn sc_service::ChainSpec> {
+ fn is_unique(&self) -> bool {
+ self.id().starts_with("unique")
+ }
+ fn is_quartz(&self) -> bool {
+ self.id().starts_with("quartz")
+ }
+
+ fn is_opal(&self) -> bool {
+ self.id().starts_with("opal")
+ }
+}
+
/// Helper function to generate a crypto pair from seed
pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
TPublic::Pair::from_string(&format!("//{}", seed), None)
@@ -225,10 +238,12 @@
initial_authorities: Vec<AuraId>,
endowed_accounts: Vec<AccountId>,
id: ParaId,
-) -> GenesisConfig {
+) -> unique_runtime::GenesisConfig {
+ use unique_runtime::*;
+
GenesisConfig {
- system: runtime::SystemConfig {
- code: runtime::WASM_BINARY
+ system: SystemConfig {
+ code: WASM_BINARY
.expect("WASM binary was not build, please build it!")
.to_vec(),
},
@@ -245,9 +260,9 @@
key: Some(root_key),
},
vesting: VestingConfig { vesting: vec![] },
- parachain_info: runtime::ParachainInfoConfig { parachain_id: id },
+ parachain_info: ParachainInfoConfig { parachain_id: id },
parachain_system: Default::default(),
- aura: runtime::AuraConfig {
+ aura: AuraConfig {
authorities: initial_authorities,
},
aura_ext: Default::default(),
node/cli/src/command.rsdiffbeforeafterboth--- a/node/cli/src/command.rs
+++ b/node/cli/src/command.rs
@@ -33,10 +33,20 @@
// limitations under the License.
use crate::{
- chain_spec,
+ chain_spec::{self, RuntimeIdentification},
cli::{Cli, RelayChainCli, Subcommand},
- service::{new_partial, ParachainRuntimeExecutor},
+ service::new_partial,
};
+
+#[cfg(feature = "unique-runtime")]
+use crate::service::UniqueRuntimeExecutor;
+
+#[cfg(feature = "quartz-runtime")]
+use crate::service::QuartzRuntimeExecutor;
+
+#[cfg(feature = "opal-runtime")]
+use crate::service::OpalRuntimeExecutor;
+
use codec::Encode;
use cumulus_primitives_core::ParaId;
use cumulus_client_service::genesis::generate_genesis_block;
@@ -53,16 +63,14 @@
use sp_runtime::traits::Block as BlockT;
use std::{io::Write, net::SocketAddr};
-#[cfg(feature = "unique-runtime")]
-use unique_runtime as runtime;
+use unique_runtime_common::types::Block;
-#[cfg(feature = "quartz-runtime")]
-use quartz_runtime as runtime;
-
-#[cfg(feature = "opal-runtime")]
-use opal_runtime as runtime;
-
-use runtime::Block;
+macro_rules! no_runtime_err {
+ ($chain_spec:expr) => {
+ format!("No runtime valid runtime was found, chain id: {}",
+ $chain_spec.id())
+ };
+}
fn load_spec(id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
Ok(match id {
@@ -79,7 +87,7 @@
impl SubstrateCli for Cli {
// TODO use args
fn impl_name() -> String {
- format!("{} Node", runtime::RUNTIME_NAME)
+ "Unique Node".into()
}
fn impl_version() -> String {
@@ -88,11 +96,10 @@
// TODO use args
fn description() -> String {
format!(
- "{} Node\n\nThe command-line arguments provided first will be \
+ "Unique Node\n\nThe command-line arguments provided first will be \
passed to the parachain node, while the arguments provided after -- will be passed \
to the relaychain node.\n\n\
{} [parachain-args] -- [relaychain-args]",
- runtime::RUNTIME_NAME,
Self::executable_name()
)
}
@@ -114,15 +121,30 @@
load_spec(id)
}
- fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
- &runtime::VERSION
+ fn native_runtime_version(chain_spec: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
+ #[cfg(feature = "unique-runtime")]
+ if chain_spec.is_unique() {
+ return &unique_runtime::VERSION;
+ }
+
+ #[cfg(feature = "quartz-runtime")]
+ if chain_spec.is_quartz() {
+ return &quartz_runtime::VERSION;
+ }
+
+ #[cfg(feature = "opal-runtime")]
+ if chain_spec.is_opal() {
+ return &opal_runtime::VERSION;
+ }
+
+ panic!("{}", no_runtime_err!(chain_spec));
}
}
impl SubstrateCli for RelayChainCli {
// TODO use args
fn impl_name() -> String {
- format!("{} Node", runtime::RUNTIME_NAME)
+ "Unique Node".into()
}
fn impl_version() -> String {
@@ -130,13 +152,11 @@
}
// TODO use args
fn description() -> String {
- format!(
- "{} Node\n\nThe command-line arguments provided first will be \
+ "Unique Node\n\nThe command-line arguments provided first will be \
passed to the parachain node, while the arguments provided after -- will be passed \
to the relaychain node.\n\n\
- parachain-collator [parachain-args] -- [relaychain-args]",
- runtime::RUNTIME_NAME
- )
+ parachain-collator [parachain-args] -- [relaychain-args]"
+ .into()
}
fn author() -> String {
@@ -173,16 +193,50 @@
macro_rules! construct_async_run {
(|$components:ident, $cli:ident, $cmd:ident, $config:ident| $( $code:tt )* ) => {{
let runner = $cli.create_runner($cmd)?;
- runner.async_run(|$config| {
- let $components = new_partial::<
- _
- >(
- &$config,
- crate::service::parachain_build_import_queue,
- )?;
- let task_manager = $components.task_manager;
- { $( $code )* }.map(|v| (v, task_manager))
- })
+
+ #[cfg(feature = "unique-runtime")]
+ if runner.config().chain_spec.is_unique() {
+ return runner.async_run(|$config| {
+ let $components = new_partial::<
+ unique_runtime::RuntimeApi, UniqueRuntimeExecutor, _
+ >(
+ &$config,
+ crate::service::parachain_build_import_queue,
+ )?;
+ let task_manager = $components.task_manager;
+ { $( $code )* }.map(|v| (v, task_manager))
+ });
+ }
+
+ #[cfg(feature = "quartz-runtime")]
+ if runner.config().chain_spec.is_quartz() {
+ return runner.async_run(|$config| {
+ let $components = new_partial::<
+ quartz_runtime::RuntimeApi, QuartzRuntimeExecutor, _
+ >(
+ &$config,
+ crate::service::parachain_build_import_queue,
+ )?;
+ let task_manager = $components.task_manager;
+ { $( $code )* }.map(|v| (v, task_manager))
+ });
+ }
+
+ #[cfg(feature = "opal-runtime")]
+ if runner.config().chain_spec.is_opal() {
+ return runner.async_run(|$config| {
+ let $components = new_partial::<
+ opal_runtime::RuntimeApi, OpalRuntimeExecutor, _
+ >(
+ &$config,
+ crate::service::parachain_build_import_queue,
+ )?;
+ let task_manager = $components.task_manager;
+ { $( $code )* }.map(|v| (v, task_manager))
+ });
+ }
+
+ Err(no_runtime_err!(runner.config().chain_spec).into())
}}
}
@@ -286,8 +340,24 @@
Some(Subcommand::Benchmark(cmd)) => {
if cfg!(feature = "runtime-benchmarks") {
let runner = cli.create_runner(cmd)?;
+ runner.sync_run(|config| {
+ #[cfg(feature = "unique-runtime")]
+ if config.chain_spec.is_unique() {
+ return cmd.run::<Block, UniqueRuntimeExecutor>(config);
+ }
+
+ #[cfg(feature = "quartz-runtime")]
+ if config.chain_spec.is_quartz() {
+ return cmd.run::<Block, QuartzRuntimeExecutor>(config);
+ }
+
+ #[cfg(feature = "opal-runtime")]
+ if config.chain_spec.is_opal() {
+ return cmd.run::<Block, OpalRuntimeExecutor>(config);
+ }
- runner.sync_run(|config| cmd.run::<Block, ParachainRuntimeExecutor>(config))
+ Err(no_runtime_err!(config.chain_spec).into())
+ })
} else {
Err("Benchmarking wasn't enabled when building the node. \
You can enable it with `--features runtime-benchmarks`."
@@ -341,10 +411,43 @@
}
);
- crate::service::start_node(config, polkadot_config, id)
+ #[cfg(feature = "unique-runtime")]
+ if config.chain_spec.is_unique() {
+ return crate::service::start_node::<
+ unique_runtime::Runtime,
+ unique_runtime::RuntimeApi,
+ UniqueRuntimeExecutor,
+ >(config, polkadot_config, id)
.await
.map(|r| r.0)
- .map_err(Into::into)
+ .map_err(Into::into);
+ }
+
+ #[cfg(feature = "quartz-runtime")]
+ if config.chain_spec.is_quartz() {
+ return crate::service::start_node::<
+ quartz_runtime::Runtime,
+ quartz_runtime::RuntimeApi,
+ QuartzRuntimeExecutor,
+ >(config, polkadot_config, id)
+ .await
+ .map(|r| r.0)
+ .map_err(Into::into);
+ }
+
+ #[cfg(feature = "opal-runtime")]
+ if config.chain_spec.is_opal() {
+ return crate::service::start_node::<
+ opal_runtime::Runtime,
+ opal_runtime::RuntimeApi,
+ OpalRuntimeExecutor,
+ >(config, polkadot_config, id)
+ .await
+ .map(|r| r.0)
+ .map_err(Into::into);
+ }
+
+ Err(no_runtime_err!(config.chain_spec).into())
})
}
}
node/cli/src/service.rsdiffbeforeafterboth--- a/node/cli/src/service.rs
+++ b/node/cli/src/service.rs
@@ -25,17 +25,8 @@
use futures::StreamExt;
use unique_rpc::overrides_handle;
-// Local Runtime Types
-#[cfg(feature = "unique-runtime")]
-use unique_runtime as runtime;
-
-#[cfg(feature = "quartz-runtime")]
-use quartz_runtime as runtime;
-#[cfg(feature = "opal-runtime")]
-use opal_runtime as runtime;
-
-use runtime::RuntimeApi;
+use serde::{Serialize, Deserialize};
// Cumulus Imports
use cumulus_client_consensus_aura::{AuraConsensus, BuildAuraConsensusParams, SlotProportion};
@@ -71,18 +62,46 @@
pub type Block = sp_runtime::generic::Block<Header, sp_runtime::OpaqueExtrinsic>;
type Hash = sp_core::H256;
+use unique_runtime_common::types::{AuraId, RuntimeInstance, AccountId, Balance, Index};
+
/// Native executor instance.
-pub struct ParachainRuntimeExecutor;
+pub struct UniqueRuntimeExecutor;
+pub struct QuartzRuntimeExecutor;
+pub struct OpalRuntimeExecutor;
+
+impl NativeExecutionDispatch for UniqueRuntimeExecutor {
+ type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;
+
+ fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+ unique_runtime::api::dispatch(method, data)
+ }
+
+ fn native_version() -> sc_executor::NativeVersion {
+ unique_runtime::native_version()
+ }
+}
+
+impl NativeExecutionDispatch for QuartzRuntimeExecutor {
+ type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;
-impl NativeExecutionDispatch for ParachainRuntimeExecutor {
+ fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+ unique_runtime::api::dispatch(method, data)
+ }
+
+ fn native_version() -> sc_executor::NativeVersion {
+ unique_runtime::native_version()
+ }
+}
+
+impl NativeExecutionDispatch for OpalRuntimeExecutor {
type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;
fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
- runtime::api::dispatch(method, data)
+ unique_runtime::api::dispatch(method, data)
}
fn native_version() -> sc_executor::NativeVersion {
- runtime::native_version()
+ unique_runtime::native_version()
}
}
@@ -106,9 +125,7 @@
)?))
}
-type ExecutorDispatch = ParachainRuntimeExecutor;
-
-type FullClient =
+type FullClient<RuntimeApi, ExecutorDispatch> =
sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<ExecutorDispatch>>;
type FullBackend = sc_service::TFullBackend<Block>;
type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
@@ -118,16 +135,16 @@
/// Use this macro if you don't actually need the full service, but just the builder in order to
/// be able to perform chain operations.
#[allow(clippy::type_complexity)]
-pub fn new_partial<BIQ>(
+pub fn new_partial<RuntimeApi, ExecutorDispatch, BIQ>(
config: &Configuration,
build_import_queue: BIQ,
) -> Result<
PartialComponents<
- FullClient,
+ FullClient<RuntimeApi, ExecutorDispatch>,
FullBackend,
FullSelectChain,
- sc_consensus::DefaultImportQueue<Block, FullClient>,
- sc_transaction_pool::FullPool<Block, FullClient>,
+ sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,
+ sc_transaction_pool::FullPool<Block, FullClient<RuntimeApi, ExecutorDispatch>>,
(
Option<Telemetry>,
Option<FilterPool>,
@@ -140,13 +157,21 @@
>
where
sc_client_api::StateBackendFor<FullBackend, Block>: sp_api::StateBackend<BlakeTwo256>,
+ RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>
+ + Send
+ + Sync
+ + 'static,
+ RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>,
ExecutorDispatch: NativeExecutionDispatch + 'static,
BIQ: FnOnce(
- Arc<FullClient>,
+ Arc<FullClient<RuntimeApi, ExecutorDispatch>>,
&Configuration,
Option<TelemetryHandle>,
&TaskManager,
- ) -> Result<sc_consensus::DefaultImportQueue<Block, FullClient>, sc_service::Error>,
+ ) -> Result<
+ sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,
+ sc_service::Error,
+ >,
{
let _telemetry = config
.telemetry_endpoints
@@ -240,29 +265,50 @@
///
/// This is the actual implementation that is abstract over the executor and the runtime api.
#[sc_tracing::logging::prefix_logs_with("Parachain")]
-async fn start_node_impl<BIQ, BIC>(
+async fn start_node_impl<Runtime, RuntimeApi, ExecutorDispatch, BIQ, BIC>(
parachain_config: Configuration,
polkadot_config: Configuration,
id: ParaId,
build_import_queue: BIQ,
build_consensus: BIC,
-) -> sc_service::error::Result<(TaskManager, Arc<FullClient>)>
+) -> sc_service::error::Result<(TaskManager, Arc<FullClient<RuntimeApi, ExecutorDispatch>>)>
where
sc_client_api::StateBackendFor<FullBackend, Block>: sp_api::StateBackend<BlakeTwo256>,
+ Runtime: RuntimeInstance + Send + Sync + 'static,
+ <Runtime as RuntimeInstance>::CrossAccountId: Serialize,
+ for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,
+ RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>
+ + Send
+ + Sync
+ + 'static,
+ RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
+ + fp_rpc::EthereumRuntimeRPCApi<Block>
+ + sp_session::SessionKeys<Block>
+ + sp_block_builder::BlockBuilder<Block>
+ + pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
+ + sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
+ + up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
+ + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+ + sp_api::Metadata<Block>
+ + sp_offchain::OffchainWorkerApi<Block>
+ + cumulus_primitives_core::CollectCollationInfo<Block>,
ExecutorDispatch: NativeExecutionDispatch + 'static,
BIQ: FnOnce(
- Arc<FullClient>,
+ Arc<FullClient<RuntimeApi, ExecutorDispatch>>,
&Configuration,
Option<TelemetryHandle>,
&TaskManager,
- ) -> Result<sc_consensus::DefaultImportQueue<Block, FullClient>, sc_service::Error>,
+ ) -> Result<
+ sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,
+ sc_service::Error,
+ >,
BIC: FnOnce(
- Arc<FullClient>,
+ Arc<FullClient<RuntimeApi, ExecutorDispatch>>,
Option<&Registry>,
Option<TelemetryHandle>,
&TaskManager,
Arc<dyn RelayChainInterface>,
- Arc<sc_transaction_pool::FullPool<Block, FullClient>>,
+ Arc<sc_transaction_pool::FullPool<Block, FullClient<RuntimeApi, ExecutorDispatch>>>,
Arc<NetworkService<Block, Hash>>,
SyncCryptoStorePtr,
bool,
@@ -274,7 +320,8 @@
let parachain_config = prepare_node_config(parachain_config);
- let params = new_partial::<BIQ>(¶chain_config, build_import_queue)?;
+ let params =
+ new_partial::<RuntimeApi, ExecutorDispatch, BIQ>(¶chain_config, build_import_queue)?;
let (mut telemetry, filter_pool, frontier_backend, telemetry_worker_handle, fee_history_cache) =
params.other;
@@ -320,7 +367,7 @@
let block_data_cache = Arc::new(fc_rpc::EthBlockDataCache::new(
task_manager.spawn_handle(),
- overrides_handle(client.clone()),
+ overrides_handle::<_, _, Runtime>(client.clone()),
50,
50,
));
@@ -346,10 +393,12 @@
fee_history_limit: 2048,
};
- Ok(unique_rpc::create_full::<_, _, _, _, RuntimeApi, _>(
- full_deps,
- subscription_executor.clone(),
- ))
+ Ok(
+ unique_rpc::create_full::<_, _, _, _, Runtime, RuntimeApi, _>(
+ full_deps,
+ subscription_executor.clone(),
+ ),
+ )
});
task_manager.spawn_essential_handle().spawn(
@@ -436,12 +485,26 @@
}
/// Build the import queue for the the parachain runtime.
-pub fn parachain_build_import_queue(
- client: Arc<FullClient>,
+pub fn parachain_build_import_queue<RuntimeApi, ExecutorDispatch>(
+ client: Arc<FullClient<RuntimeApi, ExecutorDispatch>>,
config: &Configuration,
telemetry: Option<TelemetryHandle>,
task_manager: &TaskManager,
-) -> Result<sc_consensus::DefaultImportQueue<Block, FullClient>, sc_service::Error> {
+) -> Result<
+ sc_consensus::DefaultImportQueue<Block, FullClient<RuntimeApi, ExecutorDispatch>>,
+ sc_service::Error,
+>
+where
+ RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>
+ + Send
+ + Sync
+ + 'static,
+ RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
+ + sp_block_builder::BlockBuilder<Block>
+ + sp_consensus_aura::AuraApi<Block, AuraId>
+ + sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>,
+ ExecutorDispatch: NativeExecutionDispatch + 'static,
+{
let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?;
cumulus_client_consensus_aura::import_queue::<
@@ -475,12 +538,34 @@
}
/// Start a normal parachain node.
-pub async fn start_node(
+pub async fn start_node<Runtime, RuntimeApi, ExecutorDispatch>(
parachain_config: Configuration,
polkadot_config: Configuration,
id: ParaId,
-) -> sc_service::error::Result<(TaskManager, Arc<FullClient>)> {
- start_node_impl::<_, _>(
+) -> sc_service::error::Result<(TaskManager, Arc<FullClient<RuntimeApi, ExecutorDispatch>>)>
+where
+ Runtime: RuntimeInstance + Send + Sync + 'static,
+ <Runtime as RuntimeInstance>::CrossAccountId: Serialize,
+ for<'de> <Runtime as RuntimeInstance>::CrossAccountId: Deserialize<'de>,
+ RuntimeApi: sp_api::ConstructRuntimeApi<Block, FullClient<RuntimeApi, ExecutorDispatch>>
+ + Send
+ + Sync
+ + 'static,
+ RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>
+ + fp_rpc::EthereumRuntimeRPCApi<Block>
+ + sp_session::SessionKeys<Block>
+ + sp_block_builder::BlockBuilder<Block>
+ + pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance>
+ + sp_api::ApiExt<Block, StateBackend = sc_client_api::StateBackendFor<FullBackend, Block>>
+ + up_rpc::UniqueApi<Block, Runtime::CrossAccountId, AccountId>
+ + substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>
+ + sp_api::Metadata<Block>
+ + sp_offchain::OffchainWorkerApi<Block>
+ + cumulus_primitives_core::CollectCollationInfo<Block>
+ + sp_consensus_aura::AuraApi<Block, AuraId>,
+ ExecutorDispatch: NativeExecutionDispatch + 'static,
+{
+ start_node_impl::<Runtime, RuntimeApi, ExecutorDispatch, _, _>(
parachain_config,
polkadot_config,
id,
node/rpc/Cargo.tomldiffbeforeafterboth--- a/node/rpc/Cargo.toml
+++ b/node/rpc/Cargo.toml
@@ -48,13 +48,16 @@
fc-db = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.17" }
fc-mapping-sync = { default-features = false, git = "https://github.com/uniquenetwork/frontier.git", branch = "unique-polkadot-v0.9.17" }
+pallet-common = { default-features = false, path = "../../pallets/common" }
+unique-runtime-common = { default-features = false, path = "../../runtime/common" }
pallet-unique = { path = "../../pallets/unique" }
uc-rpc = { path = "../../client/rpc" }
up-rpc = { path = "../../primitives/rpc" }
-unique-runtime = { path = "../../runtime/unique", optional = true }
-quartz-runtime = { path = "../../runtime/quartz", optional = true }
-opal-runtime = { path = "../../runtime/opal", optional = true }
+[dependencies.serde]
+features = ['derive']
+version = '1.0.130'
+
[features]
-default = ["unique-runtime"]
+default = []
std = []
node/rpc/src/lib.rsdiffbeforeafterboth--- a/node/rpc/src/lib.rs
+++ b/node/rpc/src/lib.rs
@@ -40,16 +40,9 @@
use sc_service::TransactionPool;
use std::{collections::BTreeMap, marker::PhantomData, sync::Arc};
-#[cfg(feature = "unique-runtime")]
-use unique_runtime as runtime;
-
-#[cfg(feature = "quartz-runtime")]
-use quartz_runtime as runtime;
-
-#[cfg(feature = "opal-runtime")]
-use opal_runtime as runtime;
-
-use runtime::opaque::{Hash, AccountId, CrossAccountId, Index, Block, BlockNumber, Balance};
+use unique_runtime_common::types::{
+ Hash, AccountId, RuntimeInstance, Index, Block, BlockNumber, Balance,
+};
/// Public io handler for exporting into other modules
pub type IoHandler = jsonrpc_core::IoHandler<sc_rpc::Metadata>;
@@ -100,29 +93,33 @@
pub block_data_cache: Arc<EthBlockDataCache<Block>>,
}
-struct AccountCodes<C, B> {
+struct AccountCodes<C, B, R> {
client: Arc<C>,
- _marker: PhantomData<B>,
+ _blk_marker: PhantomData<B>,
+ _runtime_marker: PhantomData<R>,
}
-impl<C, Block> AccountCodes<C, Block>
+impl<C, Block, R> AccountCodes<C, Block, R>
where
Block: sp_api::BlockT,
C: ProvideRuntimeApi<Block>,
+ R: RuntimeInstance,
{
fn new(client: Arc<C>) -> Self {
Self {
client,
- _marker: PhantomData,
+ _blk_marker: PhantomData,
+ _runtime_marker: PhantomData,
}
}
}
-impl<C, Block> fc_rpc::AccountCodeProvider<Block> for AccountCodes<C, Block>
+impl<C, Block, Runtime> fc_rpc::AccountCodeProvider<Block> for AccountCodes<C, Block, Runtime>
where
Block: sp_api::BlockT,
C: ProvideRuntimeApi<Block>,
- C::Api: up_rpc::UniqueApi<Block, CrossAccountId, AccountId>,
+ C::Api: up_rpc::UniqueApi<Block, <Runtime as RuntimeInstance>::CrossAccountId, AccountId>,
+ Runtime: RuntimeInstance,
{
fn code(&self, block: &sp_api::BlockId<Block>, account: sp_core::H160) -> Option<Vec<u8>> {
use up_rpc::UniqueApi;
@@ -134,22 +131,23 @@
}
}
-pub fn overrides_handle<C, BE>(client: Arc<C>) -> Arc<OverrideHandle<Block>>
+pub fn overrides_handle<C, BE, R>(client: Arc<C>) -> Arc<OverrideHandle<Block>>
where
C: ProvideRuntimeApi<Block> + StorageProvider<Block, BE> + AuxStore,
C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError>,
C: Send + Sync + 'static,
C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
- C::Api: up_rpc::UniqueApi<Block, CrossAccountId, AccountId>,
+ C::Api: up_rpc::UniqueApi<Block, <R as RuntimeInstance>::CrossAccountId, AccountId>,
BE: Backend<Block> + 'static,
BE::State: StateBackend<BlakeTwo256>,
+ R: RuntimeInstance + Send + Sync + 'static,
{
let mut overrides_map = BTreeMap::new();
overrides_map.insert(
EthereumStorageSchema::V1,
Box::new(SchemaV1Override::new_with_code_provider(
client.clone(),
- Arc::new(AccountCodes::<C, Block>::new(client.clone())),
+ Arc::new(AccountCodes::<C, Block, R>::new(client.clone())),
)) as Box<dyn StorageOverride<_> + Send + Sync>,
);
overrides_map.insert(
@@ -170,7 +168,7 @@
}
/// Instantiate all Full RPC extensions.
-pub fn create_full<C, P, SC, CA, A, B>(
+pub fn create_full<C, P, SC, CA, R, A, B>(
deps: FullDeps<C, P, SC, CA>,
subscription_task_executor: SubscriptionTaskExecutor,
) -> jsonrpc_core::IoHandler<sc_rpc_api::Metadata>
@@ -184,11 +182,14 @@
// C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber, Hash>,
C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
C::Api: fp_rpc::EthereumRuntimeRPCApi<Block>,
- C::Api: up_rpc::UniqueApi<Block, CrossAccountId, AccountId>,
+ C::Api: up_rpc::UniqueApi<Block, <R as RuntimeInstance>::CrossAccountId, AccountId>,
B: sc_client_api::Backend<Block> + Send + Sync + 'static,
B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashFor<Block>>,
P: TransactionPool<Block = Block> + 'static,
CA: ChainApi<Block = Block> + 'static,
+ R: RuntimeInstance + Send + Sync + 'static,
+ <R as RuntimeInstance>::CrossAccountId: serde::Serialize,
+ for<'de> <R as RuntimeInstance>::CrossAccountId: serde::Deserialize<'de>,
{
use fc_rpc::{
EthApi, EthApiServer, EthDevSigner, EthFilterApi, EthFilterApiServer, EthPubSubApi,
@@ -235,13 +236,13 @@
signers.push(Box::new(EthDevSigner::new()) as Box<dyn EthSigner>);
}
- let overrides = overrides_handle(client.clone());
+ let overrides = overrides_handle::<_, _, R>(client.clone());
io.extend_with(EthApiServer::to_delegate(EthApi::new(
client.clone(),
pool.clone(),
graph,
- runtime::TransactionConverter,
+ <R as RuntimeInstance>::get_transaction_converter(),
network.clone(),
signers,
overrides.clone(),