git.delta.rocks / unique-network / refs/commits / 8298cf829479

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::{Property as PropertyStruct, 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		let mut perms = Vec::new();101102		for (key, pp) in permissions {103			if pp.len() > EthTokenPermissions::FIELDS_COUNT {104				return Err(alloc::format!(105					"Actual number of fields {} for {}, which exceeds the maximum value of {}",106					pp.len(),107					stringify!(EthTokenPermissions),108					EthTokenPermissions::FIELDS_COUNT109				)110				.as_str()111				.into());112			}113114			let mut token_permission = PropertyPermission::default();115116			for (perm, value) in pp {117				match perm {118					EthTokenPermissions::Mutable => token_permission.mutable = value,119					EthTokenPermissions::TokenOwner => token_permission.token_owner = value,120					EthTokenPermissions::CollectionAdmin => {121						token_permission.collection_admin = value122					}123				}124			}125126			perms.push(PropertyKeyPermission {127				key: key.into_bytes().try_into().map_err(|_| "too long key")?,128				permission: token_permission,129			});130		}131132		<Pallet<T>>::set_token_property_permissions(self, &caller, perms)133			.map_err(dispatch_to_evm::<T>)134	}135136	/// @notice Get permissions for token properties.137	fn token_property_permissions(138		&self,139	) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {140		let perms = <Pallet<T>>::token_property_permission(self.id);141		Ok(perms142			.into_iter()143			.map(|(key, pp)| {144				let key = string::from_utf8(key.into_inner()).expect("Stored key must be valid");145				let pp = vec![146					(EthTokenPermissions::Mutable, pp.mutable),147					(EthTokenPermissions::TokenOwner, pp.token_owner),148					(EthTokenPermissions::CollectionAdmin, pp.collection_admin),149				];150				(key, pp)151			})152			.collect())153	}154155	/// @notice Set token property value.156	/// @dev Throws error if `msg.sender` has no permission to edit the property.157	/// @param tokenId ID of the token.158	/// @param key Property key.159	/// @param value Property value.160	#[solidity(hide)]161	#[weight(<SelfWeightOf<T>>::set_token_properties(1))]162	fn set_property(163		&mut self,164		caller: caller,165		token_id: uint256,166		key: string,167		value: bytes,168	) -> Result<()> {169		let caller = T::CrossAccountId::from_eth(caller);170		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;171		let key = <Vec<u8>>::from(key)172			.try_into()173			.map_err(|_| "key too long")?;174		let value = value.0.try_into().map_err(|_| "value too long")?;175176		let nesting_budget = self177			.recorder178			.weight_calls_budget(<StructureWeight<T>>::find_parent());179180		<Pallet<T>>::set_token_property(181			self,182			&caller,183			TokenId(token_id),184			Property { key, value },185			&nesting_budget,186		)187		.map_err(dispatch_to_evm::<T>)188	}189190	/// @notice Set token properties value.191	/// @dev Throws error if `msg.sender` has no permission to edit the property.192	/// @param tokenId ID of the token.193	/// @param properties settable properties194	#[weight(<SelfWeightOf<T>>::set_token_properties(properties.len() as u32))]195	fn set_properties(196		&mut self,197		caller: caller,198		token_id: uint256,199		properties: Vec<PropertyStruct>,200	) -> Result<()> {201		let caller = T::CrossAccountId::from_eth(caller);202		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;203204		let nesting_budget = self205			.recorder206			.weight_calls_budget(<StructureWeight<T>>::find_parent());207208		let properties = properties209			.into_iter()210			.map(|PropertyStruct { key, value }| {211				let key = <Vec<u8>>::from(key)212					.try_into()213					.map_err(|_| "key too large")?;214215				let value = value.0.try_into().map_err(|_| "value too large")?;216217				Ok(Property { key, value })218			})219			.collect::<Result<Vec<_>>>()?;220221		<Pallet<T>>::set_token_properties(222			self,223			&caller,224			TokenId(token_id),225			properties.into_iter(),226			false,227			&nesting_budget,228		)229		.map_err(dispatch_to_evm::<T>)230	}231232	/// @notice Delete token property value.233	/// @dev Throws error if `msg.sender` has no permission to edit the property.234	/// @param tokenId ID of the token.235	/// @param key Property key.236	#[solidity(hide)]237	#[weight(<SelfWeightOf<T>>::delete_token_properties(1))]238	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {239		let caller = T::CrossAccountId::from_eth(caller);240		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;241		let key = <Vec<u8>>::from(key)242			.try_into()243			.map_err(|_| "key too long")?;244245		let nesting_budget = self246			.recorder247			.weight_calls_budget(<StructureWeight<T>>::find_parent());248249		<Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)250			.map_err(dispatch_to_evm::<T>)251	}252253	/// @notice Delete token properties value.254	/// @dev Throws error if `msg.sender` has no permission to edit the property.255	/// @param tokenId ID of the token.256	/// @param keys Properties key.257	#[weight(<SelfWeightOf<T>>::delete_token_properties(keys.len() as u32))]258	fn delete_properties(259		&mut self,260		token_id: uint256,261		caller: caller,262		keys: Vec<string>,263	) -> Result<()> {264		let caller = T::CrossAccountId::from_eth(caller);265		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;266		let keys = keys267			.into_iter()268			.map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))269			.collect::<Result<Vec<_>>>()?;270271		let nesting_budget = self272			.recorder273			.weight_calls_budget(<StructureWeight<T>>::find_parent());274275		<Pallet<T>>::delete_token_properties(276			self,277			&caller,278			TokenId(token_id),279			keys.into_iter(),280			&nesting_budget,281		)282		.map_err(dispatch_to_evm::<T>)283	}284285	/// @notice Get token property value.286	/// @dev Throws error if key not found287	/// @param tokenId ID of the token.288	/// @param key Property key.289	/// @return Property value bytes290	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {291		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;292		let key = <Vec<u8>>::from(key)293			.try_into()294			.map_err(|_| "key too long")?;295296		let props = <TokenProperties<T>>::get((self.id, token_id));297		let prop = props.get(&key).ok_or("key not found")?;298299		Ok(prop.to_vec().into())300	}301}302303#[derive(ToLog)]304pub enum ERC721Events {305	/// @dev This emits when ownership of any NFT changes by any mechanism.306	///  This event emits when NFTs are created (`from` == 0) and destroyed307	///  (`to` == 0). Exception: during contract creation, any number of NFTs308	///  may be created and assigned without emitting Transfer. At the time of309	///  any transfer, the approved address for that NFT (if any) is reset to none.310	Transfer {311		#[indexed]312		from: address,313		#[indexed]314		to: address,315		#[indexed]316		token_id: uint256,317	},318	/// @dev This emits when the approved address for an NFT is changed or319	///  reaffirmed. The zero address indicates there is no approved address.320	///  When a Transfer event emits, this also indicates that the approved321	///  address for that NFT (if any) is reset to none.322	Approval {323		#[indexed]324		owner: address,325		#[indexed]326		approved: address,327		#[indexed]328		token_id: uint256,329	},330	/// @dev This emits when an operator is enabled or disabled for an owner.331	///  The operator can manage all NFTs of the owner.332	#[allow(dead_code)]333	ApprovalForAll {334		#[indexed]335		owner: address,336		#[indexed]337		operator: address,338		approved: bool,339	},340}341342#[derive(ToLog)]343pub enum ERC721UniqueMintableEvents {344	#[allow(dead_code)]345	MintingFinished {},346}347348/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension349/// @dev See https://eips.ethereum.org/EIPS/eip-721350#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]351impl<T: Config> NonfungibleHandle<T>352where353	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,354{355	/// @notice A descriptive name for a collection of NFTs in this contract356	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`357	#[solidity(hide, rename_selector = "name")]358	fn name_proxy(&self) -> Result<string> {359		self.name()360	}361362	/// @notice An abbreviated name for NFTs in this contract363	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`364	#[solidity(hide, rename_selector = "symbol")]365	fn symbol_proxy(&self) -> Result<string> {366		self.symbol()367	}368369	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.370	///371	/// @dev If the token has a `url` property and it is not empty, it is returned.372	///  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`.373	///  If the collection property `baseURI` is empty or absent, return "" (empty string)374	///  otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix375	///  otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).376	///377	/// @return token's const_metadata378	#[solidity(rename_selector = "tokenURI")]379	fn token_uri(&self, token_id: uint256) -> Result<string> {380		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;381382		match get_token_property(self, token_id_u32, &key::url()).as_deref() {383			Err(_) | Ok("") => (),384			Ok(url) => {385				return Ok(url.into());386			}387		};388389		let base_uri =390			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())391				.map(BoundedVec::into_inner)392				.map(string::from_utf8)393				.transpose()394				.map_err(|e| {395					Error::Revert(alloc::format!(396						"Can not convert value \"baseURI\" to string with error \"{}\"",397						e398					))399				})?;400401		let base_uri = match base_uri.as_deref() {402			None | Some("") => {403				return Ok("".into());404			}405			Some(base_uri) => base_uri.into(),406		};407408		Ok(409			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {410				Err(_) | Ok("") => base_uri,411				Ok(suffix) => base_uri + suffix,412			},413		)414	}415}416417/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension418/// @dev See https://eips.ethereum.org/EIPS/eip-721419#[solidity_interface(name = ERC721Enumerable, expect_selector = 0x780e9d63)]420impl<T: Config> NonfungibleHandle<T> {421	/// @notice Enumerate valid NFTs422	/// @param index A counter less than `totalSupply()`423	/// @return The token identifier for the `index`th NFT,424	///  (sort order not specified)425	fn token_by_index(&self, index: uint256) -> Result<uint256> {426		Ok(index)427	}428429	/// @dev Not implemented430	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {431		// TODO: Not implemetable432		Err("not implemented".into())433	}434435	/// @notice Count NFTs tracked by this contract436	/// @return A count of valid NFTs tracked by this contract, where each one of437	///  them has an assigned and queryable owner not equal to the zero address438	fn total_supply(&self) -> Result<uint256> {439		self.consume_store_reads(1)?;440		Ok(<Pallet<T>>::total_supply(self).into())441	}442}443444/// @title ERC-721 Non-Fungible Token Standard445/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md446#[solidity_interface(name = ERC721, events(ERC721Events), expect_selector = 0x80ac58cd)]447impl<T: Config> NonfungibleHandle<T> {448	/// @notice Count all NFTs assigned to an owner449	/// @dev NFTs assigned to the zero address are considered invalid, and this450	///  function throws for queries about the zero address.451	/// @param owner An address for whom to query the balance452	/// @return The number of NFTs owned by `owner`, possibly zero453	fn balance_of(&self, owner: address) -> Result<uint256> {454		self.consume_store_reads(1)?;455		let owner = T::CrossAccountId::from_eth(owner);456		let balance = <AccountBalance<T>>::get((self.id, owner));457		Ok(balance.into())458	}459	/// @notice Find the owner of an NFT460	/// @dev NFTs assigned to zero address are considered invalid, and queries461	///  about them do throw.462	/// @param tokenId The identifier for an NFT463	/// @return The address of the owner of the NFT464	fn owner_of(&self, token_id: uint256) -> Result<address> {465		self.consume_store_reads(1)?;466		let token: TokenId = token_id.try_into()?;467		Ok(*<TokenData<T>>::get((self.id, token))468			.ok_or("token not found")?469			.owner470			.as_eth())471	}472	/// @dev Not implemented473	#[solidity(rename_selector = "safeTransferFrom")]474	fn safe_transfer_from_with_data(475		&mut self,476		_from: address,477		_to: address,478		_token_id: uint256,479		_data: bytes,480	) -> Result<void> {481		// TODO: Not implemetable482		Err("not implemented".into())483	}484	/// @dev Not implemented485	fn safe_transfer_from(486		&mut self,487		_from: address,488		_to: address,489		_token_id: uint256,490	) -> Result<void> {491		// TODO: Not implemetable492		Err("not implemented".into())493	}494495	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE496	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE497	///  THEY MAY BE PERMANENTLY LOST498	/// @dev Throws unless `msg.sender` is the current owner or an authorized499	///  operator for this NFT. Throws if `from` is not the current owner. Throws500	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.501	/// @param from The current owner of the NFT502	/// @param to The new owner503	/// @param tokenId The NFT to transfer504	#[weight(<SelfWeightOf<T>>::transfer_from())]505	fn transfer_from(506		&mut self,507		caller: caller,508		from: address,509		to: address,510		token_id: uint256,511	) -> Result<void> {512		let caller = T::CrossAccountId::from_eth(caller);513		let from = T::CrossAccountId::from_eth(from);514		let to = T::CrossAccountId::from_eth(to);515		let token = token_id.try_into()?;516		let budget = self517			.recorder518			.weight_calls_budget(<StructureWeight<T>>::find_parent());519520		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token, &budget)521			.map_err(dispatch_to_evm::<T>)?;522		Ok(())523	}524525	/// @notice Set or reaffirm the approved address for an NFT526	/// @dev The zero address indicates there is no approved address.527	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized528	///  operator of the current owner.529	/// @param approved The new approved NFT controller530	/// @param tokenId The NFT to approve531	#[weight(<SelfWeightOf<T>>::approve())]532	fn approve(&mut self, caller: caller, approved: address, token_id: uint256) -> Result<void> {533		let caller = T::CrossAccountId::from_eth(caller);534		let approved = T::CrossAccountId::from_eth(approved);535		let token = token_id.try_into()?;536537		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))538			.map_err(dispatch_to_evm::<T>)?;539		Ok(())540	}541542	/// @notice Sets or unsets the approval of a given operator.543	/// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.544	/// @param operator Operator545	/// @param approved Should operator status be granted or revoked?546	#[weight(<SelfWeightOf<T>>::set_allowance_for_all())]547	fn set_approval_for_all(548		&mut self,549		caller: caller,550		operator: address,551		approved: bool,552	) -> Result<void> {553		let caller = T::CrossAccountId::from_eth(caller);554		let operator = T::CrossAccountId::from_eth(operator);555556		<Pallet<T>>::set_allowance_for_all(self, &caller, &operator, approved)557			.map_err(dispatch_to_evm::<T>)?;558		Ok(())559	}560561	/// @dev Not implemented562	fn get_approved(&self, _token_id: uint256) -> Result<address> {563		// TODO: Not implemetable564		Err("not implemented".into())565	}566567	/// @notice Tells whether the given `owner` approves the `operator`.568	#[weight(<SelfWeightOf<T>>::allowance_for_all())]569	fn is_approved_for_all(&self, owner: address, operator: address) -> Result<bool> {570		let owner = T::CrossAccountId::from_eth(owner);571		let operator = T::CrossAccountId::from_eth(operator);572573		Ok(<Pallet<T>>::allowance_for_all(self, &owner, &operator))574	}575576	/// @notice Returns collection helper contract address577	fn collection_helper_address(&self) -> Result<address> {578		Ok(T::ContractAddress::get())579	}580}581582/// @title ERC721 Token that can be irreversibly burned (destroyed).583#[solidity_interface(name = ERC721Burnable)]584impl<T: Config> NonfungibleHandle<T> {585	/// @notice Burns a specific ERC721 token.586	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized587	///  operator of the current owner.588	/// @param tokenId The NFT to approve589	#[weight(<SelfWeightOf<T>>::burn_item())]590	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {591		let caller = T::CrossAccountId::from_eth(caller);592		let token = token_id.try_into()?;593594		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;595		Ok(())596	}597}598599/// @title ERC721 minting logic.600#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]601impl<T: Config> NonfungibleHandle<T> {602	fn minting_finished(&self) -> Result<bool> {603		Ok(false)604	}605606	/// @notice Function to mint a token.607	/// @param to The new owner608	/// @return uint256 The id of the newly minted token609	#[weight(<SelfWeightOf<T>>::create_item())]610	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {611		let token_id: uint256 = <TokensMinted<T>>::get(self.id)612			.checked_add(1)613			.ok_or("item id overflow")?614			.into();615		self.mint_check_id(caller, to, token_id)?;616		Ok(token_id)617	}618619	/// @notice Function to mint a token.620	/// @dev `tokenId` should be obtained with `nextTokenId` method,621	///  unlike standard, you can't specify it manually622	/// @param to The new owner623	/// @param tokenId ID of the minted NFT624	#[solidity(hide, rename_selector = "mint")]625	#[weight(<SelfWeightOf<T>>::create_item())]626	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {627		let caller = T::CrossAccountId::from_eth(caller);628		let to = T::CrossAccountId::from_eth(to);629		let token_id: u32 = token_id.try_into()?;630		let budget = self631			.recorder632			.weight_calls_budget(<StructureWeight<T>>::find_parent());633634		if <TokensMinted<T>>::get(self.id)635			.checked_add(1)636			.ok_or("item id overflow")?637			!= token_id638		{639			return Err("item id should be next".into());640		}641642		<Pallet<T>>::create_item(643			self,644			&caller,645			CreateItemData::<T> {646				properties: BoundedVec::default(),647				owner: to,648			},649			&budget,650		)651		.map_err(dispatch_to_evm::<T>)?;652653		Ok(true)654	}655656	/// @notice Function to mint token with the given tokenUri.657	/// @param to The new owner658	/// @param tokenUri Token URI that would be stored in the NFT properties659	/// @return uint256 The id of the newly minted token660	#[solidity(rename_selector = "mintWithTokenURI")]661	#[weight(<SelfWeightOf<T>>::create_item())]662	fn mint_with_token_uri(663		&mut self,664		caller: caller,665		to: address,666		token_uri: string,667	) -> Result<uint256> {668		let token_id: uint256 = <TokensMinted<T>>::get(self.id)669			.checked_add(1)670			.ok_or("item id overflow")?671			.into();672		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;673		Ok(token_id)674	}675676	/// @notice Function to mint token with the given tokenUri.677	/// @dev `tokenId` should be obtained with `nextTokenId` method,678	///  unlike standard, you can't specify it manually679	/// @param to The new owner680	/// @param tokenId ID of the minted NFT681	/// @param tokenUri Token URI that would be stored in the NFT properties682	#[solidity(hide, rename_selector = "mintWithTokenURI")]683	#[weight(<SelfWeightOf<T>>::create_item())]684	fn mint_with_token_uri_check_id(685		&mut self,686		caller: caller,687		to: address,688		token_id: uint256,689		token_uri: string,690	) -> Result<bool> {691		let key = key::url();692		let permission = get_token_permission::<T>(self.id, &key)?;693		if !permission.collection_admin {694			return Err("Operation is not allowed".into());695		}696697		let caller = T::CrossAccountId::from_eth(caller);698		let to = T::CrossAccountId::from_eth(to);699		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;700		let budget = self701			.recorder702			.weight_calls_budget(<StructureWeight<T>>::find_parent());703704		if <TokensMinted<T>>::get(self.id)705			.checked_add(1)706			.ok_or("item id overflow")?707			!= token_id708		{709			return Err("item id should be next".into());710		}711712		let mut properties = CollectionPropertiesVec::default();713		properties714			.try_push(Property {715				key,716				value: token_uri717					.into_bytes()718					.try_into()719					.map_err(|_| "token uri is too long")?,720			})721			.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;722723		<Pallet<T>>::create_item(724			self,725			&caller,726			CreateItemData::<T> {727				properties,728				owner: to,729			},730			&budget,731		)732		.map_err(dispatch_to_evm::<T>)?;733		Ok(true)734	}735736	/// @dev Not implemented737	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {738		Err("not implementable".into())739	}740}741742fn get_token_property<T: Config>(743	collection: &CollectionHandle<T>,744	token_id: u32,745	key: &up_data_structs::PropertyKey,746) -> Result<string> {747	collection.consume_store_reads(1)?;748	let properties = <TokenProperties<T>>::try_get((collection.id, token_id))749		.map_err(|_| Error::Revert("Token properties not found".into()))?;750	if let Some(property) = properties.get(key) {751		return Ok(string::from_utf8_lossy(property).into());752	}753754	Err("Property tokenURI not found".into())755}756757fn get_token_permission<T: Config>(758	collection_id: CollectionId,759	key: &PropertyKey,760) -> Result<PropertyPermission> {761	let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)762		.map_err(|_| Error::Revert("No permissions for collection".into()))?;763	let a = token_property_permissions764		.get(key)765		.map(Clone::clone)766		.ok_or_else(|| {767			let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();768			Error::Revert(alloc::format!("No permission for key {}", key))769		})?;770	Ok(a)771}772773/// @title Unique extensions for ERC721.774#[solidity_interface(name = ERC721UniqueExtensions)]775impl<T: Config> NonfungibleHandle<T>776where777	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,778{779	/// @notice A descriptive name for a collection of NFTs in this contract780	fn name(&self) -> Result<string> {781		Ok(decode_utf16(self.name.iter().copied())782			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))783			.collect::<string>())784	}785786	/// @notice An abbreviated name for NFTs in this contract787	fn symbol(&self) -> Result<string> {788		Ok(string::from_utf8_lossy(&self.token_prefix).into())789	}790791	/// @notice A description for the collection.792	fn description(&self) -> Result<string> {793		Ok(decode_utf16(self.description.iter().copied())794			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))795			.collect::<string>())796	}797798	/// Returns the owner (in cross format) of the token.799	///800	/// @param tokenId Id for the token.801	fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {802		Self::token_owner(&self, token_id.try_into()?)803			.map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))804			.ok_or(Error::Revert("key too large".into()))805	}806807	/// Returns the token properties.808	///809	/// @param tokenId Id for the token.810	/// @param keys Properties keys. Empty keys for all propertyes.811	/// @return Vector of properties key/value pairs.812	fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {813		let keys = keys814			.into_iter()815			.map(|key| {816				<Vec<u8>>::from(key)817					.try_into()818					.map_err(|_| Error::Revert("key too large".into()))819			})820			.collect::<Result<Vec<_>>>()?;821822		<Self as CommonCollectionOperations<T>>::token_properties(823			&self,824			token_id.try_into()?,825			if keys.is_empty() { None } else { Some(keys) },826		)827		.into_iter()828		.map(|p| {829			let key = string::from_utf8(p.key.to_vec())830				.map_err(|e| Error::Revert(alloc::format!("{}", e)))?;831			let value = bytes(p.value.to_vec());832			Ok(PropertyStruct { key, value })833		})834		.collect::<Result<Vec<_>>>()835	}836837	/// @notice Set or reaffirm the approved address for an NFT838	/// @dev The zero address indicates there is no approved address.839	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized840	///  operator of the current owner.841	/// @param approved The new substrate address approved NFT controller842	/// @param tokenId The NFT to approve843	#[weight(<SelfWeightOf<T>>::approve())]844	fn approve_cross(845		&mut self,846		caller: caller,847		approved: EthCrossAccount,848		token_id: uint256,849	) -> Result<void> {850		let caller = T::CrossAccountId::from_eth(caller);851		let approved = approved.into_sub_cross_account::<T>()?;852		let token = token_id.try_into()?;853854		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))855			.map_err(dispatch_to_evm::<T>)?;856		Ok(())857	}858859	/// @notice Transfer ownership of an NFT860	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`861	///  is the zero address. Throws if `tokenId` is not a valid NFT.862	/// @param to The new owner863	/// @param tokenId The NFT to transfer864	#[weight(<SelfWeightOf<T>>::transfer())]865	fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {866		let caller = T::CrossAccountId::from_eth(caller);867		let to = T::CrossAccountId::from_eth(to);868		let token = token_id.try_into()?;869		let budget = self870			.recorder871			.weight_calls_budget(<StructureWeight<T>>::find_parent());872873		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;874		Ok(())875	}876877	/// @notice Transfer ownership of an NFT878	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`879	///  is the zero address. Throws if `tokenId` is not a valid NFT.880	/// @param to The new owner881	/// @param tokenId The NFT to transfer882	#[weight(<SelfWeightOf<T>>::transfer())]883	fn transfer_cross(884		&mut self,885		caller: caller,886		to: EthCrossAccount,887		token_id: uint256,888	) -> Result<void> {889		let caller = T::CrossAccountId::from_eth(caller);890		let to = to.into_sub_cross_account::<T>()?;891		let token = token_id.try_into()?;892		let budget = self893			.recorder894			.weight_calls_budget(<StructureWeight<T>>::find_parent());895896		<Pallet<T>>::transfer(self, &caller, &to, token, &budget).map_err(dispatch_to_evm::<T>)?;897		Ok(())898	}899900	/// @notice Transfer ownership of an NFT from cross account address to cross account address901	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`902	///  is the zero address. Throws if `tokenId` is not a valid NFT.903	/// @param from Cross acccount address of current owner904	/// @param to Cross acccount address of new owner905	/// @param tokenId The NFT to transfer906	#[weight(<SelfWeightOf<T>>::transfer())]907	fn transfer_from_cross(908		&mut self,909		caller: caller,910		from: EthCrossAccount,911		to: EthCrossAccount,912		token_id: uint256,913	) -> Result<void> {914		let caller = T::CrossAccountId::from_eth(caller);915		let from = from.into_sub_cross_account::<T>()?;916		let to = to.into_sub_cross_account::<T>()?;917		let token_id = token_id.try_into()?;918		let budget = self919			.recorder920			.weight_calls_budget(<StructureWeight<T>>::find_parent());921		Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, &budget)922			.map_err(dispatch_to_evm::<T>)?;923		Ok(())924	}925926	/// @notice Burns a specific ERC721 token.927	/// @dev Throws unless `msg.sender` is the current owner or an authorized928	///  operator for this NFT. Throws if `from` is not the current owner. Throws929	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.930	/// @param from The current owner of the NFT931	/// @param tokenId The NFT to transfer932	#[solidity(hide)]933	#[weight(<SelfWeightOf<T>>::burn_from())]934	fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {935		let caller = T::CrossAccountId::from_eth(caller);936		let from = T::CrossAccountId::from_eth(from);937		let token = token_id.try_into()?;938		let budget = self939			.recorder940			.weight_calls_budget(<StructureWeight<T>>::find_parent());941942		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)943			.map_err(dispatch_to_evm::<T>)?;944		Ok(())945	}946947	/// @notice Burns a specific ERC721 token.948	/// @dev Throws unless `msg.sender` is the current owner or an authorized949	///  operator for this NFT. Throws if `from` is not the current owner. Throws950	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.951	/// @param from The current owner of the NFT952	/// @param tokenId The NFT to transfer953	#[weight(<SelfWeightOf<T>>::burn_from())]954	fn burn_from_cross(955		&mut self,956		caller: caller,957		from: EthCrossAccount,958		token_id: uint256,959	) -> Result<void> {960		let caller = T::CrossAccountId::from_eth(caller);961		let from = from.into_sub_cross_account::<T>()?;962		let token = token_id.try_into()?;963		let budget = self964			.recorder965			.weight_calls_budget(<StructureWeight<T>>::find_parent());966967		<Pallet<T>>::burn_from(self, &caller, &from, token, &budget)968			.map_err(dispatch_to_evm::<T>)?;969		Ok(())970	}971972	/// @notice Returns next free NFT ID.973	fn next_token_id(&self) -> Result<uint256> {974		self.consume_store_reads(1)?;975		Ok(<TokensMinted<T>>::get(self.id)976			.checked_add(1)977			.ok_or("item id overflow")?978			.into())979	}980981	/// @notice Function to mint multiple tokens.982	/// @dev `tokenIds` should be an array of consecutive numbers and first number983	///  should be obtained with `nextTokenId` method984	/// @param to The new owner985	/// @param tokenIds IDs of the minted NFTs986	#[solidity(hide)]987	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]988	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {989		let caller = T::CrossAccountId::from_eth(caller);990		let to = T::CrossAccountId::from_eth(to);991		let mut expected_index = <TokensMinted<T>>::get(self.id)992			.checked_add(1)993			.ok_or("item id overflow")?;994		let budget = self995			.recorder996			.weight_calls_budget(<StructureWeight<T>>::find_parent());997998		let total_tokens = token_ids.len();999		for id in token_ids.into_iter() {1000			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1001			if id != expected_index {1002				return Err("item id should be next".into());1003			}1004			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;1005		}1006		let data = (0..total_tokens)1007			.map(|_| CreateItemData::<T> {1008				properties: BoundedVec::default(),1009				owner: to.clone(),1010			})1011			.collect();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 multiple tokens with the given tokenUris.1019	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive1020	///  numbers and first number should be obtained with `nextTokenId` method1021	/// @param to The new owner1022	/// @param tokens array of pairs of token ID and token URI for minted tokens1023	#[solidity(hide, rename_selector = "mintBulkWithTokenURI")]1024	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]1025	fn mint_bulk_with_token_uri(1026		&mut self,1027		caller: caller,1028		to: address,1029		tokens: Vec<(uint256, string)>,1030	) -> Result<bool> {1031		let key = key::url();1032		let caller = T::CrossAccountId::from_eth(caller);1033		let to = T::CrossAccountId::from_eth(to);1034		let mut expected_index = <TokensMinted<T>>::get(self.id)1035			.checked_add(1)1036			.ok_or("item id overflow")?;1037		let budget = self1038			.recorder1039			.weight_calls_budget(<StructureWeight<T>>::find_parent());10401041		let mut data = Vec::with_capacity(tokens.len());1042		for (id, token_uri) in tokens {1043			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1044			if id != expected_index {1045				return Err("item id should be next".into());1046			}1047			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10481049			let mut properties = CollectionPropertiesVec::default();1050			properties1051				.try_push(Property {1052					key: key.clone(),1053					value: token_uri1054						.into_bytes()1055						.try_into()1056						.map_err(|_| "token uri is too long")?,1057				})1058				.map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10591060			data.push(CreateItemData::<T> {1061				properties,1062				owner: to.clone(),1063			});1064		}10651066		<Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1067			.map_err(dispatch_to_evm::<T>)?;1068		Ok(true)1069	}10701071	/// @notice Function to mint a token.1072	/// @param to The new owner crossAccountId1073	/// @param properties Properties of minted token1074	/// @return uint256 The id of the newly minted token1075	#[weight(<SelfWeightOf<T>>::create_item())]1076	fn mint_cross(1077		&mut self,1078		caller: caller,1079		to: EthCrossAccount,1080		properties: Vec<PropertyStruct>,1081	) -> Result<uint256> {1082		let token_id = <TokensMinted<T>>::get(self.id)1083			.checked_add(1)1084			.ok_or("item id overflow")?;10851086		let to = to.into_sub_cross_account::<T>()?;10871088		let properties = properties1089			.into_iter()1090			.map(|PropertyStruct { key, value }| {1091				let key = <Vec<u8>>::from(key)1092					.try_into()1093					.map_err(|_| "key too large")?;10941095				let value = value.0.try_into().map_err(|_| "value too large")?;10961097				Ok(Property { key, value })1098			})1099			.collect::<Result<Vec<_>>>()?1100			.try_into()1101			.map_err(|_| Error::Revert(alloc::format!("too many properties")))?;11021103		let caller = T::CrossAccountId::from_eth(caller);11041105		let budget = self1106			.recorder1107			.weight_calls_budget(<StructureWeight<T>>::find_parent());11081109		<Pallet<T>>::create_item(1110			self,1111			&caller,1112			CreateItemData::<T> {1113				properties,1114				owner: to,1115			},1116			&budget,1117		)1118		.map_err(dispatch_to_evm::<T>)?;11191120		Ok(token_id.into())1121	}1122}11231124#[solidity_interface(1125	name = UniqueNFT,1126	is(1127		ERC721,1128		ERC721Enumerable,1129		ERC721UniqueExtensions,1130		ERC721UniqueMintable,1131		ERC721Burnable,1132		ERC721Metadata(if(this.flags.erc721metadata)),1133		Collection(via(common_mut returns CollectionHandle<T>)),1134		TokenProperties,1135	)1136)]1137impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}11381139// Not a tests, but code generators1140generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);1141generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);11421143impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>1144where1145	T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1146{1147	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");11481149	fn call(self, handle: &mut impl PrecompileHandle) -> Option<PrecompileResult> {1150		call::<T, UniqueNFTCall<T>, _, _>(handle, self)1151	}1152}