1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Wrapper type for serializing Move module IDs as strings.

use anyhow::Result;
use move_core_types::{
    account_address::AccountAddress,
    language_storage::{ModuleId, StructTag},
    parser::parse_struct_tag,
};
use serde::{Deserialize, Serialize, Serializer};
use std::{fmt::Display, str::FromStr};

/// Wrapper around [ModuleId] which is serialized as a string.
#[derive(Debug, PartialEq, Hash, Eq, Clone, PartialOrd, Ord)]
pub struct ModuleIdData(ModuleId);

impl ModuleIdData {
    /// Gets the address of the module.
    pub fn address(&self) -> &AccountAddress {
        self.0.address()
    }

    /// Gets the name of the module as a [String].
    pub fn name(&self) -> &str {
        self.0.name().as_str()
    }

    /// Renders the [ModuleIdData] as a short string.
    ///
    /// # Example
    ///
    /// ```
    /// use module_id::*;
    /// let id: ModuleIdData = module_id::parse_module_id("0x1::Errors").unwrap();
    /// assert_eq!("0x1::Errors", id.short_str_lossless());
    /// ```
    pub fn short_str_lossless(&self) -> String {
        self.0.short_str_lossless()
    }

    /// Gets the [ModuleId].
    pub fn inner(&self) -> &ModuleId {
        &self.0
    }
}

impl Display for ModuleIdData {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.short_str_lossless().fmt(f)
    }
}

impl Serialize for ModuleIdData {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.0.short_str_lossless())
    }
}

impl From<&ModuleId> for ModuleIdData {
    fn from(id: &ModuleId) -> Self {
        Self(id.clone())
    }
}

impl From<ModuleId> for ModuleIdData {
    fn from(id: ModuleId) -> Self {
        Self(id)
    }
}

impl From<&ModuleIdData> for ModuleId {
    fn from(id: &ModuleIdData) -> Self {
        id.0.clone()
    }
}

impl From<ModuleIdData> for ModuleId {
    fn from(id: ModuleIdData) -> Self {
        id.0
    }
}

impl<'de> Deserialize<'de> for ModuleIdData {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        ModuleIdData::from_str(&s).map_err(serde::de::Error::custom)
    }
}

impl FromStr for ModuleIdData {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let tt: StructTag = parse_struct_tag(&format!("{}::Dummy", s))?;
        Ok(ModuleIdData(tt.module_id()))
    }
}

/// Parses a module ID.
///
/// # Example
///
/// ```
/// use move_core_types::language_storage::ModuleId;
/// let id: ModuleId = module_id::parse_module_id("0x1::Errors").unwrap().into();
/// assert_eq!("0x1::Errors", id.short_str_lossless());
/// ```
pub fn parse_module_id(raw: &str) -> Result<ModuleIdData> {
    ModuleIdData::from_str(raw)
}

#[cfg(test)]
mod tests {
    use move_core_types::parser::parse_struct_tag;

    use crate::ModuleIdData;

    #[test]
    fn test_serde() {
        let my_module_id = ModuleIdData(parse_struct_tag("0x1::A::B").unwrap().module_id());

        let ser = serde_json::to_string(&my_module_id).unwrap();
        let des: ModuleIdData = serde_json::from_str(&ser).unwrap();

        assert_eq!(my_module_id, des);
    }
}