1#![allow(dead_code)]
2use super::reverse_lookup::PAGE_SIZE;
3
4#[cfg(not(target_arch = "wasm32"))]
5use crate::cep78::{
6 modalities::{
7 BurnMode, EventsMode, MetadataMutability, MintingMode, NFTHolderMode, NFTIdentifierMode,
8 NFTKind, NFTMetadataKind, OwnerReverseLookupMode, OwnershipMode, WhitelistMode
9 },
10 token::TestCep78InitArgs
11};
12use odra::{args::Maybe, prelude::*};
13
14pub fn address_to_key(address: &Address) -> String {
15 match address {
16 Address::Account(account) => account.to_string(),
17 Address::Contract(contract) => contract.to_string()
18 }
19}
20
21pub fn max_number_of_pages(total_token_supply: u64) -> u64 {
22 if total_token_supply < PAGE_SIZE {
23 1
24 } else {
25 let max_number_of_pages = total_token_supply / PAGE_SIZE;
26 let overflow = total_token_supply % PAGE_SIZE;
27 if overflow == 0 {
28 max_number_of_pages
29 } else {
30 max_number_of_pages + 1
31 }
32 }
33}
34
35#[odra::module]
36pub struct MockDummyContract;
37
38#[odra::module]
39impl MockDummyContract {}
40
41#[odra::module]
42pub struct MockCep78TransferFilter {
43 value: Var<u8>
44}
45
46#[odra::module]
47impl MockCep78TransferFilter {
48 pub fn set_return_value(&mut self, return_value: u8) {
49 self.value.set(return_value);
50 }
51
52 pub fn can_transfer(&self) -> u8 {
53 self.value.get_or_default()
54 }
55}
56
57#[odra::module]
58pub struct MockCep78Operator {
59 nft_contract: External<NftContractContractRef>
60}
61
62#[odra::module]
63impl MockCep78Operator {
64 pub fn set_address(&mut self, nft_contract: &Address) {
65 self.nft_contract.set(*nft_contract);
66 }
67
68 pub fn mint(&mut self, token_metadata: String, is_reverse_lookup_enabled: bool) {
69 let addr = self.env().self_address();
70 if is_reverse_lookup_enabled {
71 self.nft_contract.register_owner(Maybe::Some(addr));
72 }
73
74 self.nft_contract.mint(addr, token_metadata, Maybe::None)
75 }
76
77 pub fn mint_with_hash(&mut self, token_metadata: String, token_hash: String) {
78 let addr = self.env().self_address();
79 self.nft_contract
80 .mint(addr, token_metadata, Maybe::Some(token_hash))
81 }
82
83 pub fn burn(&mut self, token_id: u64) {
84 self.nft_contract.burn(Maybe::Some(token_id), Maybe::None);
85 }
86
87 pub fn mint_for(&mut self, token_owner: Address, token_metadata: String) {
88 self.nft_contract
89 .mint(token_owner, token_metadata, Maybe::None)
90 }
91
92 pub fn transfer(&mut self, token_id: u64, target: Address) {
93 let address = self.env().self_address();
94 self.nft_contract
95 .transfer(Maybe::Some(token_id), Maybe::None, address, target)
96 }
97 pub fn transfer_from(&mut self, token_id: u64, source: Address, target: Address) {
98 self.nft_contract
99 .transfer(Maybe::Some(token_id), Maybe::None, source, target)
100 }
101
102 pub fn approve(&mut self, spender: Address, token_id: u64) {
103 self.nft_contract
104 .approve(spender, Maybe::Some(token_id), Maybe::None)
105 }
106
107 pub fn revoke(&mut self, token_id: u64) {
108 self.nft_contract.revoke(Maybe::Some(token_id), Maybe::None)
109 }
110}
111
112#[odra::external_contract]
113trait NftContract {
114 fn mint(&mut self, token_owner: Address, token_meta_data: String, token_hash: Maybe<String>);
115 fn burn(&mut self, token_id: Maybe<u64>, token_hash: Maybe<String>);
116 fn register_owner(&mut self, token_owner: Maybe<Address>) -> String;
117 fn transfer(
118 &mut self,
119 token_id: Maybe<u64>,
120 token_hash: Maybe<String>,
121 source_key: Address,
122 target_key: Address
123 );
124 fn approve(&mut self, spender: Address, token_id: Maybe<u64>, token_hash: Maybe<String>);
125 fn revoke(&mut self, token_id: Maybe<u64>, token_hash: Maybe<String>);
126}
127
128#[cfg(not(target_arch = "wasm32"))]
129#[derive(Default)]
130pub struct InitArgsBuilder {
131 collection_name: String,
132 collection_symbol: String,
133 total_token_supply: u64,
134 allow_minting: Maybe<bool>,
135 minting_mode: Maybe<MintingMode>,
136 ownership_mode: OwnershipMode,
137 nft_kind: NFTKind,
138 receipt_name: String,
139 holder_mode: Maybe<NFTHolderMode>,
140 whitelist_mode: Maybe<WhitelistMode>,
141 acl_white_list: Maybe<Vec<Address>>,
142 json_schema: Maybe<String>,
143 identifier_mode: NFTIdentifierMode,
144 burn_mode: Maybe<BurnMode>,
145 operator_burn_mode: Maybe<bool>,
146 nft_metadata_kind: NFTMetadataKind,
147 metadata_mutability: MetadataMutability,
148 owner_reverse_lookup_mode: Maybe<OwnerReverseLookupMode>,
149 events_mode: Maybe<EventsMode>,
150 transfer_filter_contract_contract_key: Maybe<Address>,
151 additional_required_metadata: Maybe<Vec<NFTMetadataKind>>,
152 optional_metadata: Maybe<Vec<NFTMetadataKind>>
153}
154
155#[cfg(not(target_arch = "wasm32"))]
156impl InitArgsBuilder {
157 pub fn collection_name(mut self, collection_name: String) -> Self {
158 self.collection_name = collection_name;
159 self
160 }
161
162 pub fn collection_symbol(mut self, collection_symbol: String) -> Self {
163 self.collection_symbol = collection_symbol;
164 self
165 }
166
167 pub fn total_token_supply(mut self, total_token_supply: u64) -> Self {
168 self.total_token_supply = total_token_supply;
169 self
170 }
171
172 pub fn allow_minting(mut self, allow_minting: bool) -> Self {
173 self.allow_minting = Maybe::Some(allow_minting);
174 self
175 }
176
177 pub fn nft_kind(mut self, nft_kind: NFTKind) -> Self {
178 self.nft_kind = nft_kind;
179 self
180 }
181
182 pub fn minting_mode(mut self, minting_mode: MintingMode) -> Self {
183 self.minting_mode = Maybe::Some(minting_mode);
184 self
185 }
186
187 pub fn ownership_mode(mut self, ownership_mode: OwnershipMode) -> Self {
188 self.ownership_mode = ownership_mode;
189 self
190 }
191
192 pub fn holder_mode(mut self, holder_mode: NFTHolderMode) -> Self {
193 self.holder_mode = Maybe::Some(holder_mode);
194 self
195 }
196
197 pub fn whitelist_mode(mut self, whitelist_mode: WhitelistMode) -> Self {
198 self.whitelist_mode = Maybe::Some(whitelist_mode);
199 self
200 }
201
202 pub fn acl_white_list(mut self, acl_white_list: Vec<Address>) -> Self {
203 self.acl_white_list = Maybe::Some(acl_white_list);
204 self
205 }
206
207 pub fn json_schema(mut self, json_schema: String) -> Self {
208 self.json_schema = Maybe::Some(json_schema);
209 self
210 }
211
212 pub fn identifier_mode(mut self, identifier_mode: NFTIdentifierMode) -> Self {
213 self.identifier_mode = identifier_mode;
214 self
215 }
216
217 pub fn receipt_name(mut self, receipt_name: String) -> Self {
218 self.receipt_name = receipt_name;
219 self
220 }
221
222 pub fn burn_mode(mut self, burn_mode: BurnMode) -> Self {
223 self.burn_mode = Maybe::Some(burn_mode);
224 self
225 }
226
227 pub fn operator_burn_mode(mut self, operator_burn_mode: bool) -> Self {
228 self.operator_burn_mode = Maybe::Some(operator_burn_mode);
229 self
230 }
231
232 pub fn nft_metadata_kind(mut self, nft_metadata_kind: NFTMetadataKind) -> Self {
233 self.nft_metadata_kind = nft_metadata_kind;
234 self
235 }
236
237 pub fn metadata_mutability(mut self, metadata_mutability: MetadataMutability) -> Self {
238 self.metadata_mutability = metadata_mutability;
239 self
240 }
241
242 pub fn owner_reverse_lookup_mode(
243 mut self,
244 owner_reverse_lookup_mode: OwnerReverseLookupMode
245 ) -> Self {
246 self.owner_reverse_lookup_mode = Maybe::Some(owner_reverse_lookup_mode);
247 self
248 }
249
250 pub fn events_mode(mut self, events_mode: EventsMode) -> Self {
251 self.events_mode = Maybe::Some(events_mode);
252 self
253 }
254
255 pub fn transfer_filter_contract_contract_key(
256 mut self,
257 transfer_filter_contract_contract_key: Address
258 ) -> Self {
259 self.transfer_filter_contract_contract_key =
260 Maybe::Some(transfer_filter_contract_contract_key);
261 self
262 }
263
264 pub fn additional_required_metadata(
265 mut self,
266 additional_required_metadata: Vec<NFTMetadataKind>
267 ) -> Self {
268 self.additional_required_metadata = Maybe::Some(additional_required_metadata);
269 self
270 }
271
272 pub fn optional_metadata(mut self, optional_metadata: Vec<NFTMetadataKind>) -> Self {
273 self.optional_metadata = Maybe::Some(optional_metadata);
274 self
275 }
276
277 pub fn build(self) -> TestCep78InitArgs {
278 TestCep78InitArgs {
279 collection_name: self.collection_name,
280 collection_symbol: self.collection_symbol,
281 total_token_supply: self.total_token_supply,
282 allow_minting: self.allow_minting,
283 minting_mode: self.minting_mode,
284 ownership_mode: self.ownership_mode,
285 nft_kind: self.nft_kind,
286 holder_mode: self.holder_mode,
287 whitelist_mode: self.whitelist_mode,
288 acl_whitelist: self.acl_white_list,
289 json_schema: self.json_schema,
290 receipt_name: self.receipt_name,
291 identifier_mode: self.identifier_mode,
292 burn_mode: self.burn_mode,
293 operator_burn_mode: self.operator_burn_mode,
294 nft_metadata_kind: self.nft_metadata_kind,
295 metadata_mutability: self.metadata_mutability,
296 owner_reverse_lookup_mode: self.owner_reverse_lookup_mode,
297 events_mode: self.events_mode,
298 transfer_filter_contract_contract: self.transfer_filter_contract_contract_key,
299 additional_required_metadata: self.additional_required_metadata,
300 optional_metadata: self.optional_metadata
301 }
302 }
303}