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(pallet_common::eth::Property::try_into)174			.collect::<Result<Vec<_>>>()?;175176		<Pallet<T>>::set_token_properties(177			self,178			&caller,179			TokenId(token_id),180			properties.into_iter(),181			false,182			&nesting_budget,183		)184		.map_err(dispatch_to_evm::<T>)185	}186187	/// @notice Delete token property value.188	/// @dev Throws error if `msg.sender` has no permission to edit the property.189	/// @param tokenId ID of the token.190	/// @param key Property key.191	#[solidity(hide)]192	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]193	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {194		let caller = T::CrossAccountId::from_eth(caller);195		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;196		let key = <Vec<u8>>::from(key)197			.try_into()198			.map_err(|_| "key too long")?;199200		let nesting_budget = self201			.recorder202			.weight_calls_budget(<StructureWeight<T>>::find_parent());203204		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)205			.map_err(dispatch_to_evm::<T>)206	}207208	/// @notice Delete token properties value.209	/// @dev Throws error if `msg.sender` has no permission to edit the property.210	/// @param tokenId ID of the token.211	/// @param keys Properties key.212	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]213	fn delete_properties(214		&mut self,215		token_id: uint256,216		caller: caller,217		keys: Vec<string>,218	) -> Result<()> {219		let caller = T::CrossAccountId::from_eth(caller);220		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;221		let keys = keys222			.into_iter()223			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))224			.collect::<Result<Vec<_>>>()?;225226		let nesting_budget = self227			.recorder228			.weight_calls_budget(<StructureWeight<T>>::find_parent());229230		<Pallet<T>>::delete_token_properties(231			self,232			&caller,233			TokenId(token_id),234			keys.into_iter(),235			&nesting_budget,236		)237		.map_err(dispatch_to_evm::<T>)238	}239240	/// @notice Get token property value.241	/// @dev Throws error if key not found242	/// @param tokenId ID of the token.243	/// @param key Property key.244	/// @return Property value bytes245	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {246		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;247		let key = <Vec<u8>>::from(key)248			.try_into()249			.map_err(|_| "key too long")?;250251		let props = <TokenProperties<T>>::get((self.id, token_id));252		let prop = props.get(&key).ok_or("key not found")?;253254		Ok(prop.to_vec().into())255	}256}257258#[derive(ToLog)]259pub enum ERC721Events {260	/// @dev This emits when ownership of any NFT changes by any mechanism.261	///  This event emits when NFTs are created (`from` == 0) and destroyed262	///  (`to` == 0). Exception: during contract creation, any number of NFTs263	///  may be created and assigned without emitting Transfer. At the time of264	///  any transfer, the approved address for that NFT (if any) is reset to none.265	Transfer {266		#[indexed]267		from: address,268		#[indexed]269		to: address,270		#[indexed]271		token_id: uint256,272	},273	/// @dev This emits when the approved address for an NFT is changed or274	///  reaffirmed. The zero address indicates there is no approved address.275	///  When a Transfer event emits, this also indicates that the approved276	///  address for that NFT (if any) is reset to none.277	Approval {278		#[indexed]279		owner: address,280		#[indexed]281		approved: address,282		#[indexed]283		token_id: uint256,284	},285	/// @dev This emits when an operator is enabled or disabled for an owner.286	///  The operator can manage all NFTs of the owner.287	#[allow(dead_code)]288	ApprovalForAll {289		#[indexed]290		owner: address,291		#[indexed]292		operator: address,293		approved: bool,294	},295}296297#[derive(ToLog)]298pub enum ERC721UniqueMintableEvents {299	#[allow(dead_code)]300	MintingFinished {},301}302303/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension304/// @dev See https://eips.ethereum.org/EIPS/eip-721305#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]306impl<T: Config> NonfungibleHandle<T>307where308	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,309{310	/// @notice A descriptive name for a collection of NFTs in this contract311	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`312	#[solidity(hide, rename_selector = "name")]313	fn name_proxy(&self) -> Result<string> {314		self.name()315	}316317	/// @notice An abbreviated name for NFTs in this contract318	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`319	#[solidity(hide, rename_selector = "symbol")]320	fn symbol_proxy(&self) -> Result<string> {321		self.symbol()322	}323324	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.325	///326	/// @dev If the token has a `url` property and it is not empty, it is returned.327	///  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`.328	///  If the collection property `baseURI` is empty or absent, return "" (empty string)329	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix330	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).331	///332	/// @return token's const_metadata333	#[solidity(rename_selector = "tokenURI")]334	fn token_uri(&self, token_id: uint256) -> Result<string> {335		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;336337		match get_token_property(self, token_id_u32, &key::url()).as_deref() {338			Err(_) | Ok("") => (),339			Ok(url) => {340				return Ok(url.into());341			}342		};343344		let base_uri =345			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())346				.map(BoundedVec::into_inner)347				.map(string::from_utf8)348				.transpose()349				.map_err(|e| {350					Error::Revert(alloc::format!(351						"Can not convert value \"baseURI\" to string with error \"{}\"",352						e353					))354				})?;355356		let base_uri = match base_uri.as_deref() {357			None | Some("") => {358				return Ok("".into());359			}360			Some(base_uri) => base_uri.into(),361		};362363		Ok(364			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {365				Err(_) | Ok("") => base_uri,366				Ok(suffix) => base_uri + suffix,367			},368		)369	}370}371372/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension373/// @dev See https://eips.ethereum.org/EIPS/eip-721374#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]375impl<T: Config> NonfungibleHandle<T> {376	/// @notice Enumerate valid NFTs377	/// @param index A counter less than `totalSupply()`378	/// @return The token identifier for the `index`th NFT,379	///  (sort order not specified)380	fn token_by_index(&self, index: uint256) -> Result<uint256> {381		Ok(index)382	}383384	/// @dev Not implemented385	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {386		// TODO: Not implemetable387		Err("not implemented".into())388	}389390	/// @notice Count NFTs tracked by this contract391	/// @return A count of valid NFTs tracked by this contract, where each one of392	///  them has an assigned and queryable owner not equal to the zero address393	fn total_supply(&self) -> Result<uint256> {394		self.consume_store_reads(1)?;395		Ok(<Pallet<T>>::total_supply(self).into())396	}397}398399/// @title ERC-721 Non-Fungible Token Standard400/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md401#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]402impl<T: Config> NonfungibleHandle<T> {403	/// @notice Count all NFTs assigned to an owner404	/// @dev NFTs assigned to the zero address are considered invalid, and this405	///  function throws for queries about the zero address.406	/// @param owner An address for whom to query the balance407	/// @return The number of NFTs owned by `owner`, possibly zero408	fn balance_of(&self, owner: address) -> Result<uint256> {409		self.consume_store_reads(1)?;410		let owner = T::CrossAccountId::from_eth(owner);411		let balance = <AccountBalance<T>>::get((self.id, owner));412		Ok(balance.into())413	}414	/// @notice Find the owner of an NFT415	/// @dev NFTs assigned to zero address are considered invalid, and queries416	///  about them do throw.417	/// @param tokenId The identifier for an NFT418	/// @return The address of the owner of the NFT419	fn owner_of(&self, token_id: uint256) -> Result<address> {420		self.consume_store_reads(1)?;421		let token: TokenId = token_id.try_into()?;422		Ok(*<TokenData<T>>::get((self.id, token))423			.ok_or("token not found")?424			.owner425			.as_eth())426	}427	/// @dev Not implemented428	#[solidity(rename_selector = "safeTransferFrom")]429	fn safe_transfer_from_with_data(430		&mut self,431		_from: address,432		_to: address,433		_token_id: uint256,434		_data: bytes,435	) -> Result<void> {436		// TODO: Not implemetable437		Err("not implemented".into())438	}439	/// @dev Not implemented440	fn safe_transfer_from(441		&mut self,442		_from: address,443		_to: address,444		_token_id: uint256,445	) -> Result<void> {446		// TODO: Not implemetable447		Err("not implemented".into())448	}449450	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE451	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE452	///  THEY MAY BE PERMANENTLY LOST453	/// @dev Throws unless `msg.sender` is the current owner or an authorized454	///  operator for this NFT. Throws if `from` is not the current owner. Throws455	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.456	/// @param from The current owner of the NFT457	/// @param to The new owner458	/// @param tokenId The NFT to transfer459	#[weight(<SelfWeightOf<T>>::transfer_from())]460	fn transfer_from(461		&mut self,462		caller: caller,463		from: address,464		to: address,465		token_id: uint256,466	) -> Result<void> {467		let caller = T::CrossAccountId::from_eth(caller);468		let from = T::CrossAccountId::from_eth(from);469		let to = T::CrossAccountId::from_eth(to);470		let token = token_id.try_into()?;471		let budget = self472			.recorder473			.weight_calls_budget(<StructureWeight<T>>::find_parent());474475		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)476			.map_err(dispatch_to_evm::<T>)?;477		Ok(())478	}479480	/// @notice Set or reaffirm the approved address for an NFT481	/// @dev The zero address indicates there is no approved address.482	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized483	///  operator of the current owner.484	/// @param approved The new approved NFT controller485	/// @param tokenId The NFT to approve486	#[weight(<SelfWeightOf<T>>::approve())]487	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {488		let caller = T::CrossAccountId::from_eth(caller);489		let approved = T::CrossAccountId::from_eth(approved);490		let token = token_id.try_into()?;491492		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))493			.map_err(dispatch_to_evm::<T>)?;494		Ok(())495	}496497	/// @notice Sets or unsets the approval of a given operator.498	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.499	/// @param operator Operator500	/// @param approved Should operator status be granted or revoked?501	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]502	fn set_approval_for_all(503		&mut self,504		caller: caller,505		operator: address,506		approved: bool,507	) -> Result<void> {508		let caller = T::CrossAccountId::from_eth(caller);509		let operator = T::CrossAccountId::from_eth(operator);510511		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)512			.map_err(dispatch_to_evm::<T>)?;513		Ok(())514	}515516	/// @dev Not implemented517	fn get_approved(&self, _token_id: uint256) -> Result<address> {518		// TODO: Not implemetable519		Err("not implemented".into())520	}521522	/// @notice Tells whether the given `owner` approves the `operator`.523	#[weight(<SelfWeightOf<T>>::allowance_for_all())]524	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {525		let owner = T::CrossAccountId::from_eth(owner);526		let operator = T::CrossAccountId::from_eth(operator);527528		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))529	}530531	/// @notice Returns collection helper contract address532	fn collection_helper_address(&self) -> Result<address> {533		Ok(T::ContractAddress::get())534	}535}536537/// @title ERC721 Token that can be irreversibly burned (destroyed).538#[solidity_interface(name = ERC721Burnable)]539impl<T: Config> NonfungibleHandle<T> {540	/// @notice Burns a specific ERC721 token.541	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized542	///  operator of the current owner.543	/// @param tokenId The NFT to approve544	#[weight(<SelfWeightOf<T>>::burn_item())]545	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {546		let caller = T::CrossAccountId::from_eth(caller);547		let token = token_id.try_into()?;548549		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;550		Ok(())551	}552}553554/// @title ERC721 minting logic.555#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]556impl<T: Config> NonfungibleHandle<T> {557	fn minting_finished(&self) -> Result<bool> {558		Ok(false)559	}560561	/// @notice Function to mint a token.562	/// @param to The new owner563	/// @return uint256 The id of the newly minted token564	#[weight(<SelfWeightOf<T>>::create_item())]565	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {566		let token_id: uint256 = <TokensMinted<T>>::get(self.id)567			.checked_add(1)568			.ok_or("item id overflow")?569			.into();570		self.mint_check_id(caller, to, token_id)?;571		Ok(token_id)572	}573574	/// @notice Function to mint a token.575	/// @dev `tokenId` should be obtained with `nextTokenId` method,576	///  unlike standard, you can't specify it manually577	/// @param to The new owner578	/// @param tokenId ID of the minted NFT579	#[solidity(hide, rename_selector = "mint")]580	#[weight(<SelfWeightOf<T>>::create_item())]581	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {582		let caller = T::CrossAccountId::from_eth(caller);583		let to = T::CrossAccountId::from_eth(to);584		let token_id: u32 = token_id.try_into()?;585		let budget = self586			.recorder587			.weight_calls_budget(<StructureWeight<T>>::find_parent());588589		if <TokensMinted<T>>::get(self.id)590			.checked_add(1)591			.ok_or("item id overflow")?592			!= token_id593		{594			return Err("item id should be next".into());595		}596597		<Pallet<T>>::create_item(598			self,599			&caller,600			CreateItemData::<T> {601				properties: BoundedVec::default(),602				owner: to,603			},604			&budget,605		)606		.map_err(dispatch_to_evm::<T>)?;607608		Ok(true)609	}610611	/// @notice Function to mint token with the given tokenUri.612	/// @param to The new owner613	/// @param tokenUri Token URI that would be stored in the NFT properties614	/// @return uint256 The id of the newly minted token615	#[solidity(rename_selector = "mintWithTokenURI")]616	#[weight(<SelfWeightOf<T>>::create_item())]617	fn mint_with_token_uri(618		&mut self,619		caller: caller,620		to: address,621		token_uri: string,622	) -> Result<uint256> {623		let token_id: uint256 = <TokensMinted<T>>::get(self.id)624			.checked_add(1)625			.ok_or("item id overflow")?626			.into();627		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;628		Ok(token_id)629	}630631	/// @notice Function to mint token with the given tokenUri.632	/// @dev `tokenId` should be obtained with `nextTokenId` method,633	///  unlike standard, you can't specify it manually634	/// @param to The new owner635	/// @param tokenId ID of the minted NFT636	/// @param tokenUri Token URI that would be stored in the NFT properties637	#[solidity(hide, rename_selector = "mintWithTokenURI")]638	#[weight(<SelfWeightOf<T>>::create_item())]639	fn mint_with_token_uri_check_id(640		&mut self,641		caller: caller,642		to: address,643		token_id: uint256,644		token_uri: string,645	) -> Result<bool> {646		let key = key::url();647		let permission = get_token_permission::<T>(self.id, &key)?;648		if !permission.collection_admin {649			return Err("Operation is not allowed".into());650		}651652		let caller = T::CrossAccountId::from_eth(caller);653		let to = T::CrossAccountId::from_eth(to);654		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;655		let budget = self656			.recorder657			.weight_calls_budget(<StructureWeight<T>>::find_parent());658659		if <TokensMinted<T>>::get(self.id)660			.checked_add(1)661			.ok_or("item id overflow")?662			!= token_id663		{664			return Err("item id should be next".into());665		}666667		let mut properties = CollectionPropertiesVec::default();668		properties669			.try_push(Property {670				key,671				value: token_uri672					.into_bytes()673					.try_into()674					.map_err(|_| "token uri is too long")?,675			})676			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;677678		<Pallet<T>>::create_item(679			self,680			&caller,681			CreateItemData::<T> {682				properties,683				owner: to,684			},685			&budget,686		)687		.map_err(dispatch_to_evm::<T>)?;688		Ok(true)689	}690691	/// @dev Not implemented692	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {693		Err("not implementable".into())694	}695}696697fn get_token_property<T: Config>(698	collection: &CollectionHandle<T>,699	token_id: u32,700	key: &up_data_structs::PropertyKey,701) -> Result<string> {702	collection.consume_store_reads(1)?;703	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))704		.map_err(|_| Error::Revert("Token properties not found".into()))?;705	if let Some(property) = properties.get(key) {706		return Ok(string::from_utf8_lossy(property).into());707	}708709	Err("Property tokenURI not found".into())710}711712fn get_token_permission<T: Config>(713	collection_id: CollectionId,714	key: &PropertyKey,715) -> Result<PropertyPermission> {716	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)717		.map_err(|_| Error::Revert("No permissions for collection".into()))?;718	let a = token_property_permissions719		.get(key)720		.map(Clone::clone)721		.ok_or_else(|| {722			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();723			Error::Revert(alloc::format!("No permission for key {}", key))724		})?;725	Ok(a)726}727728/// @title Unique extensions for ERC721.729#[solidity_interface(name = ERC721UniqueExtensions)]730impl<T: Config> NonfungibleHandle<T>731where732	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,733{734	/// @notice A descriptive name for a collection of NFTs in this contract735	fn name(&self) -> Result<string> {736		Ok(decode_utf16(self.name.iter().copied())737			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))738			.collect::<string>())739	}740741	/// @notice An abbreviated name for NFTs in this contract742	fn symbol(&self) -> Result<string> {743		Ok(string::from_utf8_lossy(&self.token_prefix).into())744	}745746	/// @notice A description for the collection.747	fn description(&self) -> Result<string> {748		Ok(decode_utf16(self.description.iter().copied())749			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))750			.collect::<string>())751	}752753	/// Returns the owner (in cross format) of the token.754	///755	/// @param tokenId Id for the token.756	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAddress> {757		Self::token_owner(&self, token_id.try_into()?)758			.map(|o| pallet_common::eth::CrossAddress::from_sub_cross_account::<T>(&o))759			.ok_or(Error::Revert("key too large".into()))760	}761762	/// Returns the token properties.763	///764	/// @param tokenId Id for the token.765	/// @param keys Properties keys. Empty keys for all propertyes.766	/// @return Vector of properties key/value pairs.767	fn properties(768		&self,769		token_id: uint256,770		keys: Vec<string>,771	) -> Result<Vec<pallet_common::eth::Property>> {772		let keys = keys773			.into_iter()774			.map(|key| {775				<Vec<u8>>::from(key)776					.try_into()777					.map_err(|_| Error::Revert("key too large".into()))778			})779			.collect::<Result<Vec<_>>>()?;780781		<Self as CommonCollectionOperations<T>>::token_properties(782			&self,783			token_id.try_into()?,784			if keys.is_empty() { None } else { Some(keys) },785		)786		.into_iter()787		.map(pallet_common::eth::Property::try_from)788		.collect::<Result<Vec<_>>>()789	}790791	/// @notice Set or reaffirm the approved address for an NFT792	/// @dev The zero address indicates there is no approved address.793	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized794	///  operator of the current owner.795	/// @param approved The new substrate address approved NFT controller796	/// @param tokenId The NFT to approve797	#[weight(<SelfWeightOf<T>>::approve())]798	fn approve_cross(799		&mut self,800		caller: caller,801		approved: pallet_common::eth::CrossAddress,802		token_id: uint256,803	) -> Result<void> {804		let caller = T::CrossAccountId::from_eth(caller);805		let approved = approved.into_sub_cross_account::<T>()?;806		let token = token_id.try_into()?;807808		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))809			.map_err(dispatch_to_evm::<T>)?;810		Ok(())811	}812813	/// @notice Transfer ownership of an NFT814	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`815	///  is the zero address. Throws if `tokenId` is not a valid NFT.816	/// @param to The new owner817	/// @param tokenId The NFT to transfer818	#[weight(<SelfWeightOf<T>>::transfer())]819	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {820		let caller = T::CrossAccountId::from_eth(caller);821		let to = T::CrossAccountId::from_eth(to);822		let token = token_id.try_into()?;823		let budget = self824			.recorder825			.weight_calls_budget(<StructureWeight<T>>::find_parent());826827		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;828		Ok(())829	}830831	/// @notice Transfer ownership of an NFT832	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`833	///  is the zero address. Throws if `tokenId` is not a valid NFT.834	/// @param to The new owner835	/// @param tokenId The NFT to transfer836	#[weight(<SelfWeightOf<T>>::transfer())]837	fn transfer_cross(838		&mut self,839		caller: caller,840		to: pallet_common::eth::CrossAddress,841		token_id: uint256,842	) -> Result<void> {843		let caller = T::CrossAccountId::from_eth(caller);844		let to = to.into_sub_cross_account::<T>()?;845		let token = token_id.try_into()?;846		let budget = self847			.recorder848			.weight_calls_budget(<StructureWeight<T>>::find_parent());849850		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;851		Ok(())852	}853854	/// @notice Transfer ownership of an NFT from cross account address to cross account address855	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`856	///  is the zero address. Throws if `tokenId` is not a valid NFT.857	/// @param from Cross acccount address of current owner858	/// @param to Cross acccount address of new owner859	/// @param tokenId The NFT to transfer860	#[weight(<SelfWeightOf<T>>::transfer())]861	fn transfer_from_cross(862		&mut self,863		caller: caller,864		from: pallet_common::eth::CrossAddress,865		to: pallet_common::eth::CrossAddress,866		token_id: uint256,867	) -> Result<void> {868		let caller = T::CrossAccountId::from_eth(caller);869		let from = from.into_sub_cross_account::<T>()?;870		let to = to.into_sub_cross_account::<T>()?;871		let token_id = token_id.try_into()?;872		let budget = self873			.recorder874			.weight_calls_budget(<StructureWeight<T>>::find_parent());875		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)876			.map_err(dispatch_to_evm::<T>)?;877		Ok(())878	}879880	/// @notice Burns a specific ERC721 token.881	/// @dev Throws unless `msg.sender` is the current owner or an authorized882	///  operator for this NFT. Throws if `from` is not the current owner. Throws883	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.884	/// @param from The current owner of the NFT885	/// @param tokenId The NFT to transfer886	#[solidity(hide)]887	#[weight(<SelfWeightOf<T>>::burn_from())]888	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {889		let caller = T::CrossAccountId::from_eth(caller);890		let from = T::CrossAccountId::from_eth(from);891		let token = token_id.try_into()?;892		let budget = self893			.recorder894			.weight_calls_budget(<StructureWeight<T>>::find_parent());895896		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)897			.map_err(dispatch_to_evm::<T>)?;898		Ok(())899	}900901	/// @notice Burns a specific ERC721 token.902	/// @dev Throws unless `msg.sender` is the current owner or an authorized903	///  operator for this NFT. Throws if `from` is not the current owner. Throws904	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.905	/// @param from The current owner of the NFT906	/// @param tokenId The NFT to transfer907	#[weight(<SelfWeightOf<T>>::burn_from())]908	fn burn_from_cross(909		&mut self,910		caller: caller,911		from: pallet_common::eth::CrossAddress,912		token_id: uint256,913	) -> Result<void> {914		let caller = T::CrossAccountId::from_eth(caller);915		let from = from.into_sub_cross_account::<T>()?;916		let token = token_id.try_into()?;917		let budget = self918			.recorder919			.weight_calls_budget(<StructureWeight<T>>::find_parent());920921		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)922			.map_err(dispatch_to_evm::<T>)?;923		Ok(())924	}925926	/// @notice Returns next free NFT ID.927	fn next_token_id(&self) -> Result<uint256> {928		self.consume_store_reads(1)?;929		Ok(<TokensMinted<T>>::get(self.id)930			.checked_add(1)931			.ok_or("item id overflow")?932			.into())933	}934935	/// @notice Function to mint multiple tokens.936	/// @dev `tokenIds` should be an array of consecutive numbers and first number937	///  should be obtained with `nextTokenId` method938	/// @param to The new owner939	/// @param tokenIds IDs of the minted NFTs940	#[solidity(hide)]941	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]942	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {943		let caller = T::CrossAccountId::from_eth(caller);944		let to = T::CrossAccountId::from_eth(to);945		let mut expected_index = <TokensMinted<T>>::get(self.id)946			.checked_add(1)947			.ok_or("item id overflow")?;948		let budget = self949			.recorder950			.weight_calls_budget(<StructureWeight<T>>::find_parent());951952		let total_tokens = token_ids.len();953		for id in token_ids.into_iter() {954			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;955			if id != expected_index {956				return Err("item id should be next".into());957			}958			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;959		}960		let data = (0..total_tokens)961			.map(|_| CreateItemData::<T> {962				properties: BoundedVec::default(),963				owner: to.clone(),964			})965			.collect();966967		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)968			.map_err(dispatch_to_evm::<T>)?;969		Ok(true)970	}971972	/// @notice Function to mint multiple tokens with the given tokenUris.973	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive974	///  numbers and first number should be obtained with `nextTokenId` method975	/// @param to The new owner976	/// @param tokens array of pairs of token ID and token URI for minted tokens977	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]978	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]979	fn mint_bulk_with_token_uri(980		&mut self,981		caller: caller,982		to: address,983		tokens: Vec<(uint256, string)>,984	) -> Result<bool> {985		let key = key::url();986		let caller = T::CrossAccountId::from_eth(caller);987		let to = T::CrossAccountId::from_eth(to);988		let mut expected_index = <TokensMinted<T>>::get(self.id)989			.checked_add(1)990			.ok_or("item id overflow")?;991		let budget = self992			.recorder993			.weight_calls_budget(<StructureWeight<T>>::find_parent());994995		let mut data = Vec::with_capacity(tokens.len());996		for (id, token_uri) in tokens {997			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;998			if id != expected_index {999				return Err("item id should be next".into());1000			}1001			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10021003			let mut properties = CollectionPropertiesVec::default();1004			properties1005				.try_push(Property {1006					key: key.clone(),1007					value: token_uri1008						.into_bytes()1009						.try_into()1010						.map_err(|_| "token uri is too long")?,1011				})1012				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10131014			data.push(CreateItemData::<T> {1015				properties,1016				owner: to.clone(),1017			});1018		}10191020		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1021			.map_err(dispatch_to_evm::<T>)?;1022		Ok(true)1023	}10241025	/// @notice Function to mint a token.1026	/// @param to The new owner crossAccountId1027	/// @param properties Properties of minted token1028	/// @return uint256 The id of the newly minted token1029	#[weight(<SelfWeightOf<T>>::create_item())]1030	fn mint_cross(1031		&mut self,1032		caller: caller,1033		to: pallet_common::eth::CrossAddress,1034		properties: Vec<pallet_common::eth::Property>,1035	) -> Result<uint256> {1036		let token_id = <TokensMinted<T>>::get(self.id)1037			.checked_add(1)1038			.ok_or("item id overflow")?;10391040		let to = to.into_sub_cross_account::<T>()?;10411042		let properties = properties1043			.into_iter()1044			.map(pallet_common::eth::Property::try_into)1045			.collect::<Result<Vec<_>>>()?1046			.try_into()1047			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;10481049		let caller = T::CrossAccountId::from_eth(caller);10501051		let budget = self1052			.recorder1053			.weight_calls_budget(<StructureWeight<T>>::find_parent());10541055		<Pallet<T>>::create_item(1056			self,1057			&caller,1058			CreateItemData::<T> {1059				properties,1060				owner: to,1061			},1062			&budget,1063		)1064		.map_err(dispatch_to_evm::<T>)?;10651066		Ok(token_id.into())1067	}1068}10691070#[solidity_interface(1071	name = UniqueNFT,1072	is(1073		ERC721,1074		ERC721Enumerable,1075		ERC721UniqueExtensions,1076		ERC721UniqueMintable,1077		ERC721Burnable,1078		ERC721Metadata(if(this.flags.erc721metadata)),1079		Collection(via(common_mut returns CollectionHandle<T>)),1080		TokenProperties,1081	)1082)]1083impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10841085// Not a tests, but code generators1086generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1087generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);10881089impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1090where1091	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1092{1093	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");10941095	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1096		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1097	}1098}