git.delta.rocks / unique-network / refs/commits / 5ec07294ed3b

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::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};28use frame_support::BoundedVec;29use up_data_structs::{30	TokenId, PropertyPermission, PropertyKeyPermission, Property, CollectionId, PropertyKey,31	CollectionPropertiesVec,32};33use pallet_evm_coder_substrate::dispatch_to_evm;34use sp_std::vec::Vec;35use pallet_common::{36	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property_key_value::*},37	CollectionHandle, CollectionPropertyPermissions,38};39use pallet_evm::{account::CrossAccountId, PrecompileHandle};40use pallet_evm_coder_substrate::call;41use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};42use alloc::string::ToString;4344use crate::{45	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,46	SelfWeightOf, weights::WeightInfo, TokenProperties,47};4849/// @title A contract that allows to set and delete token properties and change token property permissions.50#[solidity_interface(name = "TokenProperties")]51impl<T: Config> NonfungibleHandle<T> {52	/// @notice Set permissions for token property.53	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.54	/// @param key Property key.55	/// @param is_mutable Permission to mutate property.56	/// @param collection_admin Permission to mutate property by collection admin if property is mutable.57	/// @param token_owner Permission to mutate property by token owner if property is mutable.58	fn set_token_property_permission(59		&mut self,60		caller: caller,61		key: string,62		is_mutable: bool,63		collection_admin: bool,64		token_owner: bool,65	) -> Result<()> {66		let caller = T::CrossAccountId::from_eth(caller);67		<Pallet<T>>::set_property_permission(68			self,69			&caller,70			PropertyKeyPermission {71				key: <Vec<u8>>::from(key)72					.try_into()73					.map_err(|_| "too long key")?,74				permission: PropertyPermission {75					mutable: is_mutable,76					collection_admin,77					token_owner,78				},79			},80		)81		.map_err(dispatch_to_evm::<T>)82	}8384	/// @notice Set token property value.85	/// @dev Throws error if `msg.sender` has no permission to edit the property.86	/// @param tokenId ID of the token.87	/// @param key Property key.88	/// @param value Property value.89	fn set_property(90		&mut self,91		caller: caller,92		token_id: uint256,93		key: string,94		value: bytes,95	) -> Result<()> {96		let caller = T::CrossAccountId::from_eth(caller);97		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;98		let key = <Vec<u8>>::from(key)99			.try_into()100			.map_err(|_| "key too long")?;101		let value = value.try_into().map_err(|_| "value too long")?;102103		let nesting_budget = self104			.recorder105			.weight_calls_budget(<StructureWeight<T>>::find_parent());106107		<Pallet<T>>::set_token_property(108			self,109			&caller,110			TokenId(token_id),111			Property { key, value },112			&nesting_budget,113		)114		.map_err(dispatch_to_evm::<T>)115	}116117	/// @notice Delete token property value.118	/// @dev Throws error if `msg.sender` has no permission to edit the property.119	/// @param tokenId ID of the token.120	/// @param key Property key.121	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {122		let caller = T::CrossAccountId::from_eth(caller);123		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;124		let key = <Vec<u8>>::from(key)125			.try_into()126			.map_err(|_| "key too long")?;127128		let nesting_budget = self129			.recorder130			.weight_calls_budget(<StructureWeight<T>>::find_parent());131132		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)133			.map_err(dispatch_to_evm::<T>)134	}135136	/// @notice Get token property value.137	/// @dev Throws error if key not found138	/// @param tokenId ID of the token.139	/// @param key Property key.140	/// @return Property value bytes141	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {142		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;143		let key = <Vec<u8>>::from(key)144			.try_into()145			.map_err(|_| "key too long")?;146147		let props = <TokenProperties<T>>::get((self.id, token_id));148		let prop = props.get(&key).ok_or("key not found")?;149150		Ok(prop.to_vec())151	}152}153154#[derive(ToLog)]155pub enum ERC721Events {156	/// @dev This emits when ownership of any NFT changes by any mechanism.157	///  This event emits when NFTs are created (`from` == 0) and destroyed158	///  (`to` == 0). Exception: during contract creation, any number of NFTs159	///  may be created and assigned without emitting Transfer. At the time of160	///  any transfer, the approved address for that NFT (if any) is reset to none.161	Transfer {162		#[indexed]163		from: address,164		#[indexed]165		to: address,166		#[indexed]167		token_id: uint256,168	},169	/// @dev This emits when the approved address for an NFT is changed or170	///  reaffirmed. The zero address indicates there is no approved address.171	///  When a Transfer event emits, this also indicates that the approved172	///  address for that NFT (if any) is reset to none.173	Approval {174		#[indexed]175		owner: address,176		#[indexed]177		approved: address,178		#[indexed]179		token_id: uint256,180	},181	/// @dev This emits when an operator is enabled or disabled for an owner.182	///  The operator can manage all NFTs of the owner.183	#[allow(dead_code)]184	ApprovalForAll {185		#[indexed]186		owner: address,187		#[indexed]188		operator: address,189		approved: bool,190	},191}192193#[derive(ToLog)]194pub enum ERC721MintableEvents {195	#[allow(dead_code)]196	MintingFinished {},197}198199/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension200/// @dev See https://eips.ethereum.org/EIPS/eip-721201#[solidity_interface(name = "ERC721Metadata")]202impl<T: Config> NonfungibleHandle<T> {203	/// @notice A descriptive name for a collection of NFTs in this contract204	fn name(&self) -> Result<string> {205		Ok(decode_utf16(self.name.iter().copied())206			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))207			.collect::<string>())208	}209210	/// @notice An abbreviated name for NFTs in this contract211	fn symbol(&self) -> Result<string> {212		Ok(string::from_utf8_lossy(&self.token_prefix).into())213	}214215	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.216	/// @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC217	///  3986. The URI may point to a JSON file that conforms to the "ERC721218	///  Metadata JSON Schema".219	/// @return token's const_metadata220	#[solidity(rename_selector = "tokenURI")]221	fn token_uri(&self, token_id: uint256) -> Result<string> {222		let is_erc721 = || {223			if let Some(shema_name) =224				pallet_common::Pallet::<T>::get_collection_property(self.id, &schema_name_key())225			{226				let shema_name = shema_name.into_inner();227				shema_name == ERC721_METADATA228			} else {229				false230			}231		};232233		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;234235		if let Ok(url) = get_token_property(self, token_id_u32, &url_key()) {236			if !url.is_empty() {237				return Ok(url);238			}239		} else if !is_erc721() {240			return Err("tokenURI not set".into());241		} else if !is_erc721() {242			return Err("tokenURI not set".into());243		}244245		if let Some(base_uri) =246			pallet_common::Pallet::<T>::get_collection_property(self.id, &base_uri_key())247		{248			if !base_uri.is_empty() {249				let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {250					Error::Revert(alloc::format!(251						"Can not convert value \"baseURI\" to string with error \"{}\"",252						e253					))254				})?;255				if let Ok(suffix) = get_token_property(self, token_id_u32, &suffix_key()) {256					if !suffix.is_empty() {257						return Ok(base_uri + suffix.as_str());258					}259				}260261				return Ok(base_uri + token_id.to_string().as_str());262			}263		}264265		Ok("".into())266	}267}268269/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension270/// @dev See https://eips.ethereum.org/EIPS/eip-721271#[solidity_interface(name = "ERC721Enumerable")]272impl<T: Config> NonfungibleHandle<T> {273	/// @notice Enumerate valid NFTs274	/// @param index A counter less than `totalSupply()`275	/// @return The token identifier for the `index`th NFT,276	///  (sort order not specified)277	fn token_by_index(&self, index: uint256) -> Result<uint256> {278		Ok(index)279	}280281	/// @dev Not implemented282	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {283		// TODO: Not implemetable284		Err("not implemented".into())285	}286287	/// @notice Count NFTs tracked by this contract288	/// @return A count of valid NFTs tracked by this contract, where each one of289	///  them has an assigned and queryable owner not equal to the zero address290	fn total_supply(&self) -> Result<uint256> {291		self.consume_store_reads(1)?;292		Ok(<Pallet<T>>::total_supply(self).into())293	}294}295296/// @title ERC-721 Non-Fungible Token Standard297/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md298#[solidity_interface(name = "ERC721", events(ERC721Events))]299impl<T: Config> NonfungibleHandle<T> {300	/// @notice Count all NFTs assigned to an owner301	/// @dev NFTs assigned to the zero address are considered invalid, and this302	///  function throws for queries about the zero address.303	/// @param owner An address for whom to query the balance304	/// @return The number of NFTs owned by `owner`, possibly zero305	fn balance_of(&self, owner: address) -> Result<uint256> {306		self.consume_store_reads(1)?;307		let owner = T::CrossAccountId::from_eth(owner);308		let balance = <AccountBalance<T>>::get((self.id, owner));309		Ok(balance.into())310	}311	/// @notice Find the owner of an NFT312	/// @dev NFTs assigned to zero address are considered invalid, and queries313	///  about them do throw.314	/// @param tokenId The identifier for an NFT315	/// @return The address of the owner of the NFT316	fn owner_of(&self, token_id: uint256) -> Result<address> {317		self.consume_store_reads(1)?;318		let token: TokenId = token_id.try_into()?;319		Ok(*<TokenData<T>>::get((self.id, token))320			.ok_or("token not found")?321			.owner322			.as_eth())323	}324	/// @dev Not implemented325	fn safe_transfer_from_with_data(326		&mut self,327		_from: address,328		_to: address,329		_token_id: uint256,330		_data: bytes,331		_value: value,332	) -> Result<void> {333		// TODO: Not implemetable334		Err("not implemented".into())335	}336	/// @dev Not implemented337	fn safe_transfer_from(338		&mut self,339		_from: address,340		_to: address,341		_token_id: uint256,342		_value: value,343	) -> Result<void> {344		// TODO: Not implemetable345		Err("not implemented".into())346	}347348	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE349	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE350	///  THEY MAY BE PERMANENTLY LOST351	/// @dev Throws unless `msg.sender` is the current owner or an authorized352	///  operator for this NFT. Throws if `from` is not the current owner. Throws353	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.354	/// @param from The current owner of the NFT355	/// @param to The new owner356	/// @param tokenId The NFT to transfer357	/// @param _value Not used for an NFT358	#[weight(<SelfWeightOf<T>>::transfer_from())]359	fn transfer_from(360		&mut self,361		caller: caller,362		from: address,363		to: address,364		token_id: uint256,365		_value: value,366	) -> Result<void> {367		let caller = T::CrossAccountId::from_eth(caller);368		let from = T::CrossAccountId::from_eth(from);369		let to = T::CrossAccountId::from_eth(to);370		let token = token_id.try_into()?;371		let budget = self372			.recorder373			.weight_calls_budget(<StructureWeight<T>>::find_parent());374375		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)376			.map_err(dispatch_to_evm::<T>)?;377		Ok(())378	}379380	/// @notice Set or reaffirm the approved address for an NFT381	/// @dev The zero address indicates there is no approved address.382	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized383	///  operator of the current owner.384	/// @param approved The new approved NFT controller385	/// @param tokenId The NFT to approve386	#[weight(<SelfWeightOf<T>>::approve())]387	fn approve(388		&mut self,389		caller: caller,390		approved: address,391		token_id: uint256,392		_value: value,393	) -> Result<void> {394		let caller = T::CrossAccountId::from_eth(caller);395		let approved = T::CrossAccountId::from_eth(approved);396		let token = token_id.try_into()?;397398		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))399			.map_err(dispatch_to_evm::<T>)?;400		Ok(())401	}402403	/// @dev Not implemented404	fn set_approval_for_all(405		&mut self,406		_caller: caller,407		_operator: address,408		_approved: bool,409	) -> Result<void> {410		// TODO: Not implemetable411		Err("not implemented".into())412	}413414	/// @dev Not implemented415	fn get_approved(&self, _token_id: uint256) -> Result<address> {416		// TODO: Not implemetable417		Err("not implemented".into())418	}419420	/// @dev Not implemented421	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {422		// TODO: Not implemetable423		Err("not implemented".into())424	}425}426427/// @title ERC721 Token that can be irreversibly burned (destroyed).428#[solidity_interface(name = "ERC721Burnable")]429impl<T: Config> NonfungibleHandle<T> {430	/// @notice Burns a specific ERC721 token.431	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized432	///  operator of the current owner.433	/// @param tokenId The NFT to approve434	#[weight(<SelfWeightOf<T>>::burn_item())]435	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {436		let caller = T::CrossAccountId::from_eth(caller);437		let token = token_id.try_into()?;438439		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;440		Ok(())441	}442}443444/// @title ERC721 minting logic.445#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]446impl<T: Config> NonfungibleHandle<T> {447	fn minting_finished(&self) -> Result<bool> {448		Ok(false)449	}450451	/// @notice Function to mint token.452	/// @dev `tokenId` should be obtained with `nextTokenId` method,453	///  unlike standard, you can't specify it manually454	/// @param to The new owner455	/// @param tokenId ID of the minted NFT456	#[weight(<SelfWeightOf<T>>::create_item())]457	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {458		let caller = T::CrossAccountId::from_eth(caller);459		let to = T::CrossAccountId::from_eth(to);460		let token_id: u32 = token_id.try_into()?;461		let budget = self462			.recorder463			.weight_calls_budget(<StructureWeight<T>>::find_parent());464465		if <TokensMinted<T>>::get(self.id)466			.checked_add(1)467			.ok_or("item id overflow")?468			!= token_id469		{470			return Err("item id should be next".into());471		}472473		<Pallet<T>>::create_item(474			self,475			&caller,476			CreateItemData::<T> {477				properties: BoundedVec::default(),478				owner: to,479			},480			&budget,481		)482		.map_err(dispatch_to_evm::<T>)?;483484		Ok(true)485	}486487	/// @notice Function to mint token with the given tokenUri.488	/// @dev `tokenId` should be obtained with `nextTokenId` method,489	///  unlike standard, you can't specify it manually490	/// @param to The new owner491	/// @param tokenId ID of the minted NFT492	/// @param tokenUri Token URI that would be stored in the NFT properties493	#[solidity(rename_selector = "mintWithTokenURI")]494	#[weight(<SelfWeightOf<T>>::create_item())]495	fn mint_with_token_uri(496		&mut self,497		caller: caller,498		to: address,499		token_id: uint256,500		token_uri: string,501	) -> Result<bool> {502		let key = u_key();503		let permission = get_token_permission::<T>(self.id, &key)?;504		if !permission.collection_admin {505			return Err("Operation is not allowed".into());506		}507508		let caller = T::CrossAccountId::from_eth(caller);509		let to = T::CrossAccountId::from_eth(to);510		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;511		let budget = self512			.recorder513			.weight_calls_budget(<StructureWeight<T>>::find_parent());514515		if <TokensMinted<T>>::get(self.id)516			.checked_add(1)517			.ok_or("item id overflow")?518			!= token_id519		{520			return Err("item id should be next".into());521		}522523		let mut properties = CollectionPropertiesVec::default();524		properties525			.try_push(Property {526				key,527				value: token_uri528					.into_bytes()529					.try_into()530					.map_err(|_| "token uri is too long")?,531			})532			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;533534		<Pallet<T>>::create_item(535			self,536			&caller,537			CreateItemData::<T> {538				properties,539				owner: to,540			},541			&budget,542		)543		.map_err(dispatch_to_evm::<T>)?;544		Ok(true)545	}546547	/// @dev Not implemented548	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {549		Err("not implementable".into())550	}551}552553fn get_token_property<T: Config>(554	collection: &CollectionHandle<T>,555	token_id: u32,556	key: &up_data_structs::PropertyKey,557) -> Result<string> {558	collection.consume_store_reads(1)?;559	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))560		.map_err(|_| Error::Revert("Token properties not found".into()))?;561	if let Some(property) = properties.get(key) {562		return Ok(string::from_utf8_lossy(property).into());563	}564565	Err("Property tokenURI not found".into())566}567568fn get_token_permission<T: Config>(569	collection_id: CollectionId,570	key: &PropertyKey,571) -> Result<PropertyPermission> {572	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)573		.map_err(|_| Error::Revert("No permissions for collection".into()))?;574	let a = token_property_permissions575		.get(key)576		.map(Clone::clone)577		.ok_or_else(|| {578			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();579			Error::Revert(alloc::format!("No permission for key {}", key))580		})?;581	Ok(a)582}583584fn has_token_permission<T: Config>(collection_id: CollectionId, key: &PropertyKey) -> bool {585	if let Ok(token_property_permissions) =586		CollectionPropertyPermissions::<T>::try_get(collection_id)587	{588		return token_property_permissions.contains_key(key);589	}590591	false592}593594/// @title Unique extensions for ERC721.595#[solidity_interface(name = "ERC721UniqueExtensions")]596impl<T: Config> NonfungibleHandle<T> {597	/// @notice Transfer ownership of an NFT598	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`599	///  is the zero address. Throws if `tokenId` is not a valid NFT.600	/// @param to The new owner601	/// @param tokenId The NFT to transfer602	/// @param _value Not used for an NFT603	#[weight(<SelfWeightOf<T>>::transfer())]604	fn transfer(605		&mut self,606		caller: caller,607		to: address,608		token_id: uint256,609		_value: value,610	) -> Result<void> {611		let caller = T::CrossAccountId::from_eth(caller);612		let to = T::CrossAccountId::from_eth(to);613		let token = token_id.try_into()?;614		let budget = self615			.recorder616			.weight_calls_budget(<StructureWeight<T>>::find_parent());617618		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;619		Ok(())620	}621622	/// @notice Burns a specific ERC721 token.623	/// @dev Throws unless `msg.sender` is the current owner or an authorized624	///  operator for this NFT. Throws if `from` is not the current owner. Throws625	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.626	/// @param from The current owner of the NFT627	/// @param tokenId The NFT to transfer628	/// @param _value Not used for an NFT629	#[weight(<SelfWeightOf<T>>::burn_from())]630	fn burn_from(631		&mut self,632		caller: caller,633		from: address,634		token_id: uint256,635		_value: value,636	) -> Result<void> {637		let caller = T::CrossAccountId::from_eth(caller);638		let from = T::CrossAccountId::from_eth(from);639		let token = token_id.try_into()?;640		let budget = self641			.recorder642			.weight_calls_budget(<StructureWeight<T>>::find_parent());643644		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)645			.map_err(dispatch_to_evm::<T>)?;646		Ok(())647	}648649	/// @notice Returns next free NFT ID.650	fn next_token_id(&self) -> Result<uint256> {651		self.consume_store_reads(1)?;652		Ok(<TokensMinted<T>>::get(self.id)653			.checked_add(1)654			.ok_or("item id overflow")?655			.into())656	}657658	/// @notice Function to mint multiple tokens.659	/// @dev `tokenIds` should be an array of consecutive numbers and first number660	///  should be obtained with `nextTokenId` method661	/// @param to The new owner662	/// @param tokenIds IDs of the minted NFTs663	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]664	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {665		let caller = T::CrossAccountId::from_eth(caller);666		let to = T::CrossAccountId::from_eth(to);667		let mut expected_index = <TokensMinted<T>>::get(self.id)668			.checked_add(1)669			.ok_or("item id overflow")?;670		let budget = self671			.recorder672			.weight_calls_budget(<StructureWeight<T>>::find_parent());673674		let total_tokens = token_ids.len();675		for id in token_ids.into_iter() {676			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;677			if id != expected_index {678				return Err("item id should be next".into());679			}680			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;681		}682		let data = (0..total_tokens)683			.map(|_| CreateItemData::<T> {684				properties: BoundedVec::default(),685				owner: to.clone(),686			})687			.collect();688689		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)690			.map_err(dispatch_to_evm::<T>)?;691		Ok(true)692	}693694	/// @notice Function to mint multiple tokens with the given tokenUris.695	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive696	///  numbers and first number should be obtained with `nextTokenId` method697	/// @param to The new owner698	/// @param tokens array of pairs of token ID and token URI for minted tokens699	#[solidity(rename_selector = "mintBulkWithTokenURI")]700	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]701	fn mint_bulk_with_token_uri(702		&mut self,703		caller: caller,704		to: address,705		tokens: Vec<(uint256, string)>,706	) -> Result<bool> {707		let key = url_key();708		let caller = T::CrossAccountId::from_eth(caller);709		let to = T::CrossAccountId::from_eth(to);710		let mut expected_index = <TokensMinted<T>>::get(self.id)711			.checked_add(1)712			.ok_or("item id overflow")?;713		let budget = self714			.recorder715			.weight_calls_budget(<StructureWeight<T>>::find_parent());716717		let mut data = Vec::with_capacity(tokens.len());718		for (id, token_uri) in tokens {719			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;720			if id != expected_index {721				return Err("item id should be next".into());722			}723			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;724725			let mut properties = CollectionPropertiesVec::default();726			properties727				.try_push(Property {728					key: key.clone(),729					value: token_uri730						.into_bytes()731						.try_into()732						.map_err(|_| "token uri is too long")?,733				})734				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;735736			data.push(CreateItemData::<T> {737				properties,738				owner: to.clone(),739			});740		}741742		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)743			.map_err(dispatch_to_evm::<T>)?;744		Ok(true)745	}746}747748#[solidity_interface(749	name = "UniqueNFT",750	is(751		ERC721,752		ERC721Metadata,753		ERC721Enumerable,754		ERC721UniqueExtensions,755		ERC721Mintable,756		ERC721Burnable,757		via("CollectionHandle<T>", common_mut, Collection),758		TokenProperties,759	)760)]761impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> {}762763// Not a tests, but code generators764generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);765generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);766767impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>768where769	T::AccountId: From<[u8; 32]>,770{771	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");772773	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {774		call::<T, UniqueNFTCall<T>, _, _>(handle, self)775	}776}