PR suggestions

iotaledger · Jul 31, 2023 · 121a4ba · 121a4ba
1 parent 81b9d84
commit 121a4ba
Show file tree

Hide file tree

Showing 31 changed files with 101 additions and 504 deletions.
diff --git a/sdk/src/types/block/address/account.rs b/sdk/src/types/block/address/account.rs
@@ -88,26 +88,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for AccountAddress {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = AccountAddressDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid account address type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for AccountAddress {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            AccountAddressDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(AccountAddress, AccountAddressDto, "account address");
 }
diff --git a/sdk/src/types/block/address/ed25519.rs b/sdk/src/types/block/address/ed25519.rs
@@ -79,26 +79,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for Ed25519Address {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = Ed25519AddressDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid ed25519 address type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for Ed25519Address {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            Ed25519AddressDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(Ed25519Address, Ed25519AddressDto, "ed25519 address");
 }
diff --git a/sdk/src/types/block/address/nft.rs b/sdk/src/types/block/address/nft.rs
@@ -88,26 +88,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for NftAddress {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = NftAddressDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid nft address type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for NftAddress {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            NftAddressDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(NftAddress, NftAddressDto, "nft address");
 }
diff --git a/sdk/src/types/block/core.rs b/sdk/src/types/block/core.rs
@@ -284,9 +284,12 @@ pub(crate) mod dto {
     use serde::{Deserialize, Serialize};
 
     use super::*;
-    use crate::types::{
-        block::{payload::dto::PayloadDto, Error},
-        TryFromDto, ValidationParams,
+    use crate::{
+        types::{
+            block::{payload::dto::PayloadDto, Error},
+            TryFromDto, ValidationParams,
+        },
+        utils::serde::string,
     };
 
     /// The block object that nodes gossip around in the network.
@@ -302,7 +305,7 @@ pub(crate) mod dto {
         ///
         #[serde(default, skip_serializing_if = "Option::is_none")]
         pub payload: Option<PayloadDto>,
-        #[serde(with = "crate::utils::serde::string")]
+        #[serde(with = "string")]
         pub burned_mana: u64,
     }
 

diff --git a/sdk/src/types/block/input/utxo.rs b/sdk/src/types/block/input/utxo.rs
@@ -82,26 +82,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for UtxoInput {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = UtxoInputDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid UTXO input type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            dto.try_into().map_err(serde::de::Error::custom)
-        }
-    }
-
-    impl Serialize for UtxoInput {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            UtxoInputDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(UtxoInput, UtxoInputDto, "UTXO input");
 }
diff --git a/sdk/src/types/block/macro.rs b/sdk/src/types/block/macro.rs
@@ -169,3 +169,32 @@ macro_rules! create_bitflags {
     };
 }
 pub(crate) use create_bitflags;
+
+#[macro_export]
+macro_rules! impl_serde_typed_dto {
+    ($base:ty, $dto:ty, $type_str:literal) => {
+        impl<'de> Deserialize<'de> for $base {
+            fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+                let dto = <$dto>::deserialize(d)?;
+                if dto.kind != Self::KIND {
+                    return Err(serde::de::Error::custom(format!(
+                        "invalid {} type: expected {}, found {}",
+                        $type_str,
+                        Self::KIND,
+                        dto.kind
+                    )));
+                }
+                dto.try_into().map_err(serde::de::Error::custom)
+            }
+        }
+
+        impl Serialize for $base {
+            fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+            where
+                S: serde::Serializer,
+            {
+                <$dto>::from(self).serialize(s)
+            }
+        }
+    };
+}
diff --git a/sdk/src/types/block/output/account.rs b/sdk/src/types/block/output/account.rs
@@ -756,7 +756,7 @@ pub(crate) mod dto {
         // Amount of IOTA tokens held by the output.
         #[serde(with = "string")]
         pub amount: u64,
-        #[serde(with = "crate::utils::serde::string")]
+        #[serde(with = "string")]
         pub mana: u64,
         // Native tokens held by the output.
         #[serde(skip_serializing_if = "Vec::is_empty", default)]

diff --git a/sdk/src/types/block/output/basic.rs b/sdk/src/types/block/output/basic.rs
@@ -371,7 +371,7 @@ pub(crate) mod dto {
         // Amount of IOTA tokens held by the output.
         #[serde(with = "string")]
         pub amount: u64,
-        #[serde(with = "crate::utils::serde::string")]
+        #[serde(with = "string")]
         pub mana: u64,
         // Native tokens held by the output.
         #[serde(skip_serializing_if = "Vec::is_empty", default)]

diff --git a/sdk/src/types/block/output/feature/issuer.rs b/sdk/src/types/block/output/feature/issuer.rs
@@ -55,26 +55,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for IssuerFeature {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = IssuerFeatureDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid issuer feature type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for IssuerFeature {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            IssuerFeatureDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(IssuerFeature, IssuerFeatureDto, "issuer feature");
 }
diff --git a/sdk/src/types/block/output/feature/metadata.rs b/sdk/src/types/block/output/feature/metadata.rs
@@ -105,26 +105,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for MetadataFeature {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = MetadataFeatureDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid metadata feature type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for MetadataFeature {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            MetadataFeatureDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(MetadataFeature, MetadataFeatureDto<'_>, "metadata feature");
 }
diff --git a/sdk/src/types/block/output/feature/sender.rs b/sdk/src/types/block/output/feature/sender.rs
@@ -55,26 +55,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for SenderFeature {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = SenderFeatureDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid sender feature type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for SenderFeature {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            SenderFeatureDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(SenderFeature, SenderFeatureDto, "sender feature");
 }
diff --git a/sdk/src/types/block/output/feature/staking.rs b/sdk/src/types/block/output/feature/staking.rs
@@ -95,26 +95,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for StakingFeature {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = StakingFeatureDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid staking feature type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for StakingFeature {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            StakingFeatureDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(StakingFeature, StakingFeatureDto, "staking feature");
 }
diff --git a/sdk/src/types/block/output/feature/tag.rs b/sdk/src/types/block/output/feature/tag.rs
@@ -97,26 +97,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for TagFeature {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = TagFeatureDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid tag feature type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for TagFeature {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            TagFeatureDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(TagFeature, TagFeatureDto<'_>, "tag feature");
 }
diff --git a/sdk/src/types/block/output/nft.rs b/sdk/src/types/block/output/nft.rs
@@ -525,7 +525,7 @@ pub(crate) mod dto {
         // Amount of IOTA tokens held by the output.
         #[serde(with = "string")]
         pub amount: u64,
-        #[serde(with = "crate::utils::serde::string")]
+        #[serde(with = "string")]
         pub mana: u64,
         // Native tokens held by the output.
         #[serde(skip_serializing_if = "Vec::is_empty", default)]

diff --git a/sdk/src/types/block/output/token_scheme/simple.rs b/sdk/src/types/block/output/token_scheme/simple.rs
@@ -157,26 +157,5 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for SimpleTokenScheme {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = SimpleTokenSchemeDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid simple token scheme type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            dto.try_into().map_err(serde::de::Error::custom)
-        }
-    }
-
-    impl Serialize for SimpleTokenScheme {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            SimpleTokenSchemeDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(SimpleTokenScheme, SimpleTokenSchemeDto, "simple token scheme");
 }
diff --git a/sdk/src/types/block/output/unlock_condition/address.rs b/sdk/src/types/block/output/unlock_condition/address.rs
@@ -55,26 +55,9 @@ mod dto {
         }
     }
 
-    impl<'de> Deserialize<'de> for AddressUnlockCondition {
-        fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-            let dto = AddressUnlockConditionDto::deserialize(d)?;
-            if dto.kind != Self::KIND {
-                return Err(serde::de::Error::custom(format!(
-                    "invalid address unlock condition type: expected {}, found {}",
-                    Self::KIND,
-                    dto.kind
-                )));
-            }
-            Ok(dto.into())
-        }
-    }
-
-    impl Serialize for AddressUnlockCondition {
-        fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-        where
-            S: serde::Serializer,
-        {
-            AddressUnlockConditionDto::from(self).serialize(s)
-        }
-    }
+    impl_serde_typed_dto!(
+        AddressUnlockCondition,
+        AddressUnlockConditionDto,
+        "address unlock condition"
+    );
 }