git.delta.rocks / unique-network / refs/commits / ccf797c021e8

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Nonfungible Pallet EVM API18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Nonfungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.2122extern crate alloc;23use core::{24	char::{REPLACEMENT_CHARACTER, decode_utf16},25	convert::TryInto,26};27use evm_coder::{28	abi::AbiType, ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*,29	types::Property as PropertyStruct, weight,30};31use frame_support::BoundedVec;32use up_data_structs::{33	TokenId, PropertyPermission, PropertyKeyPermission, Property, CollectionId, PropertyKey,34	CollectionPropertiesVec,35};36use pallet_evm_coder_substrate::dispatch_to_evm;37use sp_std::vec::Vec;38use pallet_common::{39	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},40	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,41};42use pallet_evm::{account::CrossAccountId, PrecompileHandle};43use pallet_evm_coder_substrate::call;44use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};4546use crate::{47	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,48	SelfWeightOf, weights::WeightInfo, TokenProperties,49};5051/// @title A contract that allows to set and delete token properties and change token property permissions.52#[solidity_interface(name = TokenProperties)]53impl<T: Config> NonfungibleHandle<T> {54	/// @notice Set permissions for token property.55	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.56	/// @param key Property key.57	/// @param isMutable Permission to mutate property.58	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.59	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.60	fn set_token_property_permission(61		&mut self,62		caller: caller,63		key: string,64		is_mutable: bool,65		collection_admin: bool,66		token_owner: bool,67	) -> Result<()> {68		let caller = T::CrossAccountId::from_eth(caller);69		<Pallet<T>>::set_property_permission(70			self,71			&caller,72			PropertyKeyPermission {73				key: <Vec<u8>>::from(key)74					.try_into()75					.map_err(|_| "too long key")?,76				permission: PropertyPermission {77					mutable: is_mutable,78					collection_admin,79					token_owner,80				},81			},82		)83		.map_err(dispatch_to_evm::<T>)84	}8586	/// @notice Set token property value.87	/// @dev Throws error if `msg.sender` has no permission to edit the property.88	/// @param tokenId ID of the token.89	/// @param key Property key.90	/// @param value Property value.91	#[solidity(hide)]92	fn set_property(93		&mut self,94		caller: caller,95		token_id: uint256,96		key: string,97		value: bytes,98	) -> Result<()> {99		let caller = T::CrossAccountId::from_eth(caller);100		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;101		let key = <Vec<u8>>::from(key)102			.try_into()103			.map_err(|_| "key too long")?;104		let value = value.0.try_into().map_err(|_| "value too long")?;105106		let nesting_budget = self107			.recorder108			.weight_calls_budget(<StructureWeight<T>>::find_parent());109110		<Pallet<T>>::set_token_property(111			self,112			&caller,113			TokenId(token_id),114			Property { key, value },115			&nesting_budget,116		)117		.map_err(dispatch_to_evm::<T>)118	}119120	/// @notice Set token properties value.121	/// @dev Throws error if `msg.sender` has no permission to edit the property.122	/// @param tokenId ID of the token.123	/// @param properties settable properties124	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]125	fn set_properties(126		&mut self,127		caller: caller,128		token_id: uint256,129		properties: Vec<PropertyStruct>,130	) -> Result<()> {131		let caller = T::CrossAccountId::from_eth(caller);132		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;133134		let nesting_budget = self135			.recorder136			.weight_calls_budget(<StructureWeight<T>>::find_parent());137138		let properties = properties139			.into_iter()140			.map(|PropertyStruct { key, value }| {141				let key = <Vec<u8>>::from(key)142					.try_into()143					.map_err(|_| "key too large")?;144145				let value = value.0.try_into().map_err(|_| "value too large")?;146147				Ok(Property { key, value })148			})149			.collect::<Result<Vec<_>>>()?;150151		<Pallet<T>>::set_token_properties(152			self,153			&caller,154			TokenId(token_id),155			properties.into_iter(),156			<Pallet<T>>::token_exists(&self, TokenId(token_id)),157			&nesting_budget,158		)159		.map_err(dispatch_to_evm::<T>)160	}161162	/// @notice Delete token property value.163	/// @dev Throws error if `msg.sender` has no permission to edit the property.164	/// @param tokenId ID of the token.165	/// @param key Property key.166	#[solidity(hide)]167	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {168		let caller = T::CrossAccountId::from_eth(caller);169		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;170		let key = <Vec<u8>>::from(key)171			.try_into()172			.map_err(|_| "key too long")?;173174		let nesting_budget = self175			.recorder176			.weight_calls_budget(<StructureWeight<T>>::find_parent());177178		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)179			.map_err(dispatch_to_evm::<T>)180	}181182	/// @notice Delete token properties value.183	/// @dev Throws error if `msg.sender` has no permission to edit the property.184	/// @param tokenId ID of the token.185	/// @param keys Properties key.186	fn delete_properties(187		&mut self,188		token_id: uint256,189		caller: caller,190		keys: Vec<string>,191	) -> Result<()> {192		let caller = T::CrossAccountId::from_eth(caller);193		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;194		let keys = keys195			.into_iter()196			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))197			.collect::<Result<Vec<_>>>()?;198199		let nesting_budget = self200			.recorder201			.weight_calls_budget(<StructureWeight<T>>::find_parent());202203		<Pallet<T>>::delete_token_properties(204			self,205			&caller,206			TokenId(token_id),207			keys.into_iter(),208			&nesting_budget,209		)210		.map_err(dispatch_to_evm::<T>)211	}212213	/// @notice Get token property value.214	/// @dev Throws error if key not found215	/// @param tokenId ID of the token.216	/// @param key Property key.217	/// @return Property value bytes218	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {219		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;220		let key = <Vec<u8>>::from(key)221			.try_into()222			.map_err(|_| "key too long")?;223224		let props = <TokenProperties<T>>::get((self.id, token_id));225		let prop = props.get(&key).ok_or("key not found")?;226227		Ok(prop.to_vec().into())228	}229}230231#[derive(ToLog)]232pub enum ERC721Events {233	/// @dev This emits when ownership of any NFT changes by any mechanism.234	///  This event emits when NFTs are created (`from` == 0) and destroyed235	///  (`to` == 0). Exception: during contract creation, any number of NFTs236	///  may be created and assigned without emitting Transfer. At the time of237	///  any transfer, the approved address for that NFT (if any) is reset to none.238	Transfer {239		#[indexed]240		from: address,241		#[indexed]242		to: address,243		#[indexed]244		token_id: uint256,245	},246	/// @dev This emits when the approved address for an NFT is changed or247	///  reaffirmed. The zero address indicates there is no approved address.248	///  When a Transfer event emits, this also indicates that the approved249	///  address for that NFT (if any) is reset to none.250	Approval {251		#[indexed]252		owner: address,253		#[indexed]254		approved: address,255		#[indexed]256		token_id: uint256,257	},258	/// @dev This emits when an operator is enabled or disabled for an owner.259	///  The operator can manage all NFTs of the owner.260	#[allow(dead_code)]261	ApprovalForAll {262		#[indexed]263		owner: address,264		#[indexed]265		operator: address,266		approved: bool,267	},268}269270#[derive(ToLog)]271pub enum ERC721UniqueMintableEvents {272	#[allow(dead_code)]273	MintingFinished {},274}275276/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension277/// @dev See https://eips.ethereum.org/EIPS/eip-721278#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]279impl<T: Config> NonfungibleHandle<T>280where281	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,282{283	/// @notice A descriptive name for a collection of NFTs in this contract284	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`285	#[solidity(hide, rename_selector = "name")]286	fn name_proxy(&self) -> Result<string> {287		self.name()288	}289290	/// @notice An abbreviated name for NFTs in this contract291	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`292	#[solidity(hide, rename_selector = "symbol")]293	fn symbol_proxy(&self) -> Result<string> {294		self.symbol()295	}296297	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.298	///299	/// @dev If the token has a `url` property and it is not empty, it is returned.300	///  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`.301	///  If the collection property `baseURI` is empty or absent, return "" (empty string)302	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix303	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).304	///305	/// @return token's const_metadata306	#[solidity(rename_selector = "tokenURI")]307	fn token_uri(&self, token_id: uint256) -> Result<string> {308		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;309310		match get_token_property(self, token_id_u32, &key::url()).as_deref() {311			Err(_) | Ok("") => (),312			Ok(url) => {313				return Ok(url.into());314			}315		};316317		let base_uri =318			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())319				.map(BoundedVec::into_inner)320				.map(string::from_utf8)321				.transpose()322				.map_err(|e| {323					Error::Revert(alloc::format!(324						"Can not convert value \"baseURI\" to string with error \"{}\"",325						e326					))327				})?;328329		let base_uri = match base_uri.as_deref() {330			None | Some("") => {331				return Ok("".into());332			}333			Some(base_uri) => base_uri.into(),334		};335336		Ok(337			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {338				Err(_) | Ok("") => base_uri,339				Ok(suffix) => base_uri + suffix,340			},341		)342	}343}344345/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension346/// @dev See https://eips.ethereum.org/EIPS/eip-721347#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]348impl<T: Config> NonfungibleHandle<T> {349	/// @notice Enumerate valid NFTs350	/// @param index A counter less than `totalSupply()`351	/// @return The token identifier for the `index`th NFT,352	///  (sort order not specified)353	fn token_by_index(&self, index: uint256) -> Result<uint256> {354		Ok(index)355	}356357	/// @dev Not implemented358	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {359		// TODO: Not implemetable360		Err("not implemented".into())361	}362363	/// @notice Count NFTs tracked by this contract364	/// @return A count of valid NFTs tracked by this contract, where each one of365	///  them has an assigned and queryable owner not equal to the zero address366	fn total_supply(&self) -> Result<uint256> {367		self.consume_store_reads(1)?;368		Ok(<Pallet<T>>::total_supply(self).into())369	}370}371372/// @title ERC-721 Non-Fungible Token Standard373/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md374#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]375impl<T: Config> NonfungibleHandle<T> {376	/// @notice Count all NFTs assigned to an owner377	/// @dev NFTs assigned to the zero address are considered invalid, and this378	///  function throws for queries about the zero address.379	/// @param owner An address for whom to query the balance380	/// @return The number of NFTs owned by `owner`, possibly zero381	fn balance_of(&self, owner: address) -> Result<uint256> {382		self.consume_store_reads(1)?;383		let owner = T::CrossAccountId::from_eth(owner);384		let balance = <AccountBalance<T>>::get((self.id, owner));385		Ok(balance.into())386	}387	/// @notice Find the owner of an NFT388	/// @dev NFTs assigned to zero address are considered invalid, and queries389	///  about them do throw.390	/// @param tokenId The identifier for an NFT391	/// @return The address of the owner of the NFT392	fn owner_of(&self, token_id: uint256) -> Result<address> {393		self.consume_store_reads(1)?;394		let token: TokenId = token_id.try_into()?;395		Ok(*<TokenData<T>>::get((self.id, token))396			.ok_or("token not found")?397			.owner398			.as_eth())399	}400	/// @dev Not implemented401	#[solidity(rename_selector = "safeTransferFrom")]402	fn safe_transfer_from_with_data(403		&mut self,404		_from: address,405		_to: address,406		_token_id: uint256,407		_data: bytes,408	) -> Result<void> {409		// TODO: Not implemetable410		Err("not implemented".into())411	}412	/// @dev Not implemented413	fn safe_transfer_from(414		&mut self,415		_from: address,416		_to: address,417		_token_id: uint256,418	) -> Result<void> {419		// TODO: Not implemetable420		Err("not implemented".into())421	}422423	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE424	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE425	///  THEY MAY BE PERMANENTLY LOST426	/// @dev Throws unless `msg.sender` is the current owner or an authorized427	///  operator for this NFT. Throws if `from` is not the current owner. Throws428	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.429	/// @param from The current owner of the NFT430	/// @param to The new owner431	/// @param tokenId The NFT to transfer432	#[weight(<SelfWeightOf<T>>::transfer_from())]433	fn transfer_from(434		&mut self,435		caller: caller,436		from: address,437		to: address,438		token_id: uint256,439	) -> Result<void> {440		let caller = T::CrossAccountId::from_eth(caller);441		let from = T::CrossAccountId::from_eth(from);442		let to = T::CrossAccountId::from_eth(to);443		let token = token_id.try_into()?;444		let budget = self445			.recorder446			.weight_calls_budget(<StructureWeight<T>>::find_parent());447448		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)449			.map_err(dispatch_to_evm::<T>)?;450		Ok(())451	}452453	/// @notice Set or reaffirm the approved address for an NFT454	/// @dev The zero address indicates there is no approved address.455	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized456	///  operator of the current owner.457	/// @param approved The new approved NFT controller458	/// @param tokenId The NFT to approve459	#[weight(<SelfWeightOf<T>>::approve())]460	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {461		let caller = T::CrossAccountId::from_eth(caller);462		let approved = T::CrossAccountId::from_eth(approved);463		let token = token_id.try_into()?;464465		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))466			.map_err(dispatch_to_evm::<T>)?;467		Ok(())468	}469470	/// @dev Not implemented471	fn set_approval_for_all(472		&mut self,473		_caller: caller,474		_operator: address,475		_approved: bool,476	) -> Result<void> {477		// TODO: Not implemetable478		Err("not implemented".into())479	}480481	/// @dev Not implemented482	fn get_approved(&self, _token_id: uint256) -> Result<address> {483		// TODO: Not implemetable484		Err("not implemented".into())485	}486487	/// @dev Not implemented488	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {489		// TODO: Not implemetable490		Err("not implemented".into())491	}492}493494/// @title ERC721 Token that can be irreversibly burned (destroyed).495#[solidity_interface(name = ERC721Burnable)]496impl<T: Config> NonfungibleHandle<T> {497	/// @notice Burns a specific ERC721 token.498	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized499	///  operator of the current owner.500	/// @param tokenId The NFT to approve501	#[weight(<SelfWeightOf<T>>::burn_item())]502	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {503		let caller = T::CrossAccountId::from_eth(caller);504		let token = token_id.try_into()?;505506		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;507		Ok(())508	}509}510511/// @title ERC721 minting logic.512#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]513impl<T: Config> NonfungibleHandle<T> {514	fn minting_finished(&self) -> Result<bool> {515		Ok(false)516	}517518	/// @notice Function to mint token.519	/// @param to The new owner520	/// @return uint256 The id of the newly minted token521	#[weight(<SelfWeightOf<T>>::create_item())]522	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {523		let token_id: uint256 = <TokensMinted<T>>::get(self.id)524			.checked_add(1)525			.ok_or("item id overflow")?526			.into();527		self.mint_check_id(caller, to, token_id)?;528		Ok(token_id)529	}530531	/// @notice Function to mint token.532	/// @dev `tokenId` should be obtained with `nextTokenId` method,533	///  unlike standard, you can't specify it manually534	/// @param to The new owner535	/// @param tokenId ID of the minted NFT536	#[solidity(hide, rename_selector = "mint")]537	#[weight(<SelfWeightOf<T>>::create_item())]538	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {539		let caller = T::CrossAccountId::from_eth(caller);540		let to = T::CrossAccountId::from_eth(to);541		let token_id: u32 = token_id.try_into()?;542		let budget = self543			.recorder544			.weight_calls_budget(<StructureWeight<T>>::find_parent());545546		if <TokensMinted<T>>::get(self.id)547			.checked_add(1)548			.ok_or("item id overflow")?549			!= token_id550		{551			return Err("item id should be next".into());552		}553554		<Pallet<T>>::create_item(555			self,556			&caller,557			CreateItemData::<T> {558				properties: BoundedVec::default(),559				owner: to,560			},561			&budget,562		)563		.map_err(dispatch_to_evm::<T>)?;564565		Ok(true)566	}567568	/// @notice Function to mint token with the given tokenUri.569	/// @param to The new owner570	/// @param tokenUri Token URI that would be stored in the NFT properties571	/// @return uint256 The id of the newly minted token572	#[solidity(rename_selector = "mintWithTokenURI")]573	#[weight(<SelfWeightOf<T>>::create_item())]574	fn mint_with_token_uri(575		&mut self,576		caller: caller,577		to: address,578		token_uri: string,579	) -> Result<uint256> {580		let token_id: uint256 = <TokensMinted<T>>::get(self.id)581			.checked_add(1)582			.ok_or("item id overflow")?583			.into();584		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;585		Ok(token_id)586	}587588	/// @notice Function to mint token with the given tokenUri.589	/// @dev `tokenId` should be obtained with `nextTokenId` method,590	///  unlike standard, you can't specify it manually591	/// @param to The new owner592	/// @param tokenId ID of the minted NFT593	/// @param tokenUri Token URI that would be stored in the NFT properties594	#[solidity(hide, rename_selector = "mintWithTokenURI")]595	#[weight(<SelfWeightOf<T>>::create_item())]596	fn mint_with_token_uri_check_id(597		&mut self,598		caller: caller,599		to: address,600		token_id: uint256,601		token_uri: string,602	) -> Result<bool> {603		let key = key::url();604		let permission = get_token_permission::<T>(self.id, &key)?;605		if !permission.collection_admin {606			return Err("Operation is not allowed".into());607		}608609		let caller = T::CrossAccountId::from_eth(caller);610		let to = T::CrossAccountId::from_eth(to);611		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;612		let budget = self613			.recorder614			.weight_calls_budget(<StructureWeight<T>>::find_parent());615616		if <TokensMinted<T>>::get(self.id)617			.checked_add(1)618			.ok_or("item id overflow")?619			!= token_id620		{621			return Err("item id should be next".into());622		}623624		let mut properties = CollectionPropertiesVec::default();625		properties626			.try_push(Property {627				key,628				value: token_uri629					.into_bytes()630					.try_into()631					.map_err(|_| "token uri is too long")?,632			})633			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;634635		<Pallet<T>>::create_item(636			self,637			&caller,638			CreateItemData::<T> {639				properties,640				owner: to,641			},642			&budget,643		)644		.map_err(dispatch_to_evm::<T>)?;645		Ok(true)646	}647648	/// @dev Not implemented649	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {650		Err("not implementable".into())651	}652}653654fn get_token_property<T: Config>(655	collection: &CollectionHandle<T>,656	token_id: u32,657	key: &up_data_structs::PropertyKey,658) -> Result<string> {659	collection.consume_store_reads(1)?;660	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))661		.map_err(|_| Error::Revert("Token properties not found".into()))?;662	if let Some(property) = properties.get(key) {663		return Ok(string::from_utf8_lossy(property).into());664	}665666	Err("Property tokenURI not found".into())667}668669fn get_token_permission<T: Config>(670	collection_id: CollectionId,671	key: &PropertyKey,672) -> Result<PropertyPermission> {673	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)674		.map_err(|_| Error::Revert("No permissions for collection".into()))?;675	let a = token_property_permissions676		.get(key)677		.map(Clone::clone)678		.ok_or_else(|| {679			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();680			Error::Revert(alloc::format!("No permission for key {}", key))681		})?;682	Ok(a)683}684685/// @title Unique extensions for ERC721.686#[solidity_interface(name = ERC721UniqueExtensions)]687impl<T: Config> NonfungibleHandle<T>688where689	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,690{691	/// @notice A descriptive name for a collection of NFTs in this contract692	fn name(&self) -> Result<string> {693		Ok(decode_utf16(self.name.iter().copied())694			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))695			.collect::<string>())696	}697698	/// @notice An abbreviated name for NFTs in this contract699	fn symbol(&self) -> Result<string> {700		Ok(string::from_utf8_lossy(&self.token_prefix).into())701	}702703	/// @notice A description for the collection.704	fn description(&self) -> Result<string> {705		Ok(decode_utf16(self.description.iter().copied())706			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))707			.collect::<string>())708	}709710	/// Returns the owner (in cross format) of the token.711	///712	/// @param tokenId Id for the token.713	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {714		Self::token_owner(&self, token_id.try_into()?)715			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))716			.ok_or(Error::Revert("key too large".into()))717	}718719	/// Returns the token properties.720	///721	/// @param tokenId Id for the token.722	/// @param keys Properties keys. Empty keys for all propertyes.723	/// @return Vector of properties key/value pairs.724	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {725		let keys = keys726			.into_iter()727			.map(|key| {728				<Vec<u8>>::from(key)729					.try_into()730					.map_err(|_| Error::Revert("key too large".into()))731			})732			.collect::<Result<Vec<_>>>()?;733734		<Self as CommonCollectionOperations<T>>::token_properties(735			&self,736			token_id.try_into()?,737			if keys.is_empty() { None } else { Some(keys) },738		)739		.into_iter()740		.map(|p| {741			let key = string::from_utf8(p.key.to_vec())742				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;743			let value = bytes(p.value.to_vec());744			Ok(PropertyStruct { key, value })745		})746		.collect::<Result<Vec<_>>>()747	}748749	/// @notice Set or reaffirm the approved address for an NFT750	/// @dev The zero address indicates there is no approved address.751	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized752	///  operator of the current owner.753	/// @param approved The new substrate address approved NFT controller754	/// @param tokenId The NFT to approve755	#[weight(<SelfWeightOf<T>>::approve())]756	fn approve_cross(757		&mut self,758		caller: caller,759		approved: EthCrossAccount,760		token_id: uint256,761	) -> Result<void> {762		let caller = T::CrossAccountId::from_eth(caller);763		let approved = approved.into_sub_cross_account::<T>()?;764		let token = token_id.try_into()?;765766		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))767			.map_err(dispatch_to_evm::<T>)?;768		Ok(())769	}770771	/// @notice Transfer ownership of an NFT772	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`773	///  is the zero address. Throws if `tokenId` is not a valid NFT.774	/// @param to The new owner775	/// @param tokenId The NFT to transfer776	#[weight(<SelfWeightOf<T>>::transfer())]777	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {778		let caller = T::CrossAccountId::from_eth(caller);779		let to = T::CrossAccountId::from_eth(to);780		let token = token_id.try_into()?;781		let budget = self782			.recorder783			.weight_calls_budget(<StructureWeight<T>>::find_parent());784785		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;786		Ok(())787	}788789	/// @notice Transfer ownership of an NFT790	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`791	///  is the zero address. Throws if `tokenId` is not a valid NFT.792	/// @param to The new owner793	/// @param tokenId The NFT to transfer794	#[weight(<SelfWeightOf<T>>::transfer())]795	fn transfer_cross(796		&mut self,797		caller: caller,798		to: EthCrossAccount,799		token_id: uint256,800	) -> Result<void> {801		let caller = T::CrossAccountId::from_eth(caller);802		let to = to.into_sub_cross_account::<T>()?;803		let token = token_id.try_into()?;804		let budget = self805			.recorder806			.weight_calls_budget(<StructureWeight<T>>::find_parent());807808		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;809		Ok(())810	}811812	/// @notice Transfer ownership of an NFT from cross account address to cross account address813	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`814	///  is the zero address. Throws if `tokenId` is not a valid NFT.815	/// @param from Cross acccount address of current owner816	/// @param to Cross acccount address of new owner817	/// @param tokenId The NFT to transfer818	#[weight(<SelfWeightOf<T>>::transfer())]819	fn transfer_from_cross(820		&mut self,821		caller: caller,822		from: EthCrossAccount,823		to: EthCrossAccount,824		token_id: uint256,825	) -> Result<void> {826		let caller = T::CrossAccountId::from_eth(caller);827		let from = from.into_sub_cross_account::<T>()?;828		let to = to.into_sub_cross_account::<T>()?;829		let token_id = token_id.try_into()?;830		let budget = self831			.recorder832			.weight_calls_budget(<StructureWeight<T>>::find_parent());833		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)834			.map_err(dispatch_to_evm::<T>)?;835		Ok(())836	}837838	/// @notice Burns a specific ERC721 token.839	/// @dev Throws unless `msg.sender` is the current owner or an authorized840	///  operator for this NFT. Throws if `from` is not the current owner. Throws841	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.842	/// @param from The current owner of the NFT843	/// @param tokenId The NFT to transfer844	#[solidity(hide)]845	#[weight(<SelfWeightOf<T>>::burn_from())]846	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {847		let caller = T::CrossAccountId::from_eth(caller);848		let from = T::CrossAccountId::from_eth(from);849		let token = token_id.try_into()?;850		let budget = self851			.recorder852			.weight_calls_budget(<StructureWeight<T>>::find_parent());853854		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)855			.map_err(dispatch_to_evm::<T>)?;856		Ok(())857	}858859	/// @notice Burns a specific ERC721 token.860	/// @dev Throws unless `msg.sender` is the current owner or an authorized861	///  operator for this NFT. Throws if `from` is not the current owner. Throws862	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.863	/// @param from The current owner of the NFT864	/// @param tokenId The NFT to transfer865	#[weight(<SelfWeightOf<T>>::burn_from())]866	fn burn_from_cross(867		&mut self,868		caller: caller,869		from: EthCrossAccount,870		token_id: uint256,871	) -> Result<void> {872		let caller = T::CrossAccountId::from_eth(caller);873		let from = from.into_sub_cross_account::<T>()?;874		let token = token_id.try_into()?;875		let budget = self876			.recorder877			.weight_calls_budget(<StructureWeight<T>>::find_parent());878879		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)880			.map_err(dispatch_to_evm::<T>)?;881		Ok(())882	}883884	/// @notice Returns next free NFT ID.885	fn next_token_id(&self) -> Result<uint256> {886		self.consume_store_reads(1)?;887		Ok(<TokensMinted<T>>::get(self.id)888			.checked_add(1)889			.ok_or("item id overflow")?890			.into())891	}892893	/// @notice Function to mint multiple tokens.894	/// @dev `tokenIds` should be an array of consecutive numbers and first number895	///  should be obtained with `nextTokenId` method896	/// @param to The new owner897	/// @param tokenIds IDs of the minted NFTs898	#[solidity(hide)]899	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]900	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {901		let caller = T::CrossAccountId::from_eth(caller);902		let to = T::CrossAccountId::from_eth(to);903		let mut expected_index = <TokensMinted<T>>::get(self.id)904			.checked_add(1)905			.ok_or("item id overflow")?;906		let budget = self907			.recorder908			.weight_calls_budget(<StructureWeight<T>>::find_parent());909910		let total_tokens = token_ids.len();911		for id in token_ids.into_iter() {912			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;913			if id != expected_index {914				return Err("item id should be next".into());915			}916			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;917		}918		let data = (0..total_tokens)919			.map(|_| CreateItemData::<T> {920				properties: BoundedVec::default(),921				owner: to.clone(),922			})923			.collect();924925		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)926			.map_err(dispatch_to_evm::<T>)?;927		Ok(true)928	}929930	/// @notice Function to mint multiple tokens with the given tokenUris.931	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive932	///  numbers and first number should be obtained with `nextTokenId` method933	/// @param to The new owner934	/// @param tokens array of pairs of token ID and token URI for minted tokens935	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]936	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]937	fn mint_bulk_with_token_uri(938		&mut self,939		caller: caller,940		to: address,941		tokens: Vec<(uint256, string)>,942	) -> Result<bool> {943		let key = key::url();944		let caller = T::CrossAccountId::from_eth(caller);945		let to = T::CrossAccountId::from_eth(to);946		let mut expected_index = <TokensMinted<T>>::get(self.id)947			.checked_add(1)948			.ok_or("item id overflow")?;949		let budget = self950			.recorder951			.weight_calls_budget(<StructureWeight<T>>::find_parent());952953		let mut data = Vec::with_capacity(tokens.len());954		for (id, token_uri) in tokens {955			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;956			if id != expected_index {957				return Err("item id should be next".into());958			}959			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;960961			let mut properties = CollectionPropertiesVec::default();962			properties963				.try_push(Property {964					key: key.clone(),965					value: token_uri966						.into_bytes()967						.try_into()968						.map_err(|_| "token uri is too long")?,969				})970				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;971972			data.push(CreateItemData::<T> {973				properties,974				owner: to.clone(),975			});976		}977978		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)979			.map_err(dispatch_to_evm::<T>)?;980		Ok(true)981	}982}983984#[solidity_interface(985	name = UniqueNFT,986	is(987		ERC721,988		ERC721Enumerable,989		ERC721UniqueExtensions,990		ERC721UniqueMintable,991		ERC721Burnable,992		ERC721Metadata(if(this.flags.erc721metadata)),993		Collection(via(common_mut returns CollectionHandle<T>)),994		TokenProperties,995	)996)]997impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}998999// Not a tests, but code generators1000generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1001generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);10021003impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1004where1005	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1006{1007	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");10081009	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1010		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1011	}1012}