1#![warn(missing_docs)]
32#![warn(unused_crate_dependencies)]
33
34use std::sync::Arc;
35
36use jsonrpsee::RpcModule;
37use node_primitives::{AccountId, Balance, Block, BlockNumber, Hash, Nonce};
38use sc_client_api::AuxStore;
39use sc_consensus_babe::BabeWorkerHandle;
40use sc_consensus_beefy::communication::notification::{
41 BeefyBestBlockStream, BeefyVersionedFinalityProofStream,
42};
43use sc_consensus_grandpa::{
44 FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState,
45};
46pub use sc_rpc::SubscriptionTaskExecutor;
47use sc_transaction_pool_api::TransactionPool;
48use sp_api::ProvideRuntimeApi;
49use sp_application_crypto::RuntimeAppPublic;
50use sp_block_builder::BlockBuilder;
51use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
52use sp_consensus::SelectChain;
53use sp_consensus_babe::BabeApi;
54use sp_consensus_beefy::AuthorityIdBound;
55use sp_keystore::KeystorePtr;
56
57pub struct BabeDeps {
59 pub babe_worker_handle: BabeWorkerHandle<Block>,
61 pub keystore: KeystorePtr,
63}
64
65pub struct GrandpaDeps<B> {
67 pub shared_voter_state: SharedVoterState,
69 pub shared_authority_set: SharedAuthoritySet<Hash, BlockNumber>,
71 pub justification_stream: GrandpaJustificationStream<Block>,
73 pub subscription_executor: SubscriptionTaskExecutor,
75 pub finality_provider: Arc<FinalityProofProvider<B, Block>>,
77}
78
79pub struct BeefyDeps<AuthorityId: AuthorityIdBound> {
81 pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream<Block, AuthorityId>,
83 pub beefy_best_block_stream: BeefyBestBlockStream<Block>,
85 pub subscription_executor: SubscriptionTaskExecutor,
87}
88
89pub struct FullDeps<C, P, SC, B, AuthorityId: AuthorityIdBound> {
91 pub client: Arc<C>,
93 pub pool: Arc<P>,
95 pub select_chain: SC,
97 pub chain_spec: Box<dyn sc_chain_spec::ChainSpec>,
99 pub babe: BabeDeps,
101 pub grandpa: GrandpaDeps<B>,
103 pub beefy: BeefyDeps<AuthorityId>,
105 pub statement_store: Arc<dyn sp_statement_store::StatementStore>,
107 pub backend: Arc<B>,
109 pub mixnet_api: Option<sc_mixnet::Api>,
111}
112
113pub fn create_full<C, P, SC, B, AuthorityId>(
115 FullDeps {
116 client,
117 pool,
118 select_chain,
119 chain_spec,
120 babe,
121 grandpa,
122 beefy,
123 statement_store,
124 backend,
125 mixnet_api,
126 }: FullDeps<C, P, SC, B, AuthorityId>,
127) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
128where
129 C: ProvideRuntimeApi<Block>
130 + sc_client_api::BlockBackend<Block>
131 + HeaderBackend<Block>
132 + AuxStore
133 + HeaderMetadata<Block, Error = BlockChainError>
134 + Sync
135 + Send
136 + 'static,
137 C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
138 C::Api: mmr_rpc::MmrRuntimeApi<Block, <Block as sp_runtime::traits::Block>::Hash, BlockNumber>,
139 C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
140 C::Api: BabeApi<Block>,
141 C::Api: BlockBuilder<Block>,
142 P: TransactionPool + 'static,
143 SC: SelectChain<Block> + 'static,
144 B: sc_client_api::Backend<Block> + Send + Sync + 'static,
145 B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashingFor<Block>>,
146 AuthorityId: AuthorityIdBound,
147 <AuthorityId as RuntimeAppPublic>::Signature: Send + Sync,
148{
149 use mmr_rpc::{Mmr, MmrApiServer};
150 use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
151 use sc_consensus_babe_rpc::{Babe, BabeApiServer};
152 use sc_consensus_beefy_rpc::{Beefy, BeefyApiServer};
153 use sc_consensus_grandpa_rpc::{Grandpa, GrandpaApiServer};
154 use sc_rpc::{
155 dev::{Dev, DevApiServer},
156 mixnet::MixnetApiServer,
157 statement::StatementApiServer,
158 };
159 use sc_sync_state_rpc::{SyncState, SyncStateApiServer};
160 use substrate_frame_rpc_system::{System, SystemApiServer};
161 use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer};
162
163 let mut io = RpcModule::new(());
164
165 let BabeDeps { keystore, babe_worker_handle } = babe;
166 let GrandpaDeps {
167 shared_voter_state,
168 shared_authority_set,
169 justification_stream,
170 subscription_executor,
171 finality_provider,
172 } = grandpa;
173
174 io.merge(System::new(client.clone(), pool).into_rpc())?;
175 io.merge(
179 Mmr::new(
180 client.clone(),
181 backend
182 .offchain_storage()
183 .ok_or_else(|| "Backend doesn't provide an offchain storage")?,
184 )
185 .into_rpc(),
186 )?;
187 io.merge(TransactionPayment::new(client.clone()).into_rpc())?;
188 io.merge(
189 Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain).into_rpc(),
190 )?;
191 io.merge(
192 Grandpa::new(
193 subscription_executor,
194 shared_authority_set.clone(),
195 shared_voter_state,
196 justification_stream,
197 finality_provider,
198 )
199 .into_rpc(),
200 )?;
201
202 io.merge(
203 SyncState::new(chain_spec, client.clone(), shared_authority_set, babe_worker_handle)?
204 .into_rpc(),
205 )?;
206
207 io.merge(StateMigration::new(client.clone(), backend).into_rpc())?;
208 io.merge(Dev::new(client).into_rpc())?;
209 let statement_store = sc_rpc::statement::StatementStore::new(statement_store).into_rpc();
210 io.merge(statement_store)?;
211
212 if let Some(mixnet_api) = mixnet_api {
213 let mixnet = sc_rpc::mixnet::Mixnet::new(mixnet_api).into_rpc();
214 io.merge(mixnet)?;
215 }
216
217 io.merge(
218 Beefy::<Block, AuthorityId>::new(
219 beefy.beefy_finality_proof_stream,
220 beefy.beefy_best_block_stream,
221 beefy.subscription_executor,
222 )?
223 .into_rpc(),
224 )?;
225
226 Ok(io)
227}