iota_sdk/utils/
serde.rs

1// Copyright 2023 IOTA Stiftung
2// SPDX-License-Identifier: Apache-2.0
3
4pub mod string {
5    use alloc::string::String;
6    use core::{fmt::Display, str::FromStr};
7
8    use serde::{de, Deserialize, Deserializer, Serializer};
9
10    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
11    where
12        T: Display,
13        S: Serializer,
14    {
15        serializer.collect_str(value)
16    }
17
18    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
19    where
20        T: FromStr,
21        T::Err: Display,
22        D: Deserializer<'de>,
23    {
24        String::deserialize(deserializer)?.parse().map_err(de::Error::custom)
25    }
26}
27
28pub mod option_string {
29    use alloc::string::String;
30    use core::{fmt::Display, str::FromStr};
31
32    use serde::{de, Deserialize, Deserializer, Serializer};
33
34    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
35    where
36        T: Display,
37        S: Serializer,
38    {
39        match value {
40            Some(value) => serializer.collect_str(value),
41            None => serializer.serialize_none(),
42        }
43    }
44
45    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
46    where
47        T: FromStr,
48        T::Err: Display,
49        D: Deserializer<'de>,
50    {
51        Option::<String>::deserialize(deserializer)?
52            .map(|string| string.parse().map_err(de::Error::custom))
53            .transpose()
54    }
55}
56
57pub mod prefix_hex_bytes {
58    use alloc::string::String;
59
60    use prefix_hex::{FromHexPrefixed, ToHexPrefixed};
61    use serde::{de, Deserialize, Deserializer, Serializer};
62
63    pub fn serialize<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
64    where
65        S: Serializer,
66        for<'a> &'a T: ToHexPrefixed,
67    {
68        serializer.serialize_str(&prefix_hex::encode(value))
69    }
70
71    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
72    where
73        D: Deserializer<'de>,
74        T: FromHexPrefixed,
75    {
76        prefix_hex::decode(String::deserialize(deserializer)?).map_err(de::Error::custom)
77    }
78}
79
80pub mod option_prefix_hex_bytes {
81    use alloc::string::String;
82
83    use prefix_hex::{FromHexPrefixed, ToHexPrefixed};
84    use serde::{de, Deserialize, Deserializer, Serializer};
85
86    pub fn serialize<S, T>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
87    where
88        S: Serializer,
89        for<'a> &'a T: ToHexPrefixed,
90    {
91        match value {
92            Some(bytes) => super::prefix_hex_bytes::serialize(bytes, serializer),
93            None => serializer.serialize_none(),
94        }
95    }
96
97    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error>
98    where
99        D: Deserializer<'de>,
100        T: FromHexPrefixed,
101    {
102        Option::<String>::deserialize(deserializer)?
103            .map(|string| prefix_hex::decode(string).map_err(de::Error::custom))
104            .transpose()
105    }
106}
107
108pub mod string_prefix {
109    use alloc::string::String;
110
111    use packable::{bounded::Bounded, prefix::StringPrefix};
112    use serde::{de, Deserialize, Deserializer, Serializer};
113
114    pub fn serialize<T: Bounded, S>(value: &StringPrefix<T>, serializer: S) -> Result<S::Ok, S::Error>
115    where
116        S: Serializer,
117    {
118        serializer.collect_str(&**value)
119    }
120
121    pub fn deserialize<'de, T: Bounded, D>(deserializer: D) -> Result<StringPrefix<T>, D::Error>
122    where
123        D: Deserializer<'de>,
124        <T as TryFrom<usize>>::Error: core::fmt::Display,
125    {
126        String::deserialize(deserializer)
127            .map_err(de::Error::custom)
128            .and_then(|s| s.try_into().map_err(de::Error::custom))
129    }
130}
131
132#[cfg(feature = "client")]
133pub mod bip44 {
134    use crypto::keys::bip44::Bip44;
135    use serde::{Deserialize, Serialize};
136
137    #[derive(Default, Serialize, Deserialize)]
138    #[serde(default = "default_bip44", rename_all = "camelCase", remote = "Bip44")]
139    pub struct Bip44Def {
140        coin_type: u32,
141        account: u32,
142        change: u32,
143        address_index: u32,
144    }
145
146    fn default_bip44() -> Bip44 {
147        Bip44::new(crate::client::constants::IOTA_COIN_TYPE)
148    }
149
150    pub mod option_bip44 {
151        use serde::{Deserializer, Serializer};
152
153        use super::{Bip44Def, *};
154
155        pub fn serialize<S>(value: &Option<Bip44>, serializer: S) -> Result<S::Ok, S::Error>
156        where
157            S: Serializer,
158        {
159            #[derive(Serialize)]
160            struct Helper<'a>(#[serde(with = "Bip44Def")] &'a Bip44);
161
162            value.as_ref().map(Helper).serialize(serializer)
163        }
164
165        pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Bip44>, D::Error>
166        where
167            D: Deserializer<'de>,
168        {
169            #[derive(Deserialize)]
170            struct Helper(#[serde(with = "Bip44Def")] Bip44);
171
172            let helper = Option::deserialize(deserializer)?;
173            Ok(helper.map(|Helper(external)| external))
174        }
175    }
176}
iota_sdk/utils/serde.rs

iota_sdk/utils/
serde.rs
