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

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	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, vec};38use pallet_common::{39	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},41};42use pallet_evm::{account::CrossAccountId, PrecompileHandle};43use pallet_evm_coder_substrate::call;44use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};45use sp_core::Get;4647use crate::{48	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,49	SelfWeightOf, weights::WeightInfo, TokenProperties,50};5152/// @title A contract that allows to set and delete token properties and change token property permissions.53#[solidity_interface(name = TokenProperties)]54impl<T: Config> NonfungibleHandle<T> {55	/// @notice Set permissions for token property.56	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.57	/// @param key Property key.58	/// @param isMutable Permission to mutate property.59	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.60	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.61	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]62	#[solidity(hide)]63	fn set_token_property_permission(64		&mut self,65		caller: caller,66		key: string,67		is_mutable: bool,68		collection_admin: bool,69		token_owner: bool,70	) -> Result<()> {71		let caller = T::CrossAccountId::from_eth(caller);72		<Pallet<T>>::set_token_property_permissions(73			self,74			&caller,75			vec![PropertyKeyPermission {76				key: <Vec<u8>>::from(key)77					.try_into()78					.map_err(|_| "too long key")?,79				permission: PropertyPermission {80					mutable: is_mutable,81					collection_admin,82					token_owner,83				},84			}],85		)86		.map_err(dispatch_to_evm::<T>)87	}8889	/// @notice Set permissions for token property.90	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.91	/// @param permissions Permissions for keys.92	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]93	fn set_token_property_permissions(94		&mut self,95		caller: caller,96		permissions: Vec<pallet_common::eth::TokenPropertyPermission>,97	) -> Result<()> {98		let caller = T::CrossAccountId::from_eth(caller);99		let perms = pallet_common::eth::TokenPropertyPermission::into_property_key_permissions(100			permissions,101		)?;102103		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)104			.map_err(dispatch_to_evm::<T>)105	}106107	/// @notice Get permissions for token properties.108	fn token_property_permissions(109		&self,110	) -> Result<Vec<pallet_common::eth::TokenPropertyPermission>> {111		let perms = <Pallet<T>>::token_property_permission(self.id);112		Ok(perms113			.into_iter()114			.map(pallet_common::eth::TokenPropertyPermission::from)115			.collect())116	}117118	/// @notice Set token property value.119	/// @dev Throws error if `msg.sender` has no permission to edit the property.120	/// @param tokenId ID of the token.121	/// @param key Property key.122	/// @param value Property value.123	#[solidity(hide)]124	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]125	fn set_property(126		&mut self,127		caller: caller,128		token_id: uint256,129		key: string,130		value: bytes,131	) -> Result<()> {132		let caller = T::CrossAccountId::from_eth(caller);133		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;134		let key = <Vec<u8>>::from(key)135			.try_into()136			.map_err(|_| "key too long")?;137		let value = value.0.try_into().map_err(|_| "value too long")?;138139		let nesting_budget = self140			.recorder141			.weight_calls_budget(<StructureWeight<T>>::find_parent());142143		<Pallet<T>>::set_token_property(144			self,145			&caller,146			TokenId(token_id),147			Property { key, value },148			&nesting_budget,149		)150		.map_err(dispatch_to_evm::<T>)151	}152153	/// @notice Set token properties value.154	/// @dev Throws error if `msg.sender` has no permission to edit the property.155	/// @param tokenId ID of the token.156	/// @param properties settable properties157	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]158	fn set_properties(159		&mut self,160		caller: caller,161		token_id: uint256,162		properties: Vec<pallet_common::eth::Property>,163	) -> Result<()> {164		let caller = T::CrossAccountId::from_eth(caller);165		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;166167		let nesting_budget = self168			.recorder169			.weight_calls_budget(<StructureWeight<T>>::find_parent());170171		let properties = properties172			.into_iter()173			.map(|property| {174				let (key, value) = property.take_key_value();175				let key = <Vec<u8>>::from(key)176					.try_into()177					.map_err(|_| "key too large")?;178179				let value = value.0.try_into().map_err(|_| "value too large")?;180181				Ok(Property { key, value })182			})183			.collect::<Result<Vec<_>>>()?;184185		<Pallet<T>>::set_token_properties(186			self,187			&caller,188			TokenId(token_id),189			properties.into_iter(),190			false,191			&nesting_budget,192		)193		.map_err(dispatch_to_evm::<T>)194	}195196	/// @notice Delete token property value.197	/// @dev Throws error if `msg.sender` has no permission to edit the property.198	/// @param tokenId ID of the token.199	/// @param key Property key.200	#[solidity(hide)]201	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]202	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {203		let caller = T::CrossAccountId::from_eth(caller);204		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;205		let key = <Vec<u8>>::from(key)206			.try_into()207			.map_err(|_| "key too long")?;208209		let nesting_budget = self210			.recorder211			.weight_calls_budget(<StructureWeight<T>>::find_parent());212213		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)214			.map_err(dispatch_to_evm::<T>)215	}216217	/// @notice Delete token properties value.218	/// @dev Throws error if `msg.sender` has no permission to edit the property.219	/// @param tokenId ID of the token.220	/// @param keys Properties key.221	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]222	fn delete_properties(223		&mut self,224		token_id: uint256,225		caller: caller,226		keys: Vec<string>,227	) -> Result<()> {228		let caller = T::CrossAccountId::from_eth(caller);229		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;230		let keys = keys231			.into_iter()232			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))233			.collect::<Result<Vec<_>>>()?;234235		let nesting_budget = self236			.recorder237			.weight_calls_budget(<StructureWeight<T>>::find_parent());238239		<Pallet<T>>::delete_token_properties(240			self,241			&caller,242			TokenId(token_id),243			keys.into_iter(),244			&nesting_budget,245		)246		.map_err(dispatch_to_evm::<T>)247	}248249	/// @notice Get token property value.250	/// @dev Throws error if key not found251	/// @param tokenId ID of the token.252	/// @param key Property key.253	/// @return Property value bytes254	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {255		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;256		let key = <Vec<u8>>::from(key)257			.try_into()258			.map_err(|_| "key too long")?;259260		let props = <TokenProperties<T>>::get((self.id, token_id));261		let prop = props.get(&key).ok_or("key not found")?;262263		Ok(prop.to_vec().into())264	}265}266267#[derive(ToLog)]268pub enum ERC721Events {269	/// @dev This emits when ownership of any NFT changes by any mechanism.270	///  This event emits when NFTs are created (`from` == 0) and destroyed271	///  (`to` == 0). Exception: during contract creation, any number of NFTs272	///  may be created and assigned without emitting Transfer. At the time of273	///  any transfer, the approved address for that NFT (if any) is reset to none.274	Transfer {275		#[indexed]276		from: address,277		#[indexed]278		to: address,279		#[indexed]280		token_id: uint256,281	},282	/// @dev This emits when the approved address for an NFT is changed or283	///  reaffirmed. The zero address indicates there is no approved address.284	///  When a Transfer event emits, this also indicates that the approved285	///  address for that NFT (if any) is reset to none.286	Approval {287		#[indexed]288		owner: address,289		#[indexed]290		approved: address,291		#[indexed]292		token_id: uint256,293	},294	/// @dev This emits when an operator is enabled or disabled for an owner.295	///  The operator can manage all NFTs of the owner.296	#[allow(dead_code)]297	ApprovalForAll {298		#[indexed]299		owner: address,300		#[indexed]301		operator: address,302		approved: bool,303	},304}305306#[derive(ToLog)]307pub enum ERC721UniqueMintableEvents {308	#[allow(dead_code)]309	MintingFinished {},310}311312/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension313/// @dev See https://eips.ethereum.org/EIPS/eip-721314#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]315impl<T: Config> NonfungibleHandle<T>316where317	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,318{319	/// @notice A descriptive name for a collection of NFTs in this contract320	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`321	#[solidity(hide, rename_selector = "name")]322	fn name_proxy(&self) -> Result<string> {323		self.name()324	}325326	/// @notice An abbreviated name for NFTs in this contract327	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`328	#[solidity(hide, rename_selector = "symbol")]329	fn symbol_proxy(&self) -> Result<string> {330		self.symbol()331	}332333	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.334	///335	/// @dev If the token has a `url` property and it is not empty, it is returned.336	///  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`.337	///  If the collection property `baseURI` is empty or absent, return "" (empty string)338	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix339	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).340	///341	/// @return token's const_metadata342	#[solidity(rename_selector = "tokenURI")]343	fn token_uri(&self, token_id: uint256) -> Result<string> {344		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;345346		match get_token_property(self, token_id_u32, &key::url()).as_deref() {347			Err(_) | Ok("") => (),348			Ok(url) => {349				return Ok(url.into());350			}351		};352353		let base_uri =354			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())355				.map(BoundedVec::into_inner)356				.map(string::from_utf8)357				.transpose()358				.map_err(|e| {359					Error::Revert(alloc::format!(360						"Can not convert value \"baseURI\" to string with error \"{}\"",361						e362					))363				})?;364365		let base_uri = match base_uri.as_deref() {366			None | Some("") => {367				return Ok("".into());368			}369			Some(base_uri) => base_uri.into(),370		};371372		Ok(373			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {374				Err(_) | Ok("") => base_uri,375				Ok(suffix) => base_uri + suffix,376			},377		)378	}379}380381/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension382/// @dev See https://eips.ethereum.org/EIPS/eip-721383#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]384impl<T: Config> NonfungibleHandle<T> {385	/// @notice Enumerate valid NFTs386	/// @param index A counter less than `totalSupply()`387	/// @return The token identifier for the `index`th NFT,388	///  (sort order not specified)389	fn token_by_index(&self, index: uint256) -> Result<uint256> {390		Ok(index)391	}392393	/// @dev Not implemented394	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {395		// TODO: Not implemetable396		Err("not implemented".into())397	}398399	/// @notice Count NFTs tracked by this contract400	/// @return A count of valid NFTs tracked by this contract, where each one of401	///  them has an assigned and queryable owner not equal to the zero address402	fn total_supply(&self) -> Result<uint256> {403		self.consume_store_reads(1)?;404		Ok(<Pallet<T>>::total_supply(self).into())405	}406}407408/// @title ERC-721 Non-Fungible Token Standard409/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md410#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]411impl<T: Config> NonfungibleHandle<T> {412	/// @notice Count all NFTs assigned to an owner413	/// @dev NFTs assigned to the zero address are considered invalid, and this414	///  function throws for queries about the zero address.415	/// @param owner An address for whom to query the balance416	/// @return The number of NFTs owned by `owner`, possibly zero417	fn balance_of(&self, owner: address) -> Result<uint256> {418		self.consume_store_reads(1)?;419		let owner = T::CrossAccountId::from_eth(owner);420		let balance = <AccountBalance<T>>::get((self.id, owner));421		Ok(balance.into())422	}423	/// @notice Find the owner of an NFT424	/// @dev NFTs assigned to zero address are considered invalid, and queries425	///  about them do throw.426	/// @param tokenId The identifier for an NFT427	/// @return The address of the owner of the NFT428	fn owner_of(&self, token_id: uint256) -> Result<address> {429		self.consume_store_reads(1)?;430		let token: TokenId = token_id.try_into()?;431		Ok(*<TokenData<T>>::get((self.id, token))432			.ok_or("token not found")?433			.owner434			.as_eth())435	}436	/// @dev Not implemented437	#[solidity(rename_selector = "safeTransferFrom")]438	fn safe_transfer_from_with_data(439		&mut self,440		_from: address,441		_to: address,442		_token_id: uint256,443		_data: bytes,444	) -> Result<void> {445		// TODO: Not implemetable446		Err("not implemented".into())447	}448	/// @dev Not implemented449	fn safe_transfer_from(450		&mut self,451		_from: address,452		_to: address,453		_token_id: uint256,454	) -> Result<void> {455		// TODO: Not implemetable456		Err("not implemented".into())457	}458459	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE460	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE461	///  THEY MAY BE PERMANENTLY LOST462	/// @dev Throws unless `msg.sender` is the current owner or an authorized463	///  operator for this NFT. Throws if `from` is not the current owner. Throws464	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.465	/// @param from The current owner of the NFT466	/// @param to The new owner467	/// @param tokenId The NFT to transfer468	#[weight(<SelfWeightOf<T>>::transfer_from())]469	fn transfer_from(470		&mut self,471		caller: caller,472		from: address,473		to: address,474		token_id: uint256,475	) -> Result<void> {476		let caller = T::CrossAccountId::from_eth(caller);477		let from = T::CrossAccountId::from_eth(from);478		let to = T::CrossAccountId::from_eth(to);479		let token = token_id.try_into()?;480		let budget = self481			.recorder482			.weight_calls_budget(<StructureWeight<T>>::find_parent());483484		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)485			.map_err(dispatch_to_evm::<T>)?;486		Ok(())487	}488489	/// @notice Set or reaffirm the approved address for an NFT490	/// @dev The zero address indicates there is no approved address.491	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized492	///  operator of the current owner.493	/// @param approved The new approved NFT controller494	/// @param tokenId The NFT to approve495	#[weight(<SelfWeightOf<T>>::approve())]496	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {497		let caller = T::CrossAccountId::from_eth(caller);498		let approved = T::CrossAccountId::from_eth(approved);499		let token = token_id.try_into()?;500501		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))502			.map_err(dispatch_to_evm::<T>)?;503		Ok(())504	}505506	/// @notice Sets or unsets the approval of a given operator.507	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.508	/// @param operator Operator509	/// @param approved Should operator status be granted or revoked?510	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]511	fn set_approval_for_all(512		&mut self,513		caller: caller,514		operator: address,515		approved: bool,516	) -> Result<void> {517		let caller = T::CrossAccountId::from_eth(caller);518		let operator = T::CrossAccountId::from_eth(operator);519520		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)521			.map_err(dispatch_to_evm::<T>)?;522		Ok(())523	}524525	/// @dev Not implemented526	fn get_approved(&self, _token_id: uint256) -> Result<address> {527		// TODO: Not implemetable528		Err("not implemented".into())529	}530531	/// @notice Tells whether the given `owner` approves the `operator`.532	#[weight(<SelfWeightOf<T>>::allowance_for_all())]533	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {534		let owner = T::CrossAccountId::from_eth(owner);535		let operator = T::CrossAccountId::from_eth(operator);536537		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))538	}539540	/// @notice Returns collection helper contract address541	fn collection_helper_address(&self) -> Result<address> {542		Ok(T::ContractAddress::get())543	}544}545546/// @title ERC721 Token that can be irreversibly burned (destroyed).547#[solidity_interface(name = ERC721Burnable)]548impl<T: Config> NonfungibleHandle<T> {549	/// @notice Burns a specific ERC721 token.550	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized551	///  operator of the current owner.552	/// @param tokenId The NFT to approve553	#[weight(<SelfWeightOf<T>>::burn_item())]554	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {555		let caller = T::CrossAccountId::from_eth(caller);556		let token = token_id.try_into()?;557558		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;559		Ok(())560	}561}562563/// @title ERC721 minting logic.564#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]565impl<T: Config> NonfungibleHandle<T> {566	fn minting_finished(&self) -> Result<bool> {567		Ok(false)568	}569570	/// @notice Function to mint a token.571	/// @param to The new owner572	/// @return uint256 The id of the newly minted token573	#[weight(<SelfWeightOf<T>>::create_item())]574	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {575		let token_id: uint256 = <TokensMinted<T>>::get(self.id)576			.checked_add(1)577			.ok_or("item id overflow")?578			.into();579		self.mint_check_id(caller, to, token_id)?;580		Ok(token_id)581	}582583	/// @notice Function to mint a token.584	/// @dev `tokenId` should be obtained with `nextTokenId` method,585	///  unlike standard, you can't specify it manually586	/// @param to The new owner587	/// @param tokenId ID of the minted NFT588	#[solidity(hide, rename_selector = "mint")]589	#[weight(<SelfWeightOf<T>>::create_item())]590	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {591		let caller = T::CrossAccountId::from_eth(caller);592		let to = T::CrossAccountId::from_eth(to);593		let token_id: u32 = token_id.try_into()?;594		let budget = self595			.recorder596			.weight_calls_budget(<StructureWeight<T>>::find_parent());597598		if <TokensMinted<T>>::get(self.id)599			.checked_add(1)600			.ok_or("item id overflow")?601			!= token_id602		{603			return Err("item id should be next".into());604		}605606		<Pallet<T>>::create_item(607			self,608			&caller,609			CreateItemData::<T> {610				properties: BoundedVec::default(),611				owner: to,612			},613			&budget,614		)615		.map_err(dispatch_to_evm::<T>)?;616617		Ok(true)618	}619620	/// @notice Function to mint token with the given tokenUri.621	/// @param to The new owner622	/// @param tokenUri Token URI that would be stored in the NFT properties623	/// @return uint256 The id of the newly minted token624	#[solidity(rename_selector = "mintWithTokenURI")]625	#[weight(<SelfWeightOf<T>>::create_item())]626	fn mint_with_token_uri(627		&mut self,628		caller: caller,629		to: address,630		token_uri: string,631	) -> Result<uint256> {632		let token_id: uint256 = <TokensMinted<T>>::get(self.id)633			.checked_add(1)634			.ok_or("item id overflow")?635			.into();636		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;637		Ok(token_id)638	}639640	/// @notice Function to mint token with the given tokenUri.641	/// @dev `tokenId` should be obtained with `nextTokenId` method,642	///  unlike standard, you can't specify it manually643	/// @param to The new owner644	/// @param tokenId ID of the minted NFT645	/// @param tokenUri Token URI that would be stored in the NFT properties646	#[solidity(hide, rename_selector = "mintWithTokenURI")]647	#[weight(<SelfWeightOf<T>>::create_item())]648	fn mint_with_token_uri_check_id(649		&mut self,650		caller: caller,651		to: address,652		token_id: uint256,653		token_uri: string,654	) -> Result<bool> {655		let key = key::url();656		let permission = get_token_permission::<T>(self.id, &key)?;657		if !permission.collection_admin {658			return Err("Operation is not allowed".into());659		}660661		let caller = T::CrossAccountId::from_eth(caller);662		let to = T::CrossAccountId::from_eth(to);663		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;664		let budget = self665			.recorder666			.weight_calls_budget(<StructureWeight<T>>::find_parent());667668		if <TokensMinted<T>>::get(self.id)669			.checked_add(1)670			.ok_or("item id overflow")?671			!= token_id672		{673			return Err("item id should be next".into());674		}675676		let mut properties = CollectionPropertiesVec::default();677		properties678			.try_push(Property {679				key,680				value: token_uri681					.into_bytes()682					.try_into()683					.map_err(|_| "token uri is too long")?,684			})685			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;686687		<Pallet<T>>::create_item(688			self,689			&caller,690			CreateItemData::<T> {691				properties,692				owner: to,693			},694			&budget,695		)696		.map_err(dispatch_to_evm::<T>)?;697		Ok(true)698	}699700	/// @dev Not implemented701	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {702		Err("not implementable".into())703	}704}705706fn get_token_property<T: Config>(707	collection: &CollectionHandle<T>,708	token_id: u32,709	key: &up_data_structs::PropertyKey,710) -> Result<string> {711	collection.consume_store_reads(1)?;712	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))713		.map_err(|_| Error::Revert("Token properties not found".into()))?;714	if let Some(property) = properties.get(key) {715		return Ok(string::from_utf8_lossy(property).into());716	}717718	Err("Property tokenURI not found".into())719}720721fn get_token_permission<T: Config>(722	collection_id: CollectionId,723	key: &PropertyKey,724) -> Result<PropertyPermission> {725	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)726		.map_err(|_| Error::Revert("No permissions for collection".into()))?;727	let a = token_property_permissions728		.get(key)729		.map(Clone::clone)730		.ok_or_else(|| {731			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();732			Error::Revert(alloc::format!("No permission for key {}", key))733		})?;734	Ok(a)735}736737/// @title Unique extensions for ERC721.738#[solidity_interface(name = ERC721UniqueExtensions)]739impl<T: Config> NonfungibleHandle<T>740where741	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,742{743	/// @notice A descriptive name for a collection of NFTs in this contract744	fn name(&self) -> Result<string> {745		Ok(decode_utf16(self.name.iter().copied())746			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))747			.collect::<string>())748	}749750	/// @notice An abbreviated name for NFTs in this contract751	fn symbol(&self) -> Result<string> {752		Ok(string::from_utf8_lossy(&self.token_prefix).into())753	}754755	/// @notice A description for the collection.756	fn description(&self) -> Result<string> {757		Ok(decode_utf16(self.description.iter().copied())758			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))759			.collect::<string>())760	}761762	/// Returns the owner (in cross format) of the token.763	///764	/// @param tokenId Id for the token.765	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAddress> {766		Self::token_owner(&self, token_id.try_into()?)767			.map(|o| pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(&o))768			.ok_or(Error::Revert("key too large".into()))769	}770771	/// Returns the token properties.772	///773	/// @param tokenId Id for the token.774	/// @param keys Properties keys. Empty keys for all propertyes.775	/// @return Vector of properties key/value pairs.776	fn properties(777		&self,778		token_id: uint256,779		keys: Vec<string>,780	) -> Result<Vec<pallet_common::eth::Property>> {781		let keys = keys782			.into_iter()783			.map(|key| {784				<Vec<u8>>::from(key)785					.try_into()786					.map_err(|_| Error::Revert("key too large".into()))787			})788			.collect::<Result<Vec<_>>>()?;789790		<Self as CommonCollectionOperations<T>>::token_properties(791			&self,792			token_id.try_into()?,793			if keys.is_empty() { None } else { Some(keys) },794		)795		.into_iter()796		.map(|p| {797			let key = string::from_utf8(p.key.to_vec())798				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;799			let value = bytes(p.value.to_vec());800			Ok(pallet_common::eth::Property::new(key, value))801		})802		.collect::<Result<Vec<_>>>()803	}804805	/// @notice Set or reaffirm the approved address for an NFT806	/// @dev The zero address indicates there is no approved address.807	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized808	///  operator of the current owner.809	/// @param approved The new substrate address approved NFT controller810	/// @param tokenId The NFT to approve811	#[weight(<SelfWeightOf<T>>::approve())]812	fn approve_cross(813		&mut self,814		caller: caller,815		approved: pallet_common::eth::CrossAddress,816		token_id: uint256,817	) -> Result<void> {818		let caller = T::CrossAccountId::from_eth(caller);819		let approved = approved.into_sub_cross_account::<T>()?;820		let token = token_id.try_into()?;821822		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))823			.map_err(dispatch_to_evm::<T>)?;824		Ok(())825	}826827	/// @notice Transfer ownership of an NFT828	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`829	///  is the zero address. Throws if `tokenId` is not a valid NFT.830	/// @param to The new owner831	/// @param tokenId The NFT to transfer832	#[weight(<SelfWeightOf<T>>::transfer())]833	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {834		let caller = T::CrossAccountId::from_eth(caller);835		let to = T::CrossAccountId::from_eth(to);836		let token = token_id.try_into()?;837		let budget = self838			.recorder839			.weight_calls_budget(<StructureWeight<T>>::find_parent());840841		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;842		Ok(())843	}844845	/// @notice Transfer ownership of an NFT846	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`847	///  is the zero address. Throws if `tokenId` is not a valid NFT.848	/// @param to The new owner849	/// @param tokenId The NFT to transfer850	#[weight(<SelfWeightOf<T>>::transfer())]851	fn transfer_cross(852		&mut self,853		caller: caller,854		to: pallet_common::eth::CrossAddress,855		token_id: uint256,856	) -> Result<void> {857		let caller = T::CrossAccountId::from_eth(caller);858		let to = to.into_sub_cross_account::<T>()?;859		let token = token_id.try_into()?;860		let budget = self861			.recorder862			.weight_calls_budget(<StructureWeight<T>>::find_parent());863864		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;865		Ok(())866	}867868	/// @notice Transfer ownership of an NFT from cross account address to cross account address869	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`870	///  is the zero address. Throws if `tokenId` is not a valid NFT.871	/// @param from Cross acccount address of current owner872	/// @param to Cross acccount address of new owner873	/// @param tokenId The NFT to transfer874	#[weight(<SelfWeightOf<T>>::transfer())]875	fn transfer_from_cross(876		&mut self,877		caller: caller,878		from: pallet_common::eth::CrossAddress,879		to: pallet_common::eth::CrossAddress,880		token_id: uint256,881	) -> Result<void> {882		let caller = T::CrossAccountId::from_eth(caller);883		let from = from.into_sub_cross_account::<T>()?;884		let to = to.into_sub_cross_account::<T>()?;885		let token_id = token_id.try_into()?;886		let budget = self887			.recorder888			.weight_calls_budget(<StructureWeight<T>>::find_parent());889		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)890			.map_err(dispatch_to_evm::<T>)?;891		Ok(())892	}893894	/// @notice Burns a specific ERC721 token.895	/// @dev Throws unless `msg.sender` is the current owner or an authorized896	///  operator for this NFT. Throws if `from` is not the current owner. Throws897	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.898	/// @param from The current owner of the NFT899	/// @param tokenId The NFT to transfer900	#[solidity(hide)]901	#[weight(<SelfWeightOf<T>>::burn_from())]902	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {903		let caller = T::CrossAccountId::from_eth(caller);904		let from = T::CrossAccountId::from_eth(from);905		let token = token_id.try_into()?;906		let budget = self907			.recorder908			.weight_calls_budget(<StructureWeight<T>>::find_parent());909910		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)911			.map_err(dispatch_to_evm::<T>)?;912		Ok(())913	}914915	/// @notice Burns a specific ERC721 token.916	/// @dev Throws unless `msg.sender` is the current owner or an authorized917	///  operator for this NFT. Throws if `from` is not the current owner. Throws918	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.919	/// @param from The current owner of the NFT920	/// @param tokenId The NFT to transfer921	#[weight(<SelfWeightOf<T>>::burn_from())]922	fn burn_from_cross(923		&mut self,924		caller: caller,925		from: pallet_common::eth::CrossAddress,926		token_id: uint256,927	) -> Result<void> {928		let caller = T::CrossAccountId::from_eth(caller);929		let from = from.into_sub_cross_account::<T>()?;930		let token = token_id.try_into()?;931		let budget = self932			.recorder933			.weight_calls_budget(<StructureWeight<T>>::find_parent());934935		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)936			.map_err(dispatch_to_evm::<T>)?;937		Ok(())938	}939940	/// @notice Returns next free NFT ID.941	fn next_token_id(&self) -> Result<uint256> {942		self.consume_store_reads(1)?;943		Ok(<TokensMinted<T>>::get(self.id)944			.checked_add(1)945			.ok_or("item id overflow")?946			.into())947	}948949	/// @notice Function to mint multiple tokens.950	/// @dev `tokenIds` should be an array of consecutive numbers and first number951	///  should be obtained with `nextTokenId` method952	/// @param to The new owner953	/// @param tokenIds IDs of the minted NFTs954	#[solidity(hide)]955	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]956	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {957		let caller = T::CrossAccountId::from_eth(caller);958		let to = T::CrossAccountId::from_eth(to);959		let mut expected_index = <TokensMinted<T>>::get(self.id)960			.checked_add(1)961			.ok_or("item id overflow")?;962		let budget = self963			.recorder964			.weight_calls_budget(<StructureWeight<T>>::find_parent());965966		let total_tokens = token_ids.len();967		for id in token_ids.into_iter() {968			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;969			if id != expected_index {970				return Err("item id should be next".into());971			}972			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;973		}974		let data = (0..total_tokens)975			.map(|_| CreateItemData::<T> {976				properties: BoundedVec::default(),977				owner: to.clone(),978			})979			.collect();980981		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)982			.map_err(dispatch_to_evm::<T>)?;983		Ok(true)984	}985986	/// @notice Function to mint multiple tokens with the given tokenUris.987	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive988	///  numbers and first number should be obtained with `nextTokenId` method989	/// @param to The new owner990	/// @param tokens array of pairs of token ID and token URI for minted tokens991	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]992	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]993	fn mint_bulk_with_token_uri(994		&mut self,995		caller: caller,996		to: address,997		tokens: Vec<(uint256, string)>,998	) -> Result<bool> {999		let key = key::url();1000		let caller = T::CrossAccountId::from_eth(caller);1001		let to = T::CrossAccountId::from_eth(to);1002		let mut expected_index = <TokensMinted<T>>::get(self.id)1003			.checked_add(1)1004			.ok_or("item id overflow")?;1005		let budget = self1006			.recorder1007			.weight_calls_budget(<StructureWeight<T>>::find_parent());10081009		let mut data = Vec::with_capacity(tokens.len());1010		for (id, token_uri) in tokens {1011			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1012			if id != expected_index {1013				return Err("item id should be next".into());1014			}1015			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10161017			let mut properties = CollectionPropertiesVec::default();1018			properties1019				.try_push(Property {1020					key: key.clone(),1021					value: token_uri1022						.into_bytes()1023						.try_into()1024						.map_err(|_| "token uri is too long")?,1025				})1026				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10271028			data.push(CreateItemData::<T> {1029				properties,1030				owner: to.clone(),1031			});1032		}10331034		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1035			.map_err(dispatch_to_evm::<T>)?;1036		Ok(true)1037	}10381039	/// @notice Function to mint a token.1040	/// @param to The new owner crossAccountId1041	/// @param properties Properties of minted token1042	/// @return uint256 The id of the newly minted token1043	#[weight(<SelfWeightOf<T>>::create_item())]1044	fn mint_cross(1045		&mut self,1046		caller: caller,1047		to: pallet_common::eth::CrossAddress,1048		properties: Vec<pallet_common::eth::Property>,1049	) -> Result<uint256> {1050		let token_id = <TokensMinted<T>>::get(self.id)1051			.checked_add(1)1052			.ok_or("item id overflow")?;10531054		let to = to.into_sub_cross_account::<T>()?;10551056		let properties = properties1057			.into_iter()1058			.map(|property| {1059				let (key, value) = property.take_key_value();1060				let key = <Vec<u8>>::from(key)1061					.try_into()1062					.map_err(|_| "key too large")?;10631064				let value = value.0.try_into().map_err(|_| "value too large")?;10651066				Ok(Property { key, value })1067			})1068			.collect::<Result<Vec<_>>>()?1069			.try_into()1070			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;10711072		let caller = T::CrossAccountId::from_eth(caller);10731074		let budget = self1075			.recorder1076			.weight_calls_budget(<StructureWeight<T>>::find_parent());10771078		<Pallet<T>>::create_item(1079			self,1080			&caller,1081			CreateItemData::<T> {1082				properties,1083				owner: to,1084			},1085			&budget,1086		)1087		.map_err(dispatch_to_evm::<T>)?;10881089		Ok(token_id.into())1090	}1091}10921093#[solidity_interface(1094	name = UniqueNFT,1095	is(1096		ERC721,1097		ERC721Enumerable,1098		ERC721UniqueExtensions,1099		ERC721UniqueMintable,1100		ERC721Burnable,1101		ERC721Metadata(if(this.flags.erc721metadata)),1102		Collection(via(common_mut returns CollectionHandle<T>)),1103		TokenProperties,1104	)1105)]1106impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11071108// Not a tests, but code generators1109generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1110generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);11111112impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1113where1114	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1115{1116	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");11171118	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1119		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1120	}1121}