celestia_tendermint/consensus/
params.rs

1//! Tendermint consensus parameters
2
3use serde::{Deserialize, Serialize};
4
5use crate::{block, evidence, prelude::*, public_key};
6
7/// All consensus-relevant parameters that can be adjusted by the ABCI app.
8///
9/// [ABCI documentation](https://docs.tendermint.com/master/spec/abci/abci.html#consensusparams)
10#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
11pub struct Params {
12    /// Parameters limiting the size of a block and time between consecutive blocks.
13    pub block: block::Size,
14    /// Parameters limiting the validity of evidence of byzantine behaviour.
15    pub evidence: evidence::Params,
16    /// Parameters limiting the types of public keys validators can use.
17    pub validator: ValidatorParams,
18    /// The ABCI application version.
19    #[serde(skip)] // FIXME: kvstore /genesis returns '{}' instead of '{app_version: "0"}'
20    pub version: Option<VersionParams>,
21}
22
23/// ValidatorParams restrict the public key types validators can use.
24///
25/// [Tendermint documentation](https://docs.tendermint.com/master/spec/core/data_structures.html#validatorparams)
26#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
27pub struct ValidatorParams {
28    /// List of accepted public key types.
29    pub pub_key_types: Vec<public_key::Algorithm>,
30}
31
32/// Version Parameters
33///
34/// [Tendermint documentation](https://docs.tendermint.com/master/spec/core/data_structures.html#versionparams)
35#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq, Default)]
36pub struct VersionParams {
37    /// The ABCI application version.
38    #[serde(with = "crate::serializers::from_str")]
39    pub app: u64,
40}
41
42// =============================================================================
43// Protobuf conversions
44// =============================================================================
45
46// Todo: How are these key types created?
47fn key_type(s: &str) -> public_key::Algorithm {
48    if s == "Ed25519" || s == "ed25519" {
49        return public_key::Algorithm::Ed25519;
50    }
51    if s == "Secp256k1" || s == "secp256k1" {
52        return public_key::Algorithm::Secp256k1;
53    }
54    public_key::Algorithm::Ed25519 // Todo: Shall we error out for invalid key types?
55}
56
57mod v0_34 {
58    use celestia_tendermint_proto::v0_34::{
59        abci::ConsensusParams as RawAbciParams,
60        types::{
61            ConsensusParams as RawParams, ValidatorParams as RawValidatorParams,
62            VersionParams as RawVersionParams,
63        },
64    };
65    use celestia_tendermint_proto::Protobuf;
66
67    use super::{key_type, Params, ValidatorParams, VersionParams};
68    use crate::{error::Error, prelude::*, public_key};
69
70    impl Protobuf<RawParams> for Params {}
71
72    impl TryFrom<RawParams> for Params {
73        type Error = Error;
74
75        fn try_from(value: RawParams) -> Result<Self, Self::Error> {
76            Ok(Self {
77                block: value
78                    .block
79                    .ok_or_else(|| Error::invalid_block("missing block".to_string()))?
80                    .try_into()?,
81                evidence: value
82                    .evidence
83                    .ok_or_else(Error::invalid_evidence)?
84                    .try_into()?,
85                validator: value
86                    .validator
87                    .ok_or_else(Error::invalid_validator_params)?
88                    .try_into()?,
89                version: value.version.map(TryFrom::try_from).transpose()?,
90            })
91        }
92    }
93
94    impl From<Params> for RawParams {
95        fn from(value: Params) -> Self {
96            RawParams {
97                block: Some(value.block.into()),
98                evidence: Some(value.evidence.into()),
99                validator: Some(value.validator.into()),
100                version: value.version.map(From::from),
101            }
102        }
103    }
104
105    impl Protobuf<RawAbciParams> for Params {}
106
107    impl TryFrom<RawAbciParams> for Params {
108        type Error = Error;
109
110        fn try_from(value: RawAbciParams) -> Result<Self, Self::Error> {
111            Ok(Self {
112                block: value
113                    .block
114                    .ok_or_else(|| Error::invalid_block("missing block".to_string()))?
115                    .try_into()?,
116                evidence: value
117                    .evidence
118                    .ok_or_else(Error::invalid_evidence)?
119                    .try_into()?,
120                validator: value
121                    .validator
122                    .ok_or_else(Error::invalid_validator_params)?
123                    .try_into()?,
124                version: value.version.map(TryFrom::try_from).transpose()?,
125            })
126        }
127    }
128
129    impl From<Params> for RawAbciParams {
130        fn from(value: Params) -> Self {
131            RawAbciParams {
132                block: Some(value.block.into()),
133                evidence: Some(value.evidence.into()),
134                validator: Some(value.validator.into()),
135                version: value.version.map(From::from),
136            }
137        }
138    }
139
140    impl Protobuf<RawValidatorParams> for ValidatorParams {}
141
142    impl TryFrom<RawValidatorParams> for ValidatorParams {
143        type Error = Error;
144
145        fn try_from(value: RawValidatorParams) -> Result<Self, Self::Error> {
146            Ok(Self {
147                pub_key_types: value.pub_key_types.iter().map(|f| key_type(f)).collect(),
148            })
149        }
150    }
151
152    impl From<ValidatorParams> for RawValidatorParams {
153        fn from(value: ValidatorParams) -> Self {
154            RawValidatorParams {
155                pub_key_types: value
156                    .pub_key_types
157                    .into_iter()
158                    .map(|k| match k {
159                        public_key::Algorithm::Ed25519 => "ed25519".to_string(),
160                        public_key::Algorithm::Secp256k1 => "secp256k1".to_string(),
161                    })
162                    .collect(),
163            }
164        }
165    }
166
167    impl Protobuf<RawVersionParams> for VersionParams {}
168
169    impl TryFrom<RawVersionParams> for VersionParams {
170        type Error = Error;
171
172        fn try_from(value: RawVersionParams) -> Result<Self, Self::Error> {
173            Ok(Self {
174                app: value.app_version,
175            })
176        }
177    }
178
179    impl From<VersionParams> for RawVersionParams {
180        fn from(value: VersionParams) -> Self {
181            RawVersionParams {
182                app_version: value.app,
183            }
184        }
185    }
186}
187
188mod v0_37 {
189    use celestia_tendermint_proto::v0_37::types::{
190        ConsensusParams as RawParams, ValidatorParams as RawValidatorParams,
191        VersionParams as RawVersionParams,
192    };
193    use celestia_tendermint_proto::Protobuf;
194
195    use super::{key_type, Params, ValidatorParams, VersionParams};
196    use crate::{error::Error, prelude::*, public_key};
197
198    impl Protobuf<RawParams> for Params {}
199
200    impl TryFrom<RawParams> for Params {
201        type Error = Error;
202
203        fn try_from(value: RawParams) -> Result<Self, Self::Error> {
204            Ok(Self {
205                block: value
206                    .block
207                    .ok_or_else(|| Error::invalid_block("missing block".to_string()))?
208                    .try_into()?,
209                evidence: value
210                    .evidence
211                    .ok_or_else(Error::invalid_evidence)?
212                    .try_into()?,
213                validator: value
214                    .validator
215                    .ok_or_else(Error::invalid_validator_params)?
216                    .try_into()?,
217                version: value.version.map(TryFrom::try_from).transpose()?,
218            })
219        }
220    }
221
222    impl From<Params> for RawParams {
223        fn from(value: Params) -> Self {
224            RawParams {
225                block: Some(value.block.into()),
226                evidence: Some(value.evidence.into()),
227                validator: Some(value.validator.into()),
228                version: value.version.map(From::from),
229            }
230        }
231    }
232
233    impl Protobuf<RawValidatorParams> for ValidatorParams {}
234
235    impl TryFrom<RawValidatorParams> for ValidatorParams {
236        type Error = Error;
237
238        fn try_from(value: RawValidatorParams) -> Result<Self, Self::Error> {
239            Ok(Self {
240                pub_key_types: value.pub_key_types.iter().map(|f| key_type(f)).collect(),
241            })
242        }
243    }
244
245    impl From<ValidatorParams> for RawValidatorParams {
246        fn from(value: ValidatorParams) -> Self {
247            RawValidatorParams {
248                pub_key_types: value
249                    .pub_key_types
250                    .into_iter()
251                    .map(|k| match k {
252                        public_key::Algorithm::Ed25519 => "ed25519".to_string(),
253                        public_key::Algorithm::Secp256k1 => "secp256k1".to_string(),
254                    })
255                    .collect(),
256            }
257        }
258    }
259
260    impl Protobuf<RawVersionParams> for VersionParams {}
261
262    impl TryFrom<RawVersionParams> for VersionParams {
263        type Error = Error;
264
265        fn try_from(value: RawVersionParams) -> Result<Self, Self::Error> {
266            Ok(Self { app: value.app })
267        }
268    }
269
270    impl From<VersionParams> for RawVersionParams {
271        fn from(value: VersionParams) -> Self {
272            RawVersionParams { app: value.app }
273        }
274    }
275}
celestia_tendermint/consensus/params.rs

celestia_tendermint/consensus/
params.rs
