atp-caip 0.1.3

Chain Agnostic Improvement Proposals (CAIP) implementation for ATP(Account Transfer Protocol)
Documentation 
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

use candid::CandidType;
/// Common chain namespaces
#[derive(Debug, Clone, Copy, PartialEq, Eq, CandidType)]
pub enum ChainNamespace {
    Eip155,   // Ethereum and EVM-compatible chains
    Solana,   // Solana
    Cosmos,   // Cosmos chains
    Polkadot, // Polkadot chains
    Bip155,   // Bitcoin and Bitcoin-compatible chains
    Other(&'static str),
}

impl ChainNamespace {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Eip155 => "eip155",
            Self::Solana => "solana",
            Self::Cosmos => "cosmos",
            Self::Polkadot => "polkadot",
            Self::Bip155 => "bip155",
            Self::Other(s) => s,
        }
    }
}

impl From<ChainNamespace> for String {
    fn from(namespace: ChainNamespace) -> Self {
        namespace.as_str().to_string()
    }
}

/// Common asset namespaces
#[derive(Debug, Clone, Copy, PartialEq, Eq, CandidType)]
pub enum AssetNamespace {
    Slip44,  // Native tokens
    Erc20,   // ERC-20 tokens
    Erc721,  // ERC-721 NFTs
    Erc1155, // ERC-1155 tokens
    Spl,     // Solana SPL tokens
    Other(&'static str),
}

impl AssetNamespace {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Slip44 => "slip44",
            Self::Erc20 => "erc20",
            Self::Erc721 => "erc721",
            Self::Erc1155 => "erc1155",
            Self::Spl => "spl",
            Self::Other(s) => s,
        }
    }
}

impl From<AssetNamespace> for String {
    fn from(namespace: AssetNamespace) -> Self {
        namespace.as_str().to_string()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_chain_namespace() {
        assert_eq!(ChainNamespace::Eip155.as_str(), "eip155");
        assert_eq!(ChainNamespace::Solana.as_str(), "solana");
        assert_eq!(ChainNamespace::Cosmos.as_str(), "cosmos");
        assert_eq!(ChainNamespace::Polkadot.as_str(), "polkadot");
        assert_eq!(ChainNamespace::Bip155.as_str(), "bip155");
        assert_eq!(ChainNamespace::Other("custom").as_str(), "custom");

        let ns_str: String = ChainNamespace::Eip155.into();
        assert_eq!(ns_str, "eip155");
    }

    #[test]
    fn test_asset_namespace() {
        assert_eq!(AssetNamespace::Slip44.as_str(), "slip44");
        assert_eq!(AssetNamespace::Erc20.as_str(), "erc20");
        assert_eq!(AssetNamespace::Erc721.as_str(), "erc721");
        assert_eq!(AssetNamespace::Erc1155.as_str(), "erc1155");
        assert_eq!(AssetNamespace::Spl.as_str(), "spl");
        assert_eq!(AssetNamespace::Other("custom").as_str(), "custom");

        let ns_str: String = AssetNamespace::Erc20.into();
        assert_eq!(ns_str, "erc20");
    }
}