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

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Nonfungible Pallet EVM API18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Nonfungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.2122extern crate alloc;23use core::{24	char::{REPLACEMENT_CHARACTER, decode_utf16},25	convert::TryInto,26};27use evm_coder::{28	abi::AbiType, ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*,29	types::Property as PropertyStruct, weight,30};31use frame_support::BoundedVec;32use up_data_structs::{33	TokenId, PropertyPermission, PropertyKeyPermission, Property, CollectionId, PropertyKey,34	CollectionPropertiesVec,35};36use pallet_evm_coder_substrate::dispatch_to_evm;37use sp_std::{vec::Vec, vec};38use pallet_common::{39	CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,40	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},41	eth::{EthCrossAccount, EthTokenPermissions},42};43use pallet_evm::{account::CrossAccountId, PrecompileHandle};44use pallet_evm_coder_substrate::call;45use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};46use sp_core::Get;4748use crate::{49	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,50	SelfWeightOf, weights::WeightInfo, TokenProperties,51};5253/// @title A contract that allows to set and delete token properties and change token property permissions.54#[solidity_interface(name = TokenProperties)]55impl<T: Config> NonfungibleHandle<T> {56	/// @notice Set permissions for token property.57	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.58	/// @param key Property key.59	/// @param isMutable Permission to mutate property.60	/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.61	/// @param tokenOwner Permission to mutate property by token owner if property is mutable.62	#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]63	#[solidity(hide)]64	fn set_token_property_permission(65		&mut self,66		caller: caller,67		key: string,68		is_mutable: bool,69		collection_admin: bool,70		token_owner: bool,71	) -> Result<()> {72		let caller = T::CrossAccountId::from_eth(caller);73		<Pallet<T>>::set_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<(string, Vec<(EthTokenPermissions, bool)>)>,98	) -> Result<()> {99		let caller = T::CrossAccountId::from_eth(caller);100		const PERMISSIONS_FIELDS_COUNT: usize = 3;101102		let mut perms = Vec::new();103104		for (key, pp) in permissions {105			if pp.len() > PERMISSIONS_FIELDS_COUNT {106				return Err(alloc::format!(107					"Actual number of fields {} for {}, which exceeds the maximum value of {}",108					pp.len(),109					stringify!(EthTokenPermissions),110					PERMISSIONS_FIELDS_COUNT111				)112				.as_str()113				.into());114			}115116			let mut token_permission = PropertyPermission::default();117118			for (perm, value) in pp {119				match perm {120					EthTokenPermissions::Mutable => token_permission.mutable = value,121					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,122					EthTokenPermissions::CollectionAdmin => {123						token_permission.collection_admin = value124					}125				}126			}127128			perms.push(PropertyKeyPermission {129				key: key.into_bytes().try_into().map_err(|_| "too long key")?,130				permission: token_permission,131			});132		}133134		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)135			.map_err(dispatch_to_evm::<T>)136	}137138	/// @notice Get permissions for token properties.139	fn token_property_permissions(140		&self,141	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {142		let perms = <Pallet<T>>::token_property_permission(self.id);143		Ok(perms144			.into_iter()145			.map(|(key, pp)| {146				let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid");147				let pp = vec![148					(EthTokenPermissions::Mutable, pp.mutable),149					(EthTokenPermissions::TokenOwner, pp.token_owner),150					(EthTokenPermissions::CollectionAdmin, pp.collection_admin),151				];152				(key, pp)153			})154			.collect())155	}156157	/// @notice Set token property value.158	/// @dev Throws error if `msg.sender` has no permission to edit the property.159	/// @param tokenId ID of the token.160	/// @param key Property key.161	/// @param value Property value.162	#[solidity(hide)]163	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]164	fn set_property(165		&mut self,166		caller: caller,167		token_id: uint256,168		key: string,169		value: bytes,170	) -> Result<()> {171		let caller = T::CrossAccountId::from_eth(caller);172		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;173		let key = <Vec<u8>>::from(key)174			.try_into()175			.map_err(|_| "key too long")?;176		let value = value.0.try_into().map_err(|_| "value too long")?;177178		let nesting_budget = self179			.recorder180			.weight_calls_budget(<StructureWeight<T>>::find_parent());181182		<Pallet<T>>::set_token_property(183			self,184			&caller,185			TokenId(token_id),186			Property { key, value },187			&nesting_budget,188		)189		.map_err(dispatch_to_evm::<T>)190	}191192	/// @notice Set token properties value.193	/// @dev Throws error if `msg.sender` has no permission to edit the property.194	/// @param tokenId ID of the token.195	/// @param properties settable properties196	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]197	fn set_properties(198		&mut self,199		caller: caller,200		token_id: uint256,201		properties: Vec<PropertyStruct>,202	) -> Result<()> {203		let caller = T::CrossAccountId::from_eth(caller);204		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;205206		let nesting_budget = self207			.recorder208			.weight_calls_budget(<StructureWeight<T>>::find_parent());209210		let properties = properties211			.into_iter()212			.map(|PropertyStruct { key, value }| {213				let key = <Vec<u8>>::from(key)214					.try_into()215					.map_err(|_| "key too large")?;216217				let value = value.0.try_into().map_err(|_| "value too large")?;218219				Ok(Property { key, value })220			})221			.collect::<Result<Vec<_>>>()?;222223		<Pallet<T>>::set_token_properties(224			self,225			&caller,226			TokenId(token_id),227			properties.into_iter(),228			false,229			&nesting_budget,230		)231		.map_err(dispatch_to_evm::<T>)232	}233234	/// @notice Delete token property value.235	/// @dev Throws error if `msg.sender` has no permission to edit the property.236	/// @param tokenId ID of the token.237	/// @param key Property key.238	#[solidity(hide)]239	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]240	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {241		let caller = T::CrossAccountId::from_eth(caller);242		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;243		let key = <Vec<u8>>::from(key)244			.try_into()245			.map_err(|_| "key too long")?;246247		let nesting_budget = self248			.recorder249			.weight_calls_budget(<StructureWeight<T>>::find_parent());250251		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)252			.map_err(dispatch_to_evm::<T>)253	}254255	/// @notice Delete token properties value.256	/// @dev Throws error if `msg.sender` has no permission to edit the property.257	/// @param tokenId ID of the token.258	/// @param keys Properties key.259	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]260	fn delete_properties(261		&mut self,262		token_id: uint256,263		caller: caller,264		keys: Vec<string>,265	) -> Result<()> {266		let caller = T::CrossAccountId::from_eth(caller);267		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;268		let keys = keys269			.into_iter()270			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))271			.collect::<Result<Vec<_>>>()?;272273		let nesting_budget = self274			.recorder275			.weight_calls_budget(<StructureWeight<T>>::find_parent());276277		<Pallet<T>>::delete_token_properties(278			self,279			&caller,280			TokenId(token_id),281			keys.into_iter(),282			&nesting_budget,283		)284		.map_err(dispatch_to_evm::<T>)285	}286287	/// @notice Get token property value.288	/// @dev Throws error if key not found289	/// @param tokenId ID of the token.290	/// @param key Property key.291	/// @return Property value bytes292	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {293		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;294		let key = <Vec<u8>>::from(key)295			.try_into()296			.map_err(|_| "key too long")?;297298		let props = <TokenProperties<T>>::get((self.id, token_id));299		let prop = props.get(&key).ok_or("key not found")?;300301		Ok(prop.to_vec().into())302	}303}304305#[derive(ToLog)]306pub enum ERC721Events {307	/// @dev This emits when ownership of any NFT changes by any mechanism.308	///  This event emits when NFTs are created (`from` == 0) and destroyed309	///  (`to` == 0). Exception: during contract creation, any number of NFTs310	///  may be created and assigned without emitting Transfer. At the time of311	///  any transfer, the approved address for that NFT (if any) is reset to none.312	Transfer {313		#[indexed]314		from: address,315		#[indexed]316		to: address,317		#[indexed]318		token_id: uint256,319	},320	/// @dev This emits when the approved address for an NFT is changed or321	///  reaffirmed. The zero address indicates there is no approved address.322	///  When a Transfer event emits, this also indicates that the approved323	///  address for that NFT (if any) is reset to none.324	Approval {325		#[indexed]326		owner: address,327		#[indexed]328		approved: address,329		#[indexed]330		token_id: uint256,331	},332	/// @dev This emits when an operator is enabled or disabled for an owner.333	///  The operator can manage all NFTs of the owner.334	#[allow(dead_code)]335	ApprovalForAll {336		#[indexed]337		owner: address,338		#[indexed]339		operator: address,340		approved: bool,341	},342}343344#[derive(ToLog)]345pub enum ERC721UniqueMintableEvents {346	#[allow(dead_code)]347	MintingFinished {},348}349350/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension351/// @dev See https://eips.ethereum.org/EIPS/eip-721352#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]353impl<T: Config> NonfungibleHandle<T>354where355	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,356{357	/// @notice A descriptive name for a collection of NFTs in this contract358	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`359	#[solidity(hide, rename_selector = "name")]360	fn name_proxy(&self) -> Result<string> {361		self.name()362	}363364	/// @notice An abbreviated name for NFTs in this contract365	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`366	#[solidity(hide, rename_selector = "symbol")]367	fn symbol_proxy(&self) -> Result<string> {368		self.symbol()369	}370371	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.372	///373	/// @dev If the token has a `url` property and it is not empty, it is returned.374	///  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`.375	///  If the collection property `baseURI` is empty or absent, return "" (empty string)376	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix377	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).378	///379	/// @return token's const_metadata380	#[solidity(rename_selector = "tokenURI")]381	fn token_uri(&self, token_id: uint256) -> Result<string> {382		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;383384		match get_token_property(self, token_id_u32, &key::url()).as_deref() {385			Err(_) | Ok("") => (),386			Ok(url) => {387				return Ok(url.into());388			}389		};390391		let base_uri =392			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())393				.map(BoundedVec::into_inner)394				.map(string::from_utf8)395				.transpose()396				.map_err(|e| {397					Error::Revert(alloc::format!(398						"Can not convert value \"baseURI\" to string with error \"{}\"",399						e400					))401				})?;402403		let base_uri = match base_uri.as_deref() {404			None | Some("") => {405				return Ok("".into());406			}407			Some(base_uri) => base_uri.into(),408		};409410		Ok(411			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {412				Err(_) | Ok("") => base_uri,413				Ok(suffix) => base_uri + suffix,414			},415		)416	}417}418419/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension420/// @dev See https://eips.ethereum.org/EIPS/eip-721421#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]422impl<T: Config> NonfungibleHandle<T> {423	/// @notice Enumerate valid NFTs424	/// @param index A counter less than `totalSupply()`425	/// @return The token identifier for the `index`th NFT,426	///  (sort order not specified)427	fn token_by_index(&self, index: uint256) -> Result<uint256> {428		Ok(index)429	}430431	/// @dev Not implemented432	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {433		// TODO: Not implemetable434		Err("not implemented".into())435	}436437	/// @notice Count NFTs tracked by this contract438	/// @return A count of valid NFTs tracked by this contract, where each one of439	///  them has an assigned and queryable owner not equal to the zero address440	fn total_supply(&self) -> Result<uint256> {441		self.consume_store_reads(1)?;442		Ok(<Pallet<T>>::total_supply(self).into())443	}444}445446/// @title ERC-721 Non-Fungible Token Standard447/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md448#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]449impl<T: Config> NonfungibleHandle<T> {450	/// @notice Count all NFTs assigned to an owner451	/// @dev NFTs assigned to the zero address are considered invalid, and this452	///  function throws for queries about the zero address.453	/// @param owner An address for whom to query the balance454	/// @return The number of NFTs owned by `owner`, possibly zero455	fn balance_of(&self, owner: address) -> Result<uint256> {456		self.consume_store_reads(1)?;457		let owner = T::CrossAccountId::from_eth(owner);458		let balance = <AccountBalance<T>>::get((self.id, owner));459		Ok(balance.into())460	}461	/// @notice Find the owner of an NFT462	/// @dev NFTs assigned to zero address are considered invalid, and queries463	///  about them do throw.464	/// @param tokenId The identifier for an NFT465	/// @return The address of the owner of the NFT466	fn owner_of(&self, token_id: uint256) -> Result<address> {467		self.consume_store_reads(1)?;468		let token: TokenId = token_id.try_into()?;469		Ok(*<TokenData<T>>::get((self.id, token))470			.ok_or("token not found")?471			.owner472			.as_eth())473	}474	/// @dev Not implemented475	#[solidity(rename_selector = "safeTransferFrom")]476	fn safe_transfer_from_with_data(477		&mut self,478		_from: address,479		_to: address,480		_token_id: uint256,481		_data: bytes,482	) -> Result<void> {483		// TODO: Not implemetable484		Err("not implemented".into())485	}486	/// @dev Not implemented487	fn safe_transfer_from(488		&mut self,489		_from: address,490		_to: address,491		_token_id: uint256,492	) -> Result<void> {493		// TODO: Not implemetable494		Err("not implemented".into())495	}496497	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE498	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE499	///  THEY MAY BE PERMANENTLY LOST500	/// @dev Throws unless `msg.sender` is the current owner or an authorized501	///  operator for this NFT. Throws if `from` is not the current owner. Throws502	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.503	/// @param from The current owner of the NFT504	/// @param to The new owner505	/// @param tokenId The NFT to transfer506	#[weight(<SelfWeightOf<T>>::transfer_from())]507	fn transfer_from(508		&mut self,509		caller: caller,510		from: address,511		to: address,512		token_id: uint256,513	) -> Result<void> {514		let caller = T::CrossAccountId::from_eth(caller);515		let from = T::CrossAccountId::from_eth(from);516		let to = T::CrossAccountId::from_eth(to);517		let token = token_id.try_into()?;518		let budget = self519			.recorder520			.weight_calls_budget(<StructureWeight<T>>::find_parent());521522		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)523			.map_err(dispatch_to_evm::<T>)?;524		Ok(())525	}526527	/// @notice Set or reaffirm the approved address for an NFT528	/// @dev The zero address indicates there is no approved address.529	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized530	///  operator of the current owner.531	/// @param approved The new approved NFT controller532	/// @param tokenId The NFT to approve533	#[weight(<SelfWeightOf<T>>::approve())]534	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {535		let caller = T::CrossAccountId::from_eth(caller);536		let approved = T::CrossAccountId::from_eth(approved);537		let token = token_id.try_into()?;538539		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))540			.map_err(dispatch_to_evm::<T>)?;541		Ok(())542	}543544	/// @notice Sets or unsets the approval of a given operator.545	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.546	/// @param operator Operator547	/// @param approved Should operator status be granted or revoked?548	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]549	fn set_approval_for_all(550		&mut self,551		caller: caller,552		operator: address,553		approved: bool,554	) -> Result<void> {555		let caller = T::CrossAccountId::from_eth(caller);556		let operator = T::CrossAccountId::from_eth(operator);557558		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)559			.map_err(dispatch_to_evm::<T>)?;560		Ok(())561	}562563	/// @dev Not implemented564	fn get_approved(&self, _token_id: uint256) -> Result<address> {565		// TODO: Not implemetable566		Err("not implemented".into())567	}568569	/// @notice Tells whether the given `owner` approves the `operator`.570	#[weight(<SelfWeightOf<T>>::allowance_for_all())]571	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {572		let owner = T::CrossAccountId::from_eth(owner);573		let operator = T::CrossAccountId::from_eth(operator);574575		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))576	}577578	/// @notice Returns collection helper contract address579	fn collection_helper_address(&self) -> Result<address> {580		Ok(T::ContractAddress::get())581	}582}583584/// @title ERC721 Token that can be irreversibly burned (destroyed).585#[solidity_interface(name = ERC721Burnable)]586impl<T: Config> NonfungibleHandle<T> {587	/// @notice Burns a specific ERC721 token.588	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized589	///  operator of the current owner.590	/// @param tokenId The NFT to approve591	#[weight(<SelfWeightOf<T>>::burn_item())]592	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {593		let caller = T::CrossAccountId::from_eth(caller);594		let token = token_id.try_into()?;595596		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;597		Ok(())598	}599}600601/// @title ERC721 minting logic.602#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]603impl<T: Config> NonfungibleHandle<T> {604	fn minting_finished(&self) -> Result<bool> {605		Ok(false)606	}607608	/// @notice Function to mint a token.609	/// @param to The new owner610	/// @return uint256 The id of the newly minted token611	#[weight(<SelfWeightOf<T>>::create_item())]612	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {613		let token_id: uint256 = <TokensMinted<T>>::get(self.id)614			.checked_add(1)615			.ok_or("item id overflow")?616			.into();617		self.mint_check_id(caller, to, token_id)?;618		Ok(token_id)619	}620621	/// @notice Function to mint a token.622	/// @dev `tokenId` should be obtained with `nextTokenId` method,623	///  unlike standard, you can't specify it manually624	/// @param to The new owner625	/// @param tokenId ID of the minted NFT626	#[solidity(hide, rename_selector = "mint")]627	#[weight(<SelfWeightOf<T>>::create_item())]628	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {629		let caller = T::CrossAccountId::from_eth(caller);630		let to = T::CrossAccountId::from_eth(to);631		let token_id: u32 = token_id.try_into()?;632		let budget = self633			.recorder634			.weight_calls_budget(<StructureWeight<T>>::find_parent());635636		if <TokensMinted<T>>::get(self.id)637			.checked_add(1)638			.ok_or("item id overflow")?639			!= token_id640		{641			return Err("item id should be next".into());642		}643644		<Pallet<T>>::create_item(645			self,646			&caller,647			CreateItemData::<T> {648				properties: BoundedVec::default(),649				owner: to,650			},651			&budget,652		)653		.map_err(dispatch_to_evm::<T>)?;654655		Ok(true)656	}657658	/// @notice Function to mint token with the given tokenUri.659	/// @param to The new owner660	/// @param tokenUri Token URI that would be stored in the NFT properties661	/// @return uint256 The id of the newly minted token662	#[solidity(rename_selector = "mintWithTokenURI")]663	#[weight(<SelfWeightOf<T>>::create_item())]664	fn mint_with_token_uri(665		&mut self,666		caller: caller,667		to: address,668		token_uri: string,669	) -> Result<uint256> {670		let token_id: uint256 = <TokensMinted<T>>::get(self.id)671			.checked_add(1)672			.ok_or("item id overflow")?673			.into();674		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;675		Ok(token_id)676	}677678	/// @notice Function to mint token with the given tokenUri.679	/// @dev `tokenId` should be obtained with `nextTokenId` method,680	///  unlike standard, you can't specify it manually681	/// @param to The new owner682	/// @param tokenId ID of the minted NFT683	/// @param tokenUri Token URI that would be stored in the NFT properties684	#[solidity(hide, rename_selector = "mintWithTokenURI")]685	#[weight(<SelfWeightOf<T>>::create_item())]686	fn mint_with_token_uri_check_id(687		&mut self,688		caller: caller,689		to: address,690		token_id: uint256,691		token_uri: string,692	) -> Result<bool> {693		let key = key::url();694		let permission = get_token_permission::<T>(self.id, &key)?;695		if !permission.collection_admin {696			return Err("Operation is not allowed".into());697		}698699		let caller = T::CrossAccountId::from_eth(caller);700		let to = T::CrossAccountId::from_eth(to);701		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;702		let budget = self703			.recorder704			.weight_calls_budget(<StructureWeight<T>>::find_parent());705706		if <TokensMinted<T>>::get(self.id)707			.checked_add(1)708			.ok_or("item id overflow")?709			!= token_id710		{711			return Err("item id should be next".into());712		}713714		let mut properties = CollectionPropertiesVec::default();715		properties716			.try_push(Property {717				key,718				value: token_uri719					.into_bytes()720					.try_into()721					.map_err(|_| "token uri is too long")?,722			})723			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;724725		<Pallet<T>>::create_item(726			self,727			&caller,728			CreateItemData::<T> {729				properties,730				owner: to,731			},732			&budget,733		)734		.map_err(dispatch_to_evm::<T>)?;735		Ok(true)736	}737738	/// @dev Not implemented739	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {740		Err("not implementable".into())741	}742}743744fn get_token_property<T: Config>(745	collection: &CollectionHandle<T>,746	token_id: u32,747	key: &up_data_structs::PropertyKey,748) -> Result<string> {749	collection.consume_store_reads(1)?;750	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))751		.map_err(|_| Error::Revert("Token properties not found".into()))?;752	if let Some(property) = properties.get(key) {753		return Ok(string::from_utf8_lossy(property).into());754	}755756	Err("Property tokenURI not found".into())757}758759fn get_token_permission<T: Config>(760	collection_id: CollectionId,761	key: &PropertyKey,762) -> Result<PropertyPermission> {763	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)764		.map_err(|_| Error::Revert("No permissions for collection".into()))?;765	let a = token_property_permissions766		.get(key)767		.map(Clone::clone)768		.ok_or_else(|| {769			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();770			Error::Revert(alloc::format!("No permission for key {}", key))771		})?;772	Ok(a)773}774775/// @title Unique extensions for ERC721.776#[solidity_interface(name = ERC721UniqueExtensions)]777impl<T: Config> NonfungibleHandle<T>778where779	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,780{781	/// @notice A descriptive name for a collection of NFTs in this contract782	fn name(&self) -> Result<string> {783		Ok(decode_utf16(self.name.iter().copied())784			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))785			.collect::<string>())786	}787788	/// @notice An abbreviated name for NFTs in this contract789	fn symbol(&self) -> Result<string> {790		Ok(string::from_utf8_lossy(&self.token_prefix).into())791	}792793	/// @notice A description for the collection.794	fn description(&self) -> Result<string> {795		Ok(decode_utf16(self.description.iter().copied())796			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))797			.collect::<string>())798	}799800	/// Returns the owner (in cross format) of the token.801	///802	/// @param tokenId Id for the token.803	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {804		Self::token_owner(&self, token_id.try_into()?)805			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))806			.ok_or(Error::Revert("key too large".into()))807	}808809	/// Returns the token properties.810	///811	/// @param tokenId Id for the token.812	/// @param keys Properties keys. Empty keys for all propertyes.813	/// @return Vector of properties key/value pairs.814	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {815		let keys = keys816			.into_iter()817			.map(|key| {818				<Vec<u8>>::from(key)819					.try_into()820					.map_err(|_| Error::Revert("key too large".into()))821			})822			.collect::<Result<Vec<_>>>()?;823824		<Self as CommonCollectionOperations<T>>::token_properties(825			&self,826			token_id.try_into()?,827			if keys.is_empty() { None } else { Some(keys) },828		)829		.into_iter()830		.map(|p| {831			let key = string::from_utf8(p.key.to_vec())832				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;833			let value = bytes(p.value.to_vec());834			Ok(PropertyStruct { key, value })835		})836		.collect::<Result<Vec<_>>>()837	}838839	/// @notice Set or reaffirm the approved address for an NFT840	/// @dev The zero address indicates there is no approved address.841	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized842	///  operator of the current owner.843	/// @param approved The new substrate address approved NFT controller844	/// @param tokenId The NFT to approve845	#[weight(<SelfWeightOf<T>>::approve())]846	fn approve_cross(847		&mut self,848		caller: caller,849		approved: EthCrossAccount,850		token_id: uint256,851	) -> Result<void> {852		let caller = T::CrossAccountId::from_eth(caller);853		let approved = approved.into_sub_cross_account::<T>()?;854		let token = token_id.try_into()?;855856		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))857			.map_err(dispatch_to_evm::<T>)?;858		Ok(())859	}860861	/// @notice Transfer ownership of an NFT862	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`863	///  is the zero address. Throws if `tokenId` is not a valid NFT.864	/// @param to The new owner865	/// @param tokenId The NFT to transfer866	#[weight(<SelfWeightOf<T>>::transfer())]867	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {868		let caller = T::CrossAccountId::from_eth(caller);869		let to = T::CrossAccountId::from_eth(to);870		let token = token_id.try_into()?;871		let budget = self872			.recorder873			.weight_calls_budget(<StructureWeight<T>>::find_parent());874875		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;876		Ok(())877	}878879	/// @notice Transfer ownership of an NFT880	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`881	///  is the zero address. Throws if `tokenId` is not a valid NFT.882	/// @param to The new owner883	/// @param tokenId The NFT to transfer884	#[weight(<SelfWeightOf<T>>::transfer())]885	fn transfer_cross(886		&mut self,887		caller: caller,888		to: EthCrossAccount,889		token_id: uint256,890	) -> Result<void> {891		let caller = T::CrossAccountId::from_eth(caller);892		let to = to.into_sub_cross_account::<T>()?;893		let token = token_id.try_into()?;894		let budget = self895			.recorder896			.weight_calls_budget(<StructureWeight<T>>::find_parent());897898		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;899		Ok(())900	}901902	/// @notice Transfer ownership of an NFT from cross account address to cross account address903	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`904	///  is the zero address. Throws if `tokenId` is not a valid NFT.905	/// @param from Cross acccount address of current owner906	/// @param to Cross acccount address of new owner907	/// @param tokenId The NFT to transfer908	#[weight(<SelfWeightOf<T>>::transfer())]909	fn transfer_from_cross(910		&mut self,911		caller: caller,912		from: EthCrossAccount,913		to: EthCrossAccount,914		token_id: uint256,915	) -> Result<void> {916		let caller = T::CrossAccountId::from_eth(caller);917		let from = from.into_sub_cross_account::<T>()?;918		let to = to.into_sub_cross_account::<T>()?;919		let token_id = token_id.try_into()?;920		let budget = self921			.recorder922			.weight_calls_budget(<StructureWeight<T>>::find_parent());923		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)924			.map_err(dispatch_to_evm::<T>)?;925		Ok(())926	}927928	/// @notice Burns a specific ERC721 token.929	/// @dev Throws unless `msg.sender` is the current owner or an authorized930	///  operator for this NFT. Throws if `from` is not the current owner. Throws931	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.932	/// @param from The current owner of the NFT933	/// @param tokenId The NFT to transfer934	#[solidity(hide)]935	#[weight(<SelfWeightOf<T>>::burn_from())]936	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {937		let caller = T::CrossAccountId::from_eth(caller);938		let from = T::CrossAccountId::from_eth(from);939		let token = token_id.try_into()?;940		let budget = self941			.recorder942			.weight_calls_budget(<StructureWeight<T>>::find_parent());943944		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)945			.map_err(dispatch_to_evm::<T>)?;946		Ok(())947	}948949	/// @notice Burns a specific ERC721 token.950	/// @dev Throws unless `msg.sender` is the current owner or an authorized951	///  operator for this NFT. Throws if `from` is not the current owner. Throws952	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.953	/// @param from The current owner of the NFT954	/// @param tokenId The NFT to transfer955	#[weight(<SelfWeightOf<T>>::burn_from())]956	fn burn_from_cross(957		&mut self,958		caller: caller,959		from: EthCrossAccount,960		token_id: uint256,961	) -> Result<void> {962		let caller = T::CrossAccountId::from_eth(caller);963		let from = from.into_sub_cross_account::<T>()?;964		let token = token_id.try_into()?;965		let budget = self966			.recorder967			.weight_calls_budget(<StructureWeight<T>>::find_parent());968969		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)970			.map_err(dispatch_to_evm::<T>)?;971		Ok(())972	}973974	/// @notice Returns next free NFT ID.975	fn next_token_id(&self) -> Result<uint256> {976		self.consume_store_reads(1)?;977		Ok(<TokensMinted<T>>::get(self.id)978			.checked_add(1)979			.ok_or("item id overflow")?980			.into())981	}982983	/// @notice Function to mint multiple tokens.984	/// @dev `tokenIds` should be an array of consecutive numbers and first number985	///  should be obtained with `nextTokenId` method986	/// @param to The new owner987	/// @param tokenIds IDs of the minted NFTs988	#[solidity(hide)]989	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]990	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {991		let caller = T::CrossAccountId::from_eth(caller);992		let to = T::CrossAccountId::from_eth(to);993		let mut expected_index = <TokensMinted<T>>::get(self.id)994			.checked_add(1)995			.ok_or("item id overflow")?;996		let budget = self997			.recorder998			.weight_calls_budget(<StructureWeight<T>>::find_parent());9991000		let total_tokens = token_ids.len();1001		for id in token_ids.into_iter() {1002			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1003			if id != expected_index {1004				return Err("item id should be next".into());1005			}1006			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1007		}1008		let data = (0..total_tokens)1009			.map(|_| CreateItemData::<T> {1010				properties: BoundedVec::default(),1011				owner: to.clone(),1012			})1013			.collect();10141015		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1016			.map_err(dispatch_to_evm::<T>)?;1017		Ok(true)1018	}10191020	/// @notice Function to mint multiple tokens with the given tokenUris.1021	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1022	///  numbers and first number should be obtained with `nextTokenId` method1023	/// @param to The new owner1024	/// @param tokens array of pairs of token ID and token URI for minted tokens1025	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1026	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1027	fn mint_bulk_with_token_uri(1028		&mut self,1029		caller: caller,1030		to: address,1031		tokens: Vec<(uint256, string)>,1032	) -> Result<bool> {1033		let key = key::url();1034		let caller = T::CrossAccountId::from_eth(caller);1035		let to = T::CrossAccountId::from_eth(to);1036		let mut expected_index = <TokensMinted<T>>::get(self.id)1037			.checked_add(1)1038			.ok_or("item id overflow")?;1039		let budget = self1040			.recorder1041			.weight_calls_budget(<StructureWeight<T>>::find_parent());10421043		let mut data = Vec::with_capacity(tokens.len());1044		for (id, token_uri) in tokens {1045			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1046			if id != expected_index {1047				return Err("item id should be next".into());1048			}1049			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10501051			let mut properties = CollectionPropertiesVec::default();1052			properties1053				.try_push(Property {1054					key: key.clone(),1055					value: token_uri1056						.into_bytes()1057						.try_into()1058						.map_err(|_| "token uri is too long")?,1059				})1060				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10611062			data.push(CreateItemData::<T> {1063				properties,1064				owner: to.clone(),1065			});1066		}10671068		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1069			.map_err(dispatch_to_evm::<T>)?;1070		Ok(true)1071	}10721073	/// @notice Function to mint a token.1074	/// @param to The new owner crossAccountId1075	/// @param properties Properties of minted token1076	/// @return uint256 The id of the newly minted token1077	#[weight(<SelfWeightOf<T>>::create_item())]1078	fn mint_cross(1079		&mut self,1080		caller: caller,1081		to: EthCrossAccount,1082		properties: Vec<PropertyStruct>,1083	) -> Result<uint256> {1084		let token_id = <TokensMinted<T>>::get(self.id)1085			.checked_add(1)1086			.ok_or("item id overflow")?;10871088		let to = to.into_sub_cross_account::<T>()?;10891090		let properties = properties1091			.into_iter()1092			.map(|PropertyStruct { key, value }| {1093				let key = <Vec<u8>>::from(key)1094					.try_into()1095					.map_err(|_| "key too large")?;10961097				let value = value.0.try_into().map_err(|_| "value too large")?;10981099				Ok(Property { key, value })1100			})1101			.collect::<Result<Vec<_>>>()?1102			.try_into()1103			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;11041105		let caller = T::CrossAccountId::from_eth(caller);11061107		let budget = self1108			.recorder1109			.weight_calls_budget(<StructureWeight<T>>::find_parent());11101111		<Pallet<T>>::create_item(1112			self,1113			&caller,1114			CreateItemData::<T> {1115				properties,1116				owner: to,1117			},1118			&budget,1119		)1120		.map_err(dispatch_to_evm::<T>)?;11211122		Ok(token_id.into())1123	}1124}11251126#[solidity_interface(1127	name = UniqueNFT,1128	is(1129		ERC721,1130		ERC721Enumerable,1131		ERC721UniqueExtensions,1132		ERC721UniqueMintable,1133		ERC721Burnable,1134		ERC721Metadata(if(this.flags.erc721metadata)),1135		Collection(via(common_mut returns CollectionHandle<T>)),1136		TokenProperties,1137	)1138)]1139impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11401141// Not a tests, but code generators1142generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1143generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);11441145impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1146where1147	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1148{1149	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");11501151	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1152		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1153	}1154}