ord-reqwest 0.4.1

A lightweight HTTP client for ordinals server and runes utility
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

use ordinals::Terms;

#[derive(serde::Deserialize)]
pub struct RuneEntry {
    pub spaced_rune: String,
    pub mints: u128,
    pub premine: u128,
    pub divisibility: u16,
    pub number: u128,
    pub terms: Option<Terms>,
}

impl RuneEntry {
    pub fn remaining_mints(&self) -> u128 {
        if self.terms.is_none() {
            return 0;
        }
        if let Some(cap) = self.terms.unwrap().cap {
            return cap - self.mints;
        }
        return 0;
    }
    pub fn premine_percentage(&self) -> f32 {
        if self.premine == 0 {
            return 0.0;
        }
        if self.terms.is_none() {
            return 0.0;
        }
        // normalize premine by dividing it to 10 ^ divisibility
        let denominator = 10_i32.pow(self.divisibility.into());

        let premine_normalized = if denominator != 0 {
            self.premine
                .div_ceil(10_i32.pow(self.divisibility.into()) as u128)
        } else {
            self.premine
        };
        let terms = self.terms.unwrap();
        let total_mints_supply = terms.amount.unwrap() * self.mints;
        let total_mints_normalized =
            total_mints_supply.div_ceil(10_i32.pow(self.divisibility.into()) as u128);
        let circulating_supply = total_mints_normalized + premine_normalized;
        let premine_percentage = (premine_normalized * 100) as f32 / circulating_supply as f32;
        // round to 2 decimal places
        return (premine_percentage * 100.0).round() / 100.0;
    }
}
#[derive(serde::Deserialize)]
pub struct RuneResponse {
    pub entry: RuneEntry,
    pub parent: Option<String>,
}

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

    #[test]
    fn test_premine_percentage() {
        let rune_entry = RuneEntry {
            divisibility: 2,
            spaced_rune: "Rune".to_string(),
            mints: 0,
            premine: 100,
            number: 1,
            terms: Some(Terms {
                amount: Some(1000),
                cap: Some(1000),
                ..Default::default()
            }),
        };
        assert_eq!(rune_entry.premine_percentage(), 100.0);
    }

    #[test]
    fn test_premine_percentage_nakamato() {
        let rune_entry = RuneEntry {
            divisibility: 0,
            spaced_rune: "Rune".to_string(),
            mints: 168000,
            premine: 420000000000000,
            number: 6,
            terms: Some(Terms {
                amount: Some(10000000000),
                cap: Some(168000),
                ..Default::default()
            }),
        };
        assert_eq!(rune_entry.premine_percentage(), 20.0);
    }

    #[test]
    fn test_premine_for_fehu() {
        let rune_entry = RuneEntry {
            spaced_rune: "Fehu".to_string(),
            mints: 452105,
            divisibility: 2,
            premine: 11000000000,
            number: 1,
            terms: Some(Terms {
                amount: Some(100),
                cap: Some(1111111),
                ..Default::default()
            }),
        };
        assert_eq!(rune_entry.premine_percentage(), 99.59);
    }
}