git.delta.rocks / unique-network / refs/commits / 3203150b5c74

63116311
6312[[package]]6312[[package]]
6313name = "pallet-refungible"6313name = "pallet-refungible"
6314version = "0.2.0"6314version = "0.2.1"
6315dependencies = [6315dependencies = [
6316 "ethereum",6316 "ethereum",
6317 "evm-coder",6317 "evm-coder",

15NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs15NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs
16NONFUNGIBLE_EVM_ABI=./tests/src/eth/nonFungibleAbi.json16NONFUNGIBLE_EVM_ABI=./tests/src/eth/nonFungibleAbi.json
1717
18REFUNGIBLE_EVM_STUBS=./pallets/refungible/src/stubs
18RENFUNGIBLE_EVM_ABI=./tests/src/eth/reFungibleAbi.json19REFUNGIBLE_EVM_ABI=./tests/src/eth/reFungibleAbi.json
19RENFUNGIBLE_TOKEN_EVM_ABI=./tests/src/eth/reFungibleTokenAbi.json20REFUNGIBLE_TOKEN_EVM_ABI=./tests/src/eth/reFungibleTokenAbi.json
2021
21CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/22CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/
22CONTRACT_HELPERS_ABI=./tests/src/eth/util/contractHelpersAbi.json23CONTRACT_HELPERS_ABI=./tests/src/eth/util/contractHelpersAbi.json
36UniqueNFT.sol:37UniqueNFT.sol:
37	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh38	PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
38	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh39	PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
39	40
40UniqueRefungible.sol:41UniqueRefungible.sol:
41	PACKAGE=pallet-refungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh42	PACKAGE=pallet-refungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh
42	PACKAGE=pallet-refungible NAME=erc::gen_impl OUTPUT=$(REFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh43	PACKAGE=pallet-refungible NAME=erc::gen_impl OUTPUT=$(REFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh
61	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw ./.maintain/scripts/compile_stub.sh62	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw ./.maintain/scripts/compile_stub.sh
62	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh63	INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh
6364
64UniqueRefungibleToken: UniqueRefungibleToken.sol65UniqueRefungible: UniqueRefungible.sol
65	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungibleToken.raw ./.maintain/scripts/compile_stub.sh66	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungible.raw ./.maintain/scripts/compile_stub.sh
66	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(RENFUNGIBLE_TOKEN_EVM_ABI) ./.maintain/scripts/generate_abi.sh67	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh
6768
68UniqueRefungible: UniqueRefungible.sol69UniqueRefungibleToken: UniqueRefungibleToken.sol
69	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungible.raw ./.maintain/scripts/compile_stub.sh70	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungibleToken.raw ./.maintain/scripts/compile_stub.sh
70	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh71	INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_TOKEN_EVM_ABI) ./.maintain/scripts/generate_abi.sh
7172
72ContractHelpers: ContractHelpers.sol73ContractHelpers: ContractHelpers.sol
73	INPUT=$(CONTRACT_HELPERS_STUBS)/$< OUTPUT=$(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw ./.maintain/scripts/compile_stub.sh74	INPUT=$(CONTRACT_HELPERS_STUBS)/$< OUTPUT=$(CONTRACT_HELPERS_STUBS)/ContractHelpers.raw ./.maintain/scripts/compile_stub.sh

22
3All notable changes to this project will be documented in this file.3All notable changes to this project will be documented in this file.
44
5## [v0.2.1] - 2022-07-27
6
7### New features
8
9Implementation of ERC-721 EVM API ([#452](https://github.com/UniqueNetwork/unique-chain/pull/452))
10
5## [v0.2.0] - 2022-08-0111## [v0.2.0] - 2022-08-01
12
6### Deprecated13### Deprecated
14
15`const_data` field is removed
16
7- `ItemData`17- `ItemData`
8- `TokenData`18- `TokenData`
919
15test(refungible-pallet): add tests for ERC-20 EVM API for RFT token pieces ([#413](https://github.com/UniqueNetwork/unique-chain/pull/413))25test(refungible-pallet): add tests for ERC-20 EVM API for RFT token pieces ([#413](https://github.com/UniqueNetwork/unique-chain/pull/413))
1626
17## [v0.1.1] - 2022-07-1427## [v0.1.1] - 2022-07-14
28
18### Added29### Added features
30
19- Support for properties for RFT collections and tokens.31- Support for properties for RFT collections and tokens.
2032
21### Other changes33### Other changes
2234
23- feat: RPC method `token_owners` returning 10 owners in no particular order.35- feat: RPC method `token_owners` returning 10 owners in no particular order.
2436
25This was an internal request to improve the web interface and support fractionalization event. 37This was an internal request to improve the web interface and support fractionalization event.
2638

1[package]1[package]
2name = "pallet-refungible"2name = "pallet-refungible"
3version = "0.2.0"3version = "0.2.1"
4license = "GPLv3"4license = "GPLv3"
5edition = "2021"5edition = "2021"
66

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
16
17//! # Refungible Pallet EVM API for tokens
18//!
19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Refungible Pallet.
20//! Method implementations are mostly doing parameter conversion and calling Refungible Pallet methods.
1621
17extern crate alloc;22extern crate alloc;
23
24use alloc::string::ToString;
25use core::{
26	char::{REPLACEMENT_CHARACTER, decode_utf16},
27	convert::TryInto,
28};
18use evm_coder::{generate_stubgen, solidity_interface, types::*};29use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};
1930use frame_support::{BoundedBTreeMap, BoundedVec};
20use pallet_common::{CollectionHandle, erc::CollectionCall, erc::CommonEvmHandler};31use pallet_common::{
2132	CollectionHandle, CollectionPropertyPermissions,
33	erc::{
34		CommonEvmHandler, CollectionCall,
35		static_property::{key, value as property_value},
36	},
37};
22use pallet_evm::PrecompileHandle;38use pallet_evm::{account::CrossAccountId, PrecompileHandle};
23use pallet_evm_coder_substrate::call;39use pallet_evm_coder_substrate::{call, dispatch_to_evm};
40use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
41use sp_core::H160;
42use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};
43use up_data_structs::{
44	CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,
45	PropertyPermission, TokenId,
46};
2447
25use crate::{Config, RefungibleHandle};48use crate::{
49	AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,
50	TokenProperties, TokensMinted, TotalSupply, weights::WeightInfo,
51};
52
53pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);
54
55/// @title A contract that allows to set and delete token properties and change token property permissions.
56#[solidity_interface(name = "TokenProperties")]
57impl<T: Config> RefungibleHandle<T> {
58	/// @notice Set permissions for token property.
59	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.
60	/// @param key Property key.
61	/// @param is_mutable Permission to mutate property.
62	/// @param collection_admin Permission to mutate property by collection admin if property is mutable.
63	/// @param token_owner Permission to mutate property by token owner if property is mutable.
64	fn set_token_property_permission(
65		&mut self,
66		caller: caller,
67		key: string,
68		is_mutable: bool,
69		collection_admin: bool,
70		token_owner: bool,
71	) -> Result<()> {
72		let caller = T::CrossAccountId::from_eth(caller);
73		<Pallet<T>>::set_token_property_permissions(
74			self,
75			&caller,
76			vec![PropertyKeyPermission {
77				key: <Vec<u8>>::from(key)
78					.try_into()
79					.map_err(|_| "too long key")?,
80				permission: PropertyPermission {
81					mutable: is_mutable,
82					collection_admin,
83					token_owner,
84				},
85			}],
86		)
87		.map_err(dispatch_to_evm::<T>)
88	}
89
90	/// @notice Set token property value.
91	/// @dev Throws error if `msg.sender` has no permission to edit the property.
92	/// @param tokenId ID of the token.
93	/// @param key Property key.
94	/// @param value Property value.
95	fn set_property(
96		&mut self,
97		caller: caller,
98		token_id: uint256,
99		key: string,
100		value: bytes,
101	) -> Result<()> {
102		let caller = T::CrossAccountId::from_eth(caller);
103		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
104		let key = <Vec<u8>>::from(key)
105			.try_into()
106			.map_err(|_| "key too long")?;
107		let value = value.try_into().map_err(|_| "value too long")?;
108
109		let nesting_budget = self
110			.recorder
111			.weight_calls_budget(<StructureWeight<T>>::find_parent());
112
113		<Pallet<T>>::set_token_property(
114			self,
115			&caller,
116			TokenId(token_id),
117			Property { key, value },
118			&nesting_budget,
119		)
120		.map_err(dispatch_to_evm::<T>)
121	}
122
123	/// @notice Delete token property value.
124	/// @dev Throws error if `msg.sender` has no permission to edit the property.
125	/// @param tokenId ID of the token.
126	/// @param key Property key.
127	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
128		let caller = T::CrossAccountId::from_eth(caller);
129		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
130		let key = <Vec<u8>>::from(key)
131			.try_into()
132			.map_err(|_| "key too long")?;
133
134		let nesting_budget = self
135			.recorder
136			.weight_calls_budget(<StructureWeight<T>>::find_parent());
137
138		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)
139			.map_err(dispatch_to_evm::<T>)
140	}
141
142	/// @notice Get token property value.
143	/// @dev Throws error if key not found
144	/// @param tokenId ID of the token.
145	/// @param key Property key.
146	/// @return Property value bytes
147	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
148		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
149		let key = <Vec<u8>>::from(key)
150			.try_into()
151			.map_err(|_| "key too long")?;
152
153		let props = <TokenProperties<T>>::get((self.id, token_id));
154		let prop = props.get(&key).ok_or("key not found")?;
155
156		Ok(prop.to_vec())
157	}
158}
159
160#[derive(ToLog)]
161pub enum ERC721Events {
162	/// @dev This event emits when NFTs are created (`from` == 0) and destroyed
163	///  (`to` == 0). Exception: during contract creation, any number of RFTs
164	///  may be created and assigned without emitting Transfer.
165	Transfer {
166		#[indexed]
167		from: address,
168		#[indexed]
169		to: address,
170		#[indexed]
171		token_id: uint256,
172	},
173	/// @dev Not supported
174	Approval {
175		#[indexed]
176		owner: address,
177		#[indexed]
178		approved: address,
179		#[indexed]
180		token_id: uint256,
181	},
182	/// @dev Not supported
183	#[allow(dead_code)]
184	ApprovalForAll {
185		#[indexed]
186		owner: address,
187		#[indexed]
188		operator: address,
189		approved: bool,
190	},
191}
192
193#[derive(ToLog)]
194pub enum ERC721MintableEvents {
195	/// @dev Not supported
196	#[allow(dead_code)]
197	MintingFinished {},
198}
199
200#[solidity_interface(name = "ERC721Metadata")]
201impl<T: Config> RefungibleHandle<T> {
202	/// @notice A descriptive name for a collection of RFTs in this contract
203	fn name(&self) -> Result<string> {
204		Ok(decode_utf16(self.name.iter().copied())
205			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
206			.collect::<string>())
207	}
208
209	/// @notice An abbreviated name for RFTs in this contract
210	fn symbol(&self) -> Result<string> {
211		Ok(string::from_utf8_lossy(&self.token_prefix).into())
212	}
213
214	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
215	///
216	/// @dev If the token has a `url` property and it is not empty, it is returned.
217	///  Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.
218	///  If the collection property `baseURI` is empty or absent, return "" (empty string)
219	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix
220	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).
221	///
222	/// @return token's const_metadata
223	#[solidity(rename_selector = "tokenURI")]
224	fn token_uri(&self, token_id: uint256) -> Result<string> {
225		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
226
227		if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) {
228			if !url.is_empty() {
229				return Ok(url);
230			}
231		} else if !is_erc721_metadata_compatible::<T>(self.id) {
232			return Err("tokenURI not set".into());
233		}
234
235		if let Some(base_uri) =
236			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())
237		{
238			if !base_uri.is_empty() {
239				let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {
240					Error::Revert(alloc::format!(
241						"Can not convert value \"baseURI\" to string with error \"{}\"",
242						e
243					))
244				})?;
245				if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) {
246					if !suffix.is_empty() {
247						return Ok(base_uri + suffix.as_str());
248					}
249				}
250
251				return Ok(base_uri + token_id.to_string().as_str());
252			}
253		}
254
255		Ok("".into())
256	}
257}
258
259/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
260/// @dev See https://eips.ethereum.org/EIPS/eip-721
261#[solidity_interface(name = "ERC721Enumerable")]
262impl<T: Config> RefungibleHandle<T> {
263	/// @notice Enumerate valid RFTs
264	/// @param index A counter less than `totalSupply()`
265	/// @return The token identifier for the `index`th NFT,
266	///  (sort order not specified)
267	fn token_by_index(&self, index: uint256) -> Result<uint256> {
268		Ok(index)
269	}
270
271	/// Not implemented
272	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
273		// TODO: Not implemetable
274		Err("not implemented".into())
275	}
276
277	/// @notice Count RFTs tracked by this contract
278	/// @return A count of valid RFTs tracked by this contract, where each one of
279	///  them has an assigned and queryable owner not equal to the zero address
280	fn total_supply(&self) -> Result<uint256> {
281		self.consume_store_reads(1)?;
282		Ok(<Pallet<T>>::total_supply(self).into())
283	}
284}
285
286/// @title ERC-721 Non-Fungible Token Standard
287/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
288#[solidity_interface(name = "ERC721", events(ERC721Events))]
289impl<T: Config> RefungibleHandle<T> {
290	/// @notice Count all RFTs assigned to an owner
291	/// @dev RFTs assigned to the zero address are considered invalid, and this
292	///  function throws for queries about the zero address.
293	/// @param owner An address for whom to query the balance
294	/// @return The number of RFTs owned by `owner`, possibly zero
295	fn balance_of(&self, owner: address) -> Result<uint256> {
296		self.consume_store_reads(1)?;
297		let owner = T::CrossAccountId::from_eth(owner);
298		let balance = <AccountBalance<T>>::get((self.id, owner));
299		Ok(balance.into())
300	}
301
302	/// @notice Find the owner of an RFT
303	/// @dev RFTs assigned to zero address are considered invalid, and queries
304	///  about them do throw.
305	///  Returns special 0xffffffffffffffffffffffffffffffffffffffff address for
306	///  the tokens that are partially owned.
307	/// @param tokenId The identifier for an RFT
308	/// @return The address of the owner of the RFT
309	fn owner_of(&self, token_id: uint256) -> Result<address> {
310		self.consume_store_reads(2)?;
311		let token = token_id.try_into()?;
312		let owner = <Pallet<T>>::token_owner(self.id, token);
313		Ok(owner
314			.map(|address| *address.as_eth())
315			.unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))
316	}
317
318	/// @dev Not implemented
319	fn safe_transfer_from_with_data(
320		&mut self,
321		_from: address,
322		_to: address,
323		_token_id: uint256,
324		_data: bytes,
325		_value: value,
326	) -> Result<void> {
327		// TODO: Not implemetable
328		Err("not implemented".into())
329	}
330
331	/// @dev Not implemented
332	fn safe_transfer_from(
333		&mut self,
334		_from: address,
335		_to: address,
336		_token_id: uint256,
337		_value: value,
338	) -> Result<void> {
339		// TODO: Not implemetable
340		Err("not implemented".into())
341	}
342
343	/// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE
344	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
345	///  THEY MAY BE PERMANENTLY LOST
346	/// @dev Throws unless `msg.sender` is the current owner or an authorized
347	///  operator for this RFT. Throws if `from` is not the current owner. Throws
348	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.
349	///  Throws if RFT pieces have multiple owners.
350	/// @param from The current owner of the NFT
351	/// @param to The new owner
352	/// @param tokenId The NFT to transfer
353	/// @param _value Not used for an NFT
354	#[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]
355	fn transfer_from(
356		&mut self,
357		caller: caller,
358		from: address,
359		to: address,
360		token_id: uint256,
361		_value: value,
362	) -> Result<void> {
363		let caller = T::CrossAccountId::from_eth(caller);
364		let from = T::CrossAccountId::from_eth(from);
365		let to = T::CrossAccountId::from_eth(to);
366		let token = token_id.try_into()?;
367		let budget = self
368			.recorder
369			.weight_calls_budget(<StructureWeight<T>>::find_parent());
370
371		let balance = balance(&self, token, &from)?;
372		ensure_single_owner(&self, token, balance)?;
373
374		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)
375			.map_err(dispatch_to_evm::<T>)?;
376
377		Ok(())
378	}
379
380	/// @dev Not implemented
381	fn approve(
382		&mut self,
383		_caller: caller,
384		_approved: address,
385		_token_id: uint256,
386		_value: value,
387	) -> Result<void> {
388		Err("not implemented".into())
389	}
390
391	/// @dev Not implemented
392	fn set_approval_for_all(
393		&mut self,
394		_caller: caller,
395		_operator: address,
396		_approved: bool,
397	) -> Result<void> {
398		// TODO: Not implemetable
399		Err("not implemented".into())
400	}
401
402	/// @dev Not implemented
403	fn get_approved(&self, _token_id: uint256) -> Result<address> {
404		// TODO: Not implemetable
405		Err("not implemented".into())
406	}
407
408	/// @dev Not implemented
409	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
410		// TODO: Not implemetable
411		Err("not implemented".into())
412	}
413}
414
415/// Returns amount of pieces of `token` that `owner` have
416fn balance<T: Config>(
417	collection: &RefungibleHandle<T>,
418	token: TokenId,
419	owner: &T::CrossAccountId,
420) -> Result<u128> {
421	collection.consume_store_reads(1)?;
422	let balance = <Balance<T>>::get((collection.id, token, &owner));
423	Ok(balance)
424}
425
426/// Throws if `owner_balance` is lower than total amount of `token` pieces
427fn ensure_single_owner<T: Config>(
428	collection: &RefungibleHandle<T>,
429	token: TokenId,
430	owner_balance: u128,
431) -> Result<()> {
432	collection.consume_store_reads(1)?;
433	let total_supply = <TotalSupply<T>>::get((collection.id, token));
434	if total_supply != owner_balance {
435		return Err("token has multiple owners".into());
436	}
437	Ok(())
438}
439
440/// @title ERC721 Token that can be irreversibly burned (destroyed).
441#[solidity_interface(name = "ERC721Burnable")]
442impl<T: Config> RefungibleHandle<T> {
443	/// @notice Burns a specific ERC721 token.
444	/// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized
445	///  operator of the current owner.
446	/// @param tokenId The RFT to approve
447	#[weight(<SelfWeightOf<T>>::burn_item_fully())]
448	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {
449		let caller = T::CrossAccountId::from_eth(caller);
450		let token = token_id.try_into()?;
451
452		let balance = balance(&self, token, &caller)?;
453		ensure_single_owner(&self, token, balance)?;
454
455		<Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;
456		Ok(())
457	}
458}
459
460/// @title ERC721 minting logic.
461#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]
462impl<T: Config> RefungibleHandle<T> {
463	fn minting_finished(&self) -> Result<bool> {
464		Ok(false)
465	}
466
467	/// @notice Function to mint token.
468	/// @dev `tokenId` should be obtained with `nextTokenId` method,
469	///  unlike standard, you can't specify it manually
470	/// @param to The new owner
471	/// @param tokenId ID of the minted RFT
472	#[weight(<SelfWeightOf<T>>::create_item())]
473	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
474		let caller = T::CrossAccountId::from_eth(caller);
475		let to = T::CrossAccountId::from_eth(to);
476		let token_id: u32 = token_id.try_into()?;
477		let budget = self
478			.recorder
479			.weight_calls_budget(<StructureWeight<T>>::find_parent());
480
481		if <TokensMinted<T>>::get(self.id)
482			.checked_add(1)
483			.ok_or("item id overflow")?
484			!= token_id
485		{
486			return Err("item id should be next".into());
487		}
488
489		let users = [(to.clone(), 1)]
490			.into_iter()
491			.collect::<BTreeMap<_, _>>()
492			.try_into()
493			.unwrap();
494		<Pallet<T>>::create_item(
495			self,
496			&caller,
497			CreateItemData::<T> {
498				users,
499				properties: CollectionPropertiesVec::default(),
500			},
501			&budget,
502		)
503		.map_err(dispatch_to_evm::<T>)?;
504
505		Ok(true)
506	}
507
508	/// @notice Function to mint token with the given tokenUri.
509	/// @dev `tokenId` should be obtained with `nextTokenId` method,
510	///  unlike standard, you can't specify it manually
511	/// @param to The new owner
512	/// @param tokenId ID of the minted RFT
513	/// @param tokenUri Token URI that would be stored in the RFT properties
514	#[solidity(rename_selector = "mintWithTokenURI")]
515	#[weight(<SelfWeightOf<T>>::create_item())]
516	fn mint_with_token_uri(
517		&mut self,
518		caller: caller,
519		to: address,
520		token_id: uint256,
521		token_uri: string,
522	) -> Result<bool> {
523		let key = key::url();
524		let permission = get_token_permission::<T>(self.id, &key)?;
525		if !permission.collection_admin {
526			return Err("Operation is not allowed".into());
527		}
528
529		let caller = T::CrossAccountId::from_eth(caller);
530		let to = T::CrossAccountId::from_eth(to);
531		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;
532		let budget = self
533			.recorder
534			.weight_calls_budget(<StructureWeight<T>>::find_parent());
535
536		if <TokensMinted<T>>::get(self.id)
537			.checked_add(1)
538			.ok_or("item id overflow")?
539			!= token_id
540		{
541			return Err("item id should be next".into());
542		}
543
544		let mut properties = CollectionPropertiesVec::default();
545		properties
546			.try_push(Property {
547				key,
548				value: token_uri
549					.into_bytes()
550					.try_into()
551					.map_err(|_| "token uri is too long")?,
552			})
553			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
554
555		let users = [(to.clone(), 1)]
556			.into_iter()
557			.collect::<BTreeMap<_, _>>()
558			.try_into()
559			.unwrap();
560		<Pallet<T>>::create_item(
561			self,
562			&caller,
563			CreateItemData::<T> {
564				users,
565				properties,
566			},
567			&budget,
568		)
569		.map_err(dispatch_to_evm::<T>)?;
570		Ok(true)
571	}
572
573	/// @dev Not implemented
574	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {
575		Err("not implementable".into())
576	}
577}
578
579fn get_token_property<T: Config>(
580	collection: &CollectionHandle<T>,
581	token_id: u32,
582	key: &up_data_structs::PropertyKey,
583) -> Result<string> {
584	collection.consume_store_reads(1)?;
585	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))
586		.map_err(|_| Error::Revert("Token properties not found".into()))?;
587	if let Some(property) = properties.get(key) {
588		return Ok(string::from_utf8_lossy(property).into());
589	}
590
591	Err("Property tokenURI not found".into())
592}
593
594fn is_erc721_metadata_compatible<T: Config>(collection_id: CollectionId) -> bool {
595	if let Some(shema_name) =
596		pallet_common::Pallet::<T>::get_collection_property(collection_id, &key::schema_name())
597	{
598		let shema_name = shema_name.into_inner();
599		shema_name == property_value::ERC721_METADATA
600	} else {
601		false
602	}
603}
604
605fn get_token_permission<T: Config>(
606	collection_id: CollectionId,
607	key: &PropertyKey,
608) -> Result<PropertyPermission> {
609	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)
610		.map_err(|_| Error::Revert("No permissions for collection".into()))?;
611	let a = token_property_permissions
612		.get(key)
613		.map(Clone::clone)
614		.ok_or_else(|| {
615			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();
616			Error::Revert(alloc::format!("No permission for key {}", key))
617		})?;
618	Ok(a)
619}
620
621/// @title Unique extensions for ERC721.
622#[solidity_interface(name = "ERC721UniqueExtensions")]
623impl<T: Config> RefungibleHandle<T> {
624	/// @notice Transfer ownership of an RFT
625	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
626	///  is the zero address. Throws if `tokenId` is not a valid RFT.
627	///  Throws if RFT pieces have multiple owners.
628	/// @param to The new owner
629	/// @param tokenId The RFT to transfer
630	/// @param _value Not used for an RFT
631	#[weight(<SelfWeightOf<T>>::transfer_creating_removing())]
632	fn transfer(
633		&mut self,
634		caller: caller,
635		to: address,
636		token_id: uint256,
637		_value: value,
638	) -> Result<void> {
639		let caller = T::CrossAccountId::from_eth(caller);
640		let to = T::CrossAccountId::from_eth(to);
641		let token = token_id.try_into()?;
642		let budget = self
643			.recorder
644			.weight_calls_budget(<StructureWeight<T>>::find_parent());
645
646		let balance = balance(&self, token, &caller)?;
647		ensure_single_owner(&self, token, balance)?;
648
649		<Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)
650			.map_err(dispatch_to_evm::<T>)?;
651		Ok(())
652	}
653
654	/// @notice Burns a specific ERC721 token.
655	/// @dev Throws unless `msg.sender` is the current owner or an authorized
656	///  operator for this RFT. Throws if `from` is not the current owner. Throws
657	///  if `to` is the zero address. Throws if `tokenId` is not a valid RFT.
658	///  Throws if RFT pieces have multiple owners.
659	/// @param from The current owner of the RFT
660	/// @param tokenId The RFT to transfer
661	/// @param _value Not used for an RFT
662	#[weight(<SelfWeightOf<T>>::burn_from())]
663	fn burn_from(
664		&mut self,
665		caller: caller,
666		from: address,
667		token_id: uint256,
668		_value: value,
669	) -> Result<void> {
670		let caller = T::CrossAccountId::from_eth(caller);
671		let from = T::CrossAccountId::from_eth(from);
672		let token = token_id.try_into()?;
673		let budget = self
674			.recorder
675			.weight_calls_budget(<StructureWeight<T>>::find_parent());
676
677		let balance = balance(&self, token, &caller)?;
678		ensure_single_owner(&self, token, balance)?;
679
680		<Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)
681			.map_err(dispatch_to_evm::<T>)?;
682		Ok(())
683	}
684
685	/// @notice Returns next free RFT ID.
686	fn next_token_id(&self) -> Result<uint256> {
687		self.consume_store_reads(1)?;
688		Ok(<TokensMinted<T>>::get(self.id)
689			.checked_add(1)
690			.ok_or("item id overflow")?
691			.into())
692	}
693
694	/// @notice Function to mint multiple tokens.
695	/// @dev `tokenIds` should be an array of consecutive numbers and first number
696	///  should be obtained with `nextTokenId` method
697	/// @param to The new owner
698	/// @param tokenIds IDs of the minted RFTs
699	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
700	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
701		let caller = T::CrossAccountId::from_eth(caller);
702		let to = T::CrossAccountId::from_eth(to);
703		let mut expected_index = <TokensMinted<T>>::get(self.id)
704			.checked_add(1)
705			.ok_or("item id overflow")?;
706		let budget = self
707			.recorder
708			.weight_calls_budget(<StructureWeight<T>>::find_parent());
709
710		let total_tokens = token_ids.len();
711		for id in token_ids.into_iter() {
712			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
713			if id != expected_index {
714				return Err("item id should be next".into());
715			}
716			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
717		}
718		let users = [(to.clone(), 1)]
719			.into_iter()
720			.collect::<BTreeMap<_, _>>()
721			.try_into()
722			.unwrap();
723		let create_item_data = CreateItemData::<T> {
724			users,
725			properties: CollectionPropertiesVec::default(),
726		};
727		let data = (0..total_tokens)
728			.map(|_| create_item_data.clone())
729			.collect();
730
731		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
732			.map_err(dispatch_to_evm::<T>)?;
733		Ok(true)
734	}
735
736	/// @notice Function to mint multiple tokens with the given tokenUris.
737	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
738	///  numbers and first number should be obtained with `nextTokenId` method
739	/// @param to The new owner
740	/// @param tokens array of pairs of token ID and token URI for minted tokens
741	#[solidity(rename_selector = "mintBulkWithTokenURI")]
742	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
743	fn mint_bulk_with_token_uri(
744		&mut self,
745		caller: caller,
746		to: address,
747		tokens: Vec<(uint256, string)>,
748	) -> Result<bool> {
749		let key = key::url();
750		let caller = T::CrossAccountId::from_eth(caller);
751		let to = T::CrossAccountId::from_eth(to);
752		let mut expected_index = <TokensMinted<T>>::get(self.id)
753			.checked_add(1)
754			.ok_or("item id overflow")?;
755		let budget = self
756			.recorder
757			.weight_calls_budget(<StructureWeight<T>>::find_parent());
758
759		let mut data = Vec::with_capacity(tokens.len());
760		let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]
761			.into_iter()
762			.collect::<BTreeMap<_, _>>()
763			.try_into()
764			.unwrap();
765		for (id, token_uri) in tokens {
766			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;
767			if id != expected_index {
768				return Err("item id should be next".into());
769			}
770			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;
771
772			let mut properties = CollectionPropertiesVec::default();
773			properties
774				.try_push(Property {
775					key: key.clone(),
776					value: token_uri
777						.into_bytes()
778						.try_into()
779						.map_err(|_| "token uri is too long")?,
780				})
781				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;
782
783			let create_item_data = CreateItemData::<T> {
784				users: users.clone(),
785				properties,
786			};
787			data.push(create_item_data);
788		}
789
790		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)
791			.map_err(dispatch_to_evm::<T>)?;
792		Ok(true)
793	}
794}
26795
27#[solidity_interface(796#[solidity_interface(
28	name = "UniqueRefungible",797	name = "UniqueRefungible",
29	is(via("CollectionHandle<T>", common_mut, Collection),)798	is(
799		ERC721,
800		ERC721Metadata,
801		ERC721Enumerable,
802		ERC721UniqueExtensions,
803		ERC721Mintable,
804		ERC721Burnable,
805		via("CollectionHandle<T>", common_mut, Collection),
806		TokenProperties,
807	)
30)]808)]
31impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}809impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}