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

use multiversx_sc::api::ManagedTypeApi;
use multiversx_sc::types::{EgldOrEsdtTokenIdentifier, ManagedBuffer, TokenIdentifier};
use multiversx_sc_scenario::api::StaticApi;
use crate::constants::EGLD_TOKEN_IDENTIFIER;
use crate::types::managed::ManagedConvertible;
use crate::types::native::NativeConvertible;

impl NativeConvertible for String {
    type Native = String;

    fn to_native(&self) -> Self::Native {
        self.clone()
    }
}

impl<M: ManagedTypeApi> NativeConvertible for ManagedBuffer<M> {
    type Native = String;

    fn to_native(&self) -> Self::Native {
        let bytes = self.to_boxed_bytes();
        let result = String::from_utf8_lossy(bytes.as_slice());

        result.to_string()
    }
}

impl<M: ManagedTypeApi> NativeConvertible for TokenIdentifier<M> {
    type Native = String;

    fn to_native(&self) -> Self::Native {
        self.as_managed_buffer().to_native()
    }
}

impl<M: ManagedTypeApi> NativeConvertible for EgldOrEsdtTokenIdentifier<M> {
    type Native = String;

    fn to_native(&self) -> Self::Native {
        if self.is_egld() {
            EGLD_TOKEN_IDENTIFIER.to_string()
        } else {
            self.clone().unwrap_esdt().to_native()
        }
    }
}

impl ManagedConvertible<ManagedBuffer<StaticApi>> for String {
    fn to_managed(&self) -> ManagedBuffer<StaticApi> {
        ManagedBuffer::from(self.as_bytes())
    }
}

impl ManagedConvertible<TokenIdentifier<StaticApi>> for String {
    fn to_managed(&self) -> TokenIdentifier<StaticApi> {
        TokenIdentifier::from(self.as_bytes())
    }
}

impl ManagedConvertible<EgldOrEsdtTokenIdentifier<StaticApi>> for String {
    fn to_managed(&self) -> EgldOrEsdtTokenIdentifier<StaticApi> {
        if self == EGLD_TOKEN_IDENTIFIER {
            EgldOrEsdtTokenIdentifier::egld()
        } else {
            let token_identifier: TokenIdentifier<StaticApi> = self.to_managed();
            EgldOrEsdtTokenIdentifier::esdt(token_identifier)
        }
    }
}

#[cfg(test)]
mod tests {
    use multiversx_sc::types::{ManagedBuffer, TokenIdentifier};
    use multiversx_sc_scenario::api::StaticApi;
    use crate::types::managed::ManagedConvertible;
    use crate::types::native::NativeConvertible;

    #[test]
    fn test_managed_buffer_to_native() {
        let buffer: ManagedBuffer<StaticApi> = ManagedBuffer::from("This is a buffer");
        let native = buffer.to_native();

        let expected = String::from("This is a buffer");

        assert_eq!(
            native,
            expected
        );
    }

    #[test]
    fn test_token_identifier_to_native() {
        let buffer: TokenIdentifier<StaticApi> = TokenIdentifier::from("WEGLD-abcdef");
        let native = buffer.to_native();

        let expected = String::from("WEGLD-abcdef");

        assert_eq!(
            native,
            expected
        );
    }

    #[test]
    fn test_string_to_managed_buffer() {
        let value = "This is a buffer".to_string();
        let managed: ManagedBuffer<StaticApi> = value.to_managed();

        assert_eq!(
            value.as_bytes(),
            managed.to_boxed_bytes().as_slice()
        );
    }

    #[test]
    fn test_string_to_token_identifier() {
        let value = "WEGLD-abcdef".to_string();
        let managed: TokenIdentifier<StaticApi> = value.to_managed();

        assert_eq!(
            value.as_bytes(),
            managed.to_boxed_bytes().as_slice()
        );
    }
}