ens-normalize-rs 0.2.0

Ethereum Name Service (ENS) name normalization
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
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
133
134
135
136
137
138
139

use crate::{constants, utils, CodePoint};

/// Represents a token in an ENS name.
/// see <https://docs.ens.domains/ensip/15#tokenize> for more details.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EnsNameToken {
    Valid(TokenValid),
    Mapped(TokenMapped),
    Ignored(TokenIgnored),
    Disallowed(TokenDisallowed),
    Stop(TokenStop),
    Nfc(TokenNfc),
    Emoji(TokenEmoji),
}

impl EnsNameToken {
    pub fn cps(&self) -> Vec<CodePoint> {
        match self {
            EnsNameToken::Valid(t) => t.cps.clone(),
            EnsNameToken::Mapped(t) => t.cps.clone(),
            EnsNameToken::Nfc(t) => t.cps.clone(),
            EnsNameToken::Emoji(t) => t.cps_no_fe0f.clone(),
            EnsNameToken::Disallowed(t) => vec![t.cp],
            EnsNameToken::Stop(t) => vec![t.cp],
            EnsNameToken::Ignored(t) => vec![t.cp],
        }
    }

    pub fn input_size(&self) -> usize {
        match self {
            EnsNameToken::Valid(t) => t.cps.len(),
            EnsNameToken::Nfc(t) => t.input.len(),
            EnsNameToken::Emoji(t) => t.cps_input.len(),
            EnsNameToken::Mapped(_) => 1,
            EnsNameToken::Disallowed(_) => 1,
            EnsNameToken::Ignored(_) => 1,
            EnsNameToken::Stop(_) => 1,
        }
    }

    pub fn is_text(&self) -> bool {
        matches!(
            self,
            EnsNameToken::Valid(_) | EnsNameToken::Mapped(_) | EnsNameToken::Nfc(_)
        )
    }

    pub fn is_emoji(&self) -> bool {
        matches!(self, EnsNameToken::Emoji(_))
    }

    pub fn is_ignored(&self) -> bool {
        matches!(self, EnsNameToken::Ignored(_))
    }

    pub fn is_disallowed(&self) -> bool {
        matches!(self, EnsNameToken::Disallowed(_))
    }

    pub fn is_stop(&self) -> bool {
        matches!(self, EnsNameToken::Stop(_))
    }

    pub fn stop() -> Self {
        Self::Stop(TokenStop {
            cp: constants::CP_STOP,
        })
    }

    pub fn as_string(&self) -> String {
        utils::cps2str(&self.cps())
    }
}

/// A valid vector of code points
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenValid {
    pub cps: Vec<CodePoint>,
}

/// Code point should be mapped to vector of code points
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenMapped {
    pub cps: Vec<CodePoint>,
    pub cp: CodePoint,
}

/// Code point should be ignored
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenIgnored {
    pub cp: CodePoint,
}

/// Code point is disallowed
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenDisallowed {
    pub cp: CodePoint,
}

/// Represents a stop token (.)
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenStop {
    pub cp: CodePoint,
}

/// Represents a vector of code points that should be normalized using NFC
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenNfc {
    pub cps: Vec<CodePoint>,
    pub input: Vec<CodePoint>,
}

/// Represents a vector of code points of emoji
/// `cps_input` contains vector of code from input string
/// `emoji` contains vector of beautified emoji code points
/// `cps_no_fe0f` contains vector of code points of emoji without `FE0F`
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TokenEmoji {
    pub input: String,
    pub emoji: Vec<CodePoint>,
    pub cps_input: Vec<CodePoint>,
    pub cps_no_fe0f: Vec<CodePoint>,
}

/// Represents a collapsed token in an ENS name: either text or emoji
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CollapsedEnsNameToken {
    Text(TokenValid),
    Emoji(TokenEmoji),
}

impl CollapsedEnsNameToken {
    pub fn input_size(&self) -> usize {
        match self {
            CollapsedEnsNameToken::Text(t) => t.cps.len(),
            CollapsedEnsNameToken::Emoji(t) => t.cps_input.len(),
        }
    }
}