ics721-types 0.1.0

an implementation of the ICS721 specification for transfering NFTs between blockchains
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
149

use std::ops::Deref;

use cosmwasm_schema::cw_serde;
use cosmwasm_std::{Binary, StdResult};
use cw_storage_plus::{Bound, Bounder, Key, KeyDeserialize, Prefixer, PrimaryKey};

/// A token ID according to the ICS-721 spec. The newtype pattern is
/// used here to provide some distinction between token and class IDs
/// in the type system.
#[cw_serde]
pub struct TokenId(String);

/// A token according to the ICS-721 spec.
#[cw_serde]
pub struct Token {
    /// A unique identifier for the token.
    pub id: TokenId,
    /// Optional URI pointing to off-chain metadata about the token.
    pub uri: Option<String>,
    /// Optional base64 encoded metadata about the token.
    pub data: Option<Binary>,
}

/// A class ID according to the ICS-721 spec. The newtype pattern is
/// used here to provide some distinction between token and class IDs
/// in the type system.
#[cw_serde]
pub struct ClassId(String);

#[cw_serde]
pub struct Class {
    /// A unique (from the source chain's perspective) identifier for
    /// the class.
    pub id: ClassId,
    /// Optional URI pointing to off-chain metadata about the class.
    pub uri: Option<String>,
    /// Optional base64 encoded metadata about the class.
    pub data: Option<Binary>,
}

impl TokenId {
    pub fn new<T>(token_id: T) -> Self
    where
        T: Into<String>,
    {
        Self(token_id.into())
    }
}

impl ClassId {
    pub fn new<T>(class_id: T) -> Self
    where
        T: Into<String>,
    {
        Self(class_id.into())
    }
}

#[cw_serde]
pub struct ClassToken {
    pub class_id: ClassId,
    pub token_id: TokenId,
}

impl<'a> Bounder<'a> for ClassId {
    fn inclusive_bound(self) -> Option<cw_storage_plus::Bound<'a, Self>> {
        Some(Bound::inclusive(self))
    }

    fn exclusive_bound(self) -> Option<cw_storage_plus::Bound<'a, Self>> {
        Some(Bound::exclusive(self))
    }
}

// Allow ClassId to be inferred into String
impl From<ClassId> for String {
    fn from(c: ClassId) -> Self {
        c.0
    }
}

impl From<TokenId> for String {
    fn from(t: TokenId) -> Self {
        t.0
    }
}

impl Deref for ClassId {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl std::fmt::Display for ClassId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

// Allow ClassId to be inferred into Key - using String.key()
impl<'a> PrimaryKey<'a> for ClassId {
    type Prefix = <String as PrimaryKey<'a>>::Prefix;
    type SubPrefix = <String as PrimaryKey<'a>>::SubPrefix;
    type Suffix = <String as PrimaryKey<'a>>::Suffix;
    type SuperSuffix = <String as PrimaryKey<'a>>::SuperSuffix;

    fn key(&self) -> Vec<cw_storage_plus::Key> {
        self.0.key()
    }
}

impl<'a> PrimaryKey<'a> for TokenId {
    type Prefix = <String as PrimaryKey<'a>>::Prefix;
    type SubPrefix = <String as PrimaryKey<'a>>::SubPrefix;
    type Suffix = <String as PrimaryKey<'a>>::Suffix;
    type SuperSuffix = <String as PrimaryKey<'a>>::SuperSuffix;

    fn key(&self) -> Vec<cw_storage_plus::Key> {
        self.0.key()
    }
}

impl<'a> Prefixer<'a> for ClassId {
    fn prefix(&self) -> Vec<Key> {
        self.0.prefix()
    }
}

impl<'a> Prefixer<'a> for TokenId {
    fn prefix(&self) -> Vec<Key> {
        self.0.prefix()
    }
}

impl KeyDeserialize for ClassId {
    type Output = <String as KeyDeserialize>::Output;
    fn from_vec(value: Vec<u8>) -> StdResult<Self::Output> {
        String::from_vec(value)
    }
}

impl KeyDeserialize for TokenId {
    type Output = <String as KeyDeserialize>::Output;
    fn from_vec(value: Vec<u8>) -> StdResult<Self::Output> {
        String::from_vec(value)
    }
}