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

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	eth,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_token_property_permissions(74			self,75			&caller,76			vec![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		)87		.map_err(dispatch_to_evm::<T>)88	}8990	/// @notice Set permissions for token property.91	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.92	/// @param permissions Permissions for keys.93	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(permissions.len() as u32))]94	fn set_token_property_permissions(95		&mut self,96		caller: caller,97		permissions: Vec<eth::TokenPropertyPermission>,98	) -> Result<()> {99		let caller = T::CrossAccountId::from_eth(caller);100		let perms = eth::TokenPropertyPermission::into_property_key_permissions(permissions)?;101102		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)103			.map_err(dispatch_to_evm::<T>)104	}105106	/// @notice Get permissions for token properties.107	fn token_property_permissions(&self) -> Result<Vec<eth::TokenPropertyPermission>> {108		let perms = <Pallet<T>>::token_property_permission(self.id);109		Ok(perms110			.into_iter()111			.map(eth::TokenPropertyPermission::from)112			.collect())113	}114115	/// @notice Set token property value.116	/// @dev Throws error if `msg.sender` has no permission to edit the property.117	/// @param tokenId ID of the token.118	/// @param key Property key.119	/// @param value Property value.120	#[solidity(hide)]121	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]122	fn set_property(123		&mut self,124		caller: caller,125		token_id: uint256,126		key: string,127		value: bytes,128	) -> Result<()> {129		let caller = T::CrossAccountId::from_eth(caller);130		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;131		let key = <Vec<u8>>::from(key)132			.try_into()133			.map_err(|_| "key too long")?;134		let value = value.0.try_into().map_err(|_| "value too long")?;135136		let nesting_budget = self137			.recorder138			.weight_calls_budget(<StructureWeight<T>>::find_parent());139140		<Pallet<T>>::set_token_property(141			self,142			&caller,143			TokenId(token_id),144			Property { key, value },145			&nesting_budget,146		)147		.map_err(dispatch_to_evm::<T>)148	}149150	/// @notice Set token properties value.151	/// @dev Throws error if `msg.sender` has no permission to edit the property.152	/// @param tokenId ID of the token.153	/// @param properties settable properties154	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]155	fn set_properties(156		&mut self,157		caller: caller,158		token_id: uint256,159		properties: Vec<eth::Property>,160	) -> Result<()> {161		let caller = T::CrossAccountId::from_eth(caller);162		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;163164		let nesting_budget = self165			.recorder166			.weight_calls_budget(<StructureWeight<T>>::find_parent());167168		let properties = properties169			.into_iter()170			.map(eth::Property::try_into)171			.collect::<Result<Vec<_>>>()?;172173		<Pallet<T>>::set_token_properties(174			self,175			&caller,176			TokenId(token_id),177			properties.into_iter(),178			false,179			&nesting_budget,180		)181		.map_err(dispatch_to_evm::<T>)182	}183184	/// @notice Delete token property value.185	/// @dev Throws error if `msg.sender` has no permission to edit the property.186	/// @param tokenId ID of the token.187	/// @param key Property key.188	#[solidity(hide)]189	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]190	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {191		let caller = T::CrossAccountId::from_eth(caller);192		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;193		let key = <Vec<u8>>::from(key)194			.try_into()195			.map_err(|_| "key too long")?;196197		let nesting_budget = self198			.recorder199			.weight_calls_budget(<StructureWeight<T>>::find_parent());200201		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)202			.map_err(dispatch_to_evm::<T>)203	}204205	/// @notice Delete token properties value.206	/// @dev Throws error if `msg.sender` has no permission to edit the property.207	/// @param tokenId ID of the token.208	/// @param keys Properties key.209	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]210	fn delete_properties(211		&mut self,212		token_id: uint256,213		caller: caller,214		keys: Vec<string>,215	) -> Result<()> {216		let caller = T::CrossAccountId::from_eth(caller);217		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;218		let keys = keys219			.into_iter()220			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))221			.collect::<Result<Vec<_>>>()?;222223		let nesting_budget = self224			.recorder225			.weight_calls_budget(<StructureWeight<T>>::find_parent());226227		<Pallet<T>>::delete_token_properties(228			self,229			&caller,230			TokenId(token_id),231			keys.into_iter(),232			&nesting_budget,233		)234		.map_err(dispatch_to_evm::<T>)235	}236237	/// @notice Get token property value.238	/// @dev Throws error if key not found239	/// @param tokenId ID of the token.240	/// @param key Property key.241	/// @return Property value bytes242	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {243		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;244		let key = <Vec<u8>>::from(key)245			.try_into()246			.map_err(|_| "key too long")?;247248		let props = <TokenProperties<T>>::get((self.id, token_id));249		let prop = props.get(&key).ok_or("key not found")?;250251		Ok(prop.to_vec().into())252	}253}254255#[derive(ToLog)]256pub enum ERC721Events {257	/// @dev This emits when ownership of any NFT changes by any mechanism.258	///  This event emits when NFTs are created (`from` == 0) and destroyed259	///  (`to` == 0). Exception: during contract creation, any number of NFTs260	///  may be created and assigned without emitting Transfer. At the time of261	///  any transfer, the approved address for that NFT (if any) is reset to none.262	Transfer {263		#[indexed]264		from: address,265		#[indexed]266		to: address,267		#[indexed]268		token_id: uint256,269	},270	/// @dev This emits when the approved address for an NFT is changed or271	///  reaffirmed. The zero address indicates there is no approved address.272	///  When a Transfer event emits, this also indicates that the approved273	///  address for that NFT (if any) is reset to none.274	Approval {275		#[indexed]276		owner: address,277		#[indexed]278		approved: address,279		#[indexed]280		token_id: uint256,281	},282	/// @dev This emits when an operator is enabled or disabled for an owner.283	///  The operator can manage all NFTs of the owner.284	#[allow(dead_code)]285	ApprovalForAll {286		#[indexed]287		owner: address,288		#[indexed]289		operator: address,290		approved: bool,291	},292}293294#[derive(ToLog)]295pub enum ERC721UniqueMintableEvents {296	#[allow(dead_code)]297	MintingFinished {},298}299300/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension301/// @dev See https://eips.ethereum.org/EIPS/eip-721302#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]303impl<T: Config> NonfungibleHandle<T>304where305	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,306{307	/// @notice A descriptive name for a collection of NFTs in this contract308	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`309	#[solidity(hide, rename_selector = "name")]310	fn name_proxy(&self) -> Result<string> {311		self.name()312	}313314	/// @notice An abbreviated name for NFTs in this contract315	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`316	#[solidity(hide, rename_selector = "symbol")]317	fn symbol_proxy(&self) -> Result<string> {318		self.symbol()319	}320321	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.322	///323	/// @dev If the token has a `url` property and it is not empty, it is returned.324	///  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`.325	///  If the collection property `baseURI` is empty or absent, return "" (empty string)326	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix327	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).328	///329	/// @return token's const_metadata330	#[solidity(rename_selector = "tokenURI")]331	fn token_uri(&self, token_id: uint256) -> Result<string> {332		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;333334		match get_token_property(self, token_id_u32, &key::url()).as_deref() {335			Err(_) | Ok("") => (),336			Ok(url) => {337				return Ok(url.into());338			}339		};340341		let base_uri =342			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())343				.map(BoundedVec::into_inner)344				.map(string::from_utf8)345				.transpose()346				.map_err(|e| {347					Error::Revert(alloc::format!(348						"Can not convert value \"baseURI\" to string with error \"{}\"",349						e350					))351				})?;352353		let base_uri = match base_uri.as_deref() {354			None | Some("") => {355				return Ok("".into());356			}357			Some(base_uri) => base_uri.into(),358		};359360		Ok(361			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {362				Err(_) | Ok("") => base_uri,363				Ok(suffix) => base_uri + suffix,364			},365		)366	}367}368369/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension370/// @dev See https://eips.ethereum.org/EIPS/eip-721371#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]372impl<T: Config> NonfungibleHandle<T> {373	/// @notice Enumerate valid NFTs374	/// @param index A counter less than `totalSupply()`375	/// @return The token identifier for the `index`th NFT,376	///  (sort order not specified)377	fn token_by_index(&self, index: uint256) -> Result<uint256> {378		Ok(index)379	}380381	/// @dev Not implemented382	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {383		// TODO: Not implemetable384		Err("not implemented".into())385	}386387	/// @notice Count NFTs tracked by this contract388	/// @return A count of valid NFTs tracked by this contract, where each one of389	///  them has an assigned and queryable owner not equal to the zero address390	fn total_supply(&self) -> Result<uint256> {391		self.consume_store_reads(1)?;392		Ok(<Pallet<T>>::total_supply(self).into())393	}394}395396/// @title ERC-721 Non-Fungible Token Standard397/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md398#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]399impl<T: Config> NonfungibleHandle<T> {400	/// @notice Count all NFTs assigned to an owner401	/// @dev NFTs assigned to the zero address are considered invalid, and this402	///  function throws for queries about the zero address.403	/// @param owner An address for whom to query the balance404	/// @return The number of NFTs owned by `owner`, possibly zero405	fn balance_of(&self, owner: address) -> Result<uint256> {406		self.consume_store_reads(1)?;407		let owner = T::CrossAccountId::from_eth(owner);408		let balance = <AccountBalance<T>>::get((self.id, owner));409		Ok(balance.into())410	}411	/// @notice Find the owner of an NFT412	/// @dev NFTs assigned to zero address are considered invalid, and queries413	///  about them do throw.414	/// @param tokenId The identifier for an NFT415	/// @return The address of the owner of the NFT416	fn owner_of(&self, token_id: uint256) -> Result<address> {417		self.consume_store_reads(1)?;418		let token: TokenId = token_id.try_into()?;419		Ok(*<TokenData<T>>::get((self.id, token))420			.ok_or("token not found")?421			.owner422			.as_eth())423	}424	/// @dev Not implemented425	#[solidity(rename_selector = "safeTransferFrom")]426	fn safe_transfer_from_with_data(427		&mut self,428		_from: address,429		_to: address,430		_token_id: uint256,431		_data: bytes,432	) -> Result<void> {433		// TODO: Not implemetable434		Err("not implemented".into())435	}436	/// @dev Not implemented437	fn safe_transfer_from(438		&mut self,439		_from: address,440		_to: address,441		_token_id: uint256,442	) -> Result<void> {443		// TODO: Not implemetable444		Err("not implemented".into())445	}446447	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE448	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE449	///  THEY MAY BE PERMANENTLY LOST450	/// @dev Throws unless `msg.sender` is the current owner or an authorized451	///  operator for this NFT. Throws if `from` is not the current owner. Throws452	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.453	/// @param from The current owner of the NFT454	/// @param to The new owner455	/// @param tokenId The NFT to transfer456	#[weight(<SelfWeightOf<T>>::transfer_from())]457	fn transfer_from(458		&mut self,459		caller: caller,460		from: address,461		to: address,462		token_id: uint256,463	) -> Result<void> {464		let caller = T::CrossAccountId::from_eth(caller);465		let from = T::CrossAccountId::from_eth(from);466		let to = T::CrossAccountId::from_eth(to);467		let token = token_id.try_into()?;468		let budget = self469			.recorder470			.weight_calls_budget(<StructureWeight<T>>::find_parent());471472		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)473			.map_err(dispatch_to_evm::<T>)?;474		Ok(())475	}476477	/// @notice Set or reaffirm the approved address for an NFT478	/// @dev The zero address indicates there is no approved address.479	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized480	///  operator of the current owner.481	/// @param approved The new approved NFT controller482	/// @param tokenId The NFT to approve483	#[weight(<SelfWeightOf<T>>::approve())]484	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {485		let caller = T::CrossAccountId::from_eth(caller);486		let approved = T::CrossAccountId::from_eth(approved);487		let token = token_id.try_into()?;488489		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))490			.map_err(dispatch_to_evm::<T>)?;491		Ok(())492	}493494	/// @notice Sets or unsets the approval of a given operator.495	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.496	/// @param operator Operator497	/// @param approved Should operator status be granted or revoked?498	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]499	fn set_approval_for_all(500		&mut self,501		caller: caller,502		operator: address,503		approved: bool,504	) -> Result<void> {505		let caller = T::CrossAccountId::from_eth(caller);506		let operator = T::CrossAccountId::from_eth(operator);507508		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)509			.map_err(dispatch_to_evm::<T>)?;510		Ok(())511	}512513	/// @dev Not implemented514	fn get_approved(&self, _token_id: uint256) -> Result<address> {515		// TODO: Not implemetable516		Err("not implemented".into())517	}518519	/// @notice Tells whether the given `owner` approves the `operator`.520	#[weight(<SelfWeightOf<T>>::allowance_for_all())]521	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {522		let owner = T::CrossAccountId::from_eth(owner);523		let operator = T::CrossAccountId::from_eth(operator);524525		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))526	}527528	/// @notice Returns collection helper contract address529	fn collection_helper_address(&self) -> Result<address> {530		Ok(T::ContractAddress::get())531	}532}533534/// @title ERC721 Token that can be irreversibly burned (destroyed).535#[solidity_interface(name = ERC721Burnable)]536impl<T: Config> NonfungibleHandle<T> {537	/// @notice Burns a specific ERC721 token.538	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized539	///  operator of the current owner.540	/// @param tokenId The NFT to approve541	#[weight(<SelfWeightOf<T>>::burn_item())]542	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {543		let caller = T::CrossAccountId::from_eth(caller);544		let token = token_id.try_into()?;545546		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;547		Ok(())548	}549}550551/// @title ERC721 minting logic.552#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]553impl<T: Config> NonfungibleHandle<T> {554	fn minting_finished(&self) -> Result<bool> {555		Ok(false)556	}557558	/// @notice Function to mint a token.559	/// @param to The new owner560	/// @return uint256 The id of the newly minted token561	#[weight(<SelfWeightOf<T>>::create_item())]562	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {563		let token_id: uint256 = <TokensMinted<T>>::get(self.id)564			.checked_add(1)565			.ok_or("item id overflow")?566			.into();567		self.mint_check_id(caller, to, token_id)?;568		Ok(token_id)569	}570571	/// @notice Function to mint a token.572	/// @dev `tokenId` should be obtained with `nextTokenId` method,573	///  unlike standard, you can't specify it manually574	/// @param to The new owner575	/// @param tokenId ID of the minted NFT576	#[solidity(hide, rename_selector = "mint")]577	#[weight(<SelfWeightOf<T>>::create_item())]578	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {579		let caller = T::CrossAccountId::from_eth(caller);580		let to = T::CrossAccountId::from_eth(to);581		let token_id: u32 = token_id.try_into()?;582		let budget = self583			.recorder584			.weight_calls_budget(<StructureWeight<T>>::find_parent());585586		if <TokensMinted<T>>::get(self.id)587			.checked_add(1)588			.ok_or("item id overflow")?589			!= token_id590		{591			return Err("item id should be next".into());592		}593594		<Pallet<T>>::create_item(595			self,596			&caller,597			CreateItemData::<T> {598				properties: BoundedVec::default(),599				owner: to,600			},601			&budget,602		)603		.map_err(dispatch_to_evm::<T>)?;604605		Ok(true)606	}607608	/// @notice Function to mint token with the given tokenUri.609	/// @param to The new owner610	/// @param tokenUri Token URI that would be stored in the NFT properties611	/// @return uint256 The id of the newly minted token612	#[solidity(rename_selector = "mintWithTokenURI")]613	#[weight(<SelfWeightOf<T>>::create_item())]614	fn mint_with_token_uri(615		&mut self,616		caller: caller,617		to: address,618		token_uri: string,619	) -> Result<uint256> {620		let token_id: uint256 = <TokensMinted<T>>::get(self.id)621			.checked_add(1)622			.ok_or("item id overflow")?623			.into();624		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;625		Ok(token_id)626	}627628	/// @notice Function to mint token with the given tokenUri.629	/// @dev `tokenId` should be obtained with `nextTokenId` method,630	///  unlike standard, you can't specify it manually631	/// @param to The new owner632	/// @param tokenId ID of the minted NFT633	/// @param tokenUri Token URI that would be stored in the NFT properties634	#[solidity(hide, rename_selector = "mintWithTokenURI")]635	#[weight(<SelfWeightOf<T>>::create_item())]636	fn mint_with_token_uri_check_id(637		&mut self,638		caller: caller,639		to: address,640		token_id: uint256,641		token_uri: string,642	) -> Result<bool> {643		let key = key::url();644		let permission = get_token_permission::<T>(self.id, &key)?;645		if !permission.collection_admin {646			return Err("Operation is not allowed".into());647		}648649		let caller = T::CrossAccountId::from_eth(caller);650		let to = T::CrossAccountId::from_eth(to);651		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;652		let budget = self653			.recorder654			.weight_calls_budget(<StructureWeight<T>>::find_parent());655656		if <TokensMinted<T>>::get(self.id)657			.checked_add(1)658			.ok_or("item id overflow")?659			!= token_id660		{661			return Err("item id should be next".into());662		}663664		let mut properties = CollectionPropertiesVec::default();665		properties666			.try_push(Property {667				key,668				value: token_uri669					.into_bytes()670					.try_into()671					.map_err(|_| "token uri is too long")?,672			})673			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;674675		<Pallet<T>>::create_item(676			self,677			&caller,678			CreateItemData::<T> {679				properties,680				owner: to,681			},682			&budget,683		)684		.map_err(dispatch_to_evm::<T>)?;685		Ok(true)686	}687688	/// @dev Not implemented689	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {690		Err("not implementable".into())691	}692}693694fn get_token_property<T: Config>(695	collection: &CollectionHandle<T>,696	token_id: u32,697	key: &up_data_structs::PropertyKey,698) -> Result<string> {699	collection.consume_store_reads(1)?;700	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))701		.map_err(|_| Error::Revert("Token properties not found".into()))?;702	if let Some(property) = properties.get(key) {703		return Ok(string::from_utf8_lossy(property).into());704	}705706	Err("Property tokenURI not found".into())707}708709fn get_token_permission<T: Config>(710	collection_id: CollectionId,711	key: &PropertyKey,712) -> Result<PropertyPermission> {713	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)714		.map_err(|_| Error::Revert("No permissions for collection".into()))?;715	let a = token_property_permissions716		.get(key)717		.map(Clone::clone)718		.ok_or_else(|| {719			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();720			Error::Revert(alloc::format!("No permission for key {}", key))721		})?;722	Ok(a)723}724725/// @title Unique extensions for ERC721.726#[solidity_interface(name = ERC721UniqueExtensions)]727impl<T: Config> NonfungibleHandle<T>728where729	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,730{731	/// @notice A descriptive name for a collection of NFTs in this contract732	fn name(&self) -> Result<string> {733		Ok(decode_utf16(self.name.iter().copied())734			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))735			.collect::<string>())736	}737738	/// @notice An abbreviated name for NFTs in this contract739	fn symbol(&self) -> Result<string> {740		Ok(string::from_utf8_lossy(&self.token_prefix).into())741	}742743	/// @notice A description for the collection.744	fn description(&self) -> Result<string> {745		Ok(decode_utf16(self.description.iter().copied())746			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))747			.collect::<string>())748	}749750	/// Returns the owner (in cross format) of the token.751	///752	/// @param tokenId Id for the token.753	fn cross_owner_of(&self, token_id: uint256) -> Result<eth::CrossAddress> {754		Self::token_owner(&self, token_id.try_into()?)755			.map(|o| eth::CrossAddress::from_sub_cross_account::<T>(&o))756			.ok_or(Error::Revert("key too large".into()))757	}758759	/// Returns the token properties.760	///761	/// @param tokenId Id for the token.762	/// @param keys Properties keys. Empty keys for all propertyes.763	/// @return Vector of properties key/value pairs.764	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<eth::Property>> {765		let keys = keys766			.into_iter()767			.map(|key| {768				<Vec<u8>>::from(key)769					.try_into()770					.map_err(|_| Error::Revert("key too large".into()))771			})772			.collect::<Result<Vec<_>>>()?;773774		<Self as CommonCollectionOperations<T>>::token_properties(775			&self,776			token_id.try_into()?,777			if keys.is_empty() { None } else { Some(keys) },778		)779		.into_iter()780		.map(eth::Property::try_from)781		.collect::<Result<Vec<_>>>()782	}783784	/// @notice Set or reaffirm the approved address for an NFT785	/// @dev The zero address indicates there is no approved address.786	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized787	///  operator of the current owner.788	/// @param approved The new substrate address approved NFT controller789	/// @param tokenId The NFT to approve790	#[weight(<SelfWeightOf<T>>::approve())]791	fn approve_cross(792		&mut self,793		caller: caller,794		approved: eth::CrossAddress,795		token_id: uint256,796	) -> Result<void> {797		let caller = T::CrossAccountId::from_eth(caller);798		let approved = approved.into_sub_cross_account::<T>()?;799		let token = token_id.try_into()?;800801		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))802			.map_err(dispatch_to_evm::<T>)?;803		Ok(())804	}805806	/// @notice Transfer ownership of an NFT807	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`808	///  is the zero address. Throws if `tokenId` is not a valid NFT.809	/// @param to The new owner810	/// @param tokenId The NFT to transfer811	#[weight(<SelfWeightOf<T>>::transfer())]812	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {813		let caller = T::CrossAccountId::from_eth(caller);814		let to = T::CrossAccountId::from_eth(to);815		let token = token_id.try_into()?;816		let budget = self817			.recorder818			.weight_calls_budget(<StructureWeight<T>>::find_parent());819820		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;821		Ok(())822	}823824	/// @notice Transfer ownership of an NFT825	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`826	///  is the zero address. Throws if `tokenId` is not a valid NFT.827	/// @param to The new owner828	/// @param tokenId The NFT to transfer829	#[weight(<SelfWeightOf<T>>::transfer())]830	fn transfer_cross(831		&mut self,832		caller: caller,833		to: eth::CrossAddress,834		token_id: uint256,835	) -> Result<void> {836		let caller = T::CrossAccountId::from_eth(caller);837		let to = to.into_sub_cross_account::<T>()?;838		let token = token_id.try_into()?;839		let budget = self840			.recorder841			.weight_calls_budget(<StructureWeight<T>>::find_parent());842843		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;844		Ok(())845	}846847	/// @notice Transfer ownership of an NFT from cross account address to cross account address848	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`849	///  is the zero address. Throws if `tokenId` is not a valid NFT.850	/// @param from Cross acccount address of current owner851	/// @param to Cross acccount address of new owner852	/// @param tokenId The NFT to transfer853	#[weight(<SelfWeightOf<T>>::transfer())]854	fn transfer_from_cross(855		&mut self,856		caller: caller,857		from: eth::CrossAddress,858		to: eth::CrossAddress,859		token_id: uint256,860	) -> Result<void> {861		let caller = T::CrossAccountId::from_eth(caller);862		let from = from.into_sub_cross_account::<T>()?;863		let to = to.into_sub_cross_account::<T>()?;864		let token_id = token_id.try_into()?;865		let budget = self866			.recorder867			.weight_calls_budget(<StructureWeight<T>>::find_parent());868		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)869			.map_err(dispatch_to_evm::<T>)?;870		Ok(())871	}872873	/// @notice Burns a specific ERC721 token.874	/// @dev Throws unless `msg.sender` is the current owner or an authorized875	///  operator for this NFT. Throws if `from` is not the current owner. Throws876	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.877	/// @param from The current owner of the NFT878	/// @param tokenId The NFT to transfer879	#[solidity(hide)]880	#[weight(<SelfWeightOf<T>>::burn_from())]881	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {882		let caller = T::CrossAccountId::from_eth(caller);883		let from = T::CrossAccountId::from_eth(from);884		let token = token_id.try_into()?;885		let budget = self886			.recorder887			.weight_calls_budget(<StructureWeight<T>>::find_parent());888889		<Pallet<T>>::burn_from(self, &caller, &from, token, &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	#[weight(<SelfWeightOf<T>>::burn_from())]901	fn burn_from_cross(902		&mut self,903		caller: caller,904		from: eth::CrossAddress,905		token_id: uint256,906	) -> Result<void> {907		let caller = T::CrossAccountId::from_eth(caller);908		let from = from.into_sub_cross_account::<T>()?;909		let token = token_id.try_into()?;910		let budget = self911			.recorder912			.weight_calls_budget(<StructureWeight<T>>::find_parent());913914		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)915			.map_err(dispatch_to_evm::<T>)?;916		Ok(())917	}918919	/// @notice Returns next free NFT ID.920	fn next_token_id(&self) -> Result<uint256> {921		self.consume_store_reads(1)?;922		Ok(<TokensMinted<T>>::get(self.id)923			.checked_add(1)924			.ok_or("item id overflow")?925			.into())926	}927928	/// @notice Function to mint multiple tokens.929	/// @dev `tokenIds` should be an array of consecutive numbers and first number930	///  should be obtained with `nextTokenId` method931	/// @param to The new owner932	/// @param tokenIds IDs of the minted NFTs933	#[solidity(hide)]934	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]935	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {936		let caller = T::CrossAccountId::from_eth(caller);937		let to = T::CrossAccountId::from_eth(to);938		let mut expected_index = <TokensMinted<T>>::get(self.id)939			.checked_add(1)940			.ok_or("item id overflow")?;941		let budget = self942			.recorder943			.weight_calls_budget(<StructureWeight<T>>::find_parent());944945		let total_tokens = token_ids.len();946		for id in token_ids.into_iter() {947			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;948			if id != expected_index {949				return Err("item id should be next".into());950			}951			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;952		}953		let data = (0..total_tokens)954			.map(|_| CreateItemData::<T> {955				properties: BoundedVec::default(),956				owner: to.clone(),957			})958			.collect();959960		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)961			.map_err(dispatch_to_evm::<T>)?;962		Ok(true)963	}964965	/// @notice Function to mint multiple tokens with the given tokenUris.966	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive967	///  numbers and first number should be obtained with `nextTokenId` method968	/// @param to The new owner969	/// @param tokens array of pairs of token ID and token URI for minted tokens970	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]971	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]972	fn mint_bulk_with_token_uri(973		&mut self,974		caller: caller,975		to: address,976		tokens: Vec<(uint256, string)>,977	) -> Result<bool> {978		let key = key::url();979		let caller = T::CrossAccountId::from_eth(caller);980		let to = T::CrossAccountId::from_eth(to);981		let mut expected_index = <TokensMinted<T>>::get(self.id)982			.checked_add(1)983			.ok_or("item id overflow")?;984		let budget = self985			.recorder986			.weight_calls_budget(<StructureWeight<T>>::find_parent());987988		let mut data = Vec::with_capacity(tokens.len());989		for (id, token_uri) in tokens {990			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;991			if id != expected_index {992				return Err("item id should be next".into());993			}994			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;995996			let mut properties = CollectionPropertiesVec::default();997			properties998				.try_push(Property {999					key: key.clone(),1000					value: token_uri1001						.into_bytes()1002						.try_into()1003						.map_err(|_| "token uri is too long")?,1004				})1005				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10061007			data.push(CreateItemData::<T> {1008				properties,1009				owner: to.clone(),1010			});1011		}10121013		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1014			.map_err(dispatch_to_evm::<T>)?;1015		Ok(true)1016	}10171018	/// @notice Function to mint a token.1019	/// @param to The new owner crossAccountId1020	/// @param properties Properties of minted token1021	/// @return uint256 The id of the newly minted token1022	#[weight(<SelfWeightOf<T>>::create_item())]1023	fn mint_cross(1024		&mut self,1025		caller: caller,1026		to: eth::CrossAddress,1027		properties: Vec<eth::Property>,1028	) -> Result<uint256> {1029		let token_id = <TokensMinted<T>>::get(self.id)1030			.checked_add(1)1031			.ok_or("item id overflow")?;10321033		let to = to.into_sub_cross_account::<T>()?;10341035		let properties = properties1036			.into_iter()1037			.map(eth::Property::try_into)1038			.collect::<Result<Vec<_>>>()?1039			.try_into()1040			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;10411042		let caller = T::CrossAccountId::from_eth(caller);10431044		let budget = self1045			.recorder1046			.weight_calls_budget(<StructureWeight<T>>::find_parent());10471048		<Pallet<T>>::create_item(1049			self,1050			&caller,1051			CreateItemData::<T> {1052				properties,1053				owner: to,1054			},1055			&budget,1056		)1057		.map_err(dispatch_to_evm::<T>)?;10581059		Ok(token_id.into())1060	}1061}10621063#[solidity_interface(1064	name = UniqueNFT,1065	is(1066		ERC721,1067		ERC721Enumerable,1068		ERC721UniqueExtensions,1069		ERC721UniqueMintable,1070		ERC721Burnable,1071		ERC721Metadata(if(this.flags.erc721metadata)),1072		Collection(via(common_mut returns CollectionHandle<T>)),1073		TokenProperties,1074	)1075)]1076impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10771078// Not a tests, but code generators1079generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1080generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);10811082impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1083where1084	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1085{1086	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");10871088	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1089		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1090	}1091}