bs721_base/
helpers.rs

1use std::marker::PhantomData;
2
3use cosmwasm_schema::cw_serde;
4use cosmwasm_std::{
5    to_binary, Addr, CosmosMsg, CustomMsg, QuerierWrapper, StdResult, WasmMsg, WasmQuery,
6};
7use bs721::{
8    AllNftInfoResponse, Approval, ApprovalResponse, ApprovalsResponse, ContractInfoResponse,
9    NftInfoResponse, NumTokensResponse, OperatorsResponse, OwnerOfResponse, TokensResponse,
10};
11use serde::de::DeserializeOwned;
12use serde::Serialize;
13
14use crate::{ExecuteMsg, QueryMsg};
15
16#[cw_serde]
17pub struct Bs721Contract<Q: CustomMsg, E: CustomMsg>(
18    pub Addr,
19    pub PhantomData<Q>,
20    pub PhantomData<E>,
21);
22
23#[allow(dead_code)]
24impl<Q: CustomMsg, E: CustomMsg> Bs721Contract<Q, E> {
25    pub fn addr(&self) -> Addr {
26        self.0.clone()
27    }
28
29    pub fn call<T: Serialize>(&self, msg: ExecuteMsg<T, E>) -> StdResult<CosmosMsg> {
30        let msg = to_binary(&msg)?;
31        Ok(WasmMsg::Execute {
32            contract_addr: self.addr().into(),
33            msg,
34            funds: vec![],
35        }
36        .into())
37    }
38
39    pub fn query<T: DeserializeOwned>(
40        &self,
41        querier: &QuerierWrapper,
42        req: QueryMsg<Q>,
43    ) -> StdResult<T> {
44        let query = WasmQuery::Smart {
45            contract_addr: self.addr().into(),
46            msg: to_binary(&req)?,
47        }
48        .into();
49        querier.query(&query)
50    }
51
52    /*** queries ***/
53
54    pub fn owner_of<T: Into<String>>(
55        &self,
56        querier: &QuerierWrapper,
57        token_id: T,
58        include_expired: bool,
59    ) -> StdResult<OwnerOfResponse> {
60        let req = QueryMsg::OwnerOf {
61            token_id: token_id.into(),
62            include_expired: Some(include_expired),
63        };
64        self.query(querier, req)
65    }
66
67    pub fn approval<T: Into<String>>(
68        &self,
69        querier: &QuerierWrapper,
70        token_id: T,
71        spender: T,
72        include_expired: Option<bool>,
73    ) -> StdResult<ApprovalResponse> {
74        let req = QueryMsg::Approval {
75            token_id: token_id.into(),
76            spender: spender.into(),
77            include_expired,
78        };
79        let res: ApprovalResponse = self.query(querier, req)?;
80        Ok(res)
81    }
82
83    pub fn approvals<T: Into<String>>(
84        &self,
85        querier: &QuerierWrapper,
86        token_id: T,
87        include_expired: Option<bool>,
88    ) -> StdResult<ApprovalsResponse> {
89        let req = QueryMsg::Approvals {
90            token_id: token_id.into(),
91            include_expired,
92        };
93        let res: ApprovalsResponse = self.query(querier, req)?;
94        Ok(res)
95    }
96
97    pub fn all_operators<T: Into<String>>(
98        &self,
99        querier: &QuerierWrapper,
100        owner: T,
101        include_expired: bool,
102        start_after: Option<String>,
103        limit: Option<u32>,
104    ) -> StdResult<Vec<Approval>> {
105        let req = QueryMsg::AllOperators {
106            owner: owner.into(),
107            include_expired: Some(include_expired),
108            start_after,
109            limit,
110        };
111        let res: OperatorsResponse = self.query(querier, req)?;
112        Ok(res.operators)
113    }
114
115    pub fn num_tokens(&self, querier: &QuerierWrapper) -> StdResult<u64> {
116        let req = QueryMsg::NumTokens {};
117        let res: NumTokensResponse = self.query(querier, req)?;
118        Ok(res.count)
119    }
120
121    /// With metadata extension
122    pub fn contract_info(&self, querier: &QuerierWrapper) -> StdResult<ContractInfoResponse> {
123        let req = QueryMsg::ContractInfo {};
124        self.query(querier, req)
125    }
126
127    /// With metadata extension
128    pub fn nft_info<T: Into<String>, U: DeserializeOwned>(
129        &self,
130        querier: &QuerierWrapper,
131        token_id: T,
132    ) -> StdResult<NftInfoResponse<U>> {
133        let req = QueryMsg::NftInfo {
134            token_id: token_id.into(),
135        };
136        self.query(querier, req)
137    }
138
139    /// With metadata extension
140    pub fn all_nft_info<T: Into<String>, U: DeserializeOwned>(
141        &self,
142        querier: &QuerierWrapper,
143        token_id: T,
144        include_expired: bool,
145    ) -> StdResult<AllNftInfoResponse<U>> {
146        let req = QueryMsg::AllNftInfo {
147            token_id: token_id.into(),
148            include_expired: Some(include_expired),
149        };
150        self.query(querier, req)
151    }
152
153    /// With enumerable extension
154    pub fn tokens<T: Into<String>>(
155        &self,
156        querier: &QuerierWrapper,
157        owner: T,
158        start_after: Option<String>,
159        limit: Option<u32>,
160    ) -> StdResult<TokensResponse> {
161        let req = QueryMsg::Tokens {
162            owner: owner.into(),
163            start_after,
164            limit,
165        };
166        self.query(querier, req)
167    }
168
169    /// With enumerable extension
170    pub fn all_tokens(
171        &self,
172        querier: &QuerierWrapper,
173        start_after: Option<String>,
174        limit: Option<u32>,
175    ) -> StdResult<TokensResponse> {
176        let req = QueryMsg::AllTokens { start_after, limit };
177        self.query(querier, req)
178    }
179
180    /// returns true if the contract supports the metadata extension
181    pub fn has_metadata(&self, querier: &QuerierWrapper) -> bool {
182        self.contract_info(querier).is_ok()
183    }
184
185    /// returns true if the contract supports the enumerable extension
186    pub fn has_enumerable(&self, querier: &QuerierWrapper) -> bool {
187        self.tokens(querier, self.addr(), None, Some(1)).is_ok()
188    }
189}
bs721_base/helpers.rs

bs721_base/
helpers.rs
