polymesh_api_client/
serde_impl.rs

1use serde::{de, ser, Deserialize, Serialize};
2
3use core::{fmt, str::FromStr};
4use sp_core::crypto::Ss58Codec;
5
6use crate::basic_types::{AccountId, AccountTraits, AssetId, IdentityId, MultiAddress};
7
8impl<AccountId, AccountIndex> ser::Serialize for MultiAddress<AccountId, AccountIndex>
9where
10  AccountId: AccountTraits,
11  AccountIndex: AccountTraits,
12{
13  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
14  where
15    S: ser::Serializer,
16  {
17    match self {
18      Self::Id(account) => {
19        if serializer.is_human_readable() {
20          account.serialize(serializer)
21        } else {
22          serializer.serialize_newtype_variant("MultiAddress", 0, "Id", account)
23        }
24      }
25      Self::Index(index) => serializer.serialize_newtype_variant("MultiAddress", 1, "Index", index),
26      Self::Raw(data) => {
27        if serializer.is_human_readable() {
28          let h = hex::encode(data.as_slice());
29          serializer.serialize_newtype_variant("MultiAddress", 2, "Raw", &h)
30        } else {
31          serializer.serialize_newtype_variant("MultiAddress", 2, "Raw", data)
32        }
33      }
34      Self::Address32(address) => {
35        if serializer.is_human_readable() {
36          let h = hex::encode(&address[..]);
37          serializer.serialize_newtype_variant("MultiAddress", 3, "Address32", &h)
38        } else {
39          serializer.serialize_newtype_variant("MultiAddress", 3, "Address32", address)
40        }
41      }
42      Self::Address20(address) => {
43        if serializer.is_human_readable() {
44          let h = hex::encode(&address[..]);
45          serializer.serialize_newtype_variant("MultiAddress", 4, "Address20", &h)
46        } else {
47          serializer.serialize_newtype_variant("MultiAddress", 4, "Address20", address)
48        }
49      }
50    }
51  }
52}
53
54#[derive(Deserialize)]
55#[serde(field_identifier, rename_all = "PascalCase")]
56enum MultiAddressField {
57  Id,
58  Index,
59  Raw,
60  Address32,
61  Address20,
62}
63
64#[derive(Default)]
65struct MultiAddressVisitor<AccountId: AccountTraits, AccountIndex: AccountTraits> {
66  is_human_readable: bool,
67  _phantom: core::marker::PhantomData<(AccountId, AccountIndex)>,
68}
69
70impl<AccountId: AccountTraits, AccountIndex: AccountTraits>
71  MultiAddressVisitor<AccountId, AccountIndex>
72{
73  fn new(is_human_readable: bool) -> Self {
74    Self {
75      is_human_readable,
76      _phantom: Default::default(),
77    }
78  }
79}
80
81impl<'de, AccountId, AccountIndex> de::Visitor<'de> for MultiAddressVisitor<AccountId, AccountIndex>
82where
83  AccountId: AccountTraits,
84  AccountIndex: AccountTraits,
85{
86  type Value = MultiAddress<AccountId, AccountIndex>;
87
88  fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
89    formatter.write_str("AccountId or MultiAddress")
90  }
91
92  fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
93  where
94    E: de::Error,
95  {
96    let account = AccountId::from_str(v)
97      .map_err(|_e| de::Error::custom(format!("Failed to decode AccountId")))?;
98    Ok(MultiAddress::Id(account))
99  }
100
101  fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
102  where
103    V: de::MapAccess<'de>,
104  {
105    let mut address = None;
106    while let Some(key) = map.next_key()? {
107      match key {
108        MultiAddressField::Id => {
109          if address.is_some() {
110            return Err(de::Error::duplicate_field("Id"));
111          }
112          address = Some(MultiAddress::Id(map.next_value()?));
113        }
114        MultiAddressField::Index => {
115          if address.is_some() {
116            return Err(de::Error::duplicate_field("Index"));
117          }
118          address = Some(MultiAddress::Index(map.next_value()?));
119        }
120        MultiAddressField::Raw => {
121          if address.is_some() {
122            return Err(de::Error::duplicate_field("Raw"));
123          }
124          if self.is_human_readable {
125            let h: &str = map.next_value()?;
126            let off = if h.starts_with("0x") { 2 } else { 0 };
127            let data = hex::decode(&h[off..]).map_err(|e| de::Error::custom(e))?;
128            address = Some(MultiAddress::Raw(data));
129          } else {
130            address = Some(MultiAddress::Raw(map.next_value()?));
131          }
132        }
133        MultiAddressField::Address32 => {
134          if address.is_some() {
135            return Err(de::Error::duplicate_field("Address32"));
136          }
137          if self.is_human_readable {
138            let h: &str = map.next_value()?;
139            let mut data = [0u8; 32];
140            let off = if h.starts_with("0x") { 2 } else { 0 };
141            hex::decode_to_slice(&h[off..], &mut data).map_err(|e| de::Error::custom(e))?;
142            address = Some(MultiAddress::Address32(data));
143          } else {
144            address = Some(MultiAddress::Address32(map.next_value()?));
145          }
146        }
147        MultiAddressField::Address20 => {
148          if address.is_some() {
149            return Err(de::Error::duplicate_field("Address20"));
150          }
151          if self.is_human_readable {
152            let h: &str = map.next_value()?;
153            let mut data = [0u8; 20];
154            let off = if h.starts_with("0x") { 2 } else { 0 };
155            hex::decode_to_slice(&h[off..], &mut data).map_err(|e| de::Error::custom(e))?;
156            address = Some(MultiAddress::Address20(data));
157          } else {
158            address = Some(MultiAddress::Address20(map.next_value()?));
159          }
160        }
161      }
162    }
163    let address =
164      address.ok_or_else(|| de::Error::missing_field("Id, Index, Raw, Address32, or Address20"))?;
165    Ok(address)
166  }
167}
168
169impl<'de, AccountId, AccountIndex> Deserialize<'de> for MultiAddress<AccountId, AccountIndex>
170where
171  AccountId: AccountTraits,
172  AccountIndex: AccountTraits,
173{
174  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
175  where
176    D: de::Deserializer<'de>,
177  {
178    let visitor = MultiAddressVisitor::new(deserializer.is_human_readable());
179    if deserializer.is_human_readable() {
180      deserializer.deserialize_any(visitor)
181    } else {
182      deserializer.deserialize_enum(
183        "MultiAddress",
184        &["Id", "Index", "Raw", "Address32", "Address20"],
185        visitor,
186      )
187    }
188  }
189}
190
191impl Serialize for AccountId {
192  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
193  where
194    S: ser::Serializer,
195  {
196    if serializer.is_human_readable() {
197      let ss58 = self.to_ss58check();
198      serializer.serialize_str(&ss58)
199    } else {
200      self.0.serialize(serializer)
201    }
202  }
203}
204
205impl<'de> Deserialize<'de> for AccountId {
206  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
207  where
208    D: de::Deserializer<'de>,
209  {
210    if deserializer.is_human_readable() {
211      struct StringOrBytesVisitor;
212
213      impl<'de> de::Visitor<'de> for StringOrBytesVisitor {
214        type Value = AccountId;
215
216        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
217          formatter.write_str("a hex string or [u8; 32]")
218        }
219
220        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
221        where
222          E: de::Error,
223        {
224          Ok(AccountId::from_str(s).map_err(|e| de::Error::custom(e))?)
225        }
226
227        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
228        where
229          A: de::SeqAccess<'de>,
230        {
231          let mut id = AccountId::default();
232          for n in 0..32 {
233            id.0[n] = seq
234              .next_element()?
235              .ok_or_else(|| de::Error::invalid_length(n, &self))?;
236          }
237          Ok(id)
238        }
239      }
240      deserializer.deserialize_any(StringOrBytesVisitor)
241    } else {
242      Ok(Self(Deserialize::deserialize(deserializer)?))
243    }
244  }
245}
246
247impl Serialize for IdentityId {
248  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
249  where
250    S: ser::Serializer,
251  {
252    if serializer.is_human_readable() {
253      let h = format!("0x{}", hex::encode(&self.0));
254      serializer.serialize_str(&h)
255    } else {
256      self.0.serialize(serializer)
257    }
258  }
259}
260
261impl<'de> Deserialize<'de> for IdentityId {
262  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
263  where
264    D: de::Deserializer<'de>,
265  {
266    if deserializer.is_human_readable() {
267      struct StringOrBytesVisitor;
268
269      impl<'de> de::Visitor<'de> for StringOrBytesVisitor {
270        type Value = IdentityId;
271
272        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
273          formatter.write_str("a hex string or [u8; 32]")
274        }
275
276        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
277        where
278          E: de::Error,
279        {
280          let mut id = IdentityId::default();
281          let off = if s.starts_with("0x") { 2 } else { 0 };
282          hex::decode_to_slice(&s[off..], &mut id.0).map_err(|e| de::Error::custom(e))?;
283          Ok(id)
284        }
285
286        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
287        where
288          A: de::SeqAccess<'de>,
289        {
290          let mut id = IdentityId::default();
291          for n in 0..32 {
292            id.0[n] = seq
293              .next_element()?
294              .ok_or_else(|| de::Error::invalid_length(n, &self))?;
295          }
296          Ok(id)
297        }
298      }
299      deserializer.deserialize_any(StringOrBytesVisitor)
300    } else {
301      Ok(Self(Deserialize::deserialize(deserializer)?))
302    }
303  }
304}
305
306impl Serialize for AssetId {
307  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
308  where
309    S: ser::Serializer,
310  {
311    self.as_uuid().serialize(serializer)
312  }
313}
314
315impl<'de> Deserialize<'de> for AssetId {
316  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
317  where
318    D: de::Deserializer<'de>,
319  {
320    let uuid: uuid::Uuid = Deserialize::deserialize(deserializer)?;
321    Ok(Self(uuid.into_bytes()))
322  }
323}
polymesh_api_client/serde_impl.rs

polymesh_api_client/
serde_impl.rs
