sp_inherents/
client_side.rs1use std::sync::Arc;
19
20use crate::{Error, InherentData, InherentIdentifier};
21use sp_runtime::traits::Block as BlockT;
22
23#[async_trait::async_trait]
32pub trait CreateInherentDataProviders<Block: BlockT, ExtraArgs>: Send + Sync {
33 type InherentDataProviders: InherentDataProvider;
35
36 async fn create_inherent_data_providers(
38 &self,
39 parent: Block::Hash,
40 extra_args: ExtraArgs,
41 ) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>>;
42}
43
44#[async_trait::async_trait]
45impl<F, Block, IDP, ExtraArgs, Fut> CreateInherentDataProviders<Block, ExtraArgs> for F
46where
47 Block: BlockT,
48 F: Fn(Block::Hash, ExtraArgs) -> Fut + Sync + Send,
49 Fut: std::future::Future<Output = Result<IDP, Box<dyn std::error::Error + Send + Sync>>>
50 + Send
51 + 'static,
52 IDP: InherentDataProvider + 'static,
53 ExtraArgs: Send + 'static,
54{
55 type InherentDataProviders = IDP;
56
57 async fn create_inherent_data_providers(
58 &self,
59 parent: Block::Hash,
60 extra_args: ExtraArgs,
61 ) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>> {
62 (*self)(parent, extra_args).await
63 }
64}
65
66#[async_trait::async_trait]
67impl<Block: BlockT, ExtraArgs: Send, IDPS: InherentDataProvider>
68 CreateInherentDataProviders<Block, ExtraArgs>
69 for Box<dyn CreateInherentDataProviders<Block, ExtraArgs, InherentDataProviders = IDPS>>
70{
71 type InherentDataProviders = IDPS;
72
73 async fn create_inherent_data_providers(
74 &self,
75 parent: Block::Hash,
76 extra_args: ExtraArgs,
77 ) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>> {
78 (**self).create_inherent_data_providers(parent, extra_args).await
79 }
80}
81
82#[async_trait::async_trait]
83impl<Block: BlockT, ExtraArgs: Send, IDPS: InherentDataProvider>
84 CreateInherentDataProviders<Block, ExtraArgs>
85 for Arc<dyn CreateInherentDataProviders<Block, ExtraArgs, InherentDataProviders = IDPS>>
86{
87 type InherentDataProviders = IDPS;
88
89 async fn create_inherent_data_providers(
90 &self,
91 parent: Block::Hash,
92 extra_args: ExtraArgs,
93 ) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>> {
94 (**self).create_inherent_data_providers(parent, extra_args).await
95 }
96}
97
98#[async_trait::async_trait]
100pub trait InherentDataProvider: Send + Sync {
101 async fn create_inherent_data(&self) -> Result<InherentData, Error> {
105 let mut inherent_data = InherentData::new();
106 self.provide_inherent_data(&mut inherent_data).await?;
107 Ok(inherent_data)
108 }
109
110 async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error>;
114
115 async fn try_handle_error(
119 &self,
120 identifier: &InherentIdentifier,
121 error: &[u8],
122 ) -> Option<Result<(), Error>>;
123}
124
125#[impl_trait_for_tuples::impl_for_tuples(30)]
126#[async_trait::async_trait]
127impl InherentDataProvider for Tuple {
128 for_tuples!( where #( Tuple: Send + Sync )* );
129 async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error> {
130 for_tuples!( #( Tuple.provide_inherent_data(inherent_data).await?; )* );
131 Ok(())
132 }
133
134 async fn try_handle_error(
135 &self,
136 identifier: &InherentIdentifier,
137 error: &[u8],
138 ) -> Option<Result<(), Error>> {
139 for_tuples!( #(
140 if let Some(r) = Tuple.try_handle_error(identifier, error).await { return Some(r) }
141 )* );
142
143 None
144 }
145}