Update to rc6. (#155)

* Update to rc6. * Fix clippy warnings.
2026-04-24 12:27:59 +00:00 · 2020-08-25 10:50:14 +02:00
parent eac2ce3b2a
commit 3ea9d3b8bb
11 changed files with 260 additions and 253 deletions
@@ -164,12 +164,12 @@ fn testnet_genesis(
    _enable_println: bool,
 ) -> GenesisConfig {
    GenesisConfig {
-        system: Some(SystemConfig {
+        frame_system: Some(SystemConfig {
            // Add Wasm runtime to storage.
            code: wasm_binary.to_vec(),
            changes_trie_config: Default::default(),
        }),
-        balances: Some(BalancesConfig {
+        pallet_balances: Some(BalancesConfig {
            // Configure endowed accounts with initial balance of 1 << 60.
            balances: endowed_accounts
                .iter()
@@ -177,16 +177,16 @@ fn testnet_genesis(
                .map(|k| (k, 1 << 60))
                .collect(),
        }),
-        aura: Some(AuraConfig {
+        pallet_aura: Some(AuraConfig {
            authorities: initial_authorities.iter().map(|x| (x.0.clone())).collect(),
        }),
-        grandpa: Some(GrandpaConfig {
+        pallet_grandpa: Some(GrandpaConfig {
            authorities: initial_authorities
                .iter()
                .map(|x| (x.1.clone(), 1))
                .collect(),
        }),
-        sudo: Some(SudoConfig {
+        pallet_sudo: Some(SudoConfig {
            // Assign network admin rights.
            key: root_key,
        }),
@@ -18,7 +18,6 @@ use crate::{
    chain_spec,
    cli::Cli,
    service,
-    service::new_full_params,
 };
 use sc_cli::{
    ChainSpec,
@@ -26,7 +25,7 @@ use sc_cli::{
    RuntimeVersion,
    SubstrateCli,
 };
-use sc_service::ServiceParams;
+use sc_service::PartialComponents;

 impl SubstrateCli for Cli {
    fn impl_name() -> String {
@@ -78,16 +77,13 @@ pub fn run() -> sc_cli::Result<()> {
        Some(subcommand) => {
            let runner = cli.create_runner(subcommand)?;
            runner.run_subcommand(subcommand, |config| {
-                let (
-                    ServiceParams {
-                        client,
-                        backend,
-                        task_manager,
-                        import_queue,
-                        ..
-                    },
-                    ..,
-                ) = new_full_params(config)?;
+                let PartialComponents {
+                    client,
+                    backend,
+                    task_manager,
+                    import_queue,
+                    ..
+                } = service::new_partial(&config)?;
                Ok((client, backend, import_queue, task_manager))
            })
        }
@@ -15,6 +15,7 @@
 // along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.

 //! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+#![allow(clippy::type_complexity)]

 use sc_client_api::{
    ExecutorProvider,
@@ -25,13 +26,12 @@ pub use sc_executor::NativeExecutor;
 use sc_finality_grandpa::{
    FinalityProofProvider as GrandpaFinalityProofProvider,
    SharedVoterState,
-    StorageAndProofProvider,
 };
 use sc_service::{
    error::Error as ServiceError,
    Configuration,
+    PartialComponents,
    RpcHandlers,
-    ServiceComponents,
    TaskManager,
 };
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
@@ -57,28 +57,25 @@ type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
 type FullBackend = sc_service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;

-pub fn new_full_params(
-    config: Configuration,
+pub fn new_partial(
+    config: &Configuration,
 ) -> Result<
-    (
-        sc_service::ServiceParams<
-            Block,
-            FullClient,
-            sc_consensus_aura::AuraImportQueue<Block, FullClient>,
-            sc_transaction_pool::FullPool<Block, FullClient>,
-            (),
-            FullBackend,
-        >,
+    sc_service::PartialComponents<
+        FullClient,
+        FullBackend,
        FullSelectChain,
-        sp_inherents::InherentDataProviders,
-        sc_finality_grandpa::GrandpaBlockImport<
-            FullBackend,
-            Block,
-            FullClient,
-            FullSelectChain,
-        >,
-        sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
-    ),
+        sp_consensus::DefaultImportQueue<Block, FullClient>,
+        sc_transaction_pool::FullPool<Block, FullClient>,
+        (
+            sc_finality_grandpa::GrandpaBlockImport<
+                FullBackend,
+                Block,
+                FullClient,
+                FullSelectChain,
+            >,
+            sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+        ),
+    >,
    ServiceError,
 > {
    let inherent_data_providers = sp_inherents::InherentDataProviders::new();
@@ -89,13 +86,8 @@ pub fn new_full_params(

    let select_chain = sc_consensus::LongestChain::new(backend.clone());

-    let pool_api = sc_transaction_pool::FullChainApi::new(
-        client.clone(),
-        config.prometheus_registry(),
-    );
    let transaction_pool = sc_transaction_pool::BasicPool::new_full(
        config.transaction_pool.clone(),
-        std::sync::Arc::new(pool_api),
        config.prometheus_registry(),
        task_manager.spawn_handle(),
        client.clone(),
@@ -112,7 +104,7 @@ pub fn new_full_params(
        client.clone(),
    );

-    let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _>(
+    let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
        sc_consensus_aura::slot_duration(&*client)?,
        aura_block_import,
        Some(Box::new(grandpa_block_import.clone())),
@@ -121,81 +113,86 @@ pub fn new_full_params(
        inherent_data_providers.clone(),
        &task_manager.spawn_handle(),
        config.prometheus_registry(),
+        sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
    )?;

-    let provider = client.clone() as Arc<dyn StorageAndProofProvider<_, _>>;
-    let finality_proof_provider =
-        Arc::new(GrandpaFinalityProofProvider::new(backend.clone(), provider));
-
-    let params = sc_service::ServiceParams {
-        backend,
+    Ok(sc_service::PartialComponents {
        client,
+        backend,
+        task_manager,
        import_queue,
        keystore,
-        task_manager,
-        transaction_pool,
-        config,
-        block_announce_validator_builder: None,
-        finality_proof_request_builder: None,
-        finality_proof_provider: Some(finality_proof_provider),
-        on_demand: None,
-        remote_blockchain: None,
-        rpc_extensions_builder: Box::new(|_| ()),
-    };
-
-    Ok((
-        params,
        select_chain,
+        transaction_pool,
        inherent_data_providers,
-        grandpa_block_import,
-        grandpa_link,
-    ))
+        other: (grandpa_block_import, grandpa_link),
+    })
 }

 /// Builds a new service for a full client.
 pub fn new_full(
    config: Configuration,
-) -> Result<(TaskManager, Arc<RpcHandlers>), ServiceError> {
-    let (params, select_chain, inherent_data_providers, block_import, grandpa_link) =
-        new_full_params(config)?;
-
-    let (
-        role,
-        force_authoring,
-        name,
-        enable_grandpa,
-        prometheus_registry,
+) -> Result<(TaskManager, RpcHandlers), ServiceError> {
+    let PartialComponents {
        client,
-        transaction_pool,
+        backend,
+        mut task_manager,
+        import_queue,
        keystore,
-    ) = {
-        let sc_service::ServiceParams {
-            config,
-            client,
-            transaction_pool,
-            keystore,
-            ..
-        } = &params;
+        select_chain,
+        transaction_pool,
+        inherent_data_providers,
+        other: (block_import, grandpa_link),
+    } = new_partial(&config)?;

-        (
-            config.role.clone(),
-            config.force_authoring,
-            config.network.node_name.clone(),
-            !config.disable_grandpa,
-            config.prometheus_registry().cloned(),
+    let finality_proof_provider =
+        GrandpaFinalityProofProvider::new_for_service(backend.clone(), client.clone());
+
+    let (network, network_status_sinks, system_rpc_tx, network_starter) =
+        sc_service::build_network(sc_service::BuildNetworkParams {
+            config: &config,
+            client: client.clone(),
+            transaction_pool: transaction_pool.clone(),
+            spawn_handle: task_manager.spawn_handle(),
+            import_queue,
+            on_demand: None,
+            block_announce_validator_builder: None,
+            finality_proof_request_builder: None,
+            finality_proof_provider: Some(finality_proof_provider),
+        })?;
+
+    if config.offchain_worker.enabled {
+        sc_service::build_offchain_workers(
+            &config,
+            backend.clone(),
+            task_manager.spawn_handle(),
            client.clone(),
-            transaction_pool.clone(),
-            keystore.clone(),
-        )
-    };
+            network.clone(),
+        );
+    }

-    let ServiceComponents {
-        task_manager,
-        rpc_handlers,
-        network,
-        telemetry_on_connect_sinks,
-        ..
-    } = sc_service::build(params)?;
+    let role = config.role.clone();
+    let force_authoring = config.force_authoring;
+    let name = config.network.node_name.clone();
+    let enable_grandpa = !config.disable_grandpa;
+    let prometheus_registry = config.prometheus_registry().cloned();
+    let telemetry_connection_sinks = sc_service::TelemetryConnectionSinks::default();
+
+    let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+        network: network.clone(),
+        client: client.clone(),
+        keystore: keystore.clone(),
+        task_manager: &mut task_manager,
+        transaction_pool: transaction_pool.clone(),
+        telemetry_connection_sinks: telemetry_connection_sinks.clone(),
+        rpc_extensions_builder: Box::new(|_, _| ()),
+        on_demand: None,
+        remote_blockchain: None,
+        backend,
+        network_status_sinks,
+        system_rpc_tx,
+        config,
+    })?;

    if role.is_authority() {
        let proposer = sc_basic_authorship::ProposerFactory::new(
@@ -256,7 +253,7 @@ pub fn new_full(
            link: grandpa_link,
            network,
            inherent_data_providers,
-            telemetry_on_connect: Some(telemetry_on_connect_sinks.on_connect_stream()),
+            telemetry_on_connect: Some(telemetry_connection_sinks.on_connect_stream()),
            voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
            prometheus_registry,
            shared_voter_state: SharedVoterState::empty(),
@@ -276,26 +273,24 @@ pub fn new_full(
        )?;
    }

+    network_starter.start_network();
    Ok((task_manager, rpc_handlers))
 }

 /// Builds a new service for a light client.
 pub fn new_light(
    config: Configuration,
-) -> Result<(TaskManager, Arc<RpcHandlers>), ServiceError> {
-    let (client, backend, keystore, task_manager, on_demand) =
+) -> Result<(TaskManager, RpcHandlers), ServiceError> {
+    let (client, backend, keystore, mut task_manager, on_demand) =
        sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;

-    let transaction_pool_api = Arc::new(sc_transaction_pool::LightChainApi::new(
+    let transaction_pool = Arc::new(sc_transaction_pool::BasicPool::new_light(
+        config.transaction_pool.clone(),
+        config.prometheus_registry(),
+        task_manager.spawn_handle(),
        client.clone(),
        on_demand.clone(),
    ));
-    let transaction_pool = sc_transaction_pool::BasicPool::new_light(
-        config.transaction_pool.clone(),
-        transaction_pool_api,
-        config.prometheus_registry(),
-        task_manager.spawn_handle(),
-    );

    let grandpa_block_import = sc_finality_grandpa::light_block_import(
        client.clone(),
@@ -307,7 +302,7 @@ pub fn new_light(
    let finality_proof_request_builder =
        finality_proof_import.create_finality_proof_request_builder();

-    let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _>(
+    let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
        sc_consensus_aura::slot_duration(&*client)?,
        grandpa_block_import,
        None,
@@ -316,33 +311,52 @@ pub fn new_light(
        InherentDataProviders::new(),
        &task_manager.spawn_handle(),
        config.prometheus_registry(),
+        sp_consensus::NeverCanAuthor,
    )?;

-    let finality_proof_provider = Arc::new(GrandpaFinalityProofProvider::new(
-        backend.clone(),
-        client.clone() as Arc<_>,
-    ));
+    let finality_proof_provider =
+        GrandpaFinalityProofProvider::new_for_service(backend.clone(), client.clone());

-    sc_service::build(sc_service::ServiceParams {
-        block_announce_validator_builder: None,
-        finality_proof_request_builder: Some(finality_proof_request_builder),
-        finality_proof_provider: Some(finality_proof_provider),
-        on_demand: Some(on_demand),
+    let (network, network_status_sinks, system_rpc_tx, network_starter) =
+        sc_service::build_network(sc_service::BuildNetworkParams {
+            config: &config,
+            client: client.clone(),
+            transaction_pool: transaction_pool.clone(),
+            spawn_handle: task_manager.spawn_handle(),
+            import_queue,
+            on_demand: Some(on_demand.clone()),
+            block_announce_validator_builder: None,
+            finality_proof_request_builder: Some(finality_proof_request_builder),
+            finality_proof_provider: Some(finality_proof_provider),
+        })?;
+
+    if config.offchain_worker.enabled {
+        sc_service::build_offchain_workers(
+            &config,
+            backend.clone(),
+            task_manager.spawn_handle(),
+            client.clone(),
+            network.clone(),
+        );
+    }
+
+    let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
        remote_blockchain: Some(backend.remote_blockchain()),
-        rpc_extensions_builder: Box::new(|_| ()),
-        transaction_pool: Arc::new(transaction_pool),
+        transaction_pool,
+        task_manager: &mut task_manager,
+        on_demand: Some(on_demand),
+        rpc_extensions_builder: Box::new(|_, _| ()),
+        telemetry_connection_sinks: sc_service::TelemetryConnectionSinks::default(),
        config,
        client,
-        import_queue,
        keystore,
        backend,
-        task_manager,
-    })
-    .map(
-        |ServiceComponents {
-             task_manager,
-             rpc_handlers,
-             ..
-         }| (task_manager, rpc_handlers),
-    )
+        network,
+        network_status_sinks,
+        system_rpc_tx,
+    })?;
+
+    network_starter.start_network();
+
+    Ok((task_manager, rpc_handlers))
 }