mpl-nft-packs 0.1.0

NFT Packs: mystery packs NFTs that are not revealed until after opening the pack.
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
140
141
142
143
144
145
146
147
148

//! Safe math implementation
use solana_program::program_error::ProgramError;

use crate::error::NFTPacksError;

/// Safe math
pub trait SafeMath<T> {
    /// error if overflow
    fn error_increment(self) -> Result<T, ProgramError>;
    /// error if overflow
    fn error_add(self, rhs: T) -> Result<T, ProgramError>;
    /// error if underflow
    fn error_sub(self, rhs: T) -> Result<T, ProgramError>;
    /// error if underflow
    fn error_decrement(self) -> Result<T, ProgramError>;
    /// error if overflow
    fn error_mul(self, rhs: T) -> Result<T, ProgramError>;
    /// error if underflow
    fn error_div(self, rhs: T) -> Result<T, ProgramError>;
}

impl SafeMath<u16> for u16 {
    fn error_increment(self) -> Result<u16, ProgramError> {
        self.checked_add(1)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_decrement(self) -> Result<u16, ProgramError> {
        self.checked_sub(1)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_add(self, rhs: u16) -> Result<u16, ProgramError> {
        self.checked_add(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_sub(self, rhs: u16) -> Result<u16, ProgramError> {
        self.checked_sub(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_mul(self, rhs: u16) -> Result<u16, ProgramError> {
        self.checked_mul(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_div(self, rhs: u16) -> Result<u16, ProgramError> {
        self.checked_div(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }
}

impl SafeMath<u32> for u32 {
    fn error_increment(self) -> Result<u32, ProgramError> {
        self.checked_add(1)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_decrement(self) -> Result<u32, ProgramError> {
        self.checked_sub(1)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_add(self, rhs: u32) -> Result<u32, ProgramError> {
        self.checked_add(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_sub(self, rhs: u32) -> Result<u32, ProgramError> {
        self.checked_sub(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_mul(self, rhs: u32) -> Result<u32, ProgramError> {
        self.checked_mul(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_div(self, rhs: u32) -> Result<u32, ProgramError> {
        self.checked_div(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }
}

impl SafeMath<u64> for u64 {
    fn error_increment(self) -> Result<u64, ProgramError> {
        self.checked_add(1)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_decrement(self) -> Result<u64, ProgramError> {
        self.checked_sub(1)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_add(self, rhs: u64) -> Result<u64, ProgramError> {
        self.checked_add(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_sub(self, rhs: u64) -> Result<u64, ProgramError> {
        self.checked_sub(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_mul(self, rhs: u64) -> Result<u64, ProgramError> {
        self.checked_mul(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_div(self, rhs: u64) -> Result<u64, ProgramError> {
        self.checked_div(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }
}

impl SafeMath<u128> for u128 {
    fn error_increment(self) -> Result<u128, ProgramError> {
        self.checked_add(1)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_decrement(self) -> Result<u128, ProgramError> {
        self.checked_sub(1)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_add(self, rhs: u128) -> Result<u128, ProgramError> {
        self.checked_add(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_sub(self, rhs: u128) -> Result<u128, ProgramError> {
        self.checked_sub(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }

    fn error_mul(self, rhs: u128) -> Result<u128, ProgramError> {
        self.checked_mul(rhs)
            .ok_or_else(|| NFTPacksError::Overflow.into())
    }

    fn error_div(self, rhs: u128) -> Result<u128, ProgramError> {
        self.checked_div(rhs)
            .ok_or_else(|| NFTPacksError::Underflow.into())
    }
}