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

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 { key, value }| {174				let key = <Vec<u8>>::from(key)175					.try_into()176					.map_err(|_| "key too large")?;177178				let value = value.0.try_into().map_err(|_| "value too large")?;179180				Ok(Property { key, value })181			})182			.collect::<Result<Vec<_>>>()?;183184		<Pallet<T>>::set_token_properties(185			self,186			&caller,187			TokenId(token_id),188			properties.into_iter(),189			false,190			&nesting_budget,191		)192		.map_err(dispatch_to_evm::<T>)193	}194195	/// @notice Delete token property value.196	/// @dev Throws error if `msg.sender` has no permission to edit the property.197	/// @param tokenId ID of the token.198	/// @param key Property key.199	#[solidity(hide)]200	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]201	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {202		let caller = T::CrossAccountId::from_eth(caller);203		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;204		let key = <Vec<u8>>::from(key)205			.try_into()206			.map_err(|_| "key too long")?;207208		let nesting_budget = self209			.recorder210			.weight_calls_budget(<StructureWeight<T>>::find_parent());211212		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)213			.map_err(dispatch_to_evm::<T>)214	}215216	/// @notice Delete token properties value.217	/// @dev Throws error if `msg.sender` has no permission to edit the property.218	/// @param tokenId ID of the token.219	/// @param keys Properties key.220	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]221	fn delete_properties(222		&mut self,223		token_id: uint256,224		caller: caller,225		keys: Vec<string>,226	) -> Result<()> {227		let caller = T::CrossAccountId::from_eth(caller);228		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;229		let keys = keys230			.into_iter()231			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))232			.collect::<Result<Vec<_>>>()?;233234		let nesting_budget = self235			.recorder236			.weight_calls_budget(<StructureWeight<T>>::find_parent());237238		<Pallet<T>>::delete_token_properties(239			self,240			&caller,241			TokenId(token_id),242			keys.into_iter(),243			&nesting_budget,244		)245		.map_err(dispatch_to_evm::<T>)246	}247248	/// @notice Get token property value.249	/// @dev Throws error if key not found250	/// @param tokenId ID of the token.251	/// @param key Property key.252	/// @return Property value bytes253	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {254		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;255		let key = <Vec<u8>>::from(key)256			.try_into()257			.map_err(|_| "key too long")?;258259		let props = <TokenProperties<T>>::get((self.id, token_id));260		let prop = props.get(&key).ok_or("key not found")?;261262		Ok(prop.to_vec().into())263	}264}265266#[derive(ToLog)]267pub enum ERC721Events {268	/// @dev This emits when ownership of any NFT changes by any mechanism.269	///  This event emits when NFTs are created (`from` == 0) and destroyed270	///  (`to` == 0). Exception: during contract creation, any number of NFTs271	///  may be created and assigned without emitting Transfer. At the time of272	///  any transfer, the approved address for that NFT (if any) is reset to none.273	Transfer {274		#[indexed]275		from: address,276		#[indexed]277		to: address,278		#[indexed]279		token_id: uint256,280	},281	/// @dev This emits when the approved address for an NFT is changed or282	///  reaffirmed. The zero address indicates there is no approved address.283	///  When a Transfer event emits, this also indicates that the approved284	///  address for that NFT (if any) is reset to none.285	Approval {286		#[indexed]287		owner: address,288		#[indexed]289		approved: address,290		#[indexed]291		token_id: uint256,292	},293	/// @dev This emits when an operator is enabled or disabled for an owner.294	///  The operator can manage all NFTs of the owner.295	#[allow(dead_code)]296	ApprovalForAll {297		#[indexed]298		owner: address,299		#[indexed]300		operator: address,301		approved: bool,302	},303}304305#[derive(ToLog)]306pub enum ERC721UniqueMintableEvents {307	#[allow(dead_code)]308	MintingFinished {},309}310311/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension312/// @dev See https://eips.ethereum.org/EIPS/eip-721313#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]314impl<T: Config> NonfungibleHandle<T>315where316	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,317{318	/// @notice A descriptive name for a collection of NFTs in this contract319	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`320	#[solidity(hide, rename_selector = "name")]321	fn name_proxy(&self) -> Result<string> {322		self.name()323	}324325	/// @notice An abbreviated name for NFTs in this contract326	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`327	#[solidity(hide, rename_selector = "symbol")]328	fn symbol_proxy(&self) -> Result<string> {329		self.symbol()330	}331332	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.333	///334	/// @dev If the token has a `url` property and it is not empty, it is returned.335	///  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`.336	///  If the collection property `baseURI` is empty or absent, return "" (empty string)337	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix338	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).339	///340	/// @return token's const_metadata341	#[solidity(rename_selector = "tokenURI")]342	fn token_uri(&self, token_id: uint256) -> Result<string> {343		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;344345		match get_token_property(self, token_id_u32, &key::url()).as_deref() {346			Err(_) | Ok("") => (),347			Ok(url) => {348				return Ok(url.into());349			}350		};351352		let base_uri =353			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())354				.map(BoundedVec::into_inner)355				.map(string::from_utf8)356				.transpose()357				.map_err(|e| {358					Error::Revert(alloc::format!(359						"Can not convert value \"baseURI\" to string with error \"{}\"",360						e361					))362				})?;363364		let base_uri = match base_uri.as_deref() {365			None | Some("") => {366				return Ok("".into());367			}368			Some(base_uri) => base_uri.into(),369		};370371		Ok(372			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {373				Err(_) | Ok("") => base_uri,374				Ok(suffix) => base_uri + suffix,375			},376		)377	}378}379380/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension381/// @dev See https://eips.ethereum.org/EIPS/eip-721382#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]383impl<T: Config> NonfungibleHandle<T> {384	/// @notice Enumerate valid NFTs385	/// @param index A counter less than `totalSupply()`386	/// @return The token identifier for the `index`th NFT,387	///  (sort order not specified)388	fn token_by_index(&self, index: uint256) -> Result<uint256> {389		Ok(index)390	}391392	/// @dev Not implemented393	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {394		// TODO: Not implemetable395		Err("not implemented".into())396	}397398	/// @notice Count NFTs tracked by this contract399	/// @return A count of valid NFTs tracked by this contract, where each one of400	///  them has an assigned and queryable owner not equal to the zero address401	fn total_supply(&self) -> Result<uint256> {402		self.consume_store_reads(1)?;403		Ok(<Pallet<T>>::total_supply(self).into())404	}405}406407/// @title ERC-721 Non-Fungible Token Standard408/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md409#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]410impl<T: Config> NonfungibleHandle<T> {411	/// @notice Count all NFTs assigned to an owner412	/// @dev NFTs assigned to the zero address are considered invalid, and this413	///  function throws for queries about the zero address.414	/// @param owner An address for whom to query the balance415	/// @return The number of NFTs owned by `owner`, possibly zero416	fn balance_of(&self, owner: address) -> Result<uint256> {417		self.consume_store_reads(1)?;418		let owner = T::CrossAccountId::from_eth(owner);419		let balance = <AccountBalance<T>>::get((self.id, owner));420		Ok(balance.into())421	}422	/// @notice Find the owner of an NFT423	/// @dev NFTs assigned to zero address are considered invalid, and queries424	///  about them do throw.425	/// @param tokenId The identifier for an NFT426	/// @return The address of the owner of the NFT427	fn owner_of(&self, token_id: uint256) -> Result<address> {428		self.consume_store_reads(1)?;429		let token: TokenId = token_id.try_into()?;430		Ok(*<TokenData<T>>::get((self.id, token))431			.ok_or("token not found")?432			.owner433			.as_eth())434	}435	/// @dev Not implemented436	#[solidity(rename_selector = "safeTransferFrom")]437	fn safe_transfer_from_with_data(438		&mut self,439		_from: address,440		_to: address,441		_token_id: uint256,442		_data: bytes,443	) -> Result<void> {444		// TODO: Not implemetable445		Err("not implemented".into())446	}447	/// @dev Not implemented448	fn safe_transfer_from(449		&mut self,450		_from: address,451		_to: address,452		_token_id: uint256,453	) -> Result<void> {454		// TODO: Not implemetable455		Err("not implemented".into())456	}457458	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE459	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE460	///  THEY MAY BE PERMANENTLY LOST461	/// @dev Throws unless `msg.sender` is the current owner or an authorized462	///  operator for this NFT. Throws if `from` is not the current owner. Throws463	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.464	/// @param from The current owner of the NFT465	/// @param to The new owner466	/// @param tokenId The NFT to transfer467	#[weight(<SelfWeightOf<T>>::transfer_from())]468	fn transfer_from(469		&mut self,470		caller: caller,471		from: address,472		to: address,473		token_id: uint256,474	) -> Result<void> {475		let caller = T::CrossAccountId::from_eth(caller);476		let from = T::CrossAccountId::from_eth(from);477		let to = T::CrossAccountId::from_eth(to);478		let token = token_id.try_into()?;479		let budget = self480			.recorder481			.weight_calls_budget(<StructureWeight<T>>::find_parent());482483		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)484			.map_err(dispatch_to_evm::<T>)?;485		Ok(())486	}487488	/// @notice Set or reaffirm the approved address for an NFT489	/// @dev The zero address indicates there is no approved address.490	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized491	///  operator of the current owner.492	/// @param approved The new approved NFT controller493	/// @param tokenId The NFT to approve494	#[weight(<SelfWeightOf<T>>::approve())]495	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {496		let caller = T::CrossAccountId::from_eth(caller);497		let approved = T::CrossAccountId::from_eth(approved);498		let token = token_id.try_into()?;499500		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))501			.map_err(dispatch_to_evm::<T>)?;502		Ok(())503	}504505	/// @notice Sets or unsets the approval of a given operator.506	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.507	/// @param operator Operator508	/// @param approved Should operator status be granted or revoked?509	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]510	fn set_approval_for_all(511		&mut self,512		caller: caller,513		operator: address,514		approved: bool,515	) -> Result<void> {516		let caller = T::CrossAccountId::from_eth(caller);517		let operator = T::CrossAccountId::from_eth(operator);518519		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)520			.map_err(dispatch_to_evm::<T>)?;521		Ok(())522	}523524	/// @dev Not implemented525	fn get_approved(&self, _token_id: uint256) -> Result<address> {526		// TODO: Not implemetable527		Err("not implemented".into())528	}529530	/// @notice Tells whether the given `owner` approves the `operator`.531	#[weight(<SelfWeightOf<T>>::allowance_for_all())]532	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {533		let owner = T::CrossAccountId::from_eth(owner);534		let operator = T::CrossAccountId::from_eth(operator);535536		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))537	}538539	/// @notice Returns collection helper contract address540	fn collection_helper_address(&self) -> Result<address> {541		Ok(T::ContractAddress::get())542	}543}544545/// @title ERC721 Token that can be irreversibly burned (destroyed).546#[solidity_interface(name = ERC721Burnable)]547impl<T: Config> NonfungibleHandle<T> {548	/// @notice Burns a specific ERC721 token.549	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized550	///  operator of the current owner.551	/// @param tokenId The NFT to approve552	#[weight(<SelfWeightOf<T>>::burn_item())]553	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {554		let caller = T::CrossAccountId::from_eth(caller);555		let token = token_id.try_into()?;556557		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;558		Ok(())559	}560}561562/// @title ERC721 minting logic.563#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]564impl<T: Config> NonfungibleHandle<T> {565	fn minting_finished(&self) -> Result<bool> {566		Ok(false)567	}568569	/// @notice Function to mint a token.570	/// @param to The new owner571	/// @return uint256 The id of the newly minted token572	#[weight(<SelfWeightOf<T>>::create_item())]573	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {574		let token_id: uint256 = <TokensMinted<T>>::get(self.id)575			.checked_add(1)576			.ok_or("item id overflow")?577			.into();578		self.mint_check_id(caller, to, token_id)?;579		Ok(token_id)580	}581582	/// @notice Function to mint a token.583	/// @dev `tokenId` should be obtained with `nextTokenId` method,584	///  unlike standard, you can't specify it manually585	/// @param to The new owner586	/// @param tokenId ID of the minted NFT587	#[solidity(hide, rename_selector = "mint")]588	#[weight(<SelfWeightOf<T>>::create_item())]589	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {590		let caller = T::CrossAccountId::from_eth(caller);591		let to = T::CrossAccountId::from_eth(to);592		let token_id: u32 = token_id.try_into()?;593		let budget = self594			.recorder595			.weight_calls_budget(<StructureWeight<T>>::find_parent());596597		if <TokensMinted<T>>::get(self.id)598			.checked_add(1)599			.ok_or("item id overflow")?600			!= token_id601		{602			return Err("item id should be next".into());603		}604605		<Pallet<T>>::create_item(606			self,607			&caller,608			CreateItemData::<T> {609				properties: BoundedVec::default(),610				owner: to,611			},612			&budget,613		)614		.map_err(dispatch_to_evm::<T>)?;615616		Ok(true)617	}618619	/// @notice Function to mint token with the given tokenUri.620	/// @param to The new owner621	/// @param tokenUri Token URI that would be stored in the NFT properties622	/// @return uint256 The id of the newly minted token623	#[solidity(rename_selector = "mintWithTokenURI")]624	#[weight(<SelfWeightOf<T>>::create_item())]625	fn mint_with_token_uri(626		&mut self,627		caller: caller,628		to: address,629		token_uri: string,630	) -> Result<uint256> {631		let token_id: uint256 = <TokensMinted<T>>::get(self.id)632			.checked_add(1)633			.ok_or("item id overflow")?634			.into();635		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;636		Ok(token_id)637	}638639	/// @notice Function to mint token with the given tokenUri.640	/// @dev `tokenId` should be obtained with `nextTokenId` method,641	///  unlike standard, you can't specify it manually642	/// @param to The new owner643	/// @param tokenId ID of the minted NFT644	/// @param tokenUri Token URI that would be stored in the NFT properties645	#[solidity(hide, rename_selector = "mintWithTokenURI")]646	#[weight(<SelfWeightOf<T>>::create_item())]647	fn mint_with_token_uri_check_id(648		&mut self,649		caller: caller,650		to: address,651		token_id: uint256,652		token_uri: string,653	) -> Result<bool> {654		let key = key::url();655		let permission = get_token_permission::<T>(self.id, &key)?;656		if !permission.collection_admin {657			return Err("Operation is not allowed".into());658		}659660		let caller = T::CrossAccountId::from_eth(caller);661		let to = T::CrossAccountId::from_eth(to);662		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;663		let budget = self664			.recorder665			.weight_calls_budget(<StructureWeight<T>>::find_parent());666667		if <TokensMinted<T>>::get(self.id)668			.checked_add(1)669			.ok_or("item id overflow")?670			!= token_id671		{672			return Err("item id should be next".into());673		}674675		let mut properties = CollectionPropertiesVec::default();676		properties677			.try_push(Property {678				key,679				value: token_uri680					.into_bytes()681					.try_into()682					.map_err(|_| "token uri is too long")?,683			})684			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;685686		<Pallet<T>>::create_item(687			self,688			&caller,689			CreateItemData::<T> {690				properties,691				owner: to,692			},693			&budget,694		)695		.map_err(dispatch_to_evm::<T>)?;696		Ok(true)697	}698699	/// @dev Not implemented700	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {701		Err("not implementable".into())702	}703}704705fn get_token_property<T: Config>(706	collection: &CollectionHandle<T>,707	token_id: u32,708	key: &up_data_structs::PropertyKey,709) -> Result<string> {710	collection.consume_store_reads(1)?;711	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))712		.map_err(|_| Error::Revert("Token properties not found".into()))?;713	if let Some(property) = properties.get(key) {714		return Ok(string::from_utf8_lossy(property).into());715	}716717	Err("Property tokenURI not found".into())718}719720fn get_token_permission<T: Config>(721	collection_id: CollectionId,722	key: &PropertyKey,723) -> Result<PropertyPermission> {724	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)725		.map_err(|_| Error::Revert("No permissions for collection".into()))?;726	let a = token_property_permissions727		.get(key)728		.map(Clone::clone)729		.ok_or_else(|| {730			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();731			Error::Revert(alloc::format!("No permission for key {}", key))732		})?;733	Ok(a)734}735736/// @title Unique extensions for ERC721.737#[solidity_interface(name = ERC721UniqueExtensions)]738impl<T: Config> NonfungibleHandle<T>739where740	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,741{742	/// @notice A descriptive name for a collection of NFTs in this contract743	fn name(&self) -> Result<string> {744		Ok(decode_utf16(self.name.iter().copied())745			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))746			.collect::<string>())747	}748749	/// @notice An abbreviated name for NFTs in this contract750	fn symbol(&self) -> Result<string> {751		Ok(string::from_utf8_lossy(&self.token_prefix).into())752	}753754	/// @notice A description for the collection.755	fn description(&self) -> Result<string> {756		Ok(decode_utf16(self.description.iter().copied())757			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))758			.collect::<string>())759	}760761	/// Returns the owner (in cross format) of the token.762	///763	/// @param tokenId Id for the token.764	fn cross_owner_of(&self, token_id: uint256) -> Result<pallet_common::eth::CrossAccount> {765		Self::token_owner(&self, token_id.try_into()?)766			.map(|o| pallet_common::eth::CrossAccount::from_sub_cross_account::<T>(&o))767			.ok_or(Error::Revert("key too large".into()))768	}769770	/// Returns the token properties.771	///772	/// @param tokenId Id for the token.773	/// @param keys Properties keys. Empty keys for all propertyes.774	/// @return Vector of properties key/value pairs.775	fn properties(776		&self,777		token_id: uint256,778		keys: Vec<string>,779	) -> Result<Vec<pallet_common::eth::Property>> {780		let keys = keys781			.into_iter()782			.map(|key| {783				<Vec<u8>>::from(key)784					.try_into()785					.map_err(|_| Error::Revert("key too large".into()))786			})787			.collect::<Result<Vec<_>>>()?;788789		<Self as CommonCollectionOperations<T>>::token_properties(790			&self,791			token_id.try_into()?,792			if keys.is_empty() { None } else { Some(keys) },793		)794		.into_iter()795		.map(|p| {796			let key = string::from_utf8(p.key.to_vec())797				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;798			let value = bytes(p.value.to_vec());799			Ok(pallet_common::eth::Property { key, value })800		})801		.collect::<Result<Vec<_>>>()802	}803804	/// @notice Set or reaffirm the approved address for an NFT805	/// @dev The zero address indicates there is no approved address.806	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized807	///  operator of the current owner.808	/// @param approved The new substrate address approved NFT controller809	/// @param tokenId The NFT to approve810	#[weight(<SelfWeightOf<T>>::approve())]811	fn approve_cross(812		&mut self,813		caller: caller,814		approved: pallet_common::eth::CrossAccount,815		token_id: uint256,816	) -> Result<void> {817		let caller = T::CrossAccountId::from_eth(caller);818		let approved = approved.into_sub_cross_account::<T>()?;819		let token = token_id.try_into()?;820821		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))822			.map_err(dispatch_to_evm::<T>)?;823		Ok(())824	}825826	/// @notice Transfer ownership of an NFT827	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`828	///  is the zero address. Throws if `tokenId` is not a valid NFT.829	/// @param to The new owner830	/// @param tokenId The NFT to transfer831	#[weight(<SelfWeightOf<T>>::transfer())]832	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {833		let caller = T::CrossAccountId::from_eth(caller);834		let to = T::CrossAccountId::from_eth(to);835		let token = token_id.try_into()?;836		let budget = self837			.recorder838			.weight_calls_budget(<StructureWeight<T>>::find_parent());839840		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;841		Ok(())842	}843844	/// @notice Transfer ownership of an NFT845	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`846	///  is the zero address. Throws if `tokenId` is not a valid NFT.847	/// @param to The new owner848	/// @param tokenId The NFT to transfer849	#[weight(<SelfWeightOf<T>>::transfer())]850	fn transfer_cross(851		&mut self,852		caller: caller,853		to: pallet_common::eth::CrossAccount,854		token_id: uint256,855	) -> Result<void> {856		let caller = T::CrossAccountId::from_eth(caller);857		let to = to.into_sub_cross_account::<T>()?;858		let token = token_id.try_into()?;859		let budget = self860			.recorder861			.weight_calls_budget(<StructureWeight<T>>::find_parent());862863		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;864		Ok(())865	}866867	/// @notice Transfer ownership of an NFT from cross account address to cross account address868	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`869	///  is the zero address. Throws if `tokenId` is not a valid NFT.870	/// @param from Cross acccount address of current owner871	/// @param to Cross acccount address of new owner872	/// @param tokenId The NFT to transfer873	#[weight(<SelfWeightOf<T>>::transfer())]874	fn transfer_from_cross(875		&mut self,876		caller: caller,877		from: pallet_common::eth::CrossAccount,878		to: pallet_common::eth::CrossAccount,879		token_id: uint256,880	) -> Result<void> {881		let caller = T::CrossAccountId::from_eth(caller);882		let from = from.into_sub_cross_account::<T>()?;883		let to = to.into_sub_cross_account::<T>()?;884		let token_id = token_id.try_into()?;885		let budget = self886			.recorder887			.weight_calls_budget(<StructureWeight<T>>::find_parent());888		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)889			.map_err(dispatch_to_evm::<T>)?;890		Ok(())891	}892893	/// @notice Burns a specific ERC721 token.894	/// @dev Throws unless `msg.sender` is the current owner or an authorized895	///  operator for this NFT. Throws if `from` is not the current owner. Throws896	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.897	/// @param from The current owner of the NFT898	/// @param tokenId The NFT to transfer899	#[solidity(hide)]900	#[weight(<SelfWeightOf<T>>::burn_from())]901	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {902		let caller = T::CrossAccountId::from_eth(caller);903		let from = T::CrossAccountId::from_eth(from);904		let token = token_id.try_into()?;905		let budget = self906			.recorder907			.weight_calls_budget(<StructureWeight<T>>::find_parent());908909		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)910			.map_err(dispatch_to_evm::<T>)?;911		Ok(())912	}913914	/// @notice Burns a specific ERC721 token.915	/// @dev Throws unless `msg.sender` is the current owner or an authorized916	///  operator for this NFT. Throws if `from` is not the current owner. Throws917	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.918	/// @param from The current owner of the NFT919	/// @param tokenId The NFT to transfer920	#[weight(<SelfWeightOf<T>>::burn_from())]921	fn burn_from_cross(922		&mut self,923		caller: caller,924		from: pallet_common::eth::CrossAccount,925		token_id: uint256,926	) -> Result<void> {927		let caller = T::CrossAccountId::from_eth(caller);928		let from = from.into_sub_cross_account::<T>()?;929		let token = token_id.try_into()?;930		let budget = self931			.recorder932			.weight_calls_budget(<StructureWeight<T>>::find_parent());933934		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)935			.map_err(dispatch_to_evm::<T>)?;936		Ok(())937	}938939	/// @notice Returns next free NFT ID.940	fn next_token_id(&self) -> Result<uint256> {941		self.consume_store_reads(1)?;942		Ok(<TokensMinted<T>>::get(self.id)943			.checked_add(1)944			.ok_or("item id overflow")?945			.into())946	}947948	/// @notice Function to mint multiple tokens.949	/// @dev `tokenIds` should be an array of consecutive numbers and first number950	///  should be obtained with `nextTokenId` method951	/// @param to The new owner952	/// @param tokenIds IDs of the minted NFTs953	#[solidity(hide)]954	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]955	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {956		let caller = T::CrossAccountId::from_eth(caller);957		let to = T::CrossAccountId::from_eth(to);958		let mut expected_index = <TokensMinted<T>>::get(self.id)959			.checked_add(1)960			.ok_or("item id overflow")?;961		let budget = self962			.recorder963			.weight_calls_budget(<StructureWeight<T>>::find_parent());964965		let total_tokens = token_ids.len();966		for id in token_ids.into_iter() {967			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;968			if id != expected_index {969				return Err("item id should be next".into());970			}971			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;972		}973		let data = (0..total_tokens)974			.map(|_| CreateItemData::<T> {975				properties: BoundedVec::default(),976				owner: to.clone(),977			})978			.collect();979980		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)981			.map_err(dispatch_to_evm::<T>)?;982		Ok(true)983	}984985	/// @notice Function to mint multiple tokens with the given tokenUris.986	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive987	///  numbers and first number should be obtained with `nextTokenId` method988	/// @param to The new owner989	/// @param tokens array of pairs of token ID and token URI for minted tokens990	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]991	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]992	fn mint_bulk_with_token_uri(993		&mut self,994		caller: caller,995		to: address,996		tokens: Vec<(uint256, string)>,997	) -> Result<bool> {998		let key = key::url();999		let caller = T::CrossAccountId::from_eth(caller);1000		let to = T::CrossAccountId::from_eth(to);1001		let mut expected_index = <TokensMinted<T>>::get(self.id)1002			.checked_add(1)1003			.ok_or("item id overflow")?;1004		let budget = self1005			.recorder1006			.weight_calls_budget(<StructureWeight<T>>::find_parent());10071008		let mut data = Vec::with_capacity(tokens.len());1009		for (id, token_uri) in tokens {1010			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1011			if id != expected_index {1012				return Err("item id should be next".into());1013			}1014			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10151016			let mut properties = CollectionPropertiesVec::default();1017			properties1018				.try_push(Property {1019					key: key.clone(),1020					value: token_uri1021						.into_bytes()1022						.try_into()1023						.map_err(|_| "token uri is too long")?,1024				})1025				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10261027			data.push(CreateItemData::<T> {1028				properties,1029				owner: to.clone(),1030			});1031		}10321033		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1034			.map_err(dispatch_to_evm::<T>)?;1035		Ok(true)1036	}10371038	/// @notice Function to mint a token.1039	/// @param to The new owner crossAccountId1040	/// @param properties Properties of minted token1041	/// @return uint256 The id of the newly minted token1042	#[weight(<SelfWeightOf<T>>::create_item())]1043	fn mint_cross(1044		&mut self,1045		caller: caller,1046		to: pallet_common::eth::CrossAccount,1047		properties: Vec<pallet_common::eth::Property>,1048	) -> Result<uint256> {1049		let token_id = <TokensMinted<T>>::get(self.id)1050			.checked_add(1)1051			.ok_or("item id overflow")?;10521053		let to = to.into_sub_cross_account::<T>()?;10541055		let properties = properties1056			.into_iter()1057			.map(|pallet_common::eth::Property { key, value }| {1058				let key = <Vec<u8>>::from(key)1059					.try_into()1060					.map_err(|_| "key too large")?;10611062				let value = value.0.try_into().map_err(|_| "value too large")?;10631064				Ok(Property { key, value })1065			})1066			.collect::<Result<Vec<_>>>()?1067			.try_into()1068			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;10691070		let caller = T::CrossAccountId::from_eth(caller);10711072		let budget = self1073			.recorder1074			.weight_calls_budget(<StructureWeight<T>>::find_parent());10751076		<Pallet<T>>::create_item(1077			self,1078			&caller,1079			CreateItemData::<T> {1080				properties,1081				owner: to,1082			},1083			&budget,1084		)1085		.map_err(dispatch_to_evm::<T>)?;10861087		Ok(token_id.into())1088	}1089}10901091#[solidity_interface(1092	name = UniqueNFT,1093	is(1094		ERC721,1095		ERC721Enumerable,1096		ERC721UniqueExtensions,1097		ERC721UniqueMintable,1098		ERC721Burnable,1099		ERC721Metadata(if(this.flags.erc721metadata)),1100		Collection(via(common_mut returns CollectionHandle<T>)),1101		TokenProperties,1102	)1103)]1104impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11051106// Not a tests, but code generators1107generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1108generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);11091110impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1111where1112	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1113{1114	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");11151116	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1117		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1118	}1119}