bee_block/address/
alias.rs

1// Copyright 2021 IOTA Stiftung
2// SPDX-License-Identifier: Apache-2.0
3
4use core::str::FromStr;
5
6use derive_more::{AsRef, Deref, From};
7
8use crate::{output::AliasId, Error};
9
10/// An alias address.
11#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, From, AsRef, Deref, packable::Packable)]
12#[as_ref(forward)]
13pub struct AliasAddress(AliasId);
14
15#[allow(clippy::len_without_is_empty)]
16impl AliasAddress {
17    /// The [`Address`](crate::address::Address) kind of an [`AliasAddress`].
18    pub const KIND: u8 = 8;
19    /// The length of an [`AliasAddress`].
20    pub const LENGTH: usize = AliasId::LENGTH;
21
22    /// Creates a new [`AliasAddress`].
23    #[inline(always)]
24    pub fn new(id: AliasId) -> Self {
25        Self::from(id)
26    }
27
28    /// Returns the [`AliasId`] of an [`AliasAddress`].
29    #[inline(always)]
30    pub fn alias_id(&self) -> &AliasId {
31        &self.0
32    }
33}
34
35#[cfg(feature = "serde")]
36string_serde_impl!(AliasAddress);
37
38impl FromStr for AliasAddress {
39    type Err = Error;
40
41    fn from_str(s: &str) -> Result<Self, Self::Err> {
42        Ok(AliasAddress::new(AliasId::from_str(s)?))
43    }
44}
45
46impl core::fmt::Display for AliasAddress {
47    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
48        write!(f, "{}", self.0)
49    }
50}
51
52impl core::fmt::Debug for AliasAddress {
53    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
54        write!(f, "AliasAddress({})", self)
55    }
56}
57
58#[cfg(feature = "dto")]
59#[allow(missing_docs)]
60pub mod dto {
61    use serde::{Deserialize, Serialize};
62
63    use super::*;
64    use crate::error::dto::DtoError;
65
66    /// Describes an alias address.
67    #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
68    pub struct AliasAddressDto {
69        #[serde(rename = "type")]
70        pub kind: u8,
71        #[serde(rename = "aliasId")]
72        pub alias_id: String,
73    }
74
75    impl From<&AliasAddress> for AliasAddressDto {
76        fn from(value: &AliasAddress) -> Self {
77            Self {
78                kind: AliasAddress::KIND,
79                alias_id: value.to_string(),
80            }
81        }
82    }
83
84    impl TryFrom<&AliasAddressDto> for AliasAddress {
85        type Error = DtoError;
86
87        fn try_from(value: &AliasAddressDto) -> Result<Self, Self::Error> {
88            value
89                .alias_id
90                .parse::<AliasAddress>()
91                .map_err(|_| DtoError::InvalidField("alias address"))
92        }
93    }
94}