git.delta.rocks / unique-network / refs/commits / 2e0d1a668d33

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,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]>,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]>,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 Set or reaffirm the approved address for an NFT704	/// @dev The zero address indicates there is no approved address.705	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized706	///  operator of the current owner.707	/// @param approved The new substrate address approved NFT controller708	/// @param tokenId The NFT to approve709	#[weight(<SelfWeightOf<T>>::approve())]710	fn approve_cross(711		&mut self,712		caller: caller,713		approved: EthCrossAccount,714		token_id: uint256,715	) -> Result<void> {716		let caller = T::CrossAccountId::from_eth(caller);717		let approved = approved.into_sub_cross_account::<T>()?;718		let token = token_id.try_into()?;719720		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))721			.map_err(dispatch_to_evm::<T>)?;722		Ok(())723	}724725	/// @notice Transfer ownership of an NFT726	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`727	///  is the zero address. Throws if `tokenId` is not a valid NFT.728	/// @param to The new owner729	/// @param tokenId The NFT to transfer730	#[weight(<SelfWeightOf<T>>::transfer())]731	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {732		let caller = T::CrossAccountId::from_eth(caller);733		let to = T::CrossAccountId::from_eth(to);734		let token = token_id.try_into()?;735		let budget = self736			.recorder737			.weight_calls_budget(<StructureWeight<T>>::find_parent());738739		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;740		Ok(())741	}742743	/// @notice Transfer ownership of an NFT744	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`745	///  is the zero address. Throws if `tokenId` is not a valid NFT.746	/// @param to The new owner747	/// @param tokenId The NFT to transfer748	#[weight(<SelfWeightOf<T>>::transfer())]749	fn transfer_cross(750		&mut self,751		caller: caller,752		to: EthCrossAccount,753		token_id: uint256,754	) -> Result<void> {755		let caller = T::CrossAccountId::from_eth(caller);756		let to = to.into_sub_cross_account::<T>()?;757		let token = token_id.try_into()?;758		let budget = self759			.recorder760			.weight_calls_budget(<StructureWeight<T>>::find_parent());761762		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;763		Ok(())764	}765766	/// @notice Transfer ownership of an NFT from cross account address to cross account address767	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`768	///  is the zero address. Throws if `tokenId` is not a valid NFT.769	/// @param from Cross acccount address of current owner770	/// @param to Cross acccount address of new owner771	/// @param tokenId The NFT to transfer772	#[weight(<SelfWeightOf<T>>::transfer())]773	fn transfer_from_cross(774		&mut self,775		caller: caller,776		from: EthCrossAccount,777		to: EthCrossAccount,778		token_id: uint256,779	) -> Result<void> {780		let caller = T::CrossAccountId::from_eth(caller);781		let from = from.into_sub_cross_account::<T>()?;782		let to = to.into_sub_cross_account::<T>()?;783		let token_id = token_id.try_into()?;784		let budget = self785			.recorder786			.weight_calls_budget(<StructureWeight<T>>::find_parent());787		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)788			.map_err(dispatch_to_evm::<T>)?;789		Ok(())790	}791792	/// @notice Burns a specific ERC721 token.793	/// @dev Throws unless `msg.sender` is the current owner or an authorized794	///  operator for this NFT. Throws if `from` is not the current owner. Throws795	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.796	/// @param from The current owner of the NFT797	/// @param tokenId The NFT to transfer798	#[solidity(hide)]799	#[weight(<SelfWeightOf<T>>::burn_from())]800	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {801		let caller = T::CrossAccountId::from_eth(caller);802		let from = T::CrossAccountId::from_eth(from);803		let token = token_id.try_into()?;804		let budget = self805			.recorder806			.weight_calls_budget(<StructureWeight<T>>::find_parent());807808		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)809			.map_err(dispatch_to_evm::<T>)?;810		Ok(())811	}812813	/// @notice Burns a specific ERC721 token.814	/// @dev Throws unless `msg.sender` is the current owner or an authorized815	///  operator for this NFT. Throws if `from` is not the current owner. Throws816	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.817	/// @param from The current owner of the NFT818	/// @param tokenId The NFT to transfer819	#[weight(<SelfWeightOf<T>>::burn_from())]820	fn burn_from_cross(821		&mut self,822		caller: caller,823		from: 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 token = token_id.try_into()?;829		let budget = self830			.recorder831			.weight_calls_budget(<StructureWeight<T>>::find_parent());832833		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)834			.map_err(dispatch_to_evm::<T>)?;835		Ok(())836	}837838	/// @notice Returns next free NFT ID.839	fn next_token_id(&self) -> Result<uint256> {840		self.consume_store_reads(1)?;841		Ok(<TokensMinted<T>>::get(self.id)842			.checked_add(1)843			.ok_or("item id overflow")?844			.into())845	}846847	/// @notice Function to mint multiple tokens.848	/// @dev `tokenIds` should be an array of consecutive numbers and first number849	///  should be obtained with `nextTokenId` method850	/// @param to The new owner851	/// @param tokenIds IDs of the minted NFTs852	#[solidity(hide)]853	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]854	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {855		let caller = T::CrossAccountId::from_eth(caller);856		let to = T::CrossAccountId::from_eth(to);857		let mut expected_index = <TokensMinted<T>>::get(self.id)858			.checked_add(1)859			.ok_or("item id overflow")?;860		let budget = self861			.recorder862			.weight_calls_budget(<StructureWeight<T>>::find_parent());863864		let total_tokens = token_ids.len();865		for id in token_ids.into_iter() {866			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;867			if id != expected_index {868				return Err("item id should be next".into());869			}870			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;871		}872		let data = (0..total_tokens)873			.map(|_| CreateItemData::<T> {874				properties: BoundedVec::default(),875				owner: to.clone(),876			})877			.collect();878879		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)880			.map_err(dispatch_to_evm::<T>)?;881		Ok(true)882	}883884	/// @notice Function to mint multiple tokens with the given tokenUris.885	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive886	///  numbers and first number should be obtained with `nextTokenId` method887	/// @param to The new owner888	/// @param tokens array of pairs of token ID and token URI for minted tokens889	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]890	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]891	fn mint_bulk_with_token_uri(892		&mut self,893		caller: caller,894		to: address,895		tokens: Vec<(uint256, string)>,896	) -> Result<bool> {897		let key = key::url();898		let caller = T::CrossAccountId::from_eth(caller);899		let to = T::CrossAccountId::from_eth(to);900		let mut expected_index = <TokensMinted<T>>::get(self.id)901			.checked_add(1)902			.ok_or("item id overflow")?;903		let budget = self904			.recorder905			.weight_calls_budget(<StructureWeight<T>>::find_parent());906907		let mut data = Vec::with_capacity(tokens.len());908		for (id, token_uri) in tokens {909			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;910			if id != expected_index {911				return Err("item id should be next".into());912			}913			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;914915			let mut properties = CollectionPropertiesVec::default();916			properties917				.try_push(Property {918					key: key.clone(),919					value: token_uri920						.into_bytes()921						.try_into()922						.map_err(|_| "token uri is too long")?,923				})924				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;925926			data.push(CreateItemData::<T> {927				properties,928				owner: to.clone(),929			});930		}931932		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)933			.map_err(dispatch_to_evm::<T>)?;934		Ok(true)935	}936}937938#[solidity_interface(939	name = UniqueNFT,940	is(941		ERC721,942		ERC721Enumerable,943		ERC721UniqueExtensions,944		ERC721UniqueMintable,945		ERC721Burnable,946		ERC721Metadata(if(this.flags.erc721metadata)),947		Collection(via(common_mut returns CollectionHandle<T>)),948		TokenProperties,949	)950)]951impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}952953// Not a tests, but code generators954generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);955generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);956957impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>958where959	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,960{961	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");962963	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {964		call::<T, UniqueNFTCall<T>, _, _>(handle, self)965	}966}