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

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	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},41	eth::{EthCrossAccount, EthTokenPermissions},42};43use pallet_evm::{account::CrossAccountId, PrecompileHandle};44use pallet_evm_coder_substrate::call;45use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};46use sp_core::Get;4748use crate::{49	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,50	SelfWeightOf, weights::WeightInfo, TokenProperties,51};5253/// @title A contract that allows to set and delete token properties and change token property permissions.54#[solidity_interface(name = TokenProperties)]55impl<T: Config> NonfungibleHandle<T> {56	/// @notice Set permissions for token property.57	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.58	/// @param key Property key.59	/// @param isMutable Permission to mutate property.60	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.61	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.62	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]63	#[solidity(hide)]64	fn set_token_property_permission(65		&mut self,66		caller: caller,67		key: string,68		is_mutable: bool,69		collection_admin: bool,70		token_owner: bool,71	) -> Result<()> {72		let caller = T::CrossAccountId::from_eth(caller);73		<Pallet<T>>::set_property_permissions(74			self,75			&caller,76			[PropertyKeyPermission {77				key: <Vec<u8>>::from(key)78					.try_into()79					.map_err(|_| "too long key")?,80				permission: PropertyPermission {81					mutable: is_mutable,82					collection_admin,83					token_owner,84				},85			}]86			.into(),87		)88		.map_err(dispatch_to_evm::<T>)89	}9091	/// @notice Set permissions for token property.92	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.93	/// @param permissions Permissions for keys.94	fn set_token_property_permissions(95		&mut self,96		caller: caller,97		permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>,98	) -> Result<()> {99		let caller = T::CrossAccountId::from_eth(caller);100		const PERMISSIONS_FIELDS_COUNT: usize = 3;101102		let mut perms = <Vec<_>>::new();103104		for (key, pp) in permissions {105			if pp.len() > PERMISSIONS_FIELDS_COUNT {106				return Err(alloc::format!(107					"Actual number of fields {} for {}, which exceeds the maximum value of {}",108					pp.len(),109					stringify!(EthTokenPermissions),110					PERMISSIONS_FIELDS_COUNT111				)112				.as_str()113				.into());114			}115116			let mut token_permission = PropertyPermission {117				mutable: false,118				collection_admin: false,119				token_owner: false,120			};121122			for (perm, value) in pp {123				match perm {124					EthTokenPermissions::Mutable => token_permission.mutable = value,125					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,126					EthTokenPermissions::CollectionAdmin => {127						token_permission.collection_admin = value128					}129				}130			}131132			perms.push(PropertyKeyPermission {133				key: <Vec<u8>>::from(key)134					.try_into()135					.map_err(|_| "too long key")?,136				permission: token_permission,137			});138		}139140		<Pallet<T>>::set_property_permissions(self, &caller, perms).map_err(dispatch_to_evm::<T>)141	}142143	fn token_property_permissions(144		&self,145	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {146		let mut res = <Vec<_>>::new();147		for (key, pp) in <Pallet<T>>::token_property_permission(self.id) {148			let key = string::from_utf8(key.into_inner()).unwrap();149			let pp = [150				(EthTokenPermissions::Mutable, pp.mutable),151				(EthTokenPermissions::TokenOwner, pp.token_owner),152				(EthTokenPermissions::CollectionAdmin, pp.collection_admin),153			]154			.into();155			res.push((key, pp));156		}157		Ok(res)158	}159160	/// @notice Set token property value.161	/// @dev Throws error if `msg.sender` has no permission to edit the property.162	/// @param tokenId ID of the token.163	/// @param key Property key.164	/// @param value Property value.165	#[solidity(hide)]166	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]167	fn set_property(168		&mut self,169		caller: caller,170		token_id: uint256,171		key: string,172		value: bytes,173	) -> Result<()> {174		let caller = T::CrossAccountId::from_eth(caller);175		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;176		let key = <Vec<u8>>::from(key)177			.try_into()178			.map_err(|_| "key too long")?;179		let value = value.0.try_into().map_err(|_| "value too long")?;180181		let nesting_budget = self182			.recorder183			.weight_calls_budget(<StructureWeight<T>>::find_parent());184185		<Pallet<T>>::set_token_property(186			self,187			&caller,188			TokenId(token_id),189			Property { key, value },190			&nesting_budget,191		)192		.map_err(dispatch_to_evm::<T>)193	}194195	/// @notice Set token properties value.196	/// @dev Throws error if `msg.sender` has no permission to edit the property.197	/// @param tokenId ID of the token.198	/// @param properties settable properties199	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]200	fn set_properties(201		&mut self,202		caller: caller,203		token_id: uint256,204		properties: Vec<PropertyStruct>,205	) -> Result<()> {206		let caller = T::CrossAccountId::from_eth(caller);207		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;208209		let nesting_budget = self210			.recorder211			.weight_calls_budget(<StructureWeight<T>>::find_parent());212213		let properties = properties214			.into_iter()215			.map(|PropertyStruct { key, value }| {216				let key = <Vec<u8>>::from(key)217					.try_into()218					.map_err(|_| "key too large")?;219220				let value = value.0.try_into().map_err(|_| "value too large")?;221222				Ok(Property { key, value })223			})224			.collect::<Result<Vec<_>>>()?;225226		<Pallet<T>>::set_token_properties(227			self,228			&caller,229			TokenId(token_id),230			properties.into_iter(),231			false,232			&nesting_budget,233		)234		.map_err(dispatch_to_evm::<T>)235	}236237	/// @notice Delete token property value.238	/// @dev Throws error if `msg.sender` has no permission to edit the property.239	/// @param tokenId ID of the token.240	/// @param key Property key.241	#[solidity(hide)]242	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]243	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {244		let caller = T::CrossAccountId::from_eth(caller);245		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;246		let key = <Vec<u8>>::from(key)247			.try_into()248			.map_err(|_| "key too long")?;249250		let nesting_budget = self251			.recorder252			.weight_calls_budget(<StructureWeight<T>>::find_parent());253254		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)255			.map_err(dispatch_to_evm::<T>)256	}257258	/// @notice Delete token properties value.259	/// @dev Throws error if `msg.sender` has no permission to edit the property.260	/// @param tokenId ID of the token.261	/// @param keys Properties key.262	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]263	fn delete_properties(264		&mut self,265		token_id: uint256,266		caller: caller,267		keys: Vec<string>,268	) -> Result<()> {269		let caller = T::CrossAccountId::from_eth(caller);270		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;271		let keys = keys272			.into_iter()273			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))274			.collect::<Result<Vec<_>>>()?;275276		let nesting_budget = self277			.recorder278			.weight_calls_budget(<StructureWeight<T>>::find_parent());279280		<Pallet<T>>::delete_token_properties(281			self,282			&caller,283			TokenId(token_id),284			keys.into_iter(),285			&nesting_budget,286		)287		.map_err(dispatch_to_evm::<T>)288	}289290	/// @notice Get token property value.291	/// @dev Throws error if key not found292	/// @param tokenId ID of the token.293	/// @param key Property key.294	/// @return Property value bytes295	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {296		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;297		let key = <Vec<u8>>::from(key)298			.try_into()299			.map_err(|_| "key too long")?;300301		let props = <TokenProperties<T>>::get((self.id, token_id));302		let prop = props.get(&key).ok_or("key not found")?;303304		Ok(prop.to_vec().into())305	}306}307308#[derive(ToLog)]309pub enum ERC721Events {310	/// @dev This emits when ownership of any NFT changes by any mechanism.311	///  This event emits when NFTs are created (`from` == 0) and destroyed312	///  (`to` == 0). Exception: during contract creation, any number of NFTs313	///  may be created and assigned without emitting Transfer. At the time of314	///  any transfer, the approved address for that NFT (if any) is reset to none.315	Transfer {316		#[indexed]317		from: address,318		#[indexed]319		to: address,320		#[indexed]321		token_id: uint256,322	},323	/// @dev This emits when the approved address for an NFT is changed or324	///  reaffirmed. The zero address indicates there is no approved address.325	///  When a Transfer event emits, this also indicates that the approved326	///  address for that NFT (if any) is reset to none.327	Approval {328		#[indexed]329		owner: address,330		#[indexed]331		approved: address,332		#[indexed]333		token_id: uint256,334	},335	/// @dev This emits when an operator is enabled or disabled for an owner.336	///  The operator can manage all NFTs of the owner.337	#[allow(dead_code)]338	ApprovalForAll {339		#[indexed]340		owner: address,341		#[indexed]342		operator: address,343		approved: bool,344	},345}346347#[derive(ToLog)]348pub enum ERC721UniqueMintableEvents {349	#[allow(dead_code)]350	MintingFinished {},351}352353/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension354/// @dev See https://eips.ethereum.org/EIPS/eip-721355#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]356impl<T: Config> NonfungibleHandle<T>357where358	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,359{360	/// @notice A descriptive name for a collection of NFTs in this contract361	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`362	#[solidity(hide, rename_selector = "name")]363	fn name_proxy(&self) -> Result<string> {364		self.name()365	}366367	/// @notice An abbreviated name for NFTs in this contract368	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`369	#[solidity(hide, rename_selector = "symbol")]370	fn symbol_proxy(&self) -> Result<string> {371		self.symbol()372	}373374	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.375	///376	/// @dev If the token has a `url` property and it is not empty, it is returned.377	///  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`.378	///  If the collection property `baseURI` is empty or absent, return "" (empty string)379	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix380	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).381	///382	/// @return token's const_metadata383	#[solidity(rename_selector = "tokenURI")]384	fn token_uri(&self, token_id: uint256) -> Result<string> {385		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;386387		match get_token_property(self, token_id_u32, &key::url()).as_deref() {388			Err(_) | Ok("") => (),389			Ok(url) => {390				return Ok(url.into());391			}392		};393394		let base_uri =395			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())396				.map(BoundedVec::into_inner)397				.map(string::from_utf8)398				.transpose()399				.map_err(|e| {400					Error::Revert(alloc::format!(401						"Can not convert value \"baseURI\" to string with error \"{}\"",402						e403					))404				})?;405406		let base_uri = match base_uri.as_deref() {407			None | Some("") => {408				return Ok("".into());409			}410			Some(base_uri) => base_uri.into(),411		};412413		Ok(414			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {415				Err(_) | Ok("") => base_uri,416				Ok(suffix) => base_uri + suffix,417			},418		)419	}420}421422/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension423/// @dev See https://eips.ethereum.org/EIPS/eip-721424#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]425impl<T: Config> NonfungibleHandle<T> {426	/// @notice Enumerate valid NFTs427	/// @param index A counter less than `totalSupply()`428	/// @return The token identifier for the `index`th NFT,429	///  (sort order not specified)430	fn token_by_index(&self, index: uint256) -> Result<uint256> {431		Ok(index)432	}433434	/// @dev Not implemented435	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {436		// TODO: Not implemetable437		Err("not implemented".into())438	}439440	/// @notice Count NFTs tracked by this contract441	/// @return A count of valid NFTs tracked by this contract, where each one of442	///  them has an assigned and queryable owner not equal to the zero address443	fn total_supply(&self) -> Result<uint256> {444		self.consume_store_reads(1)?;445		Ok(<Pallet<T>>::total_supply(self).into())446	}447}448449/// @title ERC-721 Non-Fungible Token Standard450/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md451#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]452impl<T: Config> NonfungibleHandle<T> {453	/// @notice Count all NFTs assigned to an owner454	/// @dev NFTs assigned to the zero address are considered invalid, and this455	///  function throws for queries about the zero address.456	/// @param owner An address for whom to query the balance457	/// @return The number of NFTs owned by `owner`, possibly zero458	fn balance_of(&self, owner: address) -> Result<uint256> {459		self.consume_store_reads(1)?;460		let owner = T::CrossAccountId::from_eth(owner);461		let balance = <AccountBalance<T>>::get((self.id, owner));462		Ok(balance.into())463	}464	/// @notice Find the owner of an NFT465	/// @dev NFTs assigned to zero address are considered invalid, and queries466	///  about them do throw.467	/// @param tokenId The identifier for an NFT468	/// @return The address of the owner of the NFT469	fn owner_of(&self, token_id: uint256) -> Result<address> {470		self.consume_store_reads(1)?;471		let token: TokenId = token_id.try_into()?;472		Ok(*<TokenData<T>>::get((self.id, token))473			.ok_or("token not found")?474			.owner475			.as_eth())476	}477	/// @dev Not implemented478	#[solidity(rename_selector = "safeTransferFrom")]479	fn safe_transfer_from_with_data(480		&mut self,481		_from: address,482		_to: address,483		_token_id: uint256,484		_data: bytes,485	) -> Result<void> {486		// TODO: Not implemetable487		Err("not implemented".into())488	}489	/// @dev Not implemented490	fn safe_transfer_from(491		&mut self,492		_from: address,493		_to: address,494		_token_id: uint256,495	) -> Result<void> {496		// TODO: Not implemetable497		Err("not implemented".into())498	}499500	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE501	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE502	///  THEY MAY BE PERMANENTLY LOST503	/// @dev Throws unless `msg.sender` is the current owner or an authorized504	///  operator for this NFT. Throws if `from` is not the current owner. Throws505	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.506	/// @param from The current owner of the NFT507	/// @param to The new owner508	/// @param tokenId The NFT to transfer509	#[weight(<SelfWeightOf<T>>::transfer_from())]510	fn transfer_from(511		&mut self,512		caller: caller,513		from: address,514		to: address,515		token_id: uint256,516	) -> Result<void> {517		let caller = T::CrossAccountId::from_eth(caller);518		let from = T::CrossAccountId::from_eth(from);519		let to = T::CrossAccountId::from_eth(to);520		let token = token_id.try_into()?;521		let budget = self522			.recorder523			.weight_calls_budget(<StructureWeight<T>>::find_parent());524525		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)526			.map_err(dispatch_to_evm::<T>)?;527		Ok(())528	}529530	/// @notice Set or reaffirm the approved address for an NFT531	/// @dev The zero address indicates there is no approved address.532	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized533	///  operator of the current owner.534	/// @param approved The new approved NFT controller535	/// @param tokenId The NFT to approve536	#[weight(<SelfWeightOf<T>>::approve())]537	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {538		let caller = T::CrossAccountId::from_eth(caller);539		let approved = T::CrossAccountId::from_eth(approved);540		let token = token_id.try_into()?;541542		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))543			.map_err(dispatch_to_evm::<T>)?;544		Ok(())545	}546547	/// @notice Sets or unsets the approval of a given operator.548	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.549	/// @param operator Operator550	/// @param approved Should operator status be granted or revoked?551	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]552	fn set_approval_for_all(553		&mut self,554		caller: caller,555		operator: address,556		approved: bool,557	) -> Result<void> {558		let caller = T::CrossAccountId::from_eth(caller);559		let operator = T::CrossAccountId::from_eth(operator);560561		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)562			.map_err(dispatch_to_evm::<T>)?;563		Ok(())564	}565566	/// @dev Not implemented567	fn get_approved(&self, _token_id: uint256) -> Result<address> {568		// TODO: Not implemetable569		Err("not implemented".into())570	}571572	/// @notice Tells whether the given `owner` approves the `operator`.573	#[weight(<SelfWeightOf<T>>::allowance_for_all())]574	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {575		let owner = T::CrossAccountId::from_eth(owner);576		let operator = T::CrossAccountId::from_eth(operator);577578		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))579	}580581	/// @notice Returns collection helper contract address582	fn collection_helper_address(&self) -> Result<address> {583		Ok(T::ContractAddress::get())584	}585}586587/// @title ERC721 Token that can be irreversibly burned (destroyed).588#[solidity_interface(name = ERC721Burnable)]589impl<T: Config> NonfungibleHandle<T> {590	/// @notice Burns a specific ERC721 token.591	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized592	///  operator of the current owner.593	/// @param tokenId The NFT to approve594	#[weight(<SelfWeightOf<T>>::burn_item())]595	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {596		let caller = T::CrossAccountId::from_eth(caller);597		let token = token_id.try_into()?;598599		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;600		Ok(())601	}602}603604/// @title ERC721 minting logic.605#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]606impl<T: Config> NonfungibleHandle<T> {607	fn minting_finished(&self) -> Result<bool> {608		Ok(false)609	}610611	/// @notice Function to mint token.612	/// @param to The new owner613	/// @return uint256 The id of the newly minted token614	#[weight(<SelfWeightOf<T>>::create_item())]615	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {616		let token_id: uint256 = <TokensMinted<T>>::get(self.id)617			.checked_add(1)618			.ok_or("item id overflow")?619			.into();620		self.mint_check_id(caller, to, token_id)?;621		Ok(token_id)622	}623624	/// @notice Function to mint token.625	/// @dev `tokenId` should be obtained with `nextTokenId` method,626	///  unlike standard, you can't specify it manually627	/// @param to The new owner628	/// @param tokenId ID of the minted NFT629	#[solidity(hide, rename_selector = "mint")]630	#[weight(<SelfWeightOf<T>>::create_item())]631	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {632		let caller = T::CrossAccountId::from_eth(caller);633		let to = T::CrossAccountId::from_eth(to);634		let token_id: u32 = token_id.try_into()?;635		let budget = self636			.recorder637			.weight_calls_budget(<StructureWeight<T>>::find_parent());638639		if <TokensMinted<T>>::get(self.id)640			.checked_add(1)641			.ok_or("item id overflow")?642			!= token_id643		{644			return Err("item id should be next".into());645		}646647		<Pallet<T>>::create_item(648			self,649			&caller,650			CreateItemData::<T> {651				properties: BoundedVec::default(),652				owner: to,653			},654			&budget,655		)656		.map_err(dispatch_to_evm::<T>)?;657658		Ok(true)659	}660661	/// @notice Function to mint token with the given tokenUri.662	/// @param to The new owner663	/// @param tokenUri Token URI that would be stored in the NFT properties664	/// @return uint256 The id of the newly minted token665	#[solidity(rename_selector = "mintWithTokenURI")]666	#[weight(<SelfWeightOf<T>>::create_item())]667	fn mint_with_token_uri(668		&mut self,669		caller: caller,670		to: address,671		token_uri: string,672	) -> Result<uint256> {673		let token_id: uint256 = <TokensMinted<T>>::get(self.id)674			.checked_add(1)675			.ok_or("item id overflow")?676			.into();677		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;678		Ok(token_id)679	}680681	/// @notice Function to mint token with the given tokenUri.682	/// @dev `tokenId` should be obtained with `nextTokenId` method,683	///  unlike standard, you can't specify it manually684	/// @param to The new owner685	/// @param tokenId ID of the minted NFT686	/// @param tokenUri Token URI that would be stored in the NFT properties687	#[solidity(hide, rename_selector = "mintWithTokenURI")]688	#[weight(<SelfWeightOf<T>>::create_item())]689	fn mint_with_token_uri_check_id(690		&mut self,691		caller: caller,692		to: address,693		token_id: uint256,694		token_uri: string,695	) -> Result<bool> {696		let key = key::url();697		let permission = get_token_permission::<T>(self.id, &key)?;698		if !permission.collection_admin {699			return Err("Operation is not allowed".into());700		}701702		let caller = T::CrossAccountId::from_eth(caller);703		let to = T::CrossAccountId::from_eth(to);704		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;705		let budget = self706			.recorder707			.weight_calls_budget(<StructureWeight<T>>::find_parent());708709		if <TokensMinted<T>>::get(self.id)710			.checked_add(1)711			.ok_or("item id overflow")?712			!= token_id713		{714			return Err("item id should be next".into());715		}716717		let mut properties = CollectionPropertiesVec::default();718		properties719			.try_push(Property {720				key,721				value: token_uri722					.into_bytes()723					.try_into()724					.map_err(|_| "token uri is too long")?,725			})726			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;727728		<Pallet<T>>::create_item(729			self,730			&caller,731			CreateItemData::<T> {732				properties,733				owner: to,734			},735			&budget,736		)737		.map_err(dispatch_to_evm::<T>)?;738		Ok(true)739	}740741	/// @dev Not implemented742	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {743		Err("not implementable".into())744	}745}746747fn get_token_property<T: Config>(748	collection: &CollectionHandle<T>,749	token_id: u32,750	key: &up_data_structs::PropertyKey,751) -> Result<string> {752	collection.consume_store_reads(1)?;753	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))754		.map_err(|_| Error::Revert("Token properties not found".into()))?;755	if let Some(property) = properties.get(key) {756		return Ok(string::from_utf8_lossy(property).into());757	}758759	Err("Property tokenURI not found".into())760}761762fn get_token_permission<T: Config>(763	collection_id: CollectionId,764	key: &PropertyKey,765) -> Result<PropertyPermission> {766	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)767		.map_err(|_| Error::Revert("No permissions for collection".into()))?;768	let a = token_property_permissions769		.get(key)770		.map(Clone::clone)771		.ok_or_else(|| {772			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();773			Error::Revert(alloc::format!("No permission for key {}", key))774		})?;775	Ok(a)776}777778/// @title Unique extensions for ERC721.779#[solidity_interface(name = ERC721UniqueExtensions)]780impl<T: Config> NonfungibleHandle<T>781where782	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,783{784	/// @notice A descriptive name for a collection of NFTs in this contract785	fn name(&self) -> Result<string> {786		Ok(decode_utf16(self.name.iter().copied())787			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))788			.collect::<string>())789	}790791	/// @notice An abbreviated name for NFTs in this contract792	fn symbol(&self) -> Result<string> {793		Ok(string::from_utf8_lossy(&self.token_prefix).into())794	}795796	/// @notice A description for the collection.797	fn description(&self) -> Result<string> {798		Ok(decode_utf16(self.description.iter().copied())799			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))800			.collect::<string>())801	}802803	/// Returns the owner (in cross format) of the token.804	///805	/// @param tokenId Id for the token.806	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {807		Self::token_owner(&self, token_id.try_into()?)808			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))809			.ok_or(Error::Revert("key too large".into()))810	}811812	/// Returns the token properties.813	///814	/// @param tokenId Id for the token.815	/// @param keys Properties keys. Empty keys for all propertyes.816	/// @return Vector of properties key/value pairs.817	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {818		let keys = keys819			.into_iter()820			.map(|key| {821				<Vec<u8>>::from(key)822					.try_into()823					.map_err(|_| Error::Revert("key too large".into()))824			})825			.collect::<Result<Vec<_>>>()?;826827		<Self as CommonCollectionOperations<T>>::token_properties(828			&self,829			token_id.try_into()?,830			if keys.is_empty() { None } else { Some(keys) },831		)832		.into_iter()833		.map(|p| {834			let key = string::from_utf8(p.key.to_vec())835				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;836			let value = bytes(p.value.to_vec());837			Ok(PropertyStruct { key, value })838		})839		.collect::<Result<Vec<_>>>()840	}841842	/// @notice Set or reaffirm the approved address for an NFT843	/// @dev The zero address indicates there is no approved address.844	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized845	///  operator of the current owner.846	/// @param approved The new substrate address approved NFT controller847	/// @param tokenId The NFT to approve848	#[weight(<SelfWeightOf<T>>::approve())]849	fn approve_cross(850		&mut self,851		caller: caller,852		approved: EthCrossAccount,853		token_id: uint256,854	) -> Result<void> {855		let caller = T::CrossAccountId::from_eth(caller);856		let approved = approved.into_sub_cross_account::<T>()?;857		let token = token_id.try_into()?;858859		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))860			.map_err(dispatch_to_evm::<T>)?;861		Ok(())862	}863864	/// @notice Transfer ownership of an NFT865	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`866	///  is the zero address. Throws if `tokenId` is not a valid NFT.867	/// @param to The new owner868	/// @param tokenId The NFT to transfer869	#[weight(<SelfWeightOf<T>>::transfer())]870	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {871		let caller = T::CrossAccountId::from_eth(caller);872		let to = T::CrossAccountId::from_eth(to);873		let token = token_id.try_into()?;874		let budget = self875			.recorder876			.weight_calls_budget(<StructureWeight<T>>::find_parent());877878		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;879		Ok(())880	}881882	/// @notice Transfer ownership of an NFT883	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`884	///  is the zero address. Throws if `tokenId` is not a valid NFT.885	/// @param to The new owner886	/// @param tokenId The NFT to transfer887	#[weight(<SelfWeightOf<T>>::transfer())]888	fn transfer_cross(889		&mut self,890		caller: caller,891		to: EthCrossAccount,892		token_id: uint256,893	) -> Result<void> {894		let caller = T::CrossAccountId::from_eth(caller);895		let to = to.into_sub_cross_account::<T>()?;896		let token = token_id.try_into()?;897		let budget = self898			.recorder899			.weight_calls_budget(<StructureWeight<T>>::find_parent());900901		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;902		Ok(())903	}904905	/// @notice Transfer ownership of an NFT from cross account address to cross account address906	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`907	///  is the zero address. Throws if `tokenId` is not a valid NFT.908	/// @param from Cross acccount address of current owner909	/// @param to Cross acccount address of new owner910	/// @param tokenId The NFT to transfer911	#[weight(<SelfWeightOf<T>>::transfer())]912	fn transfer_from_cross(913		&mut self,914		caller: caller,915		from: EthCrossAccount,916		to: EthCrossAccount,917		token_id: uint256,918	) -> Result<void> {919		let caller = T::CrossAccountId::from_eth(caller);920		let from = from.into_sub_cross_account::<T>()?;921		let to = to.into_sub_cross_account::<T>()?;922		let token_id = token_id.try_into()?;923		let budget = self924			.recorder925			.weight_calls_budget(<StructureWeight<T>>::find_parent());926		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)927			.map_err(dispatch_to_evm::<T>)?;928		Ok(())929	}930931	/// @notice Burns a specific ERC721 token.932	/// @dev Throws unless `msg.sender` is the current owner or an authorized933	///  operator for this NFT. Throws if `from` is not the current owner. Throws934	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.935	/// @param from The current owner of the NFT936	/// @param tokenId The NFT to transfer937	#[solidity(hide)]938	#[weight(<SelfWeightOf<T>>::burn_from())]939	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {940		let caller = T::CrossAccountId::from_eth(caller);941		let from = T::CrossAccountId::from_eth(from);942		let token = token_id.try_into()?;943		let budget = self944			.recorder945			.weight_calls_budget(<StructureWeight<T>>::find_parent());946947		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)948			.map_err(dispatch_to_evm::<T>)?;949		Ok(())950	}951952	/// @notice Burns a specific ERC721 token.953	/// @dev Throws unless `msg.sender` is the current owner or an authorized954	///  operator for this NFT. Throws if `from` is not the current owner. Throws955	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.956	/// @param from The current owner of the NFT957	/// @param tokenId The NFT to transfer958	#[weight(<SelfWeightOf<T>>::burn_from())]959	fn burn_from_cross(960		&mut self,961		caller: caller,962		from: EthCrossAccount,963		token_id: uint256,964	) -> Result<void> {965		let caller = T::CrossAccountId::from_eth(caller);966		let from = from.into_sub_cross_account::<T>()?;967		let token = token_id.try_into()?;968		let budget = self969			.recorder970			.weight_calls_budget(<StructureWeight<T>>::find_parent());971972		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)973			.map_err(dispatch_to_evm::<T>)?;974		Ok(())975	}976977	/// @notice Returns next free NFT ID.978	fn next_token_id(&self) -> Result<uint256> {979		self.consume_store_reads(1)?;980		Ok(<TokensMinted<T>>::get(self.id)981			.checked_add(1)982			.ok_or("item id overflow")?983			.into())984	}985986	/// @notice Function to mint multiple tokens.987	/// @dev `tokenIds` should be an array of consecutive numbers and first number988	///  should be obtained with `nextTokenId` method989	/// @param to The new owner990	/// @param tokenIds IDs of the minted NFTs991	#[solidity(hide)]992	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]993	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {994		let caller = T::CrossAccountId::from_eth(caller);995		let to = T::CrossAccountId::from_eth(to);996		let mut expected_index = <TokensMinted<T>>::get(self.id)997			.checked_add(1)998			.ok_or("item id overflow")?;999		let budget = self1000			.recorder1001			.weight_calls_budget(<StructureWeight<T>>::find_parent());10021003		let total_tokens = token_ids.len();1004		for id in token_ids.into_iter() {1005			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1006			if id != expected_index {1007				return Err("item id should be next".into());1008			}1009			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1010		}1011		let data = (0..total_tokens)1012			.map(|_| CreateItemData::<T> {1013				properties: BoundedVec::default(),1014				owner: to.clone(),1015			})1016			.collect();10171018		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1019			.map_err(dispatch_to_evm::<T>)?;1020		Ok(true)1021	}10221023	/// @notice Function to mint multiple tokens with the given tokenUris.1024	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1025	///  numbers and first number should be obtained with `nextTokenId` method1026	/// @param to The new owner1027	/// @param tokens array of pairs of token ID and token URI for minted tokens1028	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1029	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1030	fn mint_bulk_with_token_uri(1031		&mut self,1032		caller: caller,1033		to: address,1034		tokens: Vec<(uint256, string)>,1035	) -> Result<bool> {1036		let key = key::url();1037		let caller = T::CrossAccountId::from_eth(caller);1038		let to = T::CrossAccountId::from_eth(to);1039		let mut expected_index = <TokensMinted<T>>::get(self.id)1040			.checked_add(1)1041			.ok_or("item id overflow")?;1042		let budget = self1043			.recorder1044			.weight_calls_budget(<StructureWeight<T>>::find_parent());10451046		let mut data = Vec::with_capacity(tokens.len());1047		for (id, token_uri) in tokens {1048			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1049			if id != expected_index {1050				return Err("item id should be next".into());1051			}1052			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10531054			let mut properties = CollectionPropertiesVec::default();1055			properties1056				.try_push(Property {1057					key: key.clone(),1058					value: token_uri1059						.into_bytes()1060						.try_into()1061						.map_err(|_| "token uri is too long")?,1062				})1063				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10641065			data.push(CreateItemData::<T> {1066				properties,1067				owner: to.clone(),1068			});1069		}10701071		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1072			.map_err(dispatch_to_evm::<T>)?;1073		Ok(true)1074	}1075}10761077#[solidity_interface(1078	name = UniqueNFT,1079	is(1080		ERC721,1081		ERC721Enumerable,1082		ERC721UniqueExtensions,1083		ERC721UniqueMintable,1084		ERC721Burnable,1085		ERC721Metadata(if(this.flags.erc721metadata)),1086		Collection(via(common_mut returns CollectionHandle<T>)),1087		TokenProperties,1088	)1089)]1090impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10911092// Not a tests, but code generators1093generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1094generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);10951096impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1097where1098	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1099{1100	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");11011102	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1103		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1104	}1105}