git.delta.rocks / unique-network / refs/commits / 93efc9e5e22c

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 token_properties(725		&self,726		token_id: uint256,727		keys: Vec<string>,728	) -> Result<Vec<(string, bytes)>> {729		let keys = keys730			.into_iter()731			.map(|key| {732				<Vec<u8>>::from(key)733					.try_into()734					.map_err(|_| Error::Revert("key too large".into()))735			})736			.collect::<Result<Vec<_>>>()?;737738		<Self as CommonCollectionOperations<T>>::token_properties(739			&self,740			token_id.try_into()?,741			if keys.is_empty() { None } else { Some(keys) },742		)743		.into_iter()744		.map(|p| {745			let key = string::from_utf8(p.key.to_vec())746				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;747			let value = bytes(p.value.to_vec());748			Ok((key, value))749		})750		.collect::<Result<Vec<_>>>()751	}752753	/// @notice Set or reaffirm the approved address for an NFT754	/// @dev The zero address indicates there is no approved address.755	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized756	///  operator of the current owner.757	/// @param approved The new substrate address approved NFT controller758	/// @param tokenId The NFT to approve759	#[weight(<SelfWeightOf<T>>::approve())]760	fn approve_cross(761		&mut self,762		caller: caller,763		approved: EthCrossAccount,764		token_id: uint256,765	) -> Result<void> {766		let caller = T::CrossAccountId::from_eth(caller);767		let approved = approved.into_sub_cross_account::<T>()?;768		let token = token_id.try_into()?;769770		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))771			.map_err(dispatch_to_evm::<T>)?;772		Ok(())773	}774775	/// @notice Transfer ownership of an NFT776	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`777	///  is the zero address. Throws if `tokenId` is not a valid NFT.778	/// @param to The new owner779	/// @param tokenId The NFT to transfer780	#[weight(<SelfWeightOf<T>>::transfer())]781	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {782		let caller = T::CrossAccountId::from_eth(caller);783		let to = T::CrossAccountId::from_eth(to);784		let token = token_id.try_into()?;785		let budget = self786			.recorder787			.weight_calls_budget(<StructureWeight<T>>::find_parent());788789		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;790		Ok(())791	}792793	/// @notice Transfer ownership of an NFT794	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`795	///  is the zero address. Throws if `tokenId` is not a valid NFT.796	/// @param to The new owner797	/// @param tokenId The NFT to transfer798	#[weight(<SelfWeightOf<T>>::transfer())]799	fn transfer_cross(800		&mut self,801		caller: caller,802		to: EthCrossAccount,803		token_id: uint256,804	) -> Result<void> {805		let caller = T::CrossAccountId::from_eth(caller);806		let to = to.into_sub_cross_account::<T>()?;807		let token = token_id.try_into()?;808		let budget = self809			.recorder810			.weight_calls_budget(<StructureWeight<T>>::find_parent());811812		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;813		Ok(())814	}815816	/// @notice Transfer ownership of an NFT from cross account address to cross account address817	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`818	///  is the zero address. Throws if `tokenId` is not a valid NFT.819	/// @param from Cross acccount address of current owner820	/// @param to Cross acccount address of new owner821	/// @param tokenId The NFT to transfer822	#[weight(<SelfWeightOf<T>>::transfer())]823	fn transfer_from_cross(824		&mut self,825		caller: caller,826		from: EthCrossAccount,827		to: EthCrossAccount,828		token_id: uint256,829	) -> Result<void> {830		let caller = T::CrossAccountId::from_eth(caller);831		let from = from.into_sub_cross_account::<T>()?;832		let to = to.into_sub_cross_account::<T>()?;833		let token_id = token_id.try_into()?;834		let budget = self835			.recorder836			.weight_calls_budget(<StructureWeight<T>>::find_parent());837		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)838			.map_err(dispatch_to_evm::<T>)?;839		Ok(())840	}841842	/// @notice Burns a specific ERC721 token.843	/// @dev Throws unless `msg.sender` is the current owner or an authorized844	///  operator for this NFT. Throws if `from` is not the current owner. Throws845	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.846	/// @param from The current owner of the NFT847	/// @param tokenId The NFT to transfer848	#[solidity(hide)]849	#[weight(<SelfWeightOf<T>>::burn_from())]850	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {851		let caller = T::CrossAccountId::from_eth(caller);852		let from = T::CrossAccountId::from_eth(from);853		let token = token_id.try_into()?;854		let budget = self855			.recorder856			.weight_calls_budget(<StructureWeight<T>>::find_parent());857858		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)859			.map_err(dispatch_to_evm::<T>)?;860		Ok(())861	}862863	/// @notice Burns a specific ERC721 token.864	/// @dev Throws unless `msg.sender` is the current owner or an authorized865	///  operator for this NFT. Throws if `from` is not the current owner. Throws866	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.867	/// @param from The current owner of the NFT868	/// @param tokenId The NFT to transfer869	#[weight(<SelfWeightOf<T>>::burn_from())]870	fn burn_from_cross(871		&mut self,872		caller: caller,873		from: EthCrossAccount,874		token_id: uint256,875	) -> Result<void> {876		let caller = T::CrossAccountId::from_eth(caller);877		let from = from.into_sub_cross_account::<T>()?;878		let token = token_id.try_into()?;879		let budget = self880			.recorder881			.weight_calls_budget(<StructureWeight<T>>::find_parent());882883		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)884			.map_err(dispatch_to_evm::<T>)?;885		Ok(())886	}887888	/// @notice Returns next free NFT ID.889	fn next_token_id(&self) -> Result<uint256> {890		self.consume_store_reads(1)?;891		Ok(<TokensMinted<T>>::get(self.id)892			.checked_add(1)893			.ok_or("item id overflow")?894			.into())895	}896897	/// @notice Function to mint multiple tokens.898	/// @dev `tokenIds` should be an array of consecutive numbers and first number899	///  should be obtained with `nextTokenId` method900	/// @param to The new owner901	/// @param tokenIds IDs of the minted NFTs902	#[solidity(hide)]903	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]904	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {905		let caller = T::CrossAccountId::from_eth(caller);906		let to = T::CrossAccountId::from_eth(to);907		let mut expected_index = <TokensMinted<T>>::get(self.id)908			.checked_add(1)909			.ok_or("item id overflow")?;910		let budget = self911			.recorder912			.weight_calls_budget(<StructureWeight<T>>::find_parent());913914		let total_tokens = token_ids.len();915		for id in token_ids.into_iter() {916			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;917			if id != expected_index {918				return Err("item id should be next".into());919			}920			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;921		}922		let data = (0..total_tokens)923			.map(|_| CreateItemData::<T> {924				properties: BoundedVec::default(),925				owner: to.clone(),926			})927			.collect();928929		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)930			.map_err(dispatch_to_evm::<T>)?;931		Ok(true)932	}933934	/// @notice Function to mint multiple tokens with the given tokenUris.935	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive936	///  numbers and first number should be obtained with `nextTokenId` method937	/// @param to The new owner938	/// @param tokens array of pairs of token ID and token URI for minted tokens939	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]940	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]941	fn mint_bulk_with_token_uri(942		&mut self,943		caller: caller,944		to: address,945		tokens: Vec<(uint256, string)>,946	) -> Result<bool> {947		let key = key::url();948		let caller = T::CrossAccountId::from_eth(caller);949		let to = T::CrossAccountId::from_eth(to);950		let mut expected_index = <TokensMinted<T>>::get(self.id)951			.checked_add(1)952			.ok_or("item id overflow")?;953		let budget = self954			.recorder955			.weight_calls_budget(<StructureWeight<T>>::find_parent());956957		let mut data = Vec::with_capacity(tokens.len());958		for (id, token_uri) in tokens {959			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;960			if id != expected_index {961				return Err("item id should be next".into());962			}963			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;964965			let mut properties = CollectionPropertiesVec::default();966			properties967				.try_push(Property {968					key: key.clone(),969					value: token_uri970						.into_bytes()971						.try_into()972						.map_err(|_| "token uri is too long")?,973				})974				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;975976			data.push(CreateItemData::<T> {977				properties,978				owner: to.clone(),979			});980		}981982		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)983			.map_err(dispatch_to_evm::<T>)?;984		Ok(true)985	}986}987988#[solidity_interface(989	name = UniqueNFT,990	is(991		ERC721,992		ERC721Enumerable,993		ERC721UniqueExtensions,994		ERC721UniqueMintable,995		ERC721Burnable,996		ERC721Metadata(if(this.flags.erc721metadata)),997		Collection(via(common_mut returns CollectionHandle<T>)),998		TokenProperties,999	)1000)]1001impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10021003// Not a tests, but code generators1004generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1005generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);10061007impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1008where1009	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1010{1011	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");10121013	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1014		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1015	}1016}